/* hackage-packages.nix is an auto-generated file -- DO NOT EDIT! */

{ pkgs, stdenv, callPackage }:

self: {

  "3d-graphics-examples" = callPackage
    ({ mkDerivation, base, GLUT, OpenGL, random }:
     mkDerivation {
       pname = "3d-graphics-examples";
       version = "0.0.0.1";
       sha256 = "c537abf41884456b2355a52ed61bb81cc9c5f4ee87cd089f50c69dde6ab2678d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base GLUT OpenGL random ];
       jailbreak = true;
       homepage = "http://darcs.wolfgang.jeltsch.info/haskell/3d-graphics-examples";
       description = "Examples of 3D graphics programming with OpenGL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "3dmodels" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, linear, packer }:
     mkDerivation {
       pname = "3dmodels";
       version = "0.3.0";
       sha256 = "19fa758554bc6f59c37bfd390bc3d69b20d17a8dcca7194b0425a5b2c243f702";
       libraryHaskellDepends = [
         attoparsec base bytestring linear packer
       ];
       jailbreak = true;
       homepage = "https://github.com/capsjac/3dmodels";
       description = "3D model parsers";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "4Blocks" = callPackage
    ({ mkDerivation, base, cairo, containers, gtk, haskell98, mtl }:
     mkDerivation {
       pname = "4Blocks";
       version = "0.2";
       sha256 = "dcbce915d9997ea63a5698e120ea095244461b7772e79b4cdb4c3809c438cad3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cairo containers gtk haskell98 mtl
       ];
       jailbreak = true;
       homepage = "http://lambdacolyte.wordpress.com/2009/08/06/tetris-in-haskell/";
       description = "A tetris-like game (works with GHC 6.8.3 and Gtk2hs 0.9.13)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AAI" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "AAI";
       version = "0.2.0.1";
       sha256 = "d0f14c6e9040c1947c63bf82b5e3f68389e7ebf4d12177575285aecb3404b86d";
       libraryHaskellDepends = [ base ];
       description = "Abstract Application Interface";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ABList" = callPackage
    ({ mkDerivation, base, HUnit, linear, newtype, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "ABList";
       version = "0.0.3";
       sha256 = "016f571499f63744b2696708117dafdd2909f8224a83637d829d2d3a6619121a";
       libraryHaskellDepends = [ base linear newtype ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       description = "An alternating list of two types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "AC-Angle" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "AC-Angle";
       version = "1.0";
       sha256 = "b545b0086832adc7d9ae15b4c3f3d1522d63a746f204570766828f1a893a4965";
       libraryHaskellDepends = [ base ];
       description = "Angles in degrees and radians";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "AC-Boolean" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "AC-Boolean";
       version = "1.1.0";
       sha256 = "4bf08cc6648c8e9e84da14fc3b6294294869a79fdfc1f682bbe249711f4fa145";
       libraryHaskellDepends = [ base ];
       description = "Handle Boolean values generatically";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "AC-BuildPlatform" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "AC-BuildPlatform";
       version = "1.1.0";
       sha256 = "f033919101259e07668df195e1ff20172239a7ae2f93b2b6ff9fb06ad854906e";
       libraryHaskellDepends = [ base ];
       description = "Detect which OS you're running on";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AC-Colour" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "AC-Colour";
       version = "1.1.6";
       sha256 = "29fc7c00b8817e31d44c9cec82f103b7c1a3c09caeaf89281bce72e86e58630b";
       libraryHaskellDepends = [ base ];
       description = "Efficient RGB colour types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "AC-EasyRaster-GTK" = callPackage
    ({ mkDerivation, array, base, gtk }:
     mkDerivation {
       pname = "AC-EasyRaster-GTK";
       version = "1.1.3";
       sha256 = "2b118ef6f9c9caeacee662131affac969430c2c5e48213acf2718901cca15120";
       libraryHaskellDepends = [ array base gtk ];
       description = "GTK+ pixel plotting";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AC-HalfInteger" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "AC-HalfInteger";
       version = "1.2.1";
       sha256 = "6bb5eefb6a58a3d09ba19889c2fb48d3df3d6215623c2c4480efd766d4599673";
       libraryHaskellDepends = [ base ];
       description = "Efficient half-integer type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AC-MiniTest" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "AC-MiniTest";
       version = "1.1.1";
       sha256 = "fab219b210a6c4e0f99dc157665b4fc9316dba67ceb1ecea93f45a50702a5047";
       libraryHaskellDepends = [ base transformers ];
       description = "A simple test framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AC-PPM" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "AC-PPM";
       version = "1.1.1";
       sha256 = "783e93443321e5a1a1fcb63ee266bd21b9f2daf0b2bed8e6cfa0746a1dff5c78";
       libraryHaskellDepends = [ base bytestring ];
       description = "Trivial package for writing PPM images";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "AC-Random" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "AC-Random";
       version = "0.1";
       sha256 = "8159443b99eae8da13227b7a47fb59b84e860cafec072355d38212063ebb00b0";
       libraryHaskellDepends = [ base ];
       description = "A pure Haskell PRNG";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "AC-Terminal" = callPackage
    ({ mkDerivation, ansi-terminal, base }:
     mkDerivation {
       pname = "AC-Terminal";
       version = "1.0";
       sha256 = "83d09dd723aea78934fcf7feb979606e1e8a5053a99fda34142d91781c6e1b34";
       libraryHaskellDepends = [ ansi-terminal base ];
       description = "Trivial wrapper over ansi-terminal";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AC-VanillaArray" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "AC-VanillaArray";
       version = "1.1.2";
       sha256 = "7b4430ab596a5aae4245df83de7682966d8bb1a0e9b931819f398a57188f9310";
       libraryHaskellDepends = [ base ghc-prim ];
       jailbreak = true;
       description = "Immutable arrays with plain integer indicies";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AC-Vector" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "AC-Vector";
       version = "2.3.2";
       sha256 = "5e51ff6779a3803ce1009c9dffd13a3022fb3cbddeb49e685d7f43d7a8715011";
       libraryHaskellDepends = [ base ];
       description = "Efficient geometric vectors and transformations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "AC-Vector-Fancy" = callPackage
    ({ mkDerivation, AC-Angle, AC-Vector, base }:
     mkDerivation {
       pname = "AC-Vector-Fancy";
       version = "2.4.0";
       sha256 = "be1862481fbcf93fbfce7a39cb2bccb8237bd7937b33d86bd009b172b4b08a71";
       libraryHaskellDepends = [ AC-Angle AC-Vector base ];
       description = "Fancy type-system stuff for AC-Vector";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ACME" = callPackage
    ({ mkDerivation, base, list-extras, mtl, random, random-shuffle
     , void
     }:
     mkDerivation {
       pname = "ACME";
       version = "0.0.0.1";
       sha256 = "ba59ace4c4e06fcecfb080555366ae8bfbe43dbec0ff28b9d8e0f548118d7580";
       libraryHaskellDepends = [
         base list-extras mtl random random-shuffle void
       ];
       homepage = "http://alkalisoftware.net";
       description = "Essential features";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ADPfusion" = callPackage
    ({ mkDerivation, base, bits, containers, mmorph, monad-primitive
     , mtl, OrderedBits, primitive, PrimitiveArray, QuickCheck
     , singletons, strict, template-haskell, test-framework
     , test-framework-quickcheck2, test-framework-th, th-orphans
     , transformers, tuple, vector
     }:
     mkDerivation {
       pname = "ADPfusion";
       version = "0.5.0.0";
       sha256 = "bbea9d5352dba8d2d0e0d67624dee7d50babf15a954f42dc9cb0d815b859a668";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bits containers mmorph monad-primitive mtl OrderedBits
         primitive PrimitiveArray QuickCheck singletons strict
         template-haskell th-orphans transformers tuple vector
       ];
       testHaskellDepends = [
         base bits OrderedBits PrimitiveArray QuickCheck strict
         test-framework test-framework-quickcheck2 test-framework-th vector
       ];
       jailbreak = true;
       homepage = "https://github.com/choener/ADPfusion";
       description = "Efficient, high-level dynamic programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AERN-Basics" = callPackage
    ({ mkDerivation, base, containers, criterion, deepseq, directory
     , QuickCheck, random, test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "AERN-Basics";
       version = "2011.1.0.1";
       sha256 = "8a2b3447b71c22fd72c5525d340b2764d28c0327d0b5d421d79fbb4a4e32f5ff";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers criterion deepseq QuickCheck random test-framework
         test-framework-quickcheck2
       ];
       executableHaskellDepends = [ base containers directory ];
       jailbreak = true;
       homepage = "http://code.google.com/p/aern/";
       description = "foundational type classes for approximating exact real numbers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AERN-Net" = callPackage
    ({ mkDerivation, AERN-Real, AERN-RnToRm, base, binary, containers
     , html, stm, time
     }:
     mkDerivation {
       pname = "AERN-Net";
       version = "0.2.1.1";
       sha256 = "0f83f21c2cdaec93cd9fd8a6c0bb5b7d5886d6fe23d7129df4b4a1fb0be2fec0";
       libraryHaskellDepends = [
         AERN-Real AERN-RnToRm base binary containers html stm time
       ];
       jailbreak = true;
       homepage = "http://www-users.aston.ac.uk/~konecnym/DISCERN";
       description = "Compositional lazy dataflow networks for exact real number computation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AERN-Real" = callPackage
    ({ mkDerivation, AERN-Basics, base, criterion, QuickCheck
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "AERN-Real";
       version = "2011.1.0.1";
       sha256 = "db5ca1816068ececd6e2ac281d91b1e918da6b6d1276fddf2eb9d4fdd4600ed5";
       libraryHaskellDepends = [
         AERN-Basics base criterion QuickCheck test-framework
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://code.google.com/p/aern/";
       description = "arbitrary precision real interval arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AERN-Real-Double" = callPackage
    ({ mkDerivation, AERN-Basics, AERN-Real, AERN-Real-Interval, base
     , criterion, ieee-utils, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "AERN-Real-Double";
       version = "2011.1.0.2";
       sha256 = "e22d260a3574cedd97b67dad3793726d45ab42650ee1051d6ecdbd15ade08b43";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         AERN-Basics AERN-Real AERN-Real-Interval base ieee-utils QuickCheck
         test-framework test-framework-quickcheck2
       ];
       executableHaskellDepends = [
         AERN-Basics AERN-Real AERN-Real-Interval base criterion ieee-utils
         QuickCheck test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://code.google.com/p/aern/";
       description = "arbitrary precision real interval arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AERN-Real-Interval" = callPackage
    ({ mkDerivation, AERN-Basics, AERN-Real, base, deepseq, QuickCheck
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "AERN-Real-Interval";
       version = "2011.1.0.1";
       sha256 = "9b2fa7d8f36876c93e0fc38814df73728bca6f09e40e1fc43c4f93c74436d0d7";
       libraryHaskellDepends = [
         AERN-Basics AERN-Real base deepseq QuickCheck test-framework
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://code.google.com/p/aern/";
       description = "arbitrary precision real interval arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AERN-RnToRm" = callPackage
    ({ mkDerivation, AERN-Real, base, binary, containers, directory
     , filepath, html, QuickCheck, time
     }:
     mkDerivation {
       pname = "AERN-RnToRm";
       version = "0.5.0.1";
       sha256 = "5b3e4a56399ddfaabab4f24f11989b923c8a007d626099dc23798001031ca967";
       libraryHaskellDepends = [
         AERN-Real base binary containers directory filepath html QuickCheck
         time
       ];
       jailbreak = true;
       homepage = "http://www-users.aston.ac.uk/~konecnym/DISCERN";
       description = "polynomial function enclosures (PFEs) approximating exact real functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AERN-RnToRm-Plot" = callPackage
    ({ mkDerivation, AERN-Real, AERN-RnToRm, base, binary, containers
     , directory, filepath, glade, glib, gtk, gtkglext, mtl, OpenGL, stm
     , time
     }:
     mkDerivation {
       pname = "AERN-RnToRm-Plot";
       version = "0.2.0.3";
       sha256 = "78e5ad50110d29ce756978236da1e8207a686a5d5c47e39eba500a0c9206f77e";
       libraryHaskellDepends = [
         AERN-Real AERN-RnToRm base binary containers directory filepath
         glade glib gtk gtkglext mtl OpenGL stm time
       ];
       jailbreak = true;
       homepage = "http://www-users.aston.ac.uk/~konecnym/DISCERN";
       description = "GL plotting of polynomial function enclosures (PFEs)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AES" = callPackage
    ({ mkDerivation, base, bytestring, cereal, monads-tf, random
     , transformers
     }:
     mkDerivation {
       pname = "AES";
       version = "0.2.9";
       sha256 = "ec73a3f6a473671104e0b450643e3de3a60706e07b876841480864791b41c48a";
       revision = "1";
       editedCabalFile = "9e51c1b1687fe35ccd0f2983e861b5b0441399803ff76b192530984724a68d6f";
       libraryHaskellDepends = [
         base bytestring cereal monads-tf random transformers
       ];
       description = "Fast AES encryption/decryption for bytestrings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "AGI" = callPackage
    ({ mkDerivation, base, mtl, network, parsec, random, syb, unix }:
     mkDerivation {
       pname = "AGI";
       version = "1.3";
       sha256 = "dbead701e7cccf1ee62687587c691488b4f104f4d799846d2cc368d9766310c0";
       libraryHaskellDepends = [
         base mtl network parsec random syb unix
       ];
       homepage = "http://src.seereason.com/haskell-agi";
       description = "A library for writing AGI scripts for Asterisk";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ALUT" = callPackage
    ({ mkDerivation, base, freealut, OpenAL, pretty, StateVar
     , transformers
     }:
     mkDerivation {
       pname = "ALUT";
       version = "2.4.0.2";
       sha256 = "b8364da380f5f1d85d13e427851a153be2809e1838d16393e37566f34b384b87";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base OpenAL StateVar transformers ];
       librarySystemDepends = [ freealut ];
       executableHaskellDepends = [ base pretty ];
       homepage = "https://github.com/haskell-openal/ALUT";
       description = "A binding for the OpenAL Utility Toolkit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) freealut;};

  "AMI" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, network
     , pureMD5, stm
     }:
     mkDerivation {
       pname = "AMI";
       version = "0.1";
       sha256 = "7ee628826bd0e62287119f1f1eb04ab2590417879a3b838e114c1536239b8603";
       libraryHaskellDepends = [
         base bytestring containers mtl network pureMD5 stm
       ];
       homepage = "http://redmine.iportnov.ru/projects/ami";
       description = "Low-level bindings for Asterisk Manager Interface (AMI)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ANum" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ANum";
       version = "0.1.1.0";
       sha256 = "099375862dda03346ebdd2005109a3d7bf849df8b3a1d637e7cc983f55f88f46";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/DanBurton/ANum#readme";
       description = "Num instance for Applicatives provided via the ANum newtype";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ASN1" = callPackage
    ({ mkDerivation, base, containers, HUnit, mtl, NewBinary, old-time
     , pretty, QuickCheck
     }:
     mkDerivation {
       pname = "ASN1";
       version = "0.0.1.1";
       sha256 = "b032dd33ca45479386d4fd77c71304a9089b7ea346b3fbaccf08928b667015a1";
       libraryHaskellDepends = [
         base containers HUnit mtl NewBinary old-time pretty QuickCheck
       ];
       homepage = "http://www.haskell.org/asn1";
       description = "ASN.1 support for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "AVar" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "AVar";
       version = "0.0.5.1";
       sha256 = "87810e38b8b5d14887dffce8d8e4ec6b12a3fcf6a5a26d7db884075dbdfcef49";
       libraryHaskellDepends = [ base ];
       description = "Mutable variables with Exception handling and concurrency support";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "AWin32Console" = callPackage
    ({ mkDerivation, base, regex-compat, Win32 }:
     mkDerivation {
       pname = "AWin32Console";
       version = "1.1";
       sha256 = "01ceae8d21da257245e0065e35f1727ac0484e5f9567506fad2924229f5d8546";
       libraryHaskellDepends = [ base regex-compat Win32 ];
       description = "A binding to a part of the ANSI escape code for the console";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AbortT-monadstf" = callPackage
    ({ mkDerivation, AbortT-transformers, base, monads-tf }:
     mkDerivation {
       pname = "AbortT-monadstf";
       version = "1.0";
       sha256 = "ced8466aae6a5fe10926a74d8acd352a1f617c9ee1adabe7c232a624f4225bc6";
       libraryHaskellDepends = [ AbortT-transformers base monads-tf ];
       homepage = "http://github.com/gcross/AbortT-transformers";
       description = "Monads-tf instances for the AbortT monad transformer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "AbortT-mtl" = callPackage
    ({ mkDerivation, AbortT-transformers, base, mtl }:
     mkDerivation {
       pname = "AbortT-mtl";
       version = "1.0.0.1";
       sha256 = "5175fa41e0e71627a4bedd3e61fe9b871a6730b065ffe6ae1952ba6f0de151f4";
       libraryHaskellDepends = [ AbortT-transformers base mtl ];
       homepage = "http://github.com/gcross/AbortT-mtl";
       description = "mtl instances for the AbortT monad transformer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "AbortT-transformers" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "AbortT-transformers";
       version = "1.0.1.2";
       sha256 = "62e9da8630493deb3b63aa5ec4c0151fd75e44b0d530eba0cb7f1f58ffb978ea";
       libraryHaskellDepends = [ base transformers ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 transformers
       ];
       homepage = "http://github.com/gcross/AbortT-transformers";
       description = "A monad and monadic transformer providing \"abort\" functionality";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ActionKid" = callPackage
    ({ mkDerivation, base, containers, gloss, gloss-juicy, hspec, lens
     , mtl, OpenGL, StateVar, template-haskell
     }:
     mkDerivation {
       pname = "ActionKid";
       version = "0.1.1.0";
       sha256 = "b87fe93a3db4540747b8d880f592f712516417eb7b9362b7957892fe287b4e37";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers gloss gloss-juicy lens mtl OpenGL StateVar
         template-haskell
       ];
       executableHaskellDepends = [
         base containers gloss gloss-juicy lens mtl OpenGL StateVar
         template-haskell
       ];
       testHaskellDepends = [ base hspec ];
       jailbreak = true;
       homepage = "https://github.com/egonSchiele/actionkid";
       description = "An easy-to-use video game framework for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Adaptive" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Adaptive";
       version = "0.23";
       sha256 = "0c5d3e880bbcd6245ccefa16d1d2cc15f7e48bd4ab50723f321883b91b6a4758";
       revision = "1";
       editedCabalFile = "36c76cf96db195ede96306358e65aec311211569c236983efb473c3e97b864b5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Library for incremental computing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Adaptive-Blaisorblade" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Adaptive-Blaisorblade";
       version = "0.23";
       sha256 = "aa6c6fac69364cd16b547cc588e9077f4567415c45c152e04fa6447f5da42b22";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       description = "Library for incremental computing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Advgame" = callPackage
    ({ mkDerivation, base, haskell98, mtl }:
     mkDerivation {
       pname = "Advgame";
       version = "0.1.2";
       sha256 = "decf583cef9bf685417c7b3ca0171a414d610ba7e768a8d41ff65f4194fff999";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskell98 mtl ];
       jailbreak = true;
       description = "Lisperati's adventure game in Lisp translated to Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AesonBson" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bson, hspec, HUnit, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "AesonBson";
       version = "0.2.2";
       sha256 = "1ae1a774ac0f43a4d945b05a7c4476a2ef92e4ddbf31c044e49c7d269719e6dc";
       libraryHaskellDepends = [
         aeson attoparsec base bson unordered-containers vector
       ];
       testHaskellDepends = [ aeson base bson hspec HUnit text ];
       jailbreak = true;
       homepage = "https://github.com/nh2/AesonBson";
       description = "Mapping between Aeson's JSON and Bson objects";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Agata" = callPackage
    ({ mkDerivation, base, containers, mtl, QuickCheck, tagged
     , template-haskell
     }:
     mkDerivation {
       pname = "Agata";
       version = "0.2.1.1";
       sha256 = "15a6418c5d570d43325431b2ddb8fa1d14788f0a479f38fd1821d9d59ef00f6d";
       libraryHaskellDepends = [
         base containers mtl QuickCheck tagged template-haskell
       ];
       jailbreak = true;
       description = "Generator-generator for QuickCheck";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Agda_2_4_2_3" = callPackage
    ({ mkDerivation, alex, array, base, binary, boxes, bytestring
     , containers, cpphs, data-hash, deepseq, directory, edit-distance
     , emacs, equivalence, filepath, geniplate-mirror, happy, hashable
     , hashtables, haskeline, haskell-src-exts, mtl, parallel, pretty
     , process, QuickCheck, strict, template-haskell, text, time
     , transformers, transformers-compat, unordered-containers, xhtml
     , zlib
     }:
     mkDerivation {
       pname = "Agda";
       version = "2.4.2.3";
       sha256 = "bc6def45e32498f51863d67acfbe048c039d630c6a36761ed27e99a5f68d7b27";
       revision = "2";
       editedCabalFile = "b5ad21731b7a6ce714d403a5edb0b53951fe61926d47f7a21e29548602c0d763";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary boxes bytestring containers data-hash deepseq
         directory edit-distance equivalence filepath geniplate-mirror
         hashable hashtables haskeline haskell-src-exts mtl parallel pretty
         process QuickCheck strict template-haskell text time transformers
         transformers-compat unordered-containers xhtml zlib
       ];
       libraryToolDepends = [ alex cpphs happy ];
       executableHaskellDepends = [ base directory filepath process ];
       executableToolDepends = [ emacs ];
       jailbreak = true;
       postInstall = ''
         $out/bin/agda -c --no-main $(find $out/share -name Primitive.agda)
         $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;
     }) {inherit (pkgs) emacs;};

  "Agda_2_4_2_4" = callPackage
    ({ mkDerivation, alex, array, base, binary, boxes, bytestring
     , containers, cpphs, data-hash, deepseq, directory, edit-distance
     , emacs, equivalence, filepath, geniplate-mirror, happy, hashable
     , hashtables, haskeline, haskell-src-exts, mtl, parallel, pretty
     , process, QuickCheck, strict, template-haskell, text, time
     , transformers, transformers-compat, unordered-containers, xhtml
     , zlib
     }:
     mkDerivation {
       pname = "Agda";
       version = "2.4.2.4";
       sha256 = "2a27989242398f7aa55919121f7a32989a4b356d91f44e86ac6c33fa040debdf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary boxes bytestring containers data-hash deepseq
         directory edit-distance equivalence filepath geniplate-mirror
         hashable hashtables haskeline haskell-src-exts mtl parallel pretty
         process QuickCheck strict template-haskell text time transformers
         transformers-compat unordered-containers xhtml zlib
       ];
       libraryToolDepends = [ alex cpphs happy ];
       executableHaskellDepends = [ base directory filepath process ];
       executableToolDepends = [ emacs ];
       jailbreak = true;
       postInstall = ''
         $out/bin/agda -c --no-main $(find $out/share -name Primitive.agda)
         $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;
     }) {inherit (pkgs) emacs;};

  "Agda" = callPackage
    ({ mkDerivation, alex, array, base, binary, boxes, bytestring
     , containers, cpphs, data-hash, deepseq, directory, edit-distance
     , emacs, equivalence, filepath, geniplate-mirror, happy, hashable
     , hashtables, haskeline, haskell-src-exts, mtl, parallel, pretty
     , process, QuickCheck, strict, template-haskell, text, time
     , transformers, transformers-compat, unordered-containers, xhtml
     , zlib
     }:
     mkDerivation {
       pname = "Agda";
       version = "2.4.2.5";
       sha256 = "959658a372d93b735d92191b372d221461026c98de4f92e56d198b576dfb67ee";
       revision = "1";
       editedCabalFile = "85d09d8a607a351be092c5e168c35b8c303b20765ceb0f01cd34956c44ba7f5a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary boxes bytestring containers data-hash deepseq
         directory edit-distance equivalence filepath geniplate-mirror
         hashable hashtables haskeline haskell-src-exts mtl parallel pretty
         process QuickCheck strict template-haskell text time transformers
         transformers-compat unordered-containers xhtml zlib
       ];
       libraryToolDepends = [ alex cpphs happy ];
       executableHaskellDepends = [ base directory filepath process ];
       executableToolDepends = [ emacs ];
       jailbreak = true;
       postInstall = ''
         $out/bin/agda -c --no-main $(find $out/share -name Primitive.agda)
         $out/bin/agda-mode compile
       '';
       homepage = "http://wiki.portal.chalmers.se/agda/";
       description = "A dependently typed functional programming language and proof assistant";
       license = "unknown";
     }) {inherit (pkgs) emacs;};

  "Agda-executable" = callPackage
    ({ mkDerivation, Agda, base }:
     mkDerivation {
       pname = "Agda-executable";
       version = "2.3.0.1";
       sha256 = "614594c414c828c87abb1913741db66447c09617d57b92e58ffe445ceffed694";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ Agda base ];
       jailbreak = true;
       homepage = "http://wiki.portal.chalmers.se/agda/";
       description = "Command-line program for type-checking and compiling Agda programs";
       license = "unknown";
     }) {};

  "AhoCorasick" = callPackage
    ({ mkDerivation, array, base, hashable, mtl, unordered-containers
     }:
     mkDerivation {
       pname = "AhoCorasick";
       version = "0.0.3";
       sha256 = "ea53fdab246fb415d9d40d5ca5e345c55f35c400658458fb85bfbd0cfba8319c";
       libraryHaskellDepends = [
         array base hashable mtl unordered-containers
       ];
       homepage = "http://github.com/lymar/AhoCorasick";
       description = "Aho-Corasick string matching algorithm";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AlgorithmW" = callPackage
    ({ mkDerivation, base, containers, mtl, pretty }:
     mkDerivation {
       pname = "AlgorithmW";
       version = "0.1.1.0";
       sha256 = "6c28821c06371d73a14a0be1378b2f6a15137ac773705ca1fd005c5838ec732b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers mtl pretty ];
       homepage = "https://github.com/mgrabmueller/AlgorithmW";
       description = "Example implementation of Algorithm W for Hindley-Milner type inference";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "AlignmentAlgorithms" = callPackage
    ({ mkDerivation, ADPfusion, base, containers, fmlist
     , FormalGrammars, GrammarProducts, PrimitiveArray, vector
     }:
     mkDerivation {
       pname = "AlignmentAlgorithms";
       version = "0.0.2.1";
       sha256 = "8d6118e9cd863cde4ac78f726d36105979ed9f463aa56a25ff4a20cfe881c99a";
       libraryHaskellDepends = [
         ADPfusion base containers fmlist FormalGrammars GrammarProducts
         PrimitiveArray vector
       ];
       homepage = "https://github.com/choener/AlignmentAlgorithms";
       description = "Collection of alignment algorithms";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Allure" = callPackage
    ({ mkDerivation, base, containers, enummapset-th, filepath
     , LambdaHack, template-haskell, text
     }:
     mkDerivation {
       pname = "Allure";
       version = "0.5.0.0";
       sha256 = "a7e3f742f15ea3efb499461fe5373e90b023c4a0d4383a888d1882c98d72b352";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers enummapset-th filepath LambdaHack template-haskell
         text
       ];
       testHaskellDepends = [
         base containers enummapset-th filepath LambdaHack template-haskell
         text
       ];
       homepage = "http://allureofthestars.com";
       description = "Near-future Sci-Fi roguelike and tactical squad game";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AndroidViewHierarchyImporter" = callPackage
    ({ mkDerivation, base, bytestring, cmdtheline, containers, mtl
     , network, opml, pretty, process, QuickCheck, split, transformers
     , xml
     }:
     mkDerivation {
       pname = "AndroidViewHierarchyImporter";
       version = "0.1.0.1";
       sha256 = "ccf7b4d128a88e37b97bfe0dbc75b66200a9f83a0f6e5bbd1b1f791c33ec55cf";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdtheline containers mtl network opml pretty
         process QuickCheck split transformers xml
       ];
       jailbreak = true;
       description = "Android view hierarchy importer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Animas" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "Animas";
       version = "0.2";
       sha256 = "75cf0cd4d5264b4653c7c8f411b9cd325949c1fe98dcea3f6008e39174e27707";
       libraryHaskellDepends = [ base random ];
       homepage = "https://github.com/eamsden/Animas";
       description = "Updated version of Yampa: a library for programming hybrid systems";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Annotations" = callPackage
    ({ mkDerivation, base, mtl, multirec, parsec }:
     mkDerivation {
       pname = "Annotations";
       version = "0.2.1";
       sha256 = "12e2c8ad03795c5bceffc8f421655097f96bcde1ff68d98dbe2bd2990f790cc7";
       libraryHaskellDepends = [ base mtl multirec parsec ];
       testHaskellDepends = [ base mtl multirec parsec ];
       description = "Constructing, analyzing and destructing annotated trees";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Ansi2Html" = callPackage
    ({ mkDerivation, base, mtl, parsec, xhtml }:
     mkDerivation {
       pname = "Ansi2Html";
       version = "0.9";
       sha256 = "302b9edfc7f28a6c7426fcb5342a7994787ceceed5ce1038b10cf0d06d0e18b7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base mtl parsec xhtml ];
       homepage = "http://janzzstimmpfle.de/~jens/software/Ansi2Html/";
       description = "Convert ANSI Terminal Sequences to nice HTML markup";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ApplePush" = callPackage
    ({ mkDerivation, base, binary, bytestring, haskell98, json, mtl
     , network
     }:
     mkDerivation {
       pname = "ApplePush";
       version = "0.1";
       sha256 = "7950ea5bd17e5282b86f71e969aa613e1d220aea97b85f8089efb913e4158537";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring haskell98 json mtl network
       ];
       executableHaskellDepends = [ base ];
       description = "Library for Apple Push Notification Service";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AppleScript" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "AppleScript";
       version = "0.2.0.1";
       sha256 = "796b0a7deaa5a6ae0f30f98f9451afa5033aea96b41df52b1d4bd7b27d8fbcca";
       libraryHaskellDepends = [ base ];
       doHaddock = false;
       homepage = "https://github.com/reinerp/haskell-AppleScript";
       description = "Call AppleScript from Haskell, and then call back into Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ApproxFun-hs" = callPackage
    ({ mkDerivation, base, vector }:
     mkDerivation {
       pname = "ApproxFun-hs";
       version = "0.1.0.0";
       sha256 = "fe621b16f2e3b81c689e43b30173fe70534747c3bfc9e514da6f151991afeae8";
       libraryHaskellDepends = [ base vector ];
       jailbreak = true;
       homepage = "https://github.com/idontgetoutmuch/ApproxFun.hs";
       description = "Function approximation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ArrayRef" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ArrayRef";
       version = "0.1.3.1";
       sha256 = "d887cfa72c15ce17f67b481ab491a30a1bce038cbcd2fb9e9d63293a760262f9";
       libraryHaskellDepends = [ base ];
       homepage = "http://haskell.org/haskellwiki/Library/ArrayRef";
       description = "Unboxed references, dynamic arrays and more";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ArrowVHDL" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "ArrowVHDL";
       version = "1.1";
       sha256 = "0b262766252398758e1a63a8ac7fb535387cd7894f294a9f5a4a0786493567d3";
       libraryHaskellDepends = [ base process ];
       jailbreak = true;
       homepage = "https://github.com/frosch03/arrowVHDL";
       description = "A library to generate Netlist code from Arrow descriptions";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AspectAG" = callPackage
    ({ mkDerivation, base, containers, HList, mtl, template-haskell }:
     mkDerivation {
       pname = "AspectAG";
       version = "0.3.6.1";
       sha256 = "0ee6c8a3807927c671d934ea55248071acd59f7db4cd01b888b16c34dca6ef06";
       revision = "1";
       editedCabalFile = "d5b68030eaf2111998f6d5774a1d26d5afb685fe6b087fe1aed7ef90084a0070";
       libraryHaskellDepends = [
         base containers HList mtl template-haskell
       ];
       jailbreak = true;
       homepage = "http://www.cs.uu.nl/wiki/bin/view/Center/AspectAG";
       description = "Attribute Grammars in the form of an EDSL";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AttoBencode" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-textual
     , bytestring, containers, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "AttoBencode";
       version = "0.3.1.0";
       sha256 = "0b26edc3dfafefcea423b8d26d33862060f0f81bd8b74eb1456f56a71589ff67";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-textual bytestring containers
       ];
       testHaskellDepends = [
         base bytestring containers QuickCheck test-framework
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://bitbucket.org/FlorianHartwig/attobencode";
       description = "Fast Bencode encoding and parsing library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "AttoJson" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, bytestring-show
     , containers, mtl, utf8-string
     }:
     mkDerivation {
       pname = "AttoJson";
       version = "0.5.10";
       sha256 = "a28514bc7b2fba26afdcf4a4ea4a843f7de45eb56fb2127e93f7743895c15b55";
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-show containers mtl
         utf8-string
       ];
       homepage = "http://github.com/konn/AttoJSON";
       description = "Simple lightweight JSON parser, generator & manipulator based on ByteString";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Attrac" = callPackage
    ({ mkDerivation, array, base, colour, GLUT, OpenGL, random }:
     mkDerivation {
       pname = "Attrac";
       version = "0.1.3";
       sha256 = "c01caee95e1618bad2c5144c51651ec41fcb27408588429349758ee1e6dbfb6a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base colour GLUT OpenGL random
       ];
       jailbreak = true;
       homepage = "http://patch-tag.com/r/rhz/StrangeAttractors";
       description = "Visualisation of Strange Attractors in 3-Dimensions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Aurochs" = callPackage
    ({ mkDerivation, base, containers, parsec, pretty }:
     mkDerivation {
       pname = "Aurochs";
       version = "0.1";
       sha256 = "c5e1f8dafbe0f08371cceac0c054e7141cb12736891f4b0c9e6f5e8a4191a158";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers parsec pretty ];
       description = "Yet another parser generator for C/C++";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AutoForms" = callPackage
    ({ mkDerivation, array, base, haskell98, mtl, syb-with-class
     , template-haskell, wx, wxcore
     }:
     mkDerivation {
       pname = "AutoForms";
       version = "0.4.2";
       sha256 = "ee9bf0cc92bad0ffc602a481ea4c831dd4c4114eab430f7743e3f0248736ad91";
       libraryHaskellDepends = [
         array base haskell98 mtl syb-with-class template-haskell wx wxcore
       ];
       homepage = "http://autoforms.sourceforge.net/";
       description = "GUI library based upon generic programming (SYB3)";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "AvlTree" = callPackage
    ({ mkDerivation, base, COrdering }:
     mkDerivation {
       pname = "AvlTree";
       version = "4.2";
       sha256 = "bd1d5cec4b4e1621a4fb857aa660882cea3062a918efed2ad09397034d41862f";
       libraryHaskellDepends = [ base COrdering ];
       description = "Balanced binary trees using the AVL algorithm";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BASIC" = callPackage
    ({ mkDerivation, base, containers, llvm, random, timeit }:
     mkDerivation {
       pname = "BASIC";
       version = "0.1.5.0";
       sha256 = "8c761f69c904851a4fb008cf9016746d3140203bb4e1ba275fbcc499403df8fa";
       libraryHaskellDepends = [ base containers llvm random timeit ];
       description = "Embedded BASIC";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BCMtools" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-lexing, cereal
     , colour, conduit, conduit-extra, data-default-class, matrices
     , optparse-applicative, resourcet, split, transformers
     , unordered-containers, vector, zlib
     }:
     mkDerivation {
       pname = "BCMtools";
       version = "0.1.1";
       sha256 = "44fb60ce4916b2d4f766e0b23d6fb4df43bff26a21c40c20a232e40ed19b2399";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal colour conduit conduit-extra
         data-default-class matrices transformers unordered-containers
         vector zlib
       ];
       executableHaskellDepends = [
         base bytestring bytestring-lexing cereal conduit conduit-extra
         data-default-class optparse-applicative resourcet split
         unordered-containers
       ];
       description = "Big Contact Map Tools";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BNFC" = callPackage
    ({ mkDerivation, alex, array, base, containers, deepseq, directory
     , doctest, filepath, happy, hspec, HUnit, mtl, pretty, process
     , QuickCheck, temporary
     }:
     mkDerivation {
       pname = "BNFC";
       version = "2.8.1";
       sha256 = "2c1bea5c034483813091eea0ea5c830fdde8fedd31b1fc021ea69823b30a5920";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base ];
       executableHaskellDepends = [
         array base containers deepseq directory filepath mtl pretty process
       ];
       executableToolDepends = [ alex happy ];
       testHaskellDepends = [
         array base containers deepseq directory doctest filepath hspec
         HUnit mtl pretty process QuickCheck temporary
       ];
       homepage = "http://bnfc.digitalgrammars.com/";
       description = "A compiler front-end generator";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BNFC-meta" = callPackage
    ({ mkDerivation, alex-meta, array, base, happy-meta
     , haskell-src-meta, syb, template-haskell
     }:
     mkDerivation {
       pname = "BNFC-meta";
       version = "0.4.0.3";
       sha256 = "c25ba825ae48d0dbfeae9cf088b2bc17ccc6f191b80359572c87b6e7a1a42e83";
       libraryHaskellDepends = [
         alex-meta array base happy-meta haskell-src-meta syb
         template-haskell
       ];
       description = "Deriving Parsers and Quasi-Quoters from BNF Grammars";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "Baggins" = callPackage
    ({ mkDerivation, base, cairo, containers, mtl }:
     mkDerivation {
       pname = "Baggins";
       version = "1.0";
       sha256 = "6c81288356d6296abd8031be0df21ad16628b76021f990ec9ebc3a8f3fc2fd55";
       revision = "1";
       editedCabalFile = "654cbc7a4109bf3baaa2491f10a7f49d1831008129d4d5ef9e0e558a5a374098";
       libraryHaskellDepends = [ base cairo containers mtl ];
       jailbreak = true;
       homepage = "http://pageperso.lif.univ-mrs.fr/~pierre-etienne.meunier/Baggins";
       description = "Tools for self-assembly";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Bang" = callPackage
    ({ mkDerivation, base, bifunctors, hmidi, mtl, stm, time
     , transformers
     }:
     mkDerivation {
       pname = "Bang";
       version = "0.1.1.1";
       sha256 = "aa544019d45ec93139e6253f2d1b812516107f6d7ba7ceeab7f14c3be3b9876f";
       libraryHaskellDepends = [
         base bifunctors hmidi mtl stm time transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/5outh/Bang/";
       description = "A Drum Machine DSL for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "Barracuda" = callPackage
    ({ mkDerivation, adhoc-network, array, base, bytestring, containers
     , Crypto, dataenc, directory, filepath, gtk, HaXml, heap, hsgnutls
     , mtl, network, old-locale, parsec, pkcs1, random, regex-compat
     , stm, time, unix, utf8-string, xml-parsec
     }:
     mkDerivation {
       pname = "Barracuda";
       version = "1.0.2";
       sha256 = "434a92c5719f64e6096576371cb761b71c03277b6ee0105fc9e5f12dc5330b45";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         adhoc-network array base bytestring containers Crypto dataenc
         directory filepath gtk HaXml heap hsgnutls mtl network old-locale
         parsec pkcs1 random regex-compat stm time unix utf8-string
         xml-parsec
       ];
       executableHaskellDepends = [
         adhoc-network array base bytestring containers Crypto dataenc
         directory filepath gtk HaXml heap hsgnutls mtl network old-locale
         parsec pkcs1 random regex-compat stm time unix utf8-string
         xml-parsec
       ];
       homepage = "http://sep07.mroot.net/";
       description = "An ad-hoc P2P chat program";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Befunge93" = callPackage
    ({ mkDerivation, array, base, mtl, random }:
     mkDerivation {
       pname = "Befunge93";
       version = "0.1";
       sha256 = "d4509dded6dedd2dc705b75001b7df04ca72c4f1508594b33f89563074b944c3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base mtl random ];
       jailbreak = true;
       homepage = "http://coder.bsimmons.name/blog/2010/05/befunge-93-interpreter-on-hackage";
       description = "An interpreter for the Befunge-93 Programming Language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BenchmarkHistory" = callPackage
    ({ mkDerivation, base, bytestring, cassava, deepseq, directory
     , statistics, time, vector
     }:
     mkDerivation {
       pname = "BenchmarkHistory";
       version = "0.0.0.2";
       sha256 = "a3ab4de30a90e70c3b8bfe28d956322312c5e14b42f94da1051c71ff0853fa3d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cassava deepseq directory statistics time vector
       ];
       homepage = "https://github.com/choener/BenchmarkHistory";
       description = "Benchmark functions with history";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "BerkeleyDB" = callPackage
    ({ mkDerivation, base, bytestring, db, extensible-exceptions }:
     mkDerivation {
       pname = "BerkeleyDB";
       version = "0.8.7";
       sha256 = "c2c4b9b5625a48b5c303127968d3b591b372fab9568d2a689fab00ddb2613860";
       libraryHaskellDepends = [ base bytestring extensible-exceptions ];
       librarySystemDepends = [ db ];
       homepage = "http://www.haskell.org/haskellwiki/BerkeleyDBXML";
       description = "Berkeley DB binding";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) db;};

  "BerkeleyDBXML" = callPackage
    ({ mkDerivation, base, BerkeleyDB, bytestring, db, dbxml, xercesc
     , xqilla
     }:
     mkDerivation {
       pname = "BerkeleyDBXML";
       version = "0.7.2";
       sha256 = "1746f7723d1b9d81f5f26d25bf17f941e790c1403656e4f08caa43127189adfa";
       libraryHaskellDepends = [ base BerkeleyDB bytestring ];
       librarySystemDepends = [ db dbxml xercesc xqilla ];
       homepage = "http://www.haskell.org/haskellwiki/BerkeleyDBXML";
       description = "Berkeley DB XML binding";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) db; dbxml = null; inherit (pkgs) xercesc; 
         xqilla = null;};

  "BerlekampAlgorithm" = callPackage
    ({ mkDerivation, base, besout }:
     mkDerivation {
       pname = "BerlekampAlgorithm";
       version = "0.1.0.0";
       sha256 = "d9d799d9a3b8bff9a953b36aa3868323e74b8708a2de29037dd7a196b2bb9293";
       libraryHaskellDepends = [ base besout ];
       jailbreak = true;
       description = "Factorization of polynomials over finite field";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "BigPixel" = callPackage
    ({ mkDerivation, array, base, bmp, bytestring, gloss }:
     mkDerivation {
       pname = "BigPixel";
       version = "1.3.0";
       sha256 = "ff65071fc26d1e66e554ec196c3da7eb5cd3fa01c399d6af133f1f23dfeadda5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base bmp bytestring gloss ];
       homepage = "https://github.com/mchakravarty/BigPixel";
       description = "Image editor for pixel art";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "Binpack" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Binpack";
       version = "0.4.1";
       sha256 = "5a75472c100b115272e011dd9c724c2d182de172784033c57d56da430f22a02a";
       libraryHaskellDepends = [ base ];
       description = "Common bin-packing heuristics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Biobase" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , directory, either-unwrap, file-embed, filemanip, filepath
     , ghc-prim, HsTools, mtl, parsec, ParsecTools, primitive
     , PrimitiveArray, split, tuple, utility-ht, vector
     , vector-read-instances, zlib
     }:
     mkDerivation {
       pname = "Biobase";
       version = "0.3.1.1";
       sha256 = "8cd5fc11c906335cb8ef5a54c9ae4a1b9d3f120f1209b3801f8c47351ca43aff";
       libraryHaskellDepends = [
         array base bytestring containers deepseq directory either-unwrap
         file-embed filemanip filepath ghc-prim HsTools mtl parsec
         ParsecTools primitive PrimitiveArray split tuple utility-ht vector
         vector-read-instances zlib
       ];
       jailbreak = true;
       homepage = "http://www.tbi.univie.ac.at/~choener/";
       description = "Base library for bioinformatics";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BiobaseBlast" = callPackage
    ({ mkDerivation, array, base, BiobaseXNA, containers }:
     mkDerivation {
       pname = "BiobaseBlast";
       version = "0.0.0.1";
       sha256 = "0ed0c769b4a7b13186519ec825639db89854721dc8d8a177af508b84bf12eedc";
       libraryHaskellDepends = [ array base BiobaseXNA containers ];
       homepage = "http://www.tbi.univie.ac.at/~choener/";
       description = "BLAST-related tools";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BiobaseDotP" = callPackage
    ({ mkDerivation, base, bytestring, iteratee }:
     mkDerivation {
       pname = "BiobaseDotP";
       version = "0.1.0.0";
       sha256 = "fc3c18d67ea993c2ca7eedfe9aa96760dff102e9bfe76e48f0741a4f051bf654";
       libraryHaskellDepends = [ base bytestring iteratee ];
       homepage = "http://www.tbi.univie.ac.at/~choener/";
       description = "Vienna / DotBracket / ExtSS parsers";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BiobaseFR3D" = callPackage
    ({ mkDerivation, base, BiobaseXNA, bytestring, containers
     , filemanip, iteratee, tuple
     }:
     mkDerivation {
       pname = "BiobaseFR3D";
       version = "0.2.3.0";
       sha256 = "903dd78d6a0f923c0cb044ef055765f43813bdb0997111012593e08756c70af9";
       libraryHaskellDepends = [
         base BiobaseXNA bytestring containers filemanip iteratee tuple
       ];
       jailbreak = true;
       homepage = "http://www.tbi.univie.ac.at/~choener/";
       description = "Importer for FR3D resources";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BiobaseFasta" = callPackage
    ({ mkDerivation, base, biocore, bytestring, cmdargs, conduit
     , containers, transformers
     }:
     mkDerivation {
       pname = "BiobaseFasta";
       version = "0.0.1.0";
       sha256 = "dc521f4d8a3a0ff7c880d72d61d45221f8ee65409c52a4e4add0d55cc3c8b70c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base biocore bytestring conduit containers transformers
       ];
       executableHaskellDepends = [ cmdargs ];
       jailbreak = true;
       homepage = "http://www.tbi.univie.ac.at/~choener/";
       description = "conduit-based FASTA parser";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BiobaseInfernal" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-conduit, base, BiobaseXNA
     , biocore, bytestring, bytestring-lexing, conduit, containers
     , either-unwrap, lens, primitive, PrimitiveArray, repa
     , transformers, tuple, vector
     }:
     mkDerivation {
       pname = "BiobaseInfernal";
       version = "0.7.1.0";
       sha256 = "5a3417356d462b64c10516fe898923373bb07bc6e1225b479b725c871546eaa5";
       libraryHaskellDepends = [
         attoparsec attoparsec-conduit base BiobaseXNA biocore bytestring
         bytestring-lexing conduit containers either-unwrap lens primitive
         PrimitiveArray repa transformers tuple vector
       ];
       jailbreak = true;
       homepage = "http://www.tbi.univie.ac.at/~choener/";
       description = "Infernal data structures and tools";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BiobaseMAF" = callPackage
    ({ mkDerivation, base, bytestring, containers, iteratee }:
     mkDerivation {
       pname = "BiobaseMAF";
       version = "0.5.0.0";
       sha256 = "3958f2a5b63e2a4cc236aac4a60ed015f7c52e5e5a267ba37c5c0c61cff29e57";
       libraryHaskellDepends = [ base bytestring containers iteratee ];
       homepage = "http://www.tbi.univie.ac.at/~choener/";
       description = "Multiple Alignment Format";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BiobaseTrainingData" = callPackage
    ({ mkDerivation, base, BiobaseDotP, BiobaseFR3D, BiobaseXNA
     , bytestring, cmdargs, either-unwrap, iteratee, vector
     }:
     mkDerivation {
       pname = "BiobaseTrainingData";
       version = "0.1.2.3";
       sha256 = "5ad85e628d5c01ca815aa7503d774bc4d47e62ab852ec24223b2ef28fc901e63";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base BiobaseDotP BiobaseFR3D BiobaseXNA bytestring either-unwrap
         iteratee vector
       ];
       executableHaskellDepends = [ cmdargs ];
       jailbreak = true;
       homepage = "http://www.tbi.univie.ac.at/~choener/";
       description = "RNA folding training data";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BiobaseTurner" = callPackage
    ({ mkDerivation, base, BiobaseXNA, bytestring, bytestring-lexing
     , conduit, containers, filepath, lens, primitive, PrimitiveArray
     , repa, split, vector
     }:
     mkDerivation {
       pname = "BiobaseTurner";
       version = "0.3.1.1";
       sha256 = "aeaff956f267d79e8e251fa7e856946bd90ae9ec05e7e0d15f2e22caadb1dec0";
       libraryHaskellDepends = [
         base BiobaseXNA bytestring bytestring-lexing conduit containers
         filepath lens primitive PrimitiveArray repa split vector
       ];
       homepage = "http://www.tbi.univie.ac.at/~choener/";
       description = "Import Turner RNA parameters";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BiobaseTypes" = callPackage
    ({ mkDerivation, aeson, base, binary, cereal, cereal-text
     , data-default, deepseq, hashable, log-domain, primitive
     , PrimitiveArray, QuickCheck, stringable, test-framework
     , test-framework-quickcheck2, test-framework-th, text, text-binary
     , vector, vector-binary-instances, vector-th-unbox
     }:
     mkDerivation {
       pname = "BiobaseTypes";
       version = "0.1.1.1";
       sha256 = "ba23d60cdb43afb26cfa74532f40b1dba2c1f216bdd3dd6dc78b540942ece1c0";
       libraryHaskellDepends = [
         aeson base binary cereal cereal-text data-default deepseq hashable
         log-domain primitive PrimitiveArray QuickCheck stringable text
         text-binary vector vector-binary-instances vector-th-unbox
       ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
         test-framework-th
       ];
       homepage = "https://github.com/choener/BiobaseTypes";
       description = "Collection of types for bioinformatics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "BiobaseVienna" = callPackage
    ({ mkDerivation, base, BiobaseTurner, BiobaseXNA, primitive
     , PrimitiveArray, vector
     }:
     mkDerivation {
       pname = "BiobaseVienna";
       version = "0.3.0.0";
       sha256 = "92071881d7c152b848e9f9a49ac50299c64e07d9302ef517479c805c3300612f";
       libraryHaskellDepends = [
         base BiobaseTurner BiobaseXNA primitive PrimitiveArray vector
       ];
       homepage = "http://www.tbi.univie.ac.at/~choener/";
       description = "Import Vienna energy parameters";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BiobaseXNA" = callPackage
    ({ mkDerivation, aeson, base, bimaps, binary, bytes, bytestring
     , cereal, cereal-vector, cmdargs, containers, csv, deepseq
     , file-embed, hashable, lens, primitive, PrimitiveArray, split
     , text, tuple, vector, vector-binary-instances, vector-th-unbox
     }:
     mkDerivation {
       pname = "BiobaseXNA";
       version = "0.9.2.1";
       sha256 = "79ad74d27a7215c8514337af1b515ba429771692a33dcd2298c39ae2c6026d09";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bimaps binary bytes bytestring cereal cereal-vector
         containers csv deepseq file-embed hashable lens primitive
         PrimitiveArray split text tuple vector vector-binary-instances
         vector-th-unbox
       ];
       executableHaskellDepends = [ base cmdargs ];
       jailbreak = true;
       homepage = "https://github.com/choener/BiobaseXNA";
       description = "Efficient RNA/DNA representations";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "BirdPP" = callPackage
    ({ mkDerivation, base, haskell98 }:
     mkDerivation {
       pname = "BirdPP";
       version = "1.1";
       sha256 = "e2eb56de2800af809517850584487d67b1a0d0bc4c90c7ff61bb9ce765b78b93";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskell98 ];
       jailbreak = true;
       description = "A preprocessor for Bird-style Literate Haskell comments with Haddock markup";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BitSyntax" = callPackage
    ({ mkDerivation, base, bytestring, QuickCheck, template-haskell }:
     mkDerivation {
       pname = "BitSyntax";
       version = "0.3.2.1";
       sha256 = "19e112bd41c6092739d5a71850ded01b2bcd0adb19ffbd8242c62e6febb68031";
       libraryHaskellDepends = [
         base bytestring QuickCheck template-haskell
       ];
       homepage = "https://github.com/joecrayne/hs-bitsyntax";
       description = "A module to aid in the (de)serialisation of binary data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Bitly" = callPackage
    ({ mkDerivation, base, HTTP, json2 }:
     mkDerivation {
       pname = "Bitly";
       version = "0.1.0";
       sha256 = "31aba41c4abbbc003b685e3110b518e1202486551d935ceec6805d63cd7bb5de";
       libraryHaskellDepends = [ base HTTP json2 ];
       homepage = "http://bitbucket.org/jetxee/hs-bitly/";
       description = "A library to access bit.ly URL shortener.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BlastHTTP_1_0_1" = callPackage
    ({ mkDerivation, base, biocore, blastxml, bytestring, conduit, HTTP
     , http-conduit, hxt, mtl, network, transformers
     }:
     mkDerivation {
       pname = "BlastHTTP";
       version = "1.0.1";
       sha256 = "d1ab05313d823e41b66e39ec2007a644b5e1b6ba18f5a5fec4aef2a53115aee3";
       revision = "2";
       editedCabalFile = "e182e8cb8b1fdcff3f5cd8ba3e46f371f98ac55a3d2738061a6ab78aba52b308";
       libraryHaskellDepends = [
         base biocore blastxml bytestring conduit HTTP http-conduit hxt mtl
         network transformers
       ];
       homepage = "https://github.com/eggzilla/BlastHTTP";
       description = "Libary to interface with the NCBI blast REST interface";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BlastHTTP" = callPackage
    ({ mkDerivation, base, biocore, biofasta, blastxml, bytestring
     , conduit, HTTP, http-conduit, hxt, mtl, network, transformers
     }:
     mkDerivation {
       pname = "BlastHTTP";
       version = "1.2.0";
       sha256 = "65a58d1e7f5731feabef05480032c674fc55d559d2d4c391cf3fb0aa9ee4166e";
       revision = "1";
       editedCabalFile = "7076650ad04d2c5945b96ec1a8d5db8ee680314d4dc4cff54f264316e7f69bba";
       libraryHaskellDepends = [
         base biocore biofasta blastxml bytestring conduit HTTP http-conduit
         hxt mtl network transformers
       ];
       homepage = "https://github.com/eggzilla/BlastHTTP";
       description = "Libary to interface with the NCBI blast REST interface";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "Blobs" = callPackage
    ({ mkDerivation, base, containers, directory, HaXml, polyparse
     , pretty, wx, wxcore
     }:
     mkDerivation {
       pname = "Blobs";
       version = "0.3";
       sha256 = "f465046e8a5342c3ee6c82f151463c4316ca59833e7ef225051d8dccf170b726";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory HaXml polyparse pretty wx wxcore
       ];
       executableHaskellDepends = [
         base containers directory HaXml polyparse pretty wx wxcore
       ];
       homepage = "http://www.cs.york.ac.uk/fp/darcs/Blobs/";
       description = "Diagram editor";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BlogLiterately_0_7_1_7" = callPackage
    ({ mkDerivation, base, blaze-html, bool-extras, bytestring, cmdargs
     , containers, data-default, directory, filepath, HaXml, haxr
     , highlighting-kate, hscolour, lens, mtl, pandoc, pandoc-citeproc
     , pandoc-types, parsec, process, split, strict, temporary
     , transformers, utf8-string
     }:
     mkDerivation {
       pname = "BlogLiterately";
       version = "0.7.1.7";
       sha256 = "20e991ae51918b5adb2431201ab6148cc8a4a1f9e3909a71aeabdb9a6bd92016";
       revision = "3";
       editedCabalFile = "04eff5dba1e60fa191970db5aa7c08f4c95dbc5f425cdea79037c5ee5823074c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html bool-extras bytestring cmdargs containers
         data-default directory filepath HaXml haxr highlighting-kate
         hscolour lens mtl pandoc pandoc-citeproc pandoc-types parsec
         process split strict temporary transformers utf8-string
       ];
       executableHaskellDepends = [ base cmdargs utf8-string ];
       jailbreak = true;
       homepage = "http://byorgey.wordpress.com/blogliterately/";
       description = "A tool for posting Haskelly articles to blogs";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BlogLiterately_0_8_1_1" = callPackage
    ({ mkDerivation, base, blaze-html, bool-extras, bytestring, cmdargs
     , containers, data-default, directory, filepath, HaXml, haxr
     , highlighting-kate, hscolour, lens, mtl, pandoc, pandoc-citeproc
     , pandoc-types, parsec, process, split, strict, temporary
     , transformers
     }:
     mkDerivation {
       pname = "BlogLiterately";
       version = "0.8.1.1";
       sha256 = "8bf6e851005f45584e7192f2becc89377f6c8c4110927b62bd4d8984ae88000b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html bool-extras bytestring cmdargs containers
         data-default directory filepath HaXml haxr highlighting-kate
         hscolour lens mtl pandoc pandoc-citeproc pandoc-types parsec
         process split strict temporary transformers
       ];
       executableHaskellDepends = [ base cmdargs ];
       jailbreak = true;
       homepage = "http://byorgey.wordpress.com/blogliterately/";
       description = "A tool for posting Haskelly articles to blogs";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BlogLiterately_0_8_1_2" = callPackage
    ({ mkDerivation, base, blaze-html, bool-extras, bytestring, cmdargs
     , containers, data-default, directory, filepath, HaXml, haxr
     , highlighting-kate, hscolour, lens, mtl, pandoc, pandoc-citeproc
     , pandoc-types, parsec, process, split, strict, temporary
     , transformers
     }:
     mkDerivation {
       pname = "BlogLiterately";
       version = "0.8.1.2";
       sha256 = "740cf96f8d9b38d20740cc44440329632f2d5508fb42d9bf52f52052c33ed672";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html bool-extras bytestring cmdargs containers
         data-default directory filepath HaXml haxr highlighting-kate
         hscolour lens mtl pandoc pandoc-citeproc pandoc-types parsec
         process split strict temporary transformers
       ];
       executableHaskellDepends = [ base cmdargs ];
       jailbreak = true;
       homepage = "http://byorgey.wordpress.com/blogliterately/";
       description = "A tool for posting Haskelly articles to blogs";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BlogLiterately_0_8_1_3" = callPackage
    ({ mkDerivation, base, blaze-html, bool-extras, bytestring, cmdargs
     , containers, data-default, directory, filepath, HaXml, haxr
     , highlighting-kate, hscolour, lens, mtl, pandoc, pandoc-citeproc
     , pandoc-types, parsec, process, split, strict, temporary
     , transformers
     }:
     mkDerivation {
       pname = "BlogLiterately";
       version = "0.8.1.3";
       sha256 = "2a8e5ade78fed2e6e23ac35869871f11b2dbdd58701f76243ab00773b7572e73";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html bool-extras bytestring cmdargs containers
         data-default directory filepath HaXml haxr highlighting-kate
         hscolour lens mtl pandoc pandoc-citeproc pandoc-types parsec
         process split strict temporary transformers
       ];
       executableHaskellDepends = [ base cmdargs ];
       jailbreak = true;
       homepage = "http://byorgey.wordpress.com/blogliterately/";
       description = "A tool for posting Haskelly articles to blogs";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BlogLiterately_0_8_1_4" = callPackage
    ({ mkDerivation, base, blaze-html, bool-extras, bytestring, cmdargs
     , containers, data-default, directory, filepath, HaXml, haxr
     , highlighting-kate, hscolour, lens, mtl, pandoc, pandoc-citeproc
     , pandoc-types, parsec, process, split, strict, temporary
     , transformers
     }:
     mkDerivation {
       pname = "BlogLiterately";
       version = "0.8.1.4";
       sha256 = "f5771035d39ae6230d694e5b9a3391d12efa4f4e776564a7a7415611c65e20a0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html bool-extras bytestring cmdargs containers
         data-default directory filepath HaXml haxr highlighting-kate
         hscolour lens mtl pandoc pandoc-citeproc pandoc-types parsec
         process split strict temporary transformers
       ];
       executableHaskellDepends = [ base cmdargs ];
       jailbreak = true;
       homepage = "http://byorgey.wordpress.com/blogliterately/";
       description = "A tool for posting Haskelly articles to blogs";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BlogLiterately" = callPackage
    ({ mkDerivation, base, blaze-html, bool-extras, bytestring, cmdargs
     , containers, data-default, directory, filepath, HaXml, haxr
     , highlighting-kate, hscolour, lens, mtl, pandoc, pandoc-citeproc
     , pandoc-types, parsec, process, split, strict, temporary
     , transformers
     }:
     mkDerivation {
       pname = "BlogLiterately";
       version = "0.8.1.5";
       sha256 = "d75dca56afba1d391cb9756e52f2d949bbfcd5defc0fcef5371589d06cb21aeb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html bool-extras bytestring cmdargs containers
         data-default directory filepath HaXml haxr highlighting-kate
         hscolour lens mtl pandoc pandoc-citeproc pandoc-types parsec
         process split strict temporary transformers
       ];
       executableHaskellDepends = [ base cmdargs ];
       homepage = "http://byorgey.wordpress.com/blogliterately/";
       description = "A tool for posting Haskelly articles to blogs";
       license = "GPL";
     }) {};

  "BlogLiterately-diagrams_0_1_4_3" = callPackage
    ({ mkDerivation, base, BlogLiterately, containers, diagrams-builder
     , diagrams-cairo, diagrams-lib, directory, filepath, pandoc, safe
     }:
     mkDerivation {
       pname = "BlogLiterately-diagrams";
       version = "0.1.4.3";
       sha256 = "5068b0b0b60038e26818e47bd7037cba4444634f256a9edfc7c46d46b5b7c55c";
       revision = "1";
       editedCabalFile = "a9b96a72609bba1d29f628c22171dfb4e49e4c2ed7a8b3f5c2caf1127dff403d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base BlogLiterately containers diagrams-builder diagrams-cairo
         diagrams-lib directory filepath pandoc safe
       ];
       executableHaskellDepends = [ base BlogLiterately ];
       jailbreak = true;
       description = "Include images in blog posts with inline diagrams code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BlogLiterately-diagrams_0_2_0_1" = callPackage
    ({ mkDerivation, base, BlogLiterately, containers, diagrams-builder
     , diagrams-lib, diagrams-rasterific, directory, filepath
     , JuicyPixels, pandoc, safe
     }:
     mkDerivation {
       pname = "BlogLiterately-diagrams";
       version = "0.2.0.1";
       sha256 = "d598b9bbb999151de1b932e75a5656f7d9e19abd43645576d450e1f784b71ca4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base BlogLiterately containers diagrams-builder diagrams-lib
         diagrams-rasterific directory filepath JuicyPixels pandoc safe
       ];
       executableHaskellDepends = [ base BlogLiterately ];
       jailbreak = true;
       description = "Include images in blog posts with inline diagrams code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BlogLiterately-diagrams" = callPackage
    ({ mkDerivation, base, BlogLiterately, containers, diagrams-builder
     , diagrams-lib, diagrams-rasterific, directory, filepath
     , JuicyPixels, pandoc, safe
     }:
     mkDerivation {
       pname = "BlogLiterately-diagrams";
       version = "0.2.0.2";
       sha256 = "9ec7f26cbbd527e1ec1005ec0aa0c3d8edde8cf11ccbde0af6b109f1b254c11a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base BlogLiterately containers diagrams-builder diagrams-lib
         diagrams-rasterific directory filepath JuicyPixels pandoc safe
       ];
       executableHaskellDepends = [ base BlogLiterately ];
       description = "Include images in blog posts with inline diagrams code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "BluePrintCSS" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "BluePrintCSS";
       version = "0.1";
       sha256 = "0cd4687114feba3ab236d08ce27107c44fa5c3da5fb6c1edd8eee9084e7cd267";
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://git.ierton.ru/?p=BluePrint.git;a=summary";
       description = "Html document layout library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Blueprint" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "Blueprint";
       version = "0.1";
       sha256 = "24c56bc4c8a51bd52b7998b89ef46e8384fdb045c0fbdaa4b925b06689af8e99";
       doHaddock = false;
       homepage = "http://github.com/gcross/Blueprint";
       description = "Preview of a new build system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Bookshelf" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, pandoc
     , pandoc-citeproc, pandoc-types, parseargs, process
     }:
     mkDerivation {
       pname = "Bookshelf";
       version = "0.6";
       sha256 = "58b10d81bafc9a0b3c865277cec76c6fa31349c44744ba9d202bf37b6f442fa8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath pandoc pandoc-citeproc
         pandoc-types parseargs
       ];
       testHaskellDepends = [ base process ];
       homepage = "http://www.cse.chalmers.se/~emax/bookshelf/Manual.shelf.html";
       description = "A simple document organizer with some wiki functionality";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Boolean" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Boolean";
       version = "0.2.3";
       sha256 = "f64d64ddd1300beab481af21b7f451f6f1d189709a994c2b4e573e78bc0155d3";
       libraryHaskellDepends = [ base ];
       description = "Generalized booleans and numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "BoundedChan" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "BoundedChan";
       version = "1.0.3.0";
       sha256 = "531ceaed7f62844c2a63a7cbfdcab332ea5eaa218e9922ca3305580438adc46d";
       libraryHaskellDepends = [ array base ];
       description = "Implementation of bounded channels";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Bravo" = callPackage
    ({ mkDerivation, base, haskell-src-exts, haskell-src-meta, mtl
     , parsec, syb, template-haskell
     }:
     mkDerivation {
       pname = "Bravo";
       version = "0.1.0.1";
       sha256 = "368624a29a7ee145b87f23592a9da8d8b4c38c61513a12ae875b9e43b320919a";
       libraryHaskellDepends = [
         base haskell-src-exts haskell-src-meta mtl parsec syb
         template-haskell
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Bravo";
       description = "Static text template generation library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "BufferedSocket" = callPackage
    ({ mkDerivation, base, bytestring, network, text }:
     mkDerivation {
       pname = "BufferedSocket";
       version = "0.2.1.0";
       sha256 = "bf521304ccbecfd8ba5aefbf76fa7abaebfa646eb9dcff330be5a284fa899c8f";
       libraryHaskellDepends = [ base bytestring network text ];
       description = "A socker wrapper that makes the IO of sockets much cleaner";
       license = stdenv.lib.licenses.mit;
     }) {};

  "Buster" = callPackage
    ({ mkDerivation, base, bytestring, conduit, data-default, errors
     , hinotify, hslogger, hspec, hspec-expectations, http-conduit
     , http-types, string-qq, temporary, transformers, unbounded-delays
     , unix, yaml
     }:
     mkDerivation {
       pname = "Buster";
       version = "0.1.1";
       sha256 = "0d775441fedfd72a36094593d49b83e4bb88759649b4b3d66b9835ac8787ec8b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring conduit data-default errors hinotify hslogger
         http-conduit http-types transformers unbounded-delays unix yaml
       ];
       testHaskellDepends = [
         base bytestring errors hslogger hspec hspec-expectations
         http-conduit http-types string-qq temporary unix yaml
       ];
       jailbreak = true;
       homepage = "http://github.com/michaelxavier/Buster";
       description = "Hits a set of urls periodically to bust caches";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CBOR" = callPackage
    ({ mkDerivation, base, binary, binary-bits, bytestring
     , data-binary-ieee754, doctest, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "CBOR";
       version = "0.1.0.1";
       sha256 = "d8f0d06e3a1dca36759e99ef9b84773ed13c525687a184e15df9a2aacba5080e";
       libraryHaskellDepends = [
         base binary binary-bits bytestring data-binary-ieee754
       ];
       testHaskellDepends = [
         base binary binary-bits bytestring data-binary-ieee754 doctest
         QuickCheck test-framework test-framework-quickcheck2
       ];
       homepage = "https://github.com/orclev/CBOR";
       description = "Encode/Decode values to/from CBOR";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CC-delcont" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "CC-delcont";
       version = "0.2";
       sha256 = "814d54bd23b7caca1ca90661f1ca9fdd727b178447fc2952a7f75f1fe40e872e";
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://code.haskell.org/~dolio/CC-delcont";
       description = "Delimited continuations and dynamically scoped variables";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CC-delcont-alt" = callPackage
    ({ mkDerivation, base, CC-delcont-cxe, CC-delcont-exc
     , CC-delcont-ref, doctest, mtl
     }:
     mkDerivation {
       pname = "CC-delcont-alt";
       version = "0.1.1.1";
       sha256 = "5bbf45fb85158e84ee7b1037299f1dda48941089221b26dfdfa1b3dad92adf68";
       libraryHaskellDepends = [
         base CC-delcont-cxe CC-delcont-exc CC-delcont-ref mtl
       ];
       testHaskellDepends = [ base doctest mtl ];
       doHaddock = false;
       description = "Three new monad transformers for multi-prompt delimited control";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CC-delcont-cxe" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "CC-delcont-cxe";
       version = "0.1.0.2";
       sha256 = "ac2864ce814662cb4ad0b0a9903046bc30489f70248e9ad5fbcea39313c5cbe8";
       libraryHaskellDepends = [ base mtl ];
       description = "A monad transformers for multi-prompt delimited control";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CC-delcont-exc" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "CC-delcont-exc";
       version = "0.1.0.0";
       sha256 = "018d87f61ca97fdcb7c70bae819b0b522d045706619c636e98a923fd1742631f";
       libraryHaskellDepends = [ base mtl ];
       description = "A monad transformers for multi-prompt delimited control";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CC-delcont-ref" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "CC-delcont-ref";
       version = "0.1.0.0";
       sha256 = "55208f27102fd232284f774288998d8859492c0e7e48e02acb34a316c7c9f23b";
       libraryHaskellDepends = [ base mtl ];
       description = "A monad transformers for multi-prompt delimited control using refercence cells";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CC-delcont-ref-tf" = callPackage
    ({ mkDerivation, base, ref-tf, transformers }:
     mkDerivation {
       pname = "CC-delcont-ref-tf";
       version = "0.1.0.2";
       sha256 = "303a1e64000a7eaa3a2583fca3814f85440897aa30fd4b2b9421b34e04e25b7d";
       libraryHaskellDepends = [ base ref-tf transformers ];
       description = "A monad transformers for multi-prompt delimited control using refercence cells";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CCA" = callPackage
    ({ mkDerivation, array, base, containers, ghc-prim, happy
     , haskell-src, syb, template-haskell
     }:
     mkDerivation {
       pname = "CCA";
       version = "0.1.5.3";
       sha256 = "5c199d7f28c4bf57947cb987eef6a408c37fcbdccbe6dd1ae1cf85a1e00efb17";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ghc-prim syb template-haskell ];
       executableHaskellDepends = [ array base containers haskell-src ];
       executableToolDepends = [ happy ];
       homepage = "not available";
       description = "preprocessor and library for Causal Commutative Arrows (CCA)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "CHXHtml" = callPackage
    ({ mkDerivation, base, bytestring, hxt-regex-xmlschema, utf8-string
     }:
     mkDerivation {
       pname = "CHXHtml";
       version = "0.2.0";
       sha256 = "38a53d06db3389403d05743b08b7a90af5f4ef7884b46b392062fc6cd9ae225f";
       libraryHaskellDepends = [
         base bytestring hxt-regex-xmlschema utf8-string
       ];
       homepage = "http://fuzzpault.com/chxhtml";
       description = "A W3C compliant (X)HTML generating library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "CLASE" = callPackage
    ({ mkDerivation, base, containers, filepath, mtl, parsec
     , template-haskell
     }:
     mkDerivation {
       pname = "CLASE";
       version = "2009.2.11";
       sha256 = "23bab76f5cc64997a2c83cc1e4d0dfe45789e828e685c131aef742dae5594a82";
       libraryHaskellDepends = [
         base containers filepath mtl parsec template-haskell
       ];
       homepage = "http://www.zonetora.co.uk/clase/";
       description = "Cursor Library for A Structured Editor";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CLI" = callPackage
    ({ mkDerivation, base, directory, doctest, split, time }:
     mkDerivation {
       pname = "CLI";
       version = "0.1.0.0";
       sha256 = "942a45623c5b904d63aeeb2ab13e37a33da67b508af1cea9c7cd76f38f0d47bc";
       libraryHaskellDepends = [ base directory split time ];
       testHaskellDepends = [ base doctest ];
       jailbreak = true;
       description = "CLI tools";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "CMCompare" = callPackage
    ({ mkDerivation, array, base, BiobaseInfernal, BiobaseXNA, cmdargs
     , containers, lens
     }:
     mkDerivation {
       pname = "CMCompare";
       version = "0.0.1.5";
       sha256 = "4bc035d82768beb9ff52b5ace7db1b1477ca35b84aea6d9f3bdd23c680f592b1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base BiobaseInfernal BiobaseXNA containers lens
       ];
       executableHaskellDepends = [ cmdargs ];
       jailbreak = true;
       homepage = "http://www.tbi.univie.ac.at/software/cmcompare/";
       description = "Infernal covariance model comparison";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CMQ" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, iproute, mtl
     , network, PSQueue, stm, time
     }:
     mkDerivation {
       pname = "CMQ";
       version = "0.0.12";
       sha256 = "eb3a500715ed9af078c9693512a928ea22ec3f466bcb43e95c4893d6245b537f";
       libraryHaskellDepends = [
         base bytestring cereal containers iproute mtl network PSQueue stm
         time
       ];
       homepage = "http://github.com/viloocity/cmq/";
       description = "cwmwl udp message queue";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "COrdering" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "COrdering";
       version = "2.3";
       sha256 = "a8b3b0082290e4f98242db57489e57f369d5b3f40efb695cc02a673f39d96ad2";
       libraryHaskellDepends = [ base ];
       description = "An algebraic data type similar to Prelude Ordering";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CPBrainfuck" = callPackage
    ({ mkDerivation, base, haskell98 }:
     mkDerivation {
       pname = "CPBrainfuck";
       version = "1.1";
       sha256 = "96f3e7d3e58553d09b6776e24b2ca35b714ff46b0e3cf3ef350f65d505a82b10";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskell98 ];
       description = "A simple Brainfuck interpretter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CPL" = callPackage
    ({ mkDerivation, array, base, containers, mtl, parsec, readline }:
     mkDerivation {
       pname = "CPL";
       version = "0.0.8";
       sha256 = "20d364f60d8250b8a0f07da0864e02815b1527ced1e52b213c5def85339e9438";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers mtl parsec readline
       ];
       description = "An interpreter of Hagino's Categorical Programming Language (CPL)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CSPM-CoreLanguage" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "CSPM-CoreLanguage";
       version = "0.3.0.3";
       sha256 = "020f9dffa5ddecd1ef37c7da70bd6c78338bf615e745c8bf9fd7d2f2dbfd266f";
       libraryHaskellDepends = [ base ];
       description = "Definition of a FDR-compatible CSP core-language";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "CSPM-FiringRules" = callPackage
    ({ mkDerivation, base, containers, CSPM-CoreLanguage, mtl
     , parallel-tree-search, QuickCheck, random, tree-monad
     }:
     mkDerivation {
       pname = "CSPM-FiringRules";
       version = "0.4.3.0";
       sha256 = "159c3536753cfeea4d2554091faf40edae8c7a241366e31491a1e00f807baf65";
       libraryHaskellDepends = [
         base containers CSPM-CoreLanguage mtl parallel-tree-search
         QuickCheck random tree-monad
       ];
       jailbreak = true;
       description = "Firing rules semantic of CSPM";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CSPM-Frontend" = callPackage
    ({ mkDerivation, alex, array, base, containers, dlist, either
     , ghc-prim, mtl, parsec2, prettyclass, syb, transformers
     }:
     mkDerivation {
       pname = "CSPM-Frontend";
       version = "0.10.0.0";
       sha256 = "e3a75f5121707e77a97ed82e603ac31d814f0d2ac0bcf9a522c0ec1d5f9aae72";
       libraryHaskellDepends = [
         array base containers dlist either ghc-prim mtl parsec2 prettyclass
         syb transformers
       ];
       libraryToolDepends = [ alex ];
       jailbreak = true;
       description = "A CSP-M parser compatible with FDR-2.91";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "CSPM-Interpreter" = callPackage
    ({ mkDerivation, array, base, containers, CSPM-CoreLanguage
     , CSPM-Frontend, mtl, prettyclass, syb
     }:
     mkDerivation {
       pname = "CSPM-Interpreter";
       version = "0.7.0.0";
       sha256 = "1683c9736c46dfa92ae21ccb1e70a1ab9f64bcb67d6fa529dbdde24fd6020e6a";
       libraryHaskellDepends = [
         array base containers CSPM-CoreLanguage CSPM-Frontend mtl
         prettyclass syb
       ];
       jailbreak = true;
       description = "An interpreter for CSPM";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "CSPM-ToProlog" = callPackage
    ({ mkDerivation, array, base, containers, CSPM-Frontend, ghc-prim
     , pretty
     }:
     mkDerivation {
       pname = "CSPM-ToProlog";
       version = "0.5.2.0";
       sha256 = "2240f0cc4e32bdab8a80af2b17af65991be9370d6eb2282a533bd5f67afbc263";
       libraryHaskellDepends = [
         array base containers CSPM-Frontend ghc-prim pretty
       ];
       jailbreak = true;
       description = "some modules specific for the ProB tool";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "CSPM-cspm" = callPackage
    ({ mkDerivation, base, cmdargs, containers, CSPM-CoreLanguage
     , CSPM-FiringRules, CSPM-Frontend, CSPM-Interpreter, CSPM-ToProlog
     , hslua, parallel, pretty, prettyclass, syb, transformers, xml
     }:
     mkDerivation {
       pname = "CSPM-cspm";
       version = "0.8.0.0";
       sha256 = "89ad60bbc824d2648e618e745dc91ac81a3943df47f1a9791f4f682a1fc20ed2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cmdargs containers CSPM-CoreLanguage CSPM-FiringRules
         CSPM-Frontend CSPM-Interpreter CSPM-ToProlog hslua parallel pretty
         prettyclass syb transformers xml
       ];
       executableHaskellDepends = [
         base cmdargs containers CSPM-CoreLanguage CSPM-FiringRules
         CSPM-Frontend CSPM-Interpreter CSPM-ToProlog hslua parallel pretty
         prettyclass syb transformers xml
       ];
       jailbreak = true;
       description = "cspm command line tool for analyzing CSPM specifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CTRex" = callPackage
    ({ mkDerivation, base, containers, hashable, mtl
     , unordered-containers
     }:
     mkDerivation {
       pname = "CTRex";
       version = "0.6";
       sha256 = "2642d566008e4e804ea7b4278cc596fa4006cd4a44419df1e23ab73dedb75132";
       libraryHaskellDepends = [
         base containers hashable mtl unordered-containers
       ];
       homepage = "http://www.haskell.org/haskellwiki/CTRex";
       description = "Open records using closed type families";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "CV" = callPackage
    ({ mkDerivation, array, base, binary, bindings-DSL, c2hs, carray
     , containers, deepseq, directory, filepath, lazysmallcheck, mtl
     , mwc-random, opencv_calib3d, opencv_contrib, opencv_core
     , opencv_features2d, opencv_flann, opencv_gpu, opencv_highgui
     , opencv_imgproc, opencv_legacy, opencv_ml, opencv_objdetect
     , opencv_video, parallel, parallel-io, primitive, QuickCheck
     , storable-complex, storable-tuple, vector
     }:
     mkDerivation {
       pname = "CV";
       version = "0.3.7";
       sha256 = "b94eb54d18624e1413f930ee6d903f5aa240783f94ca342621c7136cac044030";
       libraryHaskellDepends = [
         array base binary bindings-DSL carray containers deepseq directory
         filepath lazysmallcheck mtl mwc-random parallel parallel-io
         primitive QuickCheck storable-complex storable-tuple vector
       ];
       librarySystemDepends = [
         opencv_calib3d opencv_contrib opencv_core opencv_features2d
         opencv_flann opencv_gpu opencv_highgui opencv_imgproc opencv_legacy
         opencv_ml opencv_objdetect opencv_video
       ];
       libraryToolDepends = [ c2hs ];
       jailbreak = true;
       homepage = "http://aleator.github.com/CV/";
       description = "OpenCV based machine vision library";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {opencv_calib3d = null; opencv_contrib = null; 
         opencv_core = null; opencv_features2d = null; opencv_flann = null; 
         opencv_gpu = null; opencv_highgui = null; opencv_imgproc = null; 
         opencv_legacy = null; opencv_ml = null; opencv_objdetect = null; 
         opencv_video = null;};

  "Cabal_1_18_1_7" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , directory, extensible-exceptions, filepath, HUnit, pretty
     , process, QuickCheck, regex-posix, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time, unix
     }:
     mkDerivation {
       pname = "Cabal";
       version = "1.18.1.7";
       sha256 = "1fc2d4d5110019cee45ffb0777ad8aa33d46673a982cbe58d602d3b17e6e7282";
       libraryHaskellDepends = [
         array base bytestring containers deepseq directory filepath pretty
         process time unix
       ];
       testHaskellDepends = [
         base bytestring directory extensible-exceptions filepath HUnit
         process QuickCheck regex-posix test-framework test-framework-hunit
         test-framework-quickcheck2 unix
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/cabal/";
       description = "A framework for packaging Haskell software";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Cabal_1_20_0_4" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , directory, extensible-exceptions, filepath, HUnit, pretty
     , process, QuickCheck, regex-posix, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time, unix
     }:
     mkDerivation {
       pname = "Cabal";
       version = "1.20.0.4";
       sha256 = "fdf6d934ec74e27e4b5071f4d54932b24828017fe6777f8829ac1271a394e4e0";
       libraryHaskellDepends = [
         array base bytestring containers deepseq directory filepath pretty
         process time unix
       ];
       testHaskellDepends = [
         base bytestring directory extensible-exceptions filepath HUnit
         process QuickCheck regex-posix test-framework test-framework-hunit
         test-framework-quickcheck2 unix
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/cabal/";
       description = "A framework for packaging Haskell software";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Cabal_1_22_4_0" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , deepseq, directory, extensible-exceptions, filepath, HUnit
     , old-time, pretty, process, QuickCheck, regex-posix
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , time, unix
     }:
     mkDerivation {
       pname = "Cabal";
       version = "1.22.4.0";
       sha256 = "b96a8db268e3501ded01bdb0d178fe334274e92c1497c3249a59ef5cfc55dca6";
       libraryHaskellDepends = [
         array base binary bytestring containers deepseq directory filepath
         pretty process time unix
       ];
       testHaskellDepends = [
         base bytestring containers directory extensible-exceptions filepath
         HUnit old-time process QuickCheck regex-posix test-framework
         test-framework-hunit test-framework-quickcheck2 unix
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.haskell.org/cabal/";
       description = "A framework for packaging Haskell software";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Cabal_1_22_5_0" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , deepseq, directory, extensible-exceptions, filepath, HUnit
     , old-time, pretty, process, QuickCheck, regex-posix
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , time, unix
     }:
     mkDerivation {
       pname = "Cabal";
       version = "1.22.5.0";
       sha256 = "0e371856c4a5042954e29dee01aa29e340b35af1cc2e1996c2cc939f0150449e";
       libraryHaskellDepends = [
         array base binary bytestring containers deepseq directory filepath
         pretty process time unix
       ];
       testHaskellDepends = [
         base bytestring containers directory extensible-exceptions filepath
         HUnit old-time process QuickCheck regex-posix test-framework
         test-framework-hunit test-framework-quickcheck2 unix
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.haskell.org/cabal/";
       description = "A framework for packaging Haskell software";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Cabal_1_22_6_0" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , deepseq, directory, extensible-exceptions, filepath, HUnit
     , old-time, pretty, process, QuickCheck, regex-posix
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , time, unix
     }:
     mkDerivation {
       pname = "Cabal";
       version = "1.22.6.0";
       sha256 = "e6a58714bd33ea107b5e99c7f149b48ddd3fbfa72e6105abbab4478bcf4f2433";
       libraryHaskellDepends = [
         array base binary bytestring containers deepseq directory filepath
         pretty process time unix
       ];
       testHaskellDepends = [
         base bytestring containers directory extensible-exceptions filepath
         HUnit old-time process QuickCheck regex-posix test-framework
         test-framework-hunit test-framework-quickcheck2 unix
       ];
       doCheck = false;
       homepage = "http://www.haskell.org/cabal/";
       description = "A framework for packaging Haskell software";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Cabal_1_22_7_0" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , deepseq, directory, extensible-exceptions, filepath, HUnit
     , old-time, pretty, process, QuickCheck, regex-posix
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , time, unix
     }:
     mkDerivation {
       pname = "Cabal";
       version = "1.22.7.0";
       sha256 = "06133e049631ce0b7b84bde991d9d5de879efd53ec0291af050a416544f57b8b";
       libraryHaskellDepends = [
         array base binary bytestring containers deepseq directory filepath
         pretty process time unix
       ];
       testHaskellDepends = [
         base bytestring containers directory extensible-exceptions filepath
         HUnit old-time process QuickCheck regex-posix test-framework
         test-framework-hunit test-framework-quickcheck2 unix
       ];
       doCheck = false;
       homepage = "http://www.haskell.org/cabal/";
       description = "A framework for packaging Haskell software";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Cabal-ide-backend" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, Cabal, containers
     , deepseq, directory, extensible-exceptions, filepath, HUnit
     , old-time, pretty, process, QuickCheck, regex-posix
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , time, unix
     }:
     mkDerivation {
       pname = "Cabal-ide-backend";
       version = "1.23.0.0";
       sha256 = "fc314197d35dbf6011b57050f7ced5a854b9de58367b25b3455f9326f07c491f";
       libraryHaskellDepends = [
         array base binary bytestring containers deepseq directory filepath
         pretty process time unix
       ];
       testHaskellDepends = [
         base bytestring Cabal containers directory extensible-exceptions
         filepath HUnit old-time process QuickCheck regex-posix
         test-framework test-framework-hunit test-framework-quickcheck2 unix
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.haskell.org/cabal/";
       description = "A framework for packaging Haskell software";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "CabalSearch" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, HDBC
     , HDBC-sqlite3, process, unix
     }:
     mkDerivation {
       pname = "CabalSearch";
       version = "0.0.2";
       sha256 = "0b8149a862670b3b004f926cbbd9cf4091e05484c960171caf12fab57c1633a0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory filepath HDBC HDBC-sqlite3 process unix
       ];
       jailbreak = true;
       homepage = "http://github.com/brinchj/cabalsearch";
       description = "Search cabal packages by name";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Capabilities" = callPackage
    ({ mkDerivation, base, compdata, directory, free, unix }:
     mkDerivation {
       pname = "Capabilities";
       version = "0.1.0.0";
       sha256 = "0434c5659c3f893942159bde4bd760089e81a3942f799010d04bd5bee0f6a559";
       libraryHaskellDepends = [ base compdata directory free unix ];
       jailbreak = true;
       homepage = "https://github.com/Icelandjack/Capabilities";
       description = "Separate and contain effects of IO monad";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Cardinality" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "Cardinality";
       version = "0.2";
       sha256 = "b619bc5eee6c495bb047bdf34abfb739caba7710114013778f1a01ba0b017705";
       libraryHaskellDepends = [ base containers mtl ];
       description = "Measure container capacity. Use it to safely change container.";
       license = "LGPL";
     }) {};

  "CarneadesDSL" = callPackage
    ({ mkDerivation, base, containers, fgl, parsec }:
     mkDerivation {
       pname = "CarneadesDSL";
       version = "1.3";
       sha256 = "4321620aba2608ee2686297de0c465957ec879967398f58ba9774fedd821311b";
       libraryHaskellDepends = [ base containers fgl parsec ];
       homepage = "http://www.cs.nott.ac.uk/~bmv/CarneadesDSL/";
       description = "An implementation and DSL for the Carneades argumentation model";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "CarneadesIntoDung" = callPackage
    ({ mkDerivation, base, CarneadesDSL, cmdargs, containers, Dung, fgl
     }:
     mkDerivation {
       pname = "CarneadesIntoDung";
       version = "1.0";
       sha256 = "3d0718a11b6cb7b78864d27fb7d408fd67334e3037e6b366cec5aa8fce61b93e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base CarneadesDSL cmdargs containers Dung fgl
       ];
       homepage = "http://www.cs.nott.ac.uk/~bmv/CarneadesIntoDung/";
       description = "A translation from the Carneades argumentation model into Dung's AFs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Cartesian" = callPackage
    ({ mkDerivation, base, lens, template-haskell }:
     mkDerivation {
       pname = "Cartesian";
       version = "0.2.1.0";
       sha256 = "b9a611298eab7e2da27a300124d4522c7dae77dd1c19ad73f4b5c781dab718d6";
       libraryHaskellDepends = [ base lens template-haskell ];
       description = "Coordinate systems";
       license = stdenv.lib.licenses.mit;
     }) {};

  "Cascade" = callPackage
    ({ mkDerivation, base, comonad, ghc-prim, mtl, void }:
     mkDerivation {
       pname = "Cascade";
       version = "0.1.0.0";
       sha256 = "cf42ad930c046204753dc670a6f37da894c254d3bb17d6e29bacab2458f308c6";
       libraryHaskellDepends = [ base comonad ghc-prim mtl void ];
       jailbreak = true;
       homepage = "http://github.com/rampion/Cascade";
       description = "Playing with reified categorical composition";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Catana" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "Catana";
       version = "0.3";
       sha256 = "2ed2e8d18e3a9d58c7c4d74bffc3d1449b18c51b6989d827e0428d1bc0a1a782";
       libraryHaskellDepends = [ base mtl ];
       description = "A monad for complex manipulation of a stream";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ChannelT" = callPackage
    ({ mkDerivation, base, free, mmorph, mtl, transformers-base }:
     mkDerivation {
       pname = "ChannelT";
       version = "0.0.0.2";
       sha256 = "1ca364133211d323a743424a45677e2f61051f704e80223247b8fdc86f8aa7a0";
       libraryHaskellDepends = [ base free mmorph mtl transformers-base ];
       homepage = "https://github.com/pthariensflame/ChannelT";
       description = "Generalized stream processors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Chart_1_3_2" = callPackage
    ({ mkDerivation, array, base, colour, data-default-class, lens, mtl
     , old-locale, operational, time
     }:
     mkDerivation {
       pname = "Chart";
       version = "1.3.2";
       sha256 = "a992efc18f399612e6e4491bc10ee894fbeaf407ff351090ebcafb551b9e9d78";
       libraryHaskellDepends = [
         array base colour data-default-class lens mtl old-locale
         operational time
       ];
       jailbreak = true;
       homepage = "https://github.com/timbod7/haskell-chart/wiki";
       description = "A library for generating 2D Charts and Plots";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Chart_1_3_3" = callPackage
    ({ mkDerivation, array, base, colour, data-default-class, lens, mtl
     , old-locale, operational, time
     }:
     mkDerivation {
       pname = "Chart";
       version = "1.3.3";
       sha256 = "290044ea79c95ad43a9e0980e6d4680e2da865cd780fee969c87b00ac40018ea";
       libraryHaskellDepends = [
         array base colour data-default-class lens mtl old-locale
         operational time
       ];
       jailbreak = true;
       homepage = "https://github.com/timbod7/haskell-chart/wiki";
       description = "A library for generating 2D Charts and Plots";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Chart_1_5_1" = callPackage
    ({ mkDerivation, array, base, colour, data-default-class, lens, mtl
     , old-locale, operational, time, vector
     }:
     mkDerivation {
       pname = "Chart";
       version = "1.5.1";
       sha256 = "2f954bc60615fa0da39087e5f88e0726684b99ad9698c270cf28876545e6a14a";
       libraryHaskellDepends = [
         array base colour data-default-class lens mtl old-locale
         operational time vector
       ];
       jailbreak = true;
       homepage = "https://github.com/timbod7/haskell-chart/wiki";
       description = "A library for generating 2D Charts and Plots";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Chart_1_5_3" = callPackage
    ({ mkDerivation, array, base, colour, data-default-class, lens, mtl
     , old-locale, operational, time, vector
     }:
     mkDerivation {
       pname = "Chart";
       version = "1.5.3";
       sha256 = "85ea6abc853f497209268cc9ab06b13722a1fcfa95b59fc62cd517533ac3c55d";
       libraryHaskellDepends = [
         array base colour data-default-class lens mtl old-locale
         operational time vector
       ];
       jailbreak = true;
       homepage = "https://github.com/timbod7/haskell-chart/wiki";
       description = "A library for generating 2D Charts and Plots";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Chart" = callPackage
    ({ mkDerivation, array, base, colour, data-default-class, lens, mtl
     , old-locale, operational, time, vector
     }:
     mkDerivation {
       pname = "Chart";
       version = "1.5.4";
       sha256 = "d2c460a7c6367f5343565781a2757de7c5c6288adb14e5eed51be0d4f4a5eded";
       libraryHaskellDepends = [
         array base colour data-default-class lens mtl old-locale
         operational time vector
       ];
       homepage = "https://github.com/timbod7/haskell-chart/wiki";
       description = "A library for generating 2D Charts and Plots";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Chart-cairo_1_5_1" = callPackage
    ({ mkDerivation, array, base, cairo, Chart, colour
     , data-default-class, lens, mtl, old-locale, operational, time
     }:
     mkDerivation {
       pname = "Chart-cairo";
       version = "1.5.1";
       sha256 = "ee7ce98d27ea4f61cab2e55622fa6ccfdc3777fcd5cdc1ddbb5a7c73747d92bb";
       libraryHaskellDepends = [
         array base cairo Chart colour data-default-class lens mtl
         old-locale operational time
       ];
       jailbreak = true;
       homepage = "https://github.com/timbod7/haskell-chart/wiki";
       description = "Cairo backend for Charts";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Chart-cairo" = callPackage
    ({ mkDerivation, array, base, cairo, Chart, colour
     , data-default-class, lens, mtl, old-locale, operational, time
     }:
     mkDerivation {
       pname = "Chart-cairo";
       version = "1.5.4";
       sha256 = "f5c0fbeaedcc6680e53d6d9c76a387360be4fd23048a42122ad2dc6a17bcbc44";
       libraryHaskellDepends = [
         array base cairo Chart colour data-default-class lens mtl
         old-locale operational time
       ];
       homepage = "https://github.com/timbod7/haskell-chart/wiki";
       description = "Cairo backend for Charts";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Chart-diagrams_1_3_2" = callPackage
    ({ mkDerivation, base, blaze-svg, bytestring, Chart, colour
     , containers, data-default-class, diagrams-core, diagrams-lib
     , diagrams-postscript, diagrams-svg, lens, mtl, old-locale
     , operational, SVGFonts, text, time
     }:
     mkDerivation {
       pname = "Chart-diagrams";
       version = "1.3.2";
       sha256 = "cf78f2d6ff782855049c15601cf9fcffd292b0b7f71b6584a439f242ffdfb860";
       libraryHaskellDepends = [
         base blaze-svg bytestring Chart colour containers
         data-default-class diagrams-core diagrams-lib diagrams-postscript
         diagrams-svg lens mtl old-locale operational SVGFonts text time
       ];
       jailbreak = true;
       homepage = "https://github.com/timbod7/haskell-chart/wiki";
       description = "Diagrams backend for Charts";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Chart-diagrams_1_3_3" = callPackage
    ({ mkDerivation, base, blaze-svg, bytestring, Chart, colour
     , containers, data-default-class, diagrams-core, diagrams-lib
     , diagrams-postscript, diagrams-svg, lens, mtl, old-locale
     , operational, SVGFonts, text, time
     }:
     mkDerivation {
       pname = "Chart-diagrams";
       version = "1.3.3";
       sha256 = "a638de8f1221c6289c46fc57c8f7fb0ebc03f36e598b91654a1cecfa847774af";
       libraryHaskellDepends = [
         base blaze-svg bytestring Chart colour containers
         data-default-class diagrams-core diagrams-lib diagrams-postscript
         diagrams-svg lens mtl old-locale operational SVGFonts text time
       ];
       jailbreak = true;
       homepage = "https://github.com/timbod7/haskell-chart/wiki";
       description = "Diagrams backend for Charts";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Chart-diagrams_1_5_1" = callPackage
    ({ mkDerivation, base, blaze-markup, bytestring, Chart, colour
     , containers, data-default-class, diagrams-core, diagrams-lib
     , diagrams-postscript, diagrams-svg, lens, lucid-svg, mtl
     , old-locale, operational, SVGFonts, text, time
     }:
     mkDerivation {
       pname = "Chart-diagrams";
       version = "1.5.1";
       sha256 = "bf6315f239ed3f3fd9598cdc4482dfd8192d065c20b50b3ded32e19a6ec29aea";
       libraryHaskellDepends = [
         base blaze-markup bytestring Chart colour containers
         data-default-class diagrams-core diagrams-lib diagrams-postscript
         diagrams-svg lens lucid-svg mtl old-locale operational SVGFonts
         text time
       ];
       jailbreak = true;
       homepage = "https://github.com/timbod7/haskell-chart/wiki";
       description = "Diagrams backend for Charts";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Chart-diagrams" = callPackage
    ({ mkDerivation, base, blaze-markup, bytestring, Chart, colour
     , containers, data-default-class, diagrams-core, diagrams-lib
     , diagrams-postscript, diagrams-svg, lens, lucid-svg, mtl
     , old-locale, operational, SVGFonts, text, time
     }:
     mkDerivation {
       pname = "Chart-diagrams";
       version = "1.5.4";
       sha256 = "e2dcab357629b180bb05b905de995475a6ed5644437aba79f4bcc4ebae5f0b10";
       libraryHaskellDepends = [
         base blaze-markup bytestring Chart colour containers
         data-default-class diagrams-core diagrams-lib diagrams-postscript
         diagrams-svg lens lucid-svg mtl old-locale operational SVGFonts
         text time
       ];
       jailbreak = true;
       homepage = "https://github.com/timbod7/haskell-chart/wiki";
       description = "Diagrams backend for Charts";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Chart-gtk" = callPackage
    ({ mkDerivation, array, base, cairo, Chart, Chart-cairo, colour
     , data-default-class, gtk, mtl, old-locale, time
     }:
     mkDerivation {
       pname = "Chart-gtk";
       version = "1.5.1";
       sha256 = "9c06817715d0f336f0dc987c044fd9599204fb1e1949c11bd54f34abd7b2ba08";
       libraryHaskellDepends = [
         array base cairo Chart Chart-cairo colour data-default-class gtk
         mtl old-locale time
       ];
       homepage = "https://github.com/timbod7/haskell-chart/wiki";
       description = "Utility functions for using the chart library with GTK";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Chart-simple" = callPackage
    ({ mkDerivation, array, base, cairo, Chart, Chart-cairo, Chart-gtk
     , colour, data-default-class, gtk, mtl, old-locale, time
     }:
     mkDerivation {
       pname = "Chart-simple";
       version = "1.3.3";
       sha256 = "b9ecf141d1397d5a192dee53e6ad26c80ac0e14cf5a1c330522f324abe0c684e";
       libraryHaskellDepends = [
         array base cairo Chart Chart-cairo Chart-gtk colour
         data-default-class gtk mtl old-locale time
       ];
       jailbreak = true;
       homepage = "https://github.com/timbod7/haskell-chart/wiki";
       description = "A wrapper for the chart library to assist with basic plots (Deprecated - use the Easy module instead)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ChasingBottoms_1_3_0_8" = callPackage
    ({ mkDerivation, array, base, containers, mtl, QuickCheck, random
     , syb
     }:
     mkDerivation {
       pname = "ChasingBottoms";
       version = "1.3.0.8";
       sha256 = "bb05710630f876767d79b684fd5f3fe59ea39c63e7bef4193c7ee8132479d2b8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl QuickCheck random syb
       ];
       executableHaskellDepends = [
         array base containers mtl QuickCheck random syb
       ];
       jailbreak = true;
       description = "For testing partial and infinite values";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ChasingBottoms_1_3_0_9" = callPackage
    ({ mkDerivation, array, base, containers, mtl, QuickCheck, random
     , syb
     }:
     mkDerivation {
       pname = "ChasingBottoms";
       version = "1.3.0.9";
       sha256 = "0cdb9b9f47f9b08477e249b0f3d0d93ad63acd99610cea1bb64bc8513454dd92";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl QuickCheck random syb
       ];
       executableHaskellDepends = [
         array base containers mtl QuickCheck random syb
       ];
       jailbreak = true;
       description = "For testing partial and infinite values";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ChasingBottoms_1_3_0_11" = callPackage
    ({ mkDerivation, array, base, containers, mtl, QuickCheck, random
     , syb
     }:
     mkDerivation {
       pname = "ChasingBottoms";
       version = "1.3.0.11";
       sha256 = "9cf0c58617ed0877eab06a3a71e4dbcf911d7f2bf64bfe3c9cc91e7f3181e303";
       libraryHaskellDepends = [
         base containers mtl QuickCheck random syb
       ];
       testHaskellDepends = [
         array base containers mtl QuickCheck random syb
       ];
       jailbreak = true;
       description = "For testing partial and infinite values";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ChasingBottoms_1_3_0_12" = callPackage
    ({ mkDerivation, array, base, containers, mtl, QuickCheck, random
     , syb
     }:
     mkDerivation {
       pname = "ChasingBottoms";
       version = "1.3.0.12";
       sha256 = "690e593a73a4baef08f4477a4246ff59c30a371b1fe9b53909e1c1b97b25047d";
       libraryHaskellDepends = [
         base containers mtl QuickCheck random syb
       ];
       testHaskellDepends = [
         array base containers mtl QuickCheck random syb
       ];
       jailbreak = true;
       description = "For testing partial and infinite values";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ChasingBottoms_1_3_0_13" = callPackage
    ({ mkDerivation, array, base, containers, mtl, QuickCheck, random
     , syb
     }:
     mkDerivation {
       pname = "ChasingBottoms";
       version = "1.3.0.13";
       sha256 = "f40e250db12ab76c31e1ed78ce3d11a84f601ab2290fe946cfe437669a3468b9";
       revision = "1";
       editedCabalFile = "1d7d5dafb21bd55a1f5828af6ac380fcb6373a9e9fb55e41ef34efa984e3b5d8";
       libraryHaskellDepends = [
         base containers mtl QuickCheck random syb
       ];
       testHaskellDepends = [
         array base containers mtl QuickCheck random syb
       ];
       description = "For testing partial and infinite values";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ChasingBottoms" = callPackage
    ({ mkDerivation, array, base, containers, mtl, QuickCheck, random
     , syb
     }:
     mkDerivation {
       pname = "ChasingBottoms";
       version = "1.3.0.14";
       sha256 = "a4a296b09d8158d25ace6fdaf17a445f30e3af14f753e6bc80282806c309704a";
       libraryHaskellDepends = [
         base containers mtl QuickCheck random syb
       ];
       testHaskellDepends = [
         array base containers mtl QuickCheck random syb
       ];
       description = "For testing partial and infinite values";
       license = stdenv.lib.licenses.mit;
     }) {};

  "CheatSheet" = callPackage
    ({ mkDerivation, base, containers, directory }:
     mkDerivation {
       pname = "CheatSheet";
       version = "2.9";
       sha256 = "433ca1df4f0c49cf5831bee710388935d26dc00a4e69382993faf6dab4d686df";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers directory ];
       homepage = "http://cheatsheet.codeslower.com";
       description = "A Haskell cheat sheet in PDF and literate formats";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Checked" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "Checked";
       version = "0.0.0.2";
       sha256 = "440b4e5ad21da2100d3b2ee7a18639a74cf1fb141698688b32990e08f31023d7";
       libraryHaskellDepends = [ base text ];
       jailbreak = true;
       description = "Inbuilt checking for ultra reliable computing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Chitra" = callPackage
    ({ mkDerivation, base, binary, bytestring, mtl, network }:
     mkDerivation {
       pname = "Chitra";
       version = "0.2.2";
       sha256 = "739046befdda7d196bd915a0845b490e7476b7636ad8ccf88549ec5b7b50c661";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base binary bytestring mtl network ];
       homepage = "https://github.com/ckkashyap/Chitra";
       description = "A platform independent mechanism to render graphics using vnc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ChristmasTree" = callPackage
    ({ mkDerivation, base, containers, fgl, template-haskell, TTTAS
     , uulib
     }:
     mkDerivation {
       pname = "ChristmasTree";
       version = "0.2.1.1";
       sha256 = "c826a563744d029618bd92736ba2c93c5ffff45c4c84fd8f0893f9a86b4acff6";
       libraryHaskellDepends = [
         base containers fgl template-haskell TTTAS uulib
       ];
       jailbreak = true;
       homepage = "http://www.cs.uu.nl/wiki/bin/view/Center/TTTAS";
       description = "Alternative approach of 'read' that composes grammars instead of parsers";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CirruParser" = callPackage
    ({ mkDerivation, aeson, base, text, vector }:
     mkDerivation {
       pname = "CirruParser";
       version = "0.0.1";
       sha256 = "e98d997c6a32292c40b26b19615356759e24e5f6cc46583c295ee6af23672c84";
       libraryHaskellDepends = [ aeson base text vector ];
       homepage = "https://github.com/Cirru/parser.hs";
       description = "Cirru Parser in Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ClassLaws" = callPackage
    ({ mkDerivation, base, ChasingBottoms, mtl, QuickCheck }:
     mkDerivation {
       pname = "ClassLaws";
       version = "0.3.1.0";
       sha256 = "f3714acd50d8e99f1e112c84a82166855b1a4fbe0fbc6ffb69fd428286dde788";
       libraryHaskellDepends = [ base ChasingBottoms mtl QuickCheck ];
       jailbreak = true;
       homepage = "http://wiki.portal.chalmers.se/cse/pmwiki.php/FP/ClassLaws";
       description = "Stating and checking laws for type class methods";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ClassyPrelude" = callPackage
    ({ mkDerivation, base, strict }:
     mkDerivation {
       pname = "ClassyPrelude";
       version = "0.1";
       sha256 = "a9c6cb34c57f40ee7448be2f67c42fdb92bbcbc67fcd8ddd80321e3adacf73fb";
       libraryHaskellDepends = [ base strict ];
       description = "Prelude replacement using classes instead of concrete types where reasonable";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Clean" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "Clean";
       version = "0.6";
       sha256 = "ae006102e1a503c23a6663d647d09a272b948529dd66c8ba658b0bc84688294f";
       libraryHaskellDepends = [ base containers ];
       jailbreak = true;
       description = "A light, clean and powerful utility library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Clipboard" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Clipboard";
       version = "2.2.0.3";
       sha256 = "e3639d09e39048b03be957492a5a55877ec1ee30900102c83682f0e7ee73ec62";
       libraryHaskellDepends = [ base ];
       homepage = "http://haskell.org/haskellwiki/Clipboard";
       description = "System clipboard interface";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ClustalParser" = callPackage
    ({ mkDerivation, base, cmdargs, either-unwrap, hspec, parsec
     , vector
     }:
     mkDerivation {
       pname = "ClustalParser";
       version = "1.1.3";
       sha256 = "8bb2b5eae83841d9474bf967f5832daf9ae9b3c50729d1449daec2c56bf774f5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base parsec vector ];
       executableHaskellDepends = [ base cmdargs either-unwrap ];
       testHaskellDepends = [ base hspec parsec ];
       description = "Libary for parsing Clustal tools output";
       license = "GPL";
     }) {};

  "Coadjute" = callPackage
    ({ mkDerivation, array, base, bytestring, bytestring-csv
     , containers, directory, fgl, filepath, mtl, old-time, pretty
     , pureMD5, safe, utf8-string
     }:
     mkDerivation {
       pname = "Coadjute";
       version = "0.1.1";
       sha256 = "632570c477dcde7d6ea6a466baeff36ec9d5f212d20e268a708e8d341bd22bb3";
       libraryHaskellDepends = [
         array base bytestring bytestring-csv containers directory fgl
         filepath mtl old-time pretty pureMD5 safe utf8-string
       ];
       jailbreak = true;
       homepage = "http://iki.fi/matti.niemenmaa/coadjute/";
       description = "A generic build tool";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Codec-Compression-LZF" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Codec-Compression-LZF";
       version = "0.2";
       sha256 = "56f345f997646634ff047836eb52470cd3bcc9334423395903468b61948a424a";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.cs.helsinki.fi/u/ekarttun/Codec-Compression-LZF/";
       description = "LZF compression bindings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Codec-Image-DevIL" = callPackage
    ({ mkDerivation, array, base, libdevil }:
     mkDerivation {
       pname = "Codec-Image-DevIL";
       version = "0.2.3";
       sha256 = "5fe78aa154e4cb5f7dd4ff2b01fcbed8fdf1fdd749da21ce72700197b48563cf";
       libraryHaskellDepends = [ array base ];
       librarySystemDepends = [ libdevil ];
       description = "An FFI interface to the DevIL library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libdevil;};

  "Combinatorrent" = callPackage
    ({ mkDerivation, array, attoparsec, base, bytestring, cereal
     , containers, deepseq, directory, filepath, hopenssl, hslogger
     , HTTP, HUnit, mtl, network, network-bytestring, parsec, pretty
     , PSQueue, QuickCheck, random, random-shuffle, stm, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time
     }:
     mkDerivation {
       pname = "Combinatorrent";
       version = "0.3.2";
       sha256 = "2aaf1c168aca3f2b1107f4416ecf9783d4f70dca12ce319403ac4cdfb5bfa537";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array attoparsec base bytestring cereal containers deepseq
         directory filepath hopenssl hslogger HTTP HUnit mtl network
         network-bytestring parsec pretty PSQueue QuickCheck random
         random-shuffle stm test-framework test-framework-hunit
         test-framework-quickcheck2 time
       ];
       description = "A concurrent bittorrent client";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Command" = callPackage
    ({ mkDerivation, base, directory, process }:
     mkDerivation {
       pname = "Command";
       version = "0.0.7";
       sha256 = "6d6c511905ac5a64b8a747b8ca88dd41b714f63b2bc697c167a20636e5e66d10";
       libraryHaskellDepends = [ base directory process ];
       homepage = "https://github.com/tonymorris/command";
       description = "A replacement for System.Exit and System.Process";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Commando" = callPackage
    ({ mkDerivation, base, data-default, fsnotify, optparse-applicative
     , process, system-fileio, system-filepath, text
     }:
     mkDerivation {
       pname = "Commando";
       version = "1.0.0.4";
       sha256 = "52732efb2c3ee1c9485674ad9f3fdc98a9c0727ff68feb82b3131999a4ead7f1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base data-default fsnotify optparse-applicative process
         system-fileio system-filepath text
       ];
       executableHaskellDepends = [
         base data-default fsnotify optparse-applicative process
         system-fileio system-filepath text
       ];
       jailbreak = true;
       homepage = "https://github.com/sordina/Commando";
       description = "Watch some files; Rerun a command";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ComonadSheet" = callPackage
    ({ mkDerivation, applicative-numbers, base, comonad, containers
     , distributive, IndexedList, NestedFunctor, PeanoWitnesses, Stream
     , Tape, transformers
     }:
     mkDerivation {
       pname = "ComonadSheet";
       version = "0.3.0.0";
       sha256 = "ff18bb7e2bfa7b1413f7342ace25f814e2da4c962ef1f72c0ab349587d61fdca";
       libraryHaskellDepends = [
         applicative-numbers base comonad containers distributive
         IndexedList NestedFunctor PeanoWitnesses Stream Tape transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/kwf/ComonadSheet";
       description = "A library for expressing spreadsheet-like computations as the fixed-points of comonads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ConcurrentUtils" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , crypto-random, cryptohash, network, parallel, process
     , reexport-crypto-random, RSA, securemem, tagged
     }:
     mkDerivation {
       pname = "ConcurrentUtils";
       version = "0.4.2.0";
       sha256 = "e4f784b7e1ee2d47049029e402242b37ff3fcdfd47ed7c2f60fcb368b344bcaf";
       libraryHaskellDepends = [
         array base binary bytestring containers crypto-random cryptohash
         network parallel process reexport-crypto-random RSA securemem
         tagged
       ];
       homepage = "http://alkalisoftware.net";
       description = "Concurrent utilities";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Concurrential" = callPackage
    ({ mkDerivation, async, base }:
     mkDerivation {
       pname = "Concurrential";
       version = "0.5.0.1";
       sha256 = "addb2abcf81ad9619d42e2f25e5866f7e998f29527409e40c7954078cc9fd676";
       libraryHaskellDepends = [ async base ];
       jailbreak = true;
       homepage = "http://github.com/avieth/Concurrential";
       description = "Mix concurrent and sequential computation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Condor" = callPackage
    ({ mkDerivation, base, binary, Cabal, containers, directory
     , filepath, glider-nlp, HUnit, text
     }:
     mkDerivation {
       pname = "Condor";
       version = "0.3";
       sha256 = "b7c09b9879f9d217ec3ab7777f8ffa9e6987f9b8e31ec0b6ab0006e665a52e6f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base binary containers glider-nlp text ];
       executableHaskellDepends = [
         base binary containers directory filepath glider-nlp text
       ];
       testHaskellDepends = [
         base binary Cabal containers glider-nlp HUnit text
       ];
       jailbreak = true;
       homepage = "https://github.com/klangner/Condor";
       description = "Information retrieval library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ConfigFile" = callPackage
    ({ mkDerivation, base, containers, MissingH, mtl, parsec }:
     mkDerivation {
       pname = "ConfigFile";
       version = "1.1.4";
       sha256 = "ae087b359ff2945a62b671449227e0a811d143ee651179f4e7e9c66548e0f514";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers MissingH mtl parsec ];
       homepage = "http://software.complete.org/configfile";
       description = "Configuration file reading & writing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ConfigFileTH" = callPackage
    ({ mkDerivation, base, ConfigFile, parsec, template-haskell }:
     mkDerivation {
       pname = "ConfigFileTH";
       version = "0.2";
       sha256 = "30c94c801d42ee4dd08e4b535b7f041f4a25cf7198aab69963e00b6af3dc898c";
       libraryHaskellDepends = [
         base ConfigFile parsec template-haskell
       ];
       description = "Template haskell for reading ConfigFiles";
       license = "LGPL";
     }) {};

  "Configger" = callPackage
    ({ mkDerivation, base, Dangerous, MissingH, mtl, parsec }:
     mkDerivation {
       pname = "Configger";
       version = "0.1";
       sha256 = "e245afe5009f1e2cf2d09957a233ed535d0cbc71c4733325e199c0a58a09673a";
       libraryHaskellDepends = [ base Dangerous MissingH mtl parsec ];
       description = "Parse config files";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Configurable" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Configurable";
       version = "0.1.0.0";
       sha256 = "4b277ee5ddb5a9d0c6b0a8323d5b802b363a85ebcf04b88394ff58679c83c0c5";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/tel/Configurable";
       description = "Declare types as Configurable then specialize them all in one place";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ConsStream" = callPackage
    ({ mkDerivation, base, Stream }:
     mkDerivation {
       pname = "ConsStream";
       version = "0.1";
       sha256 = "ffcada64d509a57932b31d26c83e979ec8b1382bd5952819f19508cc85cc90fb";
       libraryHaskellDepends = [ base Stream ];
       homepage = "github";
       description = "Trivial re-export of Wouter Swierstra's Stream package, avoiding module name clash";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Conscript" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "Conscript";
       version = "0.1.0.0";
       sha256 = "56204f9cc54702517641d826a20bdea79e89903a98d70908b1e9ba6d251f3f42";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base process ];
       jailbreak = true;
       homepage = "https://github.com/sordina/Conscript";
       description = "Restart a command on STDIN activity";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ConstraintKinds" = callPackage
    ({ mkDerivation, base, dlist, ghc-prim, vector }:
     mkDerivation {
       pname = "ConstraintKinds";
       version = "1.3.0";
       sha256 = "eab751ffb0274e79830003bf1ce453e29c493c7e9a5d64a5cf0d963d302f1e66";
       libraryHaskellDepends = [ base dlist ghc-prim vector ];
       jailbreak = true;
       description = "Repackages standard type classes with the ConstraintKinds extension";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Consumer" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "Consumer";
       version = "1.2";
       sha256 = "d1c42e4ae255c574cde528720b7ca66de682f437abb703013a3011b8cba80a0e";
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://src.seereason.com/ghc6103/haskell-consumer";
       description = "A monad and monad transformer for consuming streams";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ContArrow" = callPackage
    ({ mkDerivation, arrows, base }:
     mkDerivation {
       pname = "ContArrow";
       version = "0.0.5";
       sha256 = "2b481952047a77ce6a30a6154b5fb74e2c4714f38be910562fd1a0293a4752dd";
       libraryHaskellDepends = [ arrows base ];
       jailbreak = true;
       description = "Control.Arrow.Transformer.Cont";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ContextAlgebra" = callPackage
    ({ mkDerivation, base, containers, lattices, multiset }:
     mkDerivation {
       pname = "ContextAlgebra";
       version = "0.2.0.1";
       sha256 = "5b2e0503f9bb506a2aa5e160a49b598de7aeea34c187f3550ab5dbc5967d14d1";
       libraryHaskellDepends = [ base containers lattices multiset ];
       jailbreak = true;
       description = "Context Algebra";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Contract" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "Contract";
       version = "0.1";
       sha256 = "10ae2cbd387c044102b9f60b832230367ab85bced6b6186b3364ba2c47d9ed08";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://www.cs.kent.ac.uk/~oc/contracts.html";
       description = "Practical typed lazy contracts";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Control-Engine" = callPackage
    ({ mkDerivation, base, BoundedChan, stm }:
     mkDerivation {
       pname = "Control-Engine";
       version = "1.1.0.1";
       sha256 = "ca1989c170bc3417d987d4d2aba66b4bd8645fac2e3fa9e860112999bb20d2cb";
       libraryHaskellDepends = [ base BoundedChan stm ];
       homepage = "http://www.haskell.org/haskellwiki/Control-Engine";
       description = "A parallel producer/consumer engine (thread pool)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Control-Monad-MultiPass" = callPackage
    ({ mkDerivation, array, base, containers, Control-Monad-ST2, mtl
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "Control-Monad-MultiPass";
       version = "0.1.0.0";
       sha256 = "1178b77d04539e9b94c5bfdfef4944e6068f97788afee7003085b7b483f5aa5d";
       libraryHaskellDepends = [
         array base containers Control-Monad-ST2 mtl
       ];
       testHaskellDepends = [
         array base containers Control-Monad-ST2 mtl QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/kevinbackhouse/Control-Monad-MultiPass";
       description = "A Library for Writing Multi-Pass Algorithms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Control-Monad-ST2" = callPackage
    ({ mkDerivation, array, base, mtl, QuickCheck, SafeSemaphore
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "Control-Monad-ST2";
       version = "0.1.0.1";
       sha256 = "f3032f84e4b88622495a0d4889cc22b2e8c5684dd632b54b7f62d2035723d40a";
       libraryHaskellDepends = [ array base QuickCheck SafeSemaphore ];
       testHaskellDepends = [
         array base mtl QuickCheck SafeSemaphore test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/kevinbackhouse/Control-Monad-ST2";
       description = "A variation on the ST monad with two type parameters";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CoreDump" = callPackage
    ({ mkDerivation, base, ghc, pretty, pretty-show }:
     mkDerivation {
       pname = "CoreDump";
       version = "0.1.2.0";
       sha256 = "240a9a03ba1643cd48a3eaab22825d0ab88931c9da0022d165fab30e23e4e0e4";
       libraryHaskellDepends = [ base ghc pretty pretty-show ];
       description = "A GHC plugin for printing GHC's internal Core data structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "CoreErlang" = callPackage
    ({ mkDerivation, base, parsec, pretty }:
     mkDerivation {
       pname = "CoreErlang";
       version = "0.0.3";
       sha256 = "cc0eb5184c11d7bda4352a80ceadbe1761d94b85cef692535d43397bb9082084";
       libraryHaskellDepends = [ base parsec pretty ];
       homepage = "http://github.com/amtal/CoreErlang";
       description = "Manipulating Core Erlang source code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "CoreFoundation" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, containers, deepseq
     , filepath, network, property-list, tagged, text, time
     , transformers, vector
     }:
     mkDerivation {
       pname = "CoreFoundation";
       version = "0.1";
       sha256 = "b400230767509f876673a6c0abd808d1d068d430b1149a028bee01cab5122a57";
       libraryHaskellDepends = [
         base bytestring containers deepseq filepath network property-list
         tagged text time transformers vector
       ];
       libraryToolDepends = [ c2hs ];
       jailbreak = true;
       homepage = "https://github.com/reinerp/CoreFoundation";
       description = "Bindings to Mac OSX's CoreFoundation framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Coroutine" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Coroutine";
       version = "0.1.0.0";
       sha256 = "dc869b986666a907b65d33ba9ed5a551fcf1d11ee710e21c73d5b41d8f4c4db1";
       libraryHaskellDepends = [ base ];
       description = "Type-safe coroutines using lightweight session types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "CouchDB" = callPackage
    ({ mkDerivation, base, bytestring, containers, HTTP, HUnit, json
     , mtl, network, network-uri, utf8-string
     }:
     mkDerivation {
       pname = "CouchDB";
       version = "1.2.2";
       sha256 = "e8078c9a378eb2ba85c245c766facfb55a86b71042f4bf8656a464eb33bfbf46";
       libraryHaskellDepends = [
         base bytestring containers HTTP json mtl network network-uri
         utf8-string
       ];
       testHaskellDepends = [
         base bytestring containers HTTP HUnit json mtl network network-uri
         utf8-string
       ];
       homepage = "http://github.com/hsenag/haskell-couchdb/";
       description = "CouchDB interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Craft3e" = callPackage
    ({ mkDerivation, base, HUnit, mtl, old-locale, QuickCheck, time }:
     mkDerivation {
       pname = "Craft3e";
       version = "0.1.0.10";
       sha256 = "b7909eeb97361ab1623d4a824c6cfc6b416b7c956d6a9fa3d74dda90f9943ae3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base HUnit mtl old-locale QuickCheck time
       ];
       doHaddock = false;
       jailbreak = true;
       homepage = "http://www.haskellcraft.com/";
       description = "Code for Haskell: the Craft of Functional Programming, 3rd ed";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Crypto" = callPackage
    ({ mkDerivation, array, base, HUnit, pretty, QuickCheck, random }:
     mkDerivation {
       pname = "Crypto";
       version = "4.2.5.1";
       sha256 = "6ad5e0533d0aaaf2f30049d166881a845cc190780798661815da9b4914a0af66";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base HUnit pretty QuickCheck random
       ];
       description = "Collects together existing Haskell cryptographic functions into a package";
       license = "unknown";
     }) {};

  "CurryDB" = callPackage
    ({ mkDerivation, array, async, attoparsec, attoparsec-conduit, base
     , binary, blaze-builder, blaze-textual, bytestring, conduit
     , containers, data-default, directory, doctest, fast-logger
     , filepath, hashable, hspec, lens, lifted-base, monad-control
     , monad-logger, mtl, network, network-conduit, optparse-applicative
     , stm, system-fileio, system-filepath, template-haskell, text, time
     , transformers, transformers-base, unordered-containers
     }:
     mkDerivation {
       pname = "CurryDB";
       version = "0.1.1.0";
       sha256 = "830e1c84b7bed4d09f7a896c0a7870f3d54ae41d7839b8dac2fc0cc7ebea4fd6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array async attoparsec attoparsec-conduit base binary blaze-builder
         blaze-textual bytestring conduit containers data-default
         fast-logger hashable lens lifted-base monad-control monad-logger
         mtl network network-conduit stm system-fileio system-filepath
         template-haskell text time transformers transformers-base
         unordered-containers
       ];
       executableHaskellDepends = [
         base network-conduit optparse-applicative system-filepath
       ];
       testHaskellDepends = [
         base conduit directory doctest filepath hspec lifted-base mtl stm
       ];
       description = "CurryDB: In-memory Key/Value Database";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DAG-Tournament" = callPackage
    ({ mkDerivation, base, cairo, containers, directory, filepath, gtk
     , mtl, time
     }:
     mkDerivation {
       pname = "DAG-Tournament";
       version = "0.1";
       sha256 = "933a2b5a1639fcc18061d18ccc36adef4f4b8db1ff68a63adb92c66ff230d9fb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cairo containers directory filepath gtk mtl time
       ];
       description = "Real-Time Game Tournament Evaluator";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DAV_1_0_3" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, containers
     , data-default, either, errors, exceptions, http-client
     , http-client-tls, http-types, lens, mtl, network, network-uri
     , optparse-applicative, transformers, transformers-base
     , utf8-string, xml-conduit, xml-hamlet
     }:
     mkDerivation {
       pname = "DAV";
       version = "1.0.3";
       sha256 = "cd2b2666cde0b9b33918dc3044432f5cd6500e44aadec049fc5969325b1e3af3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring case-insensitive containers data-default either
         errors exceptions http-client http-client-tls http-types lens mtl
         transformers transformers-base utf8-string xml-conduit xml-hamlet
       ];
       executableHaskellDepends = [
         base bytestring case-insensitive containers data-default either
         errors exceptions http-client http-client-tls http-types lens mtl
         network network-uri optparse-applicative transformers
         transformers-base utf8-string xml-conduit xml-hamlet
       ];
       jailbreak = true;
       homepage = "http://floss.scru.org/hDAV";
       description = "RFC 4918 WebDAV support";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DAV_1_0_5" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, containers
     , data-default, either, errors, exceptions, http-client
     , http-client-tls, http-types, lens, mtl, network, network-uri
     , optparse-applicative, transformers, transformers-base
     , utf8-string, xml-conduit, xml-hamlet
     }:
     mkDerivation {
       pname = "DAV";
       version = "1.0.5";
       sha256 = "41ac346a0850c6099ca483179d9e25ced2275c7c17da810b99ae1d0967decb4d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring case-insensitive containers data-default either
         errors exceptions http-client http-client-tls http-types lens mtl
         transformers transformers-base utf8-string xml-conduit xml-hamlet
       ];
       executableHaskellDepends = [
         base bytestring case-insensitive containers data-default either
         errors exceptions http-client http-client-tls http-types lens mtl
         network network-uri optparse-applicative transformers
         transformers-base utf8-string xml-conduit xml-hamlet
       ];
       jailbreak = true;
       homepage = "http://floss.scru.org/hDAV";
       description = "RFC 4918 WebDAV support";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DAV_1_0_7" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, containers
     , data-default, either, exceptions, http-client, http-client-tls
     , http-types, lens, mtl, network, network-uri, optparse-applicative
     , transformers, transformers-base, utf8-string, xml-conduit
     , xml-hamlet
     }:
     mkDerivation {
       pname = "DAV";
       version = "1.0.7";
       sha256 = "a8a9000b544e872296c8597edd9df10d10ceaa097f981d98bd315c1dfb637c2e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring case-insensitive containers data-default either
         exceptions http-client http-client-tls http-types lens mtl
         transformers transformers-base utf8-string xml-conduit xml-hamlet
       ];
       executableHaskellDepends = [
         base bytestring case-insensitive containers data-default either
         exceptions http-client http-client-tls http-types lens mtl network
         network-uri optparse-applicative transformers transformers-base
         utf8-string xml-conduit xml-hamlet
       ];
       homepage = "http://floss.scru.org/hDAV";
       description = "RFC 4918 WebDAV support";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DAV" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, containers
     , data-default, exceptions, http-client, http-client-tls
     , http-types, lens, mtl, mtl-compat, network, network-uri
     , optparse-applicative, transformers, transformers-base
     , transformers-compat, utf8-string, xml-conduit, xml-hamlet
     }:
     mkDerivation {
       pname = "DAV";
       version = "1.2";
       sha256 = "1a07c8ef17cd4207c6f889e7eb5c45d9f025374f2cdacc1e34e6d71fe103b746";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring case-insensitive containers data-default exceptions
         http-client http-client-tls http-types lens mtl mtl-compat
         transformers transformers-base transformers-compat utf8-string
         xml-conduit xml-hamlet
       ];
       executableHaskellDepends = [
         base bytestring case-insensitive containers data-default exceptions
         http-client http-client-tls http-types lens mtl mtl-compat network
         network-uri optparse-applicative transformers transformers-base
         transformers-compat utf8-string xml-conduit xml-hamlet
       ];
       homepage = "http://floss.scru.org/hDAV";
       description = "RFC 4918 WebDAV support";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "DBlimited" = callPackage
    ({ mkDerivation, base, containers, parsec }:
     mkDerivation {
       pname = "DBlimited";
       version = "0.1.1";
       sha256 = "4ed0dd1aecf80c7efcf63b7c8b2ab174820162177e8a99d36bd1041c68152cd2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers parsec ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/DBlimited/";
       description = "A command-line SQL interface for flat files (tdf,csv,etc.)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "DBus" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "DBus";
       version = "0.5.1";
       sha256 = "909a25492523179b1e08eeebb39bb21bc6e98868369f5af6941a7140bc174150";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "https://github.com/alexkay/hdbus";
       description = "D-Bus bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DCFL" = callPackage
    ({ mkDerivation, base, deepseq, HUnit, parallel, random }:
     mkDerivation {
       pname = "DCFL";
       version = "0.1.6.0";
       sha256 = "5d9ab448a88229f9534efd7f87c9d61c8595b511e4efbcf7ae390d0ffc60c081";
       libraryHaskellDepends = [ base deepseq HUnit parallel random ];
       homepage = "https://github.com/Poincare/DCFL";
       description = "Communication Free Learning-based constraint solver";
       license = stdenv.lib.licenses.mit;
     }) {};

  "DMuCheck" = callPackage
    ({ mkDerivation, base, binary, directory, distributed-process
     , distributed-process-simplelocalnet, hint, MuCheck
     , network-transport-tcp, unix
     }:
     mkDerivation {
       pname = "DMuCheck";
       version = "0.3.0.2";
       sha256 = "4d0d343eedc2660f2e1f722acccca80e5fdbf993a5049d372d48350b819fb001";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary directory distributed-process
         distributed-process-simplelocalnet hint MuCheck
         network-transport-tcp unix
       ];
       jailbreak = true;
       homepage = "https://bitbucket.com/osu-testing/d-mucheck";
       description = "Distributed Mutation Analysis framework for MuCheck";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "DOM" = callPackage
    ({ mkDerivation, base, mtl, WebBits }:
     mkDerivation {
       pname = "DOM";
       version = "2.0.1";
       sha256 = "4bf0d678279b7e0012aea7d9bf9766a219de7f1c488ee85e01ba78749e24f28f";
       libraryHaskellDepends = [ base mtl WebBits ];
       jailbreak = true;
       description = "DOM Level 2 bindings for the WebBits package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DP" = callPackage
    ({ mkDerivation, array, base, containers, list-tries, mtl
     , QuickCheck, safe, semiring
     }:
     mkDerivation {
       pname = "DP";
       version = "0.1.1";
       sha256 = "1f41cdf3fb0751b84f1ca76ea335342aa7b62c8f13bc018202ae0a65ffe4f20d";
       libraryHaskellDepends = [
         array base containers list-tries mtl QuickCheck safe semiring
       ];
       jailbreak = true;
       homepage = "http://github.com/srush/SemiRings/tree/master";
       description = "Pragmatic framework for dynamic programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DPM" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers
     , convertible, darcs, directory, filepath, happy, HSH, HTF, HTTP
     , mtl, network, old-locale, pretty, process, regex-posix, split
     , syb, time, unix
     }:
     mkDerivation {
       pname = "DPM";
       version = "0.3.0.0";
       sha256 = "4cce2e06d4a04458f491ab09f57185e49d10caee0c1cc43486cad98893162e0f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers convertible darcs directory
         filepath HSH HTF HTTP mtl network old-locale pretty process
         regex-posix split syb time unix
       ];
       libraryToolDepends = [ alex happy ];
       executableHaskellDepends = [ array base bytestring HTF ];
       jailbreak = true;
       description = "Darcs Patch Manager";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DRBG_0_5_4" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, cipher-aes128
     , crypto-api, crypto-api-tests, cryptohash-cryptoapi, entropy
     , HUnit, mtl, parallel, prettyclass, QuickCheck, tagged
     , test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "DRBG";
       version = "0.5.4";
       sha256 = "bd617d0b0458acb810f20343d56ca88a0fc50c12c169a5895e6648356566d30e";
       revision = "1";
       editedCabalFile = "c331573809a538f82a7ba965c9d800c46f6e4518d6192f081432aec41fa66cc1";
       libraryHaskellDepends = [
         base bytestring cereal cipher-aes128 crypto-api
         cryptohash-cryptoapi entropy mtl parallel prettyclass tagged
       ];
       testHaskellDepends = [
         base binary bytestring cereal cipher-aes128 crypto-api
         crypto-api-tests cryptohash-cryptoapi entropy HUnit mtl parallel
         prettyclass QuickCheck tagged test-framework test-framework-hunit
       ];
       jailbreak = true;
       doCheck = false;
       description = "Deterministic random bit generator (aka RNG, PRNG) based HMACs, Hashes, and Ciphers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DRBG" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, cipher-aes128
     , crypto-api, crypto-api-tests, cryptohash-cryptoapi, entropy
     , HUnit, mtl, parallel, prettyclass, QuickCheck, tagged
     , test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "DRBG";
       version = "0.5.5";
       sha256 = "21df3202486cc83c7cc3f867cb139eac9a3f69bd91b5f6b016ae026e03c33bfd";
       libraryHaskellDepends = [
         base bytestring cereal cipher-aes128 crypto-api
         cryptohash-cryptoapi entropy mtl parallel prettyclass tagged
       ];
       testHaskellDepends = [
         base binary bytestring cereal cipher-aes128 crypto-api
         crypto-api-tests cryptohash-cryptoapi entropy HUnit mtl parallel
         prettyclass QuickCheck tagged test-framework test-framework-hunit
       ];
       doCheck = false;
       description = "Deterministic random bit generator (aka RNG, PRNG) based HMACs, Hashes, and Ciphers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "DSA" = callPackage
    ({ mkDerivation, base, binary, bytestring, crypto-api
     , crypto-pubkey-types, DRBG, ghc-prim, HUnit, integer-gmp
     , QuickCheck, SHA, tagged, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "DSA";
       version = "1.0.1";
       sha256 = "cd5fb8bc019734caca4d1351bdc360c8947fc180646be43ee4888c25b9530101";
       libraryHaskellDepends = [
         base binary bytestring crypto-api crypto-pubkey-types ghc-prim
         integer-gmp SHA tagged
       ];
       testHaskellDepends = [
         base binary bytestring crypto-api crypto-pubkey-types DRBG ghc-prim
         HUnit integer-gmp QuickCheck SHA tagged test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       description = "Implementation of DSA, based on the description of FIPS 186-4";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "DSH" = callPackage
    ({ mkDerivation, aeson, algebra-dag, ansi-wl-pprint, base
     , bytestring, containers, Decimal, dlist, either, hashable, HUnit
     , kure, mtl, process, QuickCheck, random, semigroups
     , template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "DSH";
       version = "0.12.0.1";
       sha256 = "de4df78a674097f58a5292f688ff97e77bf86ae0f496289d799cac2c31bcc9d4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson algebra-dag ansi-wl-pprint base bytestring containers Decimal
         dlist either hashable HUnit kure mtl process QuickCheck random
         semigroups template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2 text time unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson algebra-dag ansi-wl-pprint base bytestring containers Decimal
         mtl semigroups template-haskell text time vector
       ];
       description = "Database Supported Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DSTM" = callPackage
    ({ mkDerivation, base, containers, haskell98, network, process
     , unix
     }:
     mkDerivation {
       pname = "DSTM";
       version = "0.1.2";
       sha256 = "cb4538387f916a12fc7d4edea1efbe98e8a3445aa2caadc458f37abe30d39e20";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers haskell98 network process unix
       ];
       executableHaskellDepends = [
         base containers haskell98 network process unix
       ];
       description = "A framework for using STM within distributed systems";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DTC" = callPackage
    ({ mkDerivation, base, haskell-src-exts }:
     mkDerivation {
       pname = "DTC";
       version = "1.1.0.1";
       sha256 = "b4e8065dcc3ab7fe687c991c0b83da77808eec40993ad4bb4b5448c0ff496654";
       libraryHaskellDepends = [ base haskell-src-exts ];
       homepage = "https://github.com/Daniel-Diaz/DTC";
       description = "Data To Class transformation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Dangerous" = callPackage
    ({ mkDerivation, base, MaybeT, mtl }:
     mkDerivation {
       pname = "Dangerous";
       version = "0.3.2";
       sha256 = "7a1774170ef174c5d16ab84cf88db2d44937ac29d0cc4e7bbabde8a336e4de5e";
       libraryHaskellDepends = [ base MaybeT mtl ];
       description = "Monads for operations that can exit early and produce warnings";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Dao" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , Crypto, data-binary-ieee754, deepseq, directory, filepath, mtl
     , process, random, time, transformers, utf8-string
     }:
     mkDerivation {
       pname = "Dao";
       version = "0.1.0.2";
       sha256 = "d5eb3a32373e80c2703f4c640cb0951e54b7d686f935adff9340724f37defab8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers Crypto data-binary-ieee754
         deepseq directory filepath mtl process random time transformers
         utf8-string
       ];
       executableHaskellDepends = [
         array base binary bytestring containers Crypto data-binary-ieee754
         deepseq directory filepath mtl process random time transformers
         utf8-string
       ];
       testHaskellDepends = [
         array base binary bytestring containers Crypto data-binary-ieee754
         deepseq directory filepath mtl process random time transformers
         utf8-string
       ];
       description = "Dao is meta programming language with its own built-in interpreted language, designed with artificial intelligence applications in mind";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DarcsHelpers" = callPackage
    ({ mkDerivation, base, HaXml, mtl, parsec, safe, xml-parsec }:
     mkDerivation {
       pname = "DarcsHelpers";
       version = "0.1";
       sha256 = "c30ae43ca3a711f13a1d8a40d3d00647d71e591efd761e5280b48fd6e155d80a";
       libraryHaskellDepends = [ base HaXml mtl parsec safe xml-parsec ];
       jailbreak = true;
       description = "Code used by Patch-Shack that seemed sensible to open for reusability";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Data-Hash-Consistent" = callPackage
    ({ mkDerivation, base, bytestring, digest, utf8-string, vector
     , vector-algorithms
     }:
     mkDerivation {
       pname = "Data-Hash-Consistent";
       version = "0.1.1";
       sha256 = "c5d4ea2cbedd81b0c3e8ac5efe0e6285fdef2ac0cc3d6f242a647dd7ec7774ed";
       libraryHaskellDepends = [
         base bytestring digest utf8-string vector vector-algorithms
       ];
       homepage = "https://github.com/bradclawsie/haskell-Data.Hash.Consistent";
       description = "Provide a simple consistent hashing mechanism";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Data-Rope" = callPackage
    ({ mkDerivation, base, bytestring, unix }:
     mkDerivation {
       pname = "Data-Rope";
       version = "0.2";
       sha256 = "3cdbdac325e61a414653d882c3bcbbff183fae6265b422869dd40b67004c777f";
       libraryHaskellDepends = [ base bytestring unix ];
       description = "Ropes, an alternative to (Byte)Strings";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DataTreeView" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, glib, gtk
     , lifted-base, ListLike, MissingH, monad-control, mtl, syb
     , transformers-base
     }:
     mkDerivation {
       pname = "DataTreeView";
       version = "0.1.1";
       sha256 = "b2dd07c63c1d3dddecc188449d3f6f5ac1c6e74eb8676d5fe068cb954e9ea47c";
       libraryHaskellDepends = [
         base bytestring containers deepseq glib gtk lifted-base ListLike
         MissingH monad-control mtl syb transformers-base
       ];
       description = "A GTK widget for displaying arbitrary Data.Data.Data instances";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Deadpan-DDP" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , containers, doctest, filemanip, hashable, haskeline, lens, mtl
     , network, network-uri, QuickCheck, random, safe, scientific, stm
     , text, time, transformers, unordered-containers, vector
     , websockets
     }:
     mkDerivation {
       pname = "Deadpan-DDP";
       version = "0.9.6.0";
       sha256 = "dcb8603347c3e6fef34a3524636b95c7db01096956707a1d27eada526d5778c6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring containers hashable lens
         mtl network network-uri random safe scientific stm text time
         transformers unordered-containers vector websockets
       ];
       executableHaskellDepends = [
         aeson base base64-bytestring bytestring containers hashable
         haskeline lens mtl network network-uri random safe scientific stm
         text time transformers unordered-containers vector websockets
       ];
       testHaskellDepends = [ base doctest filemanip QuickCheck ];
       homepage = "http://github.com/sordina/Deadpan-DDP";
       description = "Write clients for Meteor's DDP Protocol";
       license = stdenv.lib.licenses.mit;
     }) {};

  "DebugTraceHelpers" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "DebugTraceHelpers";
       version = "0.12";
       sha256 = "c8ffb982b139633f9a5a71c2d1af77905c1daf04ac9b6131765a8e0bb91a5b7a";
       libraryHaskellDepends = [ base mtl ];
       description = "Convenience functions and instances for Debug.Trace";
       license = "GPL";
     }) {};

  "Decimal" = callPackage
    ({ mkDerivation, base, deepseq, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "Decimal";
       version = "0.4.2";
       sha256 = "c5f53652949eedd48dbafc1bb3e08c05348d5e25c248e8e1543bc380a9f84261";
       libraryHaskellDepends = [ base deepseq ];
       testHaskellDepends = [
         base deepseq HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       homepage = "https://github.com/PaulJohnson/Haskell-Decimal";
       description = "Decimal numbers with variable precision";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "DecisionTree" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "DecisionTree";
       version = "0.0";
       sha256 = "6d6dc700c23dafb3a3e61bbafc36b66238f147f5ca4f73b96ea79725a0cbd793";
       libraryHaskellDepends = [ base containers ];
       homepage = "http://page.mi.fu-berlin.de/~aneumann/decisiontree.html";
       description = "A very simple implementation of decision trees for discrete attributes";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DeepArrow" = callPackage
    ({ mkDerivation, base, haskell-src, mtl, TypeCompose }:
     mkDerivation {
       pname = "DeepArrow";
       version = "0.4.0";
       sha256 = "cccb0d57c63cec7bbffd82cc718524939482b20003a2886f8d3124313d5a7bc9";
       libraryHaskellDepends = [ base haskell-src mtl TypeCompose ];
       homepage = "http://haskell.org/haskellwiki/DeepArrow";
       description = "Arrows for \"deep application\"";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "DefendTheKing" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, GLUT, HTTP
     , MaybeT, mtl, network, peakachu, random, time, utility-ht, zlib
     }:
     mkDerivation {
       pname = "DefendTheKing";
       version = "0.3.1";
       sha256 = "fc53bc85ea025da31120a6555f4fdaa55d4e9303dbf546702fa50e32c0529f27";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring containers GLUT HTTP MaybeT mtl network
         peakachu random time utility-ht zlib
       ];
       homepage = "http://github.com/yairchu/defend/tree";
       description = "A simple RTS game";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DescriptiveKeys" = callPackage
    ({ mkDerivation, base, containers, xmonad, xmonad-contrib }:
     mkDerivation {
       pname = "DescriptiveKeys";
       version = "0.0.4";
       sha256 = "fb48af0e7c334fd7981658cce9e48f9682607df5d9075351afda8f6c2bbb917b";
       libraryHaskellDepends = [ base containers xmonad xmonad-contrib ];
       homepage = "https://bitbucket.org/dibblego/descriptive-keys/";
       description = "A library for specifying xmonad key bindings with functionality";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Dflow" = callPackage
    ({ mkDerivation, base, containers, HUnit, QuickCheck, stm
     , test-framework, test-framework-quickcheck2, time
     }:
     mkDerivation {
       pname = "Dflow";
       version = "0.0.1";
       sha256 = "38862cf11b5b430155220b7e499524f8e364a2991f13de22ded92ddf5cd1ff01";
       libraryHaskellDepends = [ base containers QuickCheck stm time ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-quickcheck2
       ];
       description = "Processing Real-time event streams";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Diff_0_3_0" = callPackage
    ({ mkDerivation, array, base, pretty }:
     mkDerivation {
       pname = "Diff";
       version = "0.3.0";
       sha256 = "28f96d7f4bb0f88a13fa0b59e89cc8b93fa901c6cbe6ca82e84540cb2291ee4c";
       revision = "1";
       editedCabalFile = "f016d6dd8604572ffa07922b2790658b0b869290c5eaf210018bca921e943d47";
       libraryHaskellDepends = [ array base pretty ];
       description = "O(ND) diff algorithm in haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Diff_0_3_1" = callPackage
    ({ mkDerivation, array, base, pretty }:
     mkDerivation {
       pname = "Diff";
       version = "0.3.1";
       sha256 = "2ebae93784c0a3735291a378404adc07b1a3a493d88217c2240a8f56d7f24a83";
       revision = "1";
       editedCabalFile = "d427dd81a963a691e4a683b78d2fd9378a8405b034210ea3423b4982237233dc";
       libraryHaskellDepends = [ array base pretty ];
       description = "O(ND) diff algorithm in haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Diff" = callPackage
    ({ mkDerivation, array, base, pretty }:
     mkDerivation {
       pname = "Diff";
       version = "0.3.2";
       sha256 = "7f032b9842228c2282a66d096e0c943b830138493fbbc5f176a7b2a66ec5388e";
       revision = "1";
       editedCabalFile = "86ab9f6bcb253cabff2673437995faa4c130be7c3898df778b27a801c5361328";
       libraryHaskellDepends = [ array base pretty ];
       description = "O(ND) diff algorithm in haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "DifferenceLogic" = callPackage
    ({ mkDerivation, base, containers, fgl, FirstOrderTheory, HUnit }:
     mkDerivation {
       pname = "DifferenceLogic";
       version = "0.1.0.4";
       sha256 = "2a250e6644f69b05a9dc9a8d8e1074ee75e41c428f15327fa7ca383d97b1977a";
       libraryHaskellDepends = [
         base containers fgl FirstOrderTheory HUnit
       ];
       jailbreak = true;
       homepage = "https://github.com/dillonhuff/DifferenceLogic";
       description = "A theory solver for conjunctions of literals in difference logic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DifferentialEvolution" = callPackage
    ({ mkDerivation, base, deepseq, fclabels, mtl, mwc-random, parallel
     , primitive, vector
     }:
     mkDerivation {
       pname = "DifferentialEvolution";
       version = "0.0.2";
       sha256 = "3c01318d2dd8ca39e108ed0a6891b7890414daad335b4931172d99610179267c";
       libraryHaskellDepends = [
         base deepseq fclabels mtl mwc-random parallel primitive vector
       ];
       jailbreak = true;
       homepage = "http://yousource.it.jyu.fi/optimization-with-haskell";
       description = "Global optimization using Differential Evolution";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Digit" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "Digit";
       version = "0.0.3";
       sha256 = "1cc52cd735b007f2b98e4ff49b0a524ba0d456b2d5b77c31f797a73a93afba31";
       libraryHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       homepage = "https://github.com/tonymorris/digit";
       description = "A data-type representing digits 0-9";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "DigitalOcean" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, exceptions
     , hspec, lens, mtl, text, transformers, unordered-containers
     , vector, wreq
     }:
     mkDerivation {
       pname = "DigitalOcean";
       version = "0.1.1.0";
       sha256 = "e4d3252564049ffc9d355c2f34dcb8494df651ecfaf13bf0b4c68cd982045027";
       libraryHaskellDepends = [
         aeson base bytestring containers exceptions lens mtl text
         transformers unordered-containers vector wreq
       ];
       testHaskellDepends = [ base hspec lens mtl text ];
       jailbreak = true;
       description = "A client library for the DigitalOcean API";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "DimensionalHash" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "DimensionalHash";
       version = "0.1.5.2";
       sha256 = "27b120463c8a749b2e6dc3ce0a20ff1037abffdb187982d03349ac610b4f6f2d";
       libraryHaskellDepends = [ base ];
       description = "An n-dimensional hash using Morton numbers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DirectSound" = callPackage
    ({ mkDerivation, base, dsound, Win32 }:
     mkDerivation {
       pname = "DirectSound";
       version = "0.0.0";
       sha256 = "dfcfe228f6cdadbddccfd66c0cf3eae0653f64be52ff48e6e3b69ca16cf0e8f4";
       libraryHaskellDepends = [ base Win32 ];
       librarySystemDepends = [ dsound ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "Partial binding to the Microsoft DirectSound API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {dsound = null;};

  "DisTract" = callPackage
    ({ mkDerivation, base, Cabal, chunks, containers, directory
     , filepath, hinstaller, old-locale, parsec, pretty, process
     , template-haskell, time, xhtml
     }:
     mkDerivation {
       pname = "DisTract";
       version = "0.2.5";
       sha256 = "8bff696b2f7c75739f4a8fe22b6ebe514a5ce5f1cc359ed5f5942a2d1398d45e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal chunks containers directory filepath hinstaller
         old-locale parsec pretty process template-haskell time xhtml
       ];
       homepage = "http://distract.wellquite.org/";
       description = "Distributed Bug Tracking System";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DiscussionSupportSystem" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, doctest, html
     , parsers
     }:
     mkDerivation {
       pname = "DiscussionSupportSystem";
       version = "0.11.0.3";
       sha256 = "434b7105ef891e8509678221f4cf2298d6823702d8f5a682c43a6503d6d80c47";
       libraryHaskellDepends = [
         base blaze-html blaze-markup html parsers
       ];
       testHaskellDepends = [ base doctest ];
       jailbreak = true;
       homepage = "https://github.com/minamiyama1994/DiscussionSupportSystem";
       description = "Discussion support system";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "Dish" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "Dish";
       version = "0.0.0.5";
       sha256 = "5d47cbf6804d16acf2c250d7672c3a769c89f2a137dfd2b7fd4de68e96071ff6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring ];
       executableHaskellDepends = [ base bytestring ];
       jailbreak = true;
       homepage = "http://github.com/zcourts/Dish";
       description = "Hash modules (currently Murmur3)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Dist" = callPackage
    ({ mkDerivation, base, containers, MonadRandom }:
     mkDerivation {
       pname = "Dist";
       version = "0.4.0.0";
       sha256 = "71b3cfb410c08cf1692d4aa484b3190cc0840245adc23ea7ed8bb3e109a41c88";
       libraryHaskellDepends = [ base containers MonadRandom ];
       testHaskellDepends = [ base containers MonadRandom ];
       jailbreak = true;
       homepage = "https://github.com/wyager/Dist";
       description = "A Haskell library for probability distributions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "DistanceTransform" = callPackage
    ({ mkDerivation, base, HUnit, primitive, test-framework
     , test-framework-hunit, vector
     }:
     mkDerivation {
       pname = "DistanceTransform";
       version = "0.1.2";
       sha256 = "653aa31329530089c5d0b8224d0d014bb937d7bd6a71b0a1e348536cfad2e730";
       libraryHaskellDepends = [ base primitive vector ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit vector
       ];
       description = "Distance transform function";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "DistanceUnits" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "DistanceUnits";
       version = "0.1.0.1";
       sha256 = "5aad6450a1dd79f783944269fd4c759f249c9cd3883e45134c7f586c09ce4653";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/gambogi/DistanceUnits";
       description = "A comprehensive distance library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "DnaProteinAlignment" = callPackage
    ({ mkDerivation, ADPfusion, ansi-wl-pprint, array, base
     , BiobaseBlast, BiobaseFasta, BiobaseXNA, biocore, bytestring
     , cmdargs, conduit, dlist, parallel, PrimitiveArray, repa, split
     , vector
     }:
     mkDerivation {
       pname = "DnaProteinAlignment";
       version = "0.0.0.1";
       sha256 = "a32f396fb76bca8833b9ba8b7105dc5dcf368288c1aa0a9ccf6a8f7aad228701";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ADPfusion ansi-wl-pprint array base BiobaseBlast BiobaseFasta
         BiobaseXNA biocore bytestring cmdargs conduit dlist parallel
         PrimitiveArray repa split vector
       ];
       executableHaskellDepends = [
         ADPfusion ansi-wl-pprint array base BiobaseBlast BiobaseFasta
         BiobaseXNA biocore bytestring cmdargs conduit dlist parallel
         PrimitiveArray repa split vector
       ];
       homepage = "http://www.tbi.univie.ac.at/~choener/";
       description = "Frameshift-aware alignment of protein sequences with DNA sequences";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DocTest" = callPackage
    ({ mkDerivation, base, containers, ghc, ghc-paths, haddock, HUnit
     , process
     }:
     mkDerivation {
       pname = "DocTest";
       version = "0.2.0.1";
       sha256 = "47205c0e6d5d9b6a90028181f35ebf0aa77d6bc503d2da887561fce8192839f1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers ghc ghc-paths haddock HUnit process
       ];
       jailbreak = true;
       homepage = "http://haskell.org/haskellwiki/DocTest";
       description = "Test interactive Haskell examples";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Docs" = callPackage
    ({ mkDerivation, base, html }:
     mkDerivation {
       pname = "Docs";
       version = "1.0.0";
       sha256 = "df6e26c757000d513d17c53e6db45eceb2a45b1bb94ba0184b92cf24aefd4dc2";
       libraryHaskellDepends = [ base html ];
       homepage = "http://ddiaz.asofilak.es/packages/Docs.html";
       description = "Documentation types library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "DrHylo" = callPackage
    ({ mkDerivation, array, base, containers, haskell-src-exts, mtl
     , pointless-haskell, pretty, syb
     }:
     mkDerivation {
       pname = "DrHylo";
       version = "0.0.2";
       sha256 = "071a7a3e51d10b770aa195224c44edb6832469808ea161f790be7d0f3efe47b3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base haskell-src-exts mtl pointless-haskell syb
       ];
       executableHaskellDepends = [ array base containers pretty ];
       jailbreak = true;
       homepage = "http://haskell.di.uminho.pt/wiki/DrHylo";
       description = "A tool for deriving hylomorphisms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DrIFT" = callPackage
    ({ mkDerivation, base, filepath, old-time, process, random }:
     mkDerivation {
       pname = "DrIFT";
       version = "2.4.2";
       sha256 = "742a0b12f16a9da215a29c8284ae379734a70e7811a5f4b1a02dba2873751cf0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [
         base filepath old-time process random
       ];
       homepage = "http://repetae.net/computer/haskell/DrIFT/";
       description = "Program to derive type class instances";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DrIFT-cabalized" = callPackage
    ({ mkDerivation, base, old-time, process, random }:
     mkDerivation {
       pname = "DrIFT-cabalized";
       version = "2.3.0";
       sha256 = "949be8c0ccc9f8b1e5d97e139cabac21fa87aeb72ba40ad1e0c970f968c5674a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base old-time process random ];
       homepage = "http://repetae.net/computer/haskell/DrIFT/";
       description = "Program to derive type class instances";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Dung" = callPackage
    ({ mkDerivation, base, cmdargs, containers, parsec }:
     mkDerivation {
       pname = "Dung";
       version = "1.1";
       sha256 = "ebe94c91fcda450eb6c4c492dccb933b5194fc27ad9d2a127334a5f2f06d2fc2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base cmdargs containers parsec ];
       homepage = "http://www.cs.nott.ac.uk/~bmv/Dung/";
       description = "An implementation of the Dung argumentation frameworks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Dust" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, containers
     , crypto-api, directory, Dust-crypto, entropy, ghc-prim, HUnit
     , network, QuickCheck, random, random-extras, random-fu
     , random-source, split, test-framework, test-framework-hunit
     , test-framework-quickcheck2, test-framework-th, threefish
     }:
     mkDerivation {
       pname = "Dust";
       version = "2.3.1";
       sha256 = "72ab2ae62f06dbac86cd5e6dbd595ca0673221075b9a580d812d9eaab2a85748";
       libraryHaskellDepends = [
         base binary bytestring cereal containers crypto-api directory
         Dust-crypto entropy ghc-prim network random random-extras random-fu
         random-source split threefish
       ];
       testHaskellDepends = [
         base bytestring cereal Dust-crypto ghc-prim HUnit QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
         test-framework-th threefish
       ];
       description = "Polymorphic protocol engine";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Dust-crypto" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, containers
     , crypto-api, cryptohash, directory, Dust, entropy, ghc-prim, HUnit
     , network, openssl, QuickCheck, random, random-extras, random-fu
     , random-source, skein, split, test-framework, test-framework-hunit
     , test-framework-quickcheck2, threefish
     }:
     mkDerivation {
       pname = "Dust-crypto";
       version = "0.1";
       sha256 = "3c7d01c4cbf975874270ac4379bab92549c5bbe6e8cdb1a312a349cd9bcf5784";
       libraryHaskellDepends = [
         base binary bytestring cereal containers crypto-api cryptohash
         directory entropy ghc-prim network random random-extras random-fu
         random-source skein split threefish
       ];
       librarySystemDepends = [ openssl ];
       testHaskellDepends = [
         base bytestring cereal Dust ghc-prim HUnit QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
         threefish
       ];
       description = "Cryptographic operations";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openssl;};

  "Dust-tools" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, containers, csv
     , directory, Dust, Dust-crypto, entropy, ghc-prim, network, random
     , random-extras, random-fu, random-source, split
     }:
     mkDerivation {
       pname = "Dust-tools";
       version = "1.3.2";
       sha256 = "c4f2fef819b4e5a3fa4bcc3e1778f9784ac9f917dc130927c3c901400a3c34bc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring cereal containers directory Dust Dust-crypto
         entropy ghc-prim network random random-extras random-fu
         random-source split
       ];
       executableHaskellDepends = [
         base binary bytestring cereal containers csv directory Dust entropy
         ghc-prim network random random-extras random-fu random-source split
       ];
       description = "Network filtering exploration tools";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Dust-tools-pcap" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, containers, csv
     , directory, Dust, Dust-crypto, Dust-tools, entropy, ghc-prim
     , network, pcap, random, random-extras, random-fu, random-source
     , split
     }:
     mkDerivation {
       pname = "Dust-tools-pcap";
       version = "1.3.1";
       sha256 = "b9e9af8c7293e9d48ee598d404bf563e2e7d08fbc6a3e1f1091e9f40999e9eeb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring cereal containers csv directory Dust
         Dust-crypto Dust-tools entropy ghc-prim network pcap random
         random-extras random-fu random-source split
       ];
       description = "Network filtering exploration tools that rely on pcap";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DynamicTimeWarp" = callPackage
    ({ mkDerivation, array, base, criterion, QuickCheck, random, vector
     }:
     mkDerivation {
       pname = "DynamicTimeWarp";
       version = "0.1.0.0";
       sha256 = "67c2a25b7c4032307f2c4df5efdb2edc38350c68cdbbabda3c21db2d055ea854";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base vector ];
       executableHaskellDepends = [
         array base criterion QuickCheck random vector
       ];
       jailbreak = true;
       homepage = "https://github.com/zombiecalypse/DynamicTimeWarp";
       description = "Dynamic time warping of sequences";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DysFRP" = callPackage
    ({ mkDerivation, base, contravariant, mtl, time, transformers }:
     mkDerivation {
       pname = "DysFRP";
       version = "0.1";
       sha256 = "4192bda1c59bc6561c93046676c37dcb1ce4e10f559f0a6282108b56a3d081cb";
       libraryHaskellDepends = [
         base contravariant mtl time transformers
       ];
       homepage = "https://github.com/tilk/DysFRP";
       description = "dysFunctional Reactive Programming";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "DysFRP-Cairo" = callPackage
    ({ mkDerivation, base, cairo, DysFRP, gtk, mtl }:
     mkDerivation {
       pname = "DysFRP-Cairo";
       version = "0.1";
       sha256 = "eed4f4d9e22bb8418883fa8c012deca0bef4073a1787a510f8e66e9a3d7fe6dd";
       libraryHaskellDepends = [ base cairo DysFRP gtk mtl ];
       homepage = "https://github.com/tilk/DysFRP";
       description = "dysFunctional Reactive Programming on Cairo";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "DysFRP-Craftwerk" = callPackage
    ({ mkDerivation, base, cairo, containers, craftwerk, craftwerk-gtk
     , DysFRP, DysFRP-Cairo, gtk
     }:
     mkDerivation {
       pname = "DysFRP-Craftwerk";
       version = "0.1";
       sha256 = "c157a58edef89efd6c52fa738a4d9447b5d42c6276333790e26d1018943f1566";
       libraryHaskellDepends = [
         base cairo containers craftwerk craftwerk-gtk DysFRP DysFRP-Cairo
         gtk
       ];
       homepage = "https://github.com/tilk/DysFRP";
       description = "dysFunctional Reactive Programming on Craftwerk";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "EEConfig" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "EEConfig";
       version = "1.0";
       sha256 = "c165cba32a8efe0ff314610ede6e2c838bd16553d5c9449b8e9648d082fc73ae";
       libraryHaskellDepends = [ base containers ];
       description = "ExtremlyEasyConfig - Extremly Simple parser for config files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Earley_0_9_0" = callPackage
    ({ mkDerivation, base, ListLike, tasty, tasty-hunit
     , tasty-quickcheck, unordered-containers
     }:
     mkDerivation {
       pname = "Earley";
       version = "0.9.0";
       sha256 = "5ec955f00c872cc585bc2dd82fec137f53b095fde73a498e2a0ca7e0eb8140aa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ListLike ];
       executableHaskellDepends = [ base unordered-containers ];
       testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ];
       description = "Parsing all context-free grammars using Earley's algorithm";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Earley" = callPackage
    ({ mkDerivation, base, ListLike, tasty, tasty-hunit
     , tasty-quickcheck, unordered-containers
     }:
     mkDerivation {
       pname = "Earley";
       version = "0.10.1.0";
       sha256 = "a90c5c1e210a0e37db577ace20b1ca2aa33d22454766ecaeb5dc253cb7d4887e";
       revision = "2";
       editedCabalFile = "310e7216914ee8e8338bc9481f6aa75f7cb2324d35ab03d29973b93bee2a725a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ListLike ];
       executableHaskellDepends = [ base unordered-containers ];
       testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ];
       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, unix
     }:
     mkDerivation {
       pname = "Ebnf2ps";
       version = "1.0.15";
       sha256 = "0ecce7d721d6c8993fa6ba6cfb16f1101d85e00bbaf0b6941d36a00badea2b4b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory old-time unix
       ];
       executableToolDepends = [ happy ];
       homepage = "https://github.com/FranklinChen/Ebnf2ps";
       description = "Peter's Syntax Diagram Drawing Tool";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "EdisonAPI" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "EdisonAPI";
       version = "1.3";
       sha256 = "a369d5c9b412bafb16a023121a72470a6fed0116b3d6d143a03dd54cb854154f";
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://rwd.rdockins.name/edison/home/";
       description = "A library of efficent, purely-functional data structures (API)";
       license = "unknown";
     }) {};

  "EdisonCore" = callPackage
    ({ mkDerivation, array, base, containers, EdisonAPI, mtl
     , QuickCheck
     }:
     mkDerivation {
       pname = "EdisonCore";
       version = "1.3.1.1";
       sha256 = "3e0720ee3b179304f563b99dd446c1d6911e31ddc4d0f78d6550b18e59ed501b";
       libraryHaskellDepends = [
         array base containers EdisonAPI mtl QuickCheck
       ];
       homepage = "http://rwd.rdockins.name/edison/home/";
       description = "A library of efficent, purely-functional data structures (Core Implementations)";
       license = "unknown";
     }) {};

  "EditTimeReport" = callPackage
    ({ mkDerivation, array, base, containers, csv, directory, editline
     , filepath, haskell98, html, pretty, xhtml
     }:
     mkDerivation {
       pname = "EditTimeReport";
       version = "1.0";
       sha256 = "e04803689a2a2bd453e4c96587a13c7024abcd97036c96cedbd2c0328a104985";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers csv directory editline filepath haskell98
         html pretty xhtml
       ];
       homepage = "http://github.com/bspaans/EditTimeReport";
       description = "Query language and report generator for edit logs";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "EitherT" = callPackage
    ({ mkDerivation, base, monad-control, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "EitherT";
       version = "0.2.0";
       sha256 = "5c6bc80ceae21f0ec21960f9b9a202ef09c70f1b6734d2d6e12ee0f6d3213eef";
       revision = "1";
       editedCabalFile = "a1c6f78c9a4379af0738a6d4dee5d1781099c5c56acb0b39c45ad23b256e8c6e";
       libraryHaskellDepends = [
         base monad-control transformers transformers-base
       ];
       jailbreak = true;
       description = "EitherT monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Elm" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, binary, blaze-html
     , blaze-markup, bytestring, cheapskate, cmdargs, containers
     , directory, filemanip, filepath, highlighting-kate, HUnit, indents
     , language-ecmascript, language-glsl, mtl, parsec, pretty, process
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, transformers, union-find
     , unordered-containers
     }:
     mkDerivation {
       pname = "Elm";
       version = "0.13";
       sha256 = "b05ac9a427afe88e49cecbb0ee08f112e1a9f4c5fb011537a7eb84032000d7d0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty base binary blaze-html blaze-markup bytestring
         cheapskate cmdargs containers directory filepath highlighting-kate
         indents language-ecmascript language-glsl mtl parsec pretty text
         transformers union-find unordered-containers
       ];
       executableHaskellDepends = [
         aeson aeson-pretty base binary blaze-html blaze-markup bytestring
         cheapskate cmdargs containers directory filepath highlighting-kate
         indents language-ecmascript language-glsl mtl parsec pretty text
         transformers union-find unordered-containers
       ];
       testHaskellDepends = [
         aeson aeson-pretty base binary blaze-html blaze-markup bytestring
         cheapskate cmdargs containers directory filemanip filepath
         highlighting-kate HUnit indents language-ecmascript language-glsl
         mtl parsec pretty process QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 text transformers
         union-find unordered-containers
       ];
       jailbreak = true;
       homepage = "http://elm-lang.org";
       description = "The Elm language module";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Emping" = callPackage
    ({ mkDerivation, array, base, containers, fgl, gtk, mtl, parsec }:
     mkDerivation {
       pname = "Emping";
       version = "0.6";
       sha256 = "795a809998003f79df41af44ddcfa8ab011d4fa16eed8a57d5eb03fb5c38308c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers fgl gtk mtl parsec
       ];
       homepage = "http://www.muitovar.com";
       description = "derives heuristic rules from nominal data";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Encode" = callPackage
    ({ mkDerivation, base, Cabal, containers, mtl }:
     mkDerivation {
       pname = "Encode";
       version = "1.3.7";
       sha256 = "653df7d535fe886b43d951c1852331d31fd7e8a8adb0d22586e6ca7d696b3190";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base Cabal containers mtl ];
       executableHaskellDepends = [ base Cabal containers mtl ];
       homepage = "http://otakar-smrz.users.sf.net/";
       description = "Encoding character data";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "EntrezHTTP" = callPackage
    ({ mkDerivation, base, biocore, bytestring, conduit, HTTP
     , http-conduit, hxt, mtl, network, Taxonomy, transformers
     }:
     mkDerivation {
       pname = "EntrezHTTP";
       version = "1.0.1";
       sha256 = "54461cb1bd772129cc9e5d725ed6997b133bc7725ec1720de511918d07cdc01f";
       libraryHaskellDepends = [
         base biocore bytestring conduit HTTP http-conduit hxt mtl network
         Taxonomy transformers
       ];
       homepage = "https://github.com/eggzilla/EntrezHTTP";
       description = "Libary to interface with the NCBI Entrez REST service";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "EnumContainers" = callPackage
    ({ mkDerivation, base, containers, deepseq }:
     mkDerivation {
       pname = "EnumContainers";
       version = "0.1";
       sha256 = "6802cc98b4b39834d53c9e18c114aa0cc47ce7a46b58191a60c3dbb8d5bb9391";
       libraryHaskellDepends = [ base containers deepseq ];
       jailbreak = true;
       description = "Simple Enum-class-based int containers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "EnumMap" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "EnumMap";
       version = "0.0.2";
       sha256 = "5f7e33f1845f6d620375e7e3792dddb9c3e83368cbdc7d69dbcbcf9268b872ec";
       libraryHaskellDepends = [ base containers ];
       jailbreak = true;
       description = "More general IntMap replacement";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Eq" = callPackage
    ({ mkDerivation, array, base, containers, filepath, HaXml, mtl
     , parsec, template-haskell, transformers
     }:
     mkDerivation {
       pname = "Eq";
       version = "1.1.3";
       sha256 = "4344182457c511c3a62755623bb8981ac57016b3523c510e9521f01ce9978e41";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers filepath HaXml mtl parsec template-haskell
         transformers
       ];
       jailbreak = true;
       description = "Render math formula in ASCII, and perform some simplifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "EqualitySolver" = callPackage
    ({ mkDerivation, base, containers, HUnit, mtl, union-find-array }:
     mkDerivation {
       pname = "EqualitySolver";
       version = "0.1.0.2";
       sha256 = "2f50063e7fd1077c613ed39e5d0ca8b61462bba5c0f466d9ecb0d85a13fddf7a";
       libraryHaskellDepends = [
         base containers HUnit mtl union-find-array
       ];
       jailbreak = true;
       description = "A theory solver for conjunctions of literals in the theory of uninterpreted functions with equality";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "EsounD" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, bindings-EsounD
     , monad-control, network, regions, safer-file-handles
     , storablevector, transformers, unix
     }:
     mkDerivation {
       pname = "EsounD";
       version = "0.2";
       sha256 = "59b6f6676e5cd005e296ee8e8f0669522d981f94fb96874deb223133d09842b4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-unicode-symbols bindings-EsounD monad-control network
         regions safer-file-handles storablevector transformers unix
       ];
       jailbreak = true;
       homepage = "http://cielonegro.org/EsounD.html";
       description = "Type-safe bindings to EsounD (ESD; Enlightened Sound Daemon)";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "EstProgress" = callPackage
    ({ mkDerivation, ansi-terminal, base, mtl }:
     mkDerivation {
       pname = "EstProgress";
       version = "0.3.0.0";
       sha256 = "2371b9ee209aa190a95125fcd1a14a6d1e60d986c2554c149f0aeb21d894b197";
       libraryHaskellDepends = [ ansi-terminal base mtl ];
       homepage = "http://alkalisoftware.net";
       description = "Methods for estimating the progress of functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "EtaMOO" = callPackage
    ({ mkDerivation, array, async, base, bytestring, case-insensitive
     , containers, cryptonite, hashable, haskeline, memory, mtl, network
     , parsec, pcre, pipes, pipes-bytestring, pipes-concurrency
     , pipes-network, random, stm, stm-chans, text, time, transformers
     , unix, unordered-containers, vcache, vector
     }:
     mkDerivation {
       pname = "EtaMOO";
       version = "0.3.0.0";
       sha256 = "501344b7dfe9ec437fd137a247d785eed7d497f35daacd6aed3d940b8837c57c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array async base bytestring case-insensitive containers cryptonite
         hashable haskeline memory mtl network parsec pipes pipes-bytestring
         pipes-concurrency pipes-network random stm stm-chans text time
         transformers unix unordered-containers vcache vector
       ];
       executablePkgconfigDepends = [ pcre ];
       homepage = "http://verement.github.io/etamoo";
       description = "A new implementation of the LambdaMOO server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) pcre;};

  "Etage" = callPackage
    ({ mkDerivation, base, containers, ghc, mtl, operational, random
     , SafeSemaphore, time, unix
     }:
     mkDerivation {
       pname = "Etage";
       version = "0.1.12";
       sha256 = "4058f25a292aa7ed6133d438da7c8793d2334f6ea886225ebb8d981ff49168c6";
       libraryHaskellDepends = [
         base containers ghc mtl operational random SafeSemaphore time unix
       ];
       homepage = "http://mitar.tnode.com";
       description = "A general data-flow framework";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Etage-Graph" = callPackage
    ({ mkDerivation, array, base, containers, deepseq, Etage, fgl, mtl
     , parallel, random, time
     }:
     mkDerivation {
       pname = "Etage-Graph";
       version = "0.1.8";
       sha256 = "82a65951481688ceac44da29e186ea605ce2e50d5b838b382cbb434ba0dafa77";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers Etage fgl mtl ];
       executableHaskellDepends = [
         array base containers deepseq Etage fgl mtl parallel random time
       ];
       jailbreak = true;
       homepage = "http://mitar.tnode.com";
       description = "Data-flow based graph algorithms";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Eternal10Seconds" = callPackage
    ({ mkDerivation, base, haskell98, SDL, SDL-mixer }:
     mkDerivation {
       pname = "Eternal10Seconds";
       version = "0.2";
       sha256 = "b7575fb3789c8bdcc7970e3eb2ee80fb8f3e328fc38be97c3fbdb294b1fc014e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskell98 SDL SDL-mixer ];
       homepage = "http://www.kryozahiro.org/eternal10/";
       description = "A 2-D shooting game";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Etherbunny" = callPackage
    ({ mkDerivation, base, binary, bytestring, haskell98, libpcap
     , network, pcap
     }:
     mkDerivation {
       pname = "Etherbunny";
       version = "0.3";
       sha256 = "d21e61cd45067d70944d1e9d1bd418e44d50b4891c3a8d53cc1c33234c47a932";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring haskell98 network pcap
       ];
       executableHaskellDepends = [
         base binary bytestring haskell98 network pcap
       ];
       executableSystemDepends = [ libpcap ];
       homepage = "http://etherbunny.anytini.com/";
       description = "A network analysis toolkit for Haskell";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libpcap;};

  "EuroIT" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "EuroIT";
       version = "2010.2.5";
       sha256 = "fb310916e307d5e88ceb9e71a735aa40aff95a5639abd141bfdfdee041dccba8";
       libraryHaskellDepends = [ base ];
       description = "Library for using euro currency, italian language";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Euterpea" = callPackage
    ({ mkDerivation, ansi-terminal, array, arrows, base, bytestring
     , Cabal, containers, deepseq, ghc-prim, HCodecs, heap, markov-chain
     , PortMidi, pure-fft, QuickCheck, random, stm, UISF
     }:
     mkDerivation {
       pname = "Euterpea";
       version = "1.1.1";
       sha256 = "e33dc58a5efdb57f05017abcfa56728a17d4f3ec152b0ea9a530c4409e61f652";
       libraryHaskellDepends = [
         array arrows base bytestring containers deepseq ghc-prim HCodecs
         heap markov-chain PortMidi pure-fft random stm UISF
       ];
       testHaskellDepends = [ ansi-terminal base Cabal QuickCheck ];
       jailbreak = true;
       homepage = "http://haskell.cs.yale.edu/";
       description = "Library for computer music research and education";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "EventSocket" = callPackage
    ({ mkDerivation, base, bytestring, containers, haskell98, mtl
     , network
     }:
     mkDerivation {
       pname = "EventSocket";
       version = "0.1";
       sha256 = "ad8ba46f5594da7d54fa5c1252ae9a2880a716e3c19d2ced5d485e2675458e0f";
       libraryHaskellDepends = [
         base bytestring containers haskell98 mtl network
       ];
       description = "Interfaces with FreeSwitch Event Socket";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Extra" = callPackage
    ({ mkDerivation, base, bytestring, bzlib, containers, directory
     , filepath, HUnit, mtl, network-uri, old-locale, old-time, pretty
     , process, pureMD5, QuickCheck, random, regex-compat, time, unix
     , Unixutils, zlib
     }:
     mkDerivation {
       pname = "Extra";
       version = "1.46.3";
       sha256 = "d0fb7267853f610a9b9e7d5e37ab39f6de2b99f21c15d44bffb6807459babcf6";
       libraryHaskellDepends = [
         base bytestring bzlib containers directory filepath HUnit mtl
         network-uri old-locale old-time pretty process pureMD5 QuickCheck
         random regex-compat time unix Unixutils zlib
       ];
       homepage = "https://github.com/ddssff/haskell-extra";
       description = "A grab bag of modules";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "FComp" = callPackage
    ({ mkDerivation, array, base, binary, deepseq, ghc-prim
     , HarmTrace-Base, haskore, instant-generics, ListLike, midi, mtl
     , QuickCheck, random, template-haskell, time, uu-parsinglib
     }:
     mkDerivation {
       pname = "FComp";
       version = "1.0.2";
       sha256 = "367795bfcf982fe9efea55e3c60435d0ee9dc58b9f2c02009c7fad28f7807542";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary deepseq ghc-prim HarmTrace-Base haskore
         instant-generics ListLike midi mtl QuickCheck random
         template-haskell time uu-parsinglib
       ];
       executableHaskellDepends = [
         array base binary deepseq ghc-prim HarmTrace-Base haskore
         instant-generics ListLike midi mtl QuickCheck random
         template-haskell time uu-parsinglib
       ];
       jailbreak = true;
       description = "Compose music";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FM-SBLEX" = callPackage
    ({ mkDerivation, array, base, containers, haskell98 }:
     mkDerivation {
       pname = "FM-SBLEX";
       version = "3.0.1";
       sha256 = "487dac912edc4b7dfd16171afda2fa6cd2a532d2fdb325f5ed2958ec11c663b1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base containers haskell98 ];
       homepage = "http://spraakbanken.gu.se/eng/research/swefn/fm-sblex";
       description = "A set of computational morphology tools for Swedish diachronic lexicons";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FModExRaw" = callPackage
    ({ mkDerivation, base, fmodex64 }:
     mkDerivation {
       pname = "FModExRaw";
       version = "0.2.0.0";
       sha256 = "f46b377566b80a5b87b9ef92fce2473c16e3fd004a85f9924f9e23043b855f50";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ fmodex64 ];
       homepage = "https://github.com/skypers/hsFModEx";
       description = "The Haskell FModEx raw API";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {fmodex64 = null;};

  "FPretty" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "FPretty";
       version = "1.1";
       sha256 = "b8ac0122e923b0e20cee6ba77ffb07dfeaa96a194cdc1622808e97f443a8eb42";
       libraryHaskellDepends = [ base containers ];
       homepage = "http://www.cs.kent.ac.uk/~oc/pretty.html";
       description = "Efficient simple pretty printing combinators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "FTGL" = callPackage
    ({ mkDerivation, base, ftgl }:
     mkDerivation {
       pname = "FTGL";
       version = "2.1";
       sha256 = "82bb01c58dce449902d54857b76146723c0d1fda118bd465963bf6be503ae62c";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ ftgl ];
       description = "Portable TrueType font rendering for OpenGL using the Freetype2 library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) ftgl;};

  "FTGL-bytestring" = callPackage
    ({ mkDerivation, base, bytestring, ftgl, StateVar-transformer
     , transformers
     }:
     mkDerivation {
       pname = "FTGL-bytestring";
       version = "2.0";
       sha256 = "c20b7fdc9fa350155072a1358890536f27478410d2f1c4d230dd3c129f78c887";
       libraryHaskellDepends = [
         base bytestring StateVar-transformer transformers
       ];
       librarySystemDepends = [ ftgl ];
       description = "Portable TrueType font rendering for OpenGL using the Freetype2 library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) ftgl;};

  "FTPLine" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, directory, ftphs
     , haskeline, mtl, network, strict
     }:
     mkDerivation {
       pname = "FTPLine";
       version = "1.4.0.0";
       sha256 = "c51299b2769c0632174550dbdf6d3bbcca1e81ed26e08730caaedb2e8975dc5a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base bytestring directory ftphs haskeline mtl network
         strict
       ];
       description = "A command-line FTP client";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Facts" = callPackage
    ({ mkDerivation, AC-Angle, base, containers, digits, QuickCheck
     , template-haskell
     }:
     mkDerivation {
       pname = "Facts";
       version = "0.1.2";
       sha256 = "e5fc2a9ce5a3d4aa801e9d95c9c354def12dc69578aa4ce8924b556b244e0f05";
       libraryHaskellDepends = [
         AC-Angle base containers digits QuickCheck template-haskell
       ];
       jailbreak = true;
       description = "A collection of facts about the real world";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "FailureT" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, mmtl }:
     mkDerivation {
       pname = "FailureT";
       version = "15778.1";
       sha256 = "65049d3816998c0b81e826d37c719ec90c571f0c74ef9b8755ce63d2b9c612e2";
       libraryHaskellDepends = [ base base-unicode-symbols mmtl ];
       description = "Failure Monad Transformer";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FastxPipe" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring, pipes
     , pipes-attoparsec, pipes-bytestring
     }:
     mkDerivation {
       pname = "FastxPipe";
       version = "0.2.0.0";
       sha256 = "4969694a810c1c6e22b58ab38a82c772eddf2e1e94fe1eb5a42d37b5a30aafc6";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring pipes pipes-attoparsec
         pipes-bytestring
       ];
       jailbreak = true;
       description = "Fasta and Fastq streaming";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "FenwickTree_0_1_1" = callPackage
    ({ mkDerivation, base, QuickCheck, template-haskell }:
     mkDerivation {
       pname = "FenwickTree";
       version = "0.1.1";
       sha256 = "4eb218c44b6b3e3f48dc2a111bdb7eddd11ba0d7a9e4c844abd228b7397d5965";
       libraryHaskellDepends = [ base QuickCheck template-haskell ];
       testHaskellDepends = [ base QuickCheck template-haskell ];
       jailbreak = true;
       homepage = "https://github.com/mgajda/FenwickTree";
       description = "Data structure for fast query and update of cumulative sums";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FenwickTree_0_1_2" = callPackage
    ({ mkDerivation, base, QuickCheck, template-haskell }:
     mkDerivation {
       pname = "FenwickTree";
       version = "0.1.2";
       sha256 = "fe8fd714c95ed75f60dd097253b03d99c372e1bd9c5d1a673f767e4a3af8b44f";
       libraryHaskellDepends = [ base QuickCheck template-haskell ];
       testHaskellDepends = [ base QuickCheck template-haskell ];
       jailbreak = true;
       homepage = "https://github.com/mgajda/FenwickTree";
       description = "Data structure for fast query and update of cumulative sums";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FenwickTree" = callPackage
    ({ mkDerivation, base, QuickCheck, template-haskell }:
     mkDerivation {
       pname = "FenwickTree";
       version = "0.1.2.1";
       sha256 = "9c172d62b24365e663a0355e8eaa34362a1a769c18a64391939a9b50e384f03c";
       libraryHaskellDepends = [ base QuickCheck template-haskell ];
       testHaskellDepends = [ base QuickCheck template-haskell ];
       homepage = "https://github.com/mgajda/FenwickTree";
       description = "Data structure for fast query and update of cumulative sums";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "FermatsLastMargin" = callPackage
    ({ mkDerivation, base, HAppS-Data, HAppS-IxSet, HAppS-Server
     , HAppS-State, HAppS-Util, haskell98, HaXml, mtl, old-time, random
     , syb-with-class, template-haskell
     }:
     mkDerivation {
       pname = "FermatsLastMargin";
       version = "0.1";
       sha256 = "c80dc30a4cb5d5b27e254110ba2f20ea6aa8e506377ffb74d6d12923acf3591f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base HAppS-Data HAppS-IxSet HAppS-Server HAppS-State HAppS-Util
         haskell98 HaXml mtl old-time random syb-with-class template-haskell
       ];
       homepage = "http://www.scannedinavian.com/";
       description = "Annotate ps and pdf documents";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FerryCore" = callPackage
    ({ mkDerivation, base, containers, HaXml, mtl, parsec, pretty
     , TableAlgebra, template-haskell
     }:
     mkDerivation {
       pname = "FerryCore";
       version = "0.4.6.4";
       sha256 = "f7f110d4816e4cc9289dde8103b9aaba69d41cf217464f4978cd0cca6a5eb0b7";
       libraryHaskellDepends = [
         base containers HaXml mtl parsec pretty TableAlgebra
         template-haskell
       ];
       description = "Ferry Core Components";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Feval" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec }:
     mkDerivation {
       pname = "Feval";
       version = "1.0.0.1";
       sha256 = "57d8d22edddce21abb7f690a3609a2daca841642d52e3641986d1e58a57b8b56";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers mtl parsec ];
       jailbreak = true;
       homepage = "http://github.com/burz/Feval";
       description = "Evaluation using F-Algebras";
       license = stdenv.lib.licenses.mit;
     }) {};

  "FieldTrip" = callPackage
    ({ mkDerivation, base, GLUT, graphicsFormats, MemoTrie, old-time
     , OpenGL, TypeCompose, vector-space
     }:
     mkDerivation {
       pname = "FieldTrip";
       version = "0.2.7";
       sha256 = "2b9708c875ebd6bf11d4d79334a1098da5c4cd7f064e7b5196410e42d0afc184";
       libraryHaskellDepends = [
         base GLUT graphicsFormats MemoTrie old-time OpenGL TypeCompose
         vector-space
       ];
       homepage = "http://haskell.org/haskellwiki/FieldTrip";
       description = "Functional 3D";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FileManip" = callPackage
    ({ mkDerivation, base, bytestring, directory, extensible-exceptions
     , filepath, mtl, unix
     }:
     mkDerivation {
       pname = "FileManip";
       version = "0.3.3.1";
       sha256 = "b137f27cbb363f95eae3a757be02ce181a78f314283295ebbbe012efe73f1436";
       libraryHaskellDepends = [
         base bytestring directory extensible-exceptions filepath mtl unix
       ];
       description = "Expressive file and directory manipulation for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FileManipCompat" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, mtl
     , unix-compat
     }:
     mkDerivation {
       pname = "FileManipCompat";
       version = "0.18";
       sha256 = "601bcad3271ecaa9bf9e2e19cc6a4238900aab12d9473057abc1bdbf4e3e0130";
       libraryHaskellDepends = [
         base bytestring directory filepath mtl unix-compat
       ];
       description = "Expressive file and directory manipulation for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FilePather" = callPackage
    ({ mkDerivation, base, comonad, comonad-transformers, data-lens
     , directory, filepath, mtl, transformers
     }:
     mkDerivation {
       pname = "FilePather";
       version = "0.2.0";
       sha256 = "ad8324e3742a6289331c4e3cbd09dc3585bc05f59c94d348b02c00ed314492e7";
       libraryHaskellDepends = [
         base comonad comonad-transformers data-lens directory filepath mtl
         transformers
       ];
       homepage = "https://github.com/tonymorris/filepather";
       description = "Functions on System.FilePath";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "FileSystem" = callPackage
    ({ mkDerivation, base, binary, bytestring, directory, filepath, mtl
     , old-time
     }:
     mkDerivation {
       pname = "FileSystem";
       version = "1.0.0";
       sha256 = "8627e1e93c8b63d4b8ff9a64ecb9979213dacbfa7b48e8ece21e6fa9f6e5df63";
       libraryHaskellDepends = [
         base binary bytestring directory filepath mtl old-time
       ];
       jailbreak = true;
       homepage = "http://ddiaz.asofilak.es/packages/FileSystem";
       description = "File system data structure and monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Finance-Quote-Yahoo" = callPackage
    ({ mkDerivation, base, bytestring, http-conduit, network
     , old-locale, time
     }:
     mkDerivation {
       pname = "Finance-Quote-Yahoo";
       version = "0.8.0";
       sha256 = "dfc5aaf2f00f0e1b63e0483629feece8ccaa7d77b377ee2a380202996737e8b4";
       libraryHaskellDepends = [
         base bytestring http-conduit network old-locale time
       ];
       homepage = "http://www.b7j0c.org/stuff/haskell-yquote.xhtml";
       description = "Obtain quote data from finance.yahoo.com";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Finance-Treasury" = callPackage
    ({ mkDerivation, base, containers, HTTP, HTTP-Simple, hxt
     , hxt-filter, network, old-locale, time
     }:
     mkDerivation {
       pname = "Finance-Treasury";
       version = "0.1.2";
       sha256 = "546960bad4932ea652189317b086864bbad18c965691cf95074c9880246f9d9f";
       libraryHaskellDepends = [
         base containers HTTP HTTP-Simple hxt hxt-filter network old-locale
         time
       ];
       homepage = "http://www.ecoin.net/haskell/Finance-Treasury.html";
       description = "Obtain Treasury yield curve data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FindBin" = callPackage
    ({ mkDerivation, base, directory, filepath }:
     mkDerivation {
       pname = "FindBin";
       version = "0.0.5";
       sha256 = "279c7967e0803ca3b9a0a1956ce7ba9b9a2294eb9f971bea8a557b5f80ddfda4";
       libraryHaskellDepends = [ base directory filepath ];
       homepage = "https://github.com/audreyt/findbin";
       description = "Locate directory of original program";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "FiniteMap" = callPackage
    ({ mkDerivation, base, haskell98 }:
     mkDerivation {
       pname = "FiniteMap";
       version = "0.1";
       sha256 = "7ebe24ca2f3dd3822ef7bfbaf9917c5a831c9a8a527005e97488e957201ac6cd";
       libraryHaskellDepends = [ base haskell98 ];
       description = "A finite map implementation, derived from the paper: Efficient sets: a balancing act, S. Adams, Journal of functional programming 3(4) Oct 1993, pp553-562";
       license = stdenv.lib.licenses.bsdOriginal;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FirstOrderTheory" = callPackage
    ({ mkDerivation, base, containers, Proper }:
     mkDerivation {
       pname = "FirstOrderTheory";
       version = "0.1.0.6";
       sha256 = "f1884e300a05a1f253bf4bbddce633025a6da245ff119fe7c2432ad4278b81a4";
       libraryHaskellDepends = [ base containers Proper ];
       jailbreak = true;
       description = "Grammar and typeclass for first order theories";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FixedPoint-simple" = callPackage
    ({ mkDerivation, base, deepseq, template-haskell }:
     mkDerivation {
       pname = "FixedPoint-simple";
       version = "0.6.1";
       sha256 = "9665ba95416c3d0d9cf54200e5e731128c806d44f9cecf81a0a6c4814fd0de61";
       libraryHaskellDepends = [ base deepseq template-haskell ];
       homepage = "https://github.com/TomMD/FixedPoint";
       description = "Fixed point, large word, and large int numerical representations (types and common class instances)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Flippi" = callPackage
    ({ mkDerivation, base, cgi, containers, directory, haskell98
     , old-time, parsec, xhtml
     }:
     mkDerivation {
       pname = "Flippi";
       version = "0.0.5";
       sha256 = "89ae06853e95f399c5c6b5a10d6803dd775cdc9724e992774b545b36ec8045f0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cgi containers directory haskell98 old-time parsec xhtml
       ];
       homepage = "http://www.flippac.org/projects/flippi/";
       description = "Wiki";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Focus" = callPackage
    ({ mkDerivation, base, MissingH, split }:
     mkDerivation {
       pname = "Focus";
       version = "0.1.2";
       sha256 = "41e6d7ebdb1750c1878087bcca87e5c8099f0eda2a349f490c55a9d7ab812cb8";
       libraryHaskellDepends = [ base MissingH split ];
       description = "Tools for focusing in on locations within numbers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "Folly" = callPackage
    ({ mkDerivation, base, containers, HUnit, parsec }:
     mkDerivation {
       pname = "Folly";
       version = "0.2.0.1";
       sha256 = "6ae5a4c048262e89a653d04f7e56fa7f44499bcff681780f263f790c6c2a92a3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers parsec ];
       executableHaskellDepends = [ base containers HUnit parsec ];
       homepage = "https://github.com/dillonhuff/Folly";
       description = "A first order logic library in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "FontyFruity_0_4" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , directory, filepath, text, vector
     }:
     mkDerivation {
       pname = "FontyFruity";
       version = "0.4";
       sha256 = "6ec7392350e7a527bf92ae646f4cb01e144104b37c97526e5dbc86ad78d4345b";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq directory filepath text
         vector
       ];
       description = "A true type file format loader";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FontyFruity_0_4_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , directory, filepath, text, vector
     }:
     mkDerivation {
       pname = "FontyFruity";
       version = "0.4.1";
       sha256 = "c0873fd33e99864d9f4d63166aec26bf66f1b26a114449163c9292415c3c6be7";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq directory filepath text
         vector
       ];
       description = "A true type file format loader";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FontyFruity_0_5" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , directory, filepath, text, vector
     }:
     mkDerivation {
       pname = "FontyFruity";
       version = "0.5";
       sha256 = "51adca1811116dad3ae88dbee54a4dea06b3fbe975899dffb637a80c7ace4e98";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq directory filepath text
         vector
       ];
       description = "A true type file format loader";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FontyFruity_0_5_1_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , directory, filepath, text, vector
     }:
     mkDerivation {
       pname = "FontyFruity";
       version = "0.5.1.1";
       sha256 = "5e4c09e6c1f21c1f1fd4ae8bc2ecad584202eef72f46b694ae536481304e8c18";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq directory filepath text
         vector
       ];
       description = "A true type file format loader";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FontyFruity_0_5_2" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , directory, filepath, text, vector
     }:
     mkDerivation {
       pname = "FontyFruity";
       version = "0.5.2";
       sha256 = "bc7c25ee36a344f31a3a99eb0f4b8cf634141897a54012276d2a821f2e01bdf4";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq directory filepath text
         vector
       ];
       description = "A true type file format loader";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FontyFruity" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , directory, filepath, text, vector
     }:
     mkDerivation {
       pname = "FontyFruity";
       version = "0.5.3.1";
       sha256 = "24c77ee0ff24e79eeca3d60eb0e8c86e374d49f7b770c127c346ff2fbc782ecd";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq directory filepath text
         vector
       ];
       description = "A true type file format loader";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ForSyDe" = callPackage
    ({ mkDerivation, array, base, containers, directory, filepath, mtl
     , old-time, parameterized-data, pretty, process, random
     , regex-posix, template-haskell, type-level
     }:
     mkDerivation {
       pname = "ForSyDe";
       version = "3.1.1";
       sha256 = "172e73ddde923ea430701dd7f7d08b7f970cc46d3f989f81b732b7dbfdd4fc3d";
       libraryHaskellDepends = [
         array base containers directory filepath mtl old-time
         parameterized-data pretty process random regex-posix
         template-haskell type-level
       ];
       homepage = "http://www.ict.kth.se/forsyde/";
       description = "ForSyDe's Haskell-embedded Domain Specific Language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ForkableT" = callPackage
    ({ mkDerivation, base, monad-control, mtl, resourcet }:
     mkDerivation {
       pname = "ForkableT";
       version = "0.1.0.2";
       sha256 = "723f5b05eacc15a27c40476a08e1c8cfb686b4f81097699654ac0419fc7bf953";
       libraryHaskellDepends = [ base monad-control mtl resourcet ];
       homepage = "https://github.com/exFalso/ForkableT/";
       description = "Forkable monad transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "FormalGrammars" = callPackage
    ({ mkDerivation, ADPfusion, ansi-wl-pprint, base, bytestring
     , cmdargs, containers, data-default, HaTeX, lens, mtl, parsers
     , PrimitiveArray, semigroups, template-haskell, text, transformers
     , trifecta, unordered-containers, vector
     }:
     mkDerivation {
       pname = "FormalGrammars";
       version = "0.2.1.1";
       sha256 = "a469d5c1400123c2888ede6aadb13af2a21f491c1f6ec9c0362042a6f4c146fc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ADPfusion ansi-wl-pprint base bytestring containers data-default
         HaTeX lens mtl parsers PrimitiveArray semigroups template-haskell
         text transformers trifecta unordered-containers vector
       ];
       executableHaskellDepends = [ ansi-wl-pprint base cmdargs ];
       jailbreak = true;
       homepage = "https://github.com/choener/FormalGrammars";
       description = "(Context-free) grammars in formal language theory";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Foster" = callPackage
    ({ mkDerivation, array, base, cmdtheline, containers, random
     , strict
     }:
     mkDerivation {
       pname = "Foster";
       version = "1.1.2";
       sha256 = "ca2c7f580c33c9a7bf08d1138ef0906ce63d991bc99f2960de17303166b79270";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base cmdtheline containers random strict
       ];
       jailbreak = true;
       description = "Utilities to generate and solve puzzles";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FpMLv53" = callPackage
    ({ mkDerivation, base, HaXml }:
     mkDerivation {
       pname = "FpMLv53";
       version = "0.1";
       sha256 = "d764b066e9ea9fd129cb4d30e4a4a80e27f880dce00986367682e60f488afb40";
       libraryHaskellDepends = [ base HaXml ];
       homepage = "http://www.fpml.org/";
       description = "A binding for the Financial Products Markup Language (v5.3)";
       license = "LGPL";
     }) {};

  "FractalArt" = callPackage
    ({ mkDerivation, base, directory, filepath, JuicyPixels, libX11
     , mwc-random, primitive, random, vector
     }:
     mkDerivation {
       pname = "FractalArt";
       version = "0.2.0.0";
       sha256 = "011d310a8ba7d5e891bf8a6c0f567ccda609324df792d8533475e4f28a4c2097";
       revision = "2";
       editedCabalFile = "5ce975b8ccd2d1ed165abada3d4b8af27d8bac02783595343aac28a6d7617b74";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath JuicyPixels mwc-random primitive random
         vector
       ];
       executableSystemDepends = [ libX11 ];
       jailbreak = true;
       homepage = "https://github.com/TomSmeets/FractalArt";
       description = "Generates colorful wallpapers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.xorg) libX11;};

  "Fractaler" = callPackage
    ({ mkDerivation, base, FTGL, GLFW-b, OpenGLRaw, parallel, random
     , time
     }:
     mkDerivation {
       pname = "Fractaler";
       version = "3";
       sha256 = "ae0c81e8b34cac290c08fefa7d30c5172fb41edbb51c8fa7bc807c5e5aa6d240";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base FTGL GLFW-b OpenGLRaw parallel random time
       ];
       jailbreak = true;
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Frames" = callPackage
    ({ mkDerivation, base, ghc-prim, pipes, primitive, readable
     , template-haskell, text, transformers, vector, vinyl
     }:
     mkDerivation {
       pname = "Frames";
       version = "0.1.2.1";
       sha256 = "3e98ce3aa849d7912b955f6f0e4898fd3f59d2e2961189c02d7a4c6c0174816f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base ghc-prim pipes primitive readable template-haskell text
         transformers vector vinyl
       ];
       description = "Data frames For working with tabular data files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Frank" = callPackage
    ({ mkDerivation, base, mtl, newtype, she, void }:
     mkDerivation {
       pname = "Frank";
       version = "0.3";
       sha256 = "8163e0ba4df1d75243f94683fe7c15da744c9102fbf1e4e308d0ef87cb5229dd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base mtl newtype she void ];
       homepage = "http://personal.cis.strath.ac.uk/~conor/pub/Frank/";
       description = "An experimental programming language with typed algebraic effects";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FreeTypeGL" = callPackage
    ({ mkDerivation, base, freetype2, OpenGL }:
     mkDerivation {
       pname = "FreeTypeGL";
       version = "0.0.4";
       sha256 = "4e85f39777c29cc145b760289906b3a9f8e518296af258004223d87bbbdc5183";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base freetype2 OpenGL ];
       jailbreak = true;
       description = "Loadable texture fonts for OpenGL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "FunGEn" = callPackage
    ({ mkDerivation, base, base-compat, GLUT, OpenGL, random }:
     mkDerivation {
       pname = "FunGEn";
       version = "1.0";
       sha256 = "119cb0c6bff7a5cf416f0c94a535a0695e4e461105841fed516d207f8c648686";
       revision = "4";
       editedCabalFile = "7994da4a472d9460df18724f7e96cece4ccd4a62516d76f26d14701ceed19623";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base base-compat GLUT OpenGL random ];
       executableHaskellDepends = [ base GLUT OpenGL random ];
       jailbreak = true;
       homepage = "http://joyful.com/fungen";
       description = "A lightweight, cross-platform, OpenGL/GLUT-based game engine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "Fungi" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , ListZipper, mtl, mwc-random, old-time, process, random
     , transformers, tuple
     }:
     mkDerivation {
       pname = "Fungi";
       version = "1.0.6";
       sha256 = "8c395e61d78acff2c8a813c8532e9105dfb95cd2578367efb48d860a183a35a0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory filepath ListZipper mtl
         mwc-random old-time process random transformers tuple
       ];
       jailbreak = true;
       homepage = "https://github.com/thomaseding/fungi";
       description = "Funge-98 interpreter written in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "GA" = callPackage
    ({ mkDerivation, base, directory, random, transformers }:
     mkDerivation {
       pname = "GA";
       version = "1.0";
       sha256 = "e2c21dc7fa622c65e61cfa77092a5c2d67a171bb0b3b08b35560fb23e0bd55db";
       libraryHaskellDepends = [ base directory random transformers ];
       homepage = "http://boegel.kejo.be";
       description = "Genetic algorithm library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "GGg" = callPackage
    ({ mkDerivation, base, bimap }:
     mkDerivation {
       pname = "GGg";
       version = "0.1.0.2";
       sha256 = "07864913862ad112531cf0d508da2d7a907521ce5160ce7b24fbd41fd2003f89";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bimap ];
       jailbreak = true;
       homepage = "https://github.com/xnil/GGg";
       description = "GGg cipher";
       license = stdenv.lib.licenses.mit;
     }) {};

  "GHood" = callPackage
    ({ mkDerivation, array, base, process }:
     mkDerivation {
       pname = "GHood";
       version = "0.0.6";
       sha256 = "116b3974cd7e3600fd3724a74e08565edaeda92748156d7a21dd85563cb93b59";
       libraryHaskellDepends = [ array base process ];
       homepage = "http://www.cs.kent.ac.uk/people/staff/cr3/toolbox/haskell/GHood";
       description = "A graphical viewer for Hood";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "GLFW" = callPackage
    ({ mkDerivation, base, libX11, mesa, OpenGL }:
     mkDerivation {
       pname = "GLFW";
       version = "0.5.2.4";
       sha256 = "48fc9efb1da85b4bf20c506341999987e3bfeadf750ad19794030e927e4f4ca9";
       libraryHaskellDepends = [ base OpenGL ];
       librarySystemDepends = [ libX11 mesa ];
       jailbreak = true;
       homepage = "http://haskell.org/haskellwiki/GLFW";
       description = "A Haskell binding for GLFW";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs.xorg) libX11; inherit (pkgs) mesa;};

  "GLFW-OGL" = callPackage
    ({ mkDerivation, base, libX11, libXrandr, mtl, OGL }:
     mkDerivation {
       pname = "GLFW-OGL";
       version = "0.0";
       sha256 = "20244bc81b86c79b4090dbffdb91cd4d4a495454acaf483795606574dbbb1085";
       libraryHaskellDepends = [ base mtl OGL ];
       librarySystemDepends = [ libX11 libXrandr ];
       homepage = "http://haskell.org/haskellwiki/GLFW-OGL";
       description = "A binding for GLFW (OGL)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXrandr;};

  "GLFW-b" = callPackage
    ({ mkDerivation, base, bindings-GLFW, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "GLFW-b";
       version = "1.4.7.3";
       sha256 = "fbc6ee746efb16ec6ee83cd251c81c116b58f774146693e2f03a963154abe013";
       libraryHaskellDepends = [ base bindings-GLFW ];
       testHaskellDepends = [
         base bindings-GLFW HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       doCheck = false;
       description = "Bindings to GLFW OpenGL library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "GLFW-b-demo" = callPackage
    ({ mkDerivation, base, GLFW-b, mtl, OpenGL, pretty, stm
     , transformers
     }:
     mkDerivation {
       pname = "GLFW-b-demo";
       version = "1.0.6";
       sha256 = "a9f8857a185dcb4f82601611dfd4a4a5dad160227898a3d5a8c0e0b1f5020e07";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base GLFW-b mtl OpenGL pretty stm transformers
       ];
       jailbreak = true;
       description = "GLFW-b demo";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "GLFW-task" = callPackage
    ({ mkDerivation, base, GLFW, monad-task, OpenGL, transformers }:
     mkDerivation {
       pname = "GLFW-task";
       version = "0.2.0";
       sha256 = "170544aab07174a107a6d236f159fe20e178feaba622b517917ce86e6ee71184";
       libraryHaskellDepends = [
         base GLFW monad-task OpenGL transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ninegua/GLFW-task";
       description = "GLFW utility functions to use together with monad-task";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "GLHUI" = callPackage
    ({ mkDerivation, base, libX11, mesa }:
     mkDerivation {
       pname = "GLHUI";
       version = "1.1.0";
       sha256 = "4a012b29ff3de29399efeea269773906d5b2f56a9eee925b37ecf30ccde07d10";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ libX11 mesa ];
       description = "Open OpenGL context windows in X11 with libX11";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs.xorg) libX11; inherit (pkgs) mesa;};

  "GLM" = callPackage
    ({ mkDerivation, aeson, base, bytestring, interpolate, lens, mtl
     , parsec, pureMD5, QuickCheck, test-framework
     , test-framework-quickcheck2, test-framework-th, transformers
     }:
     mkDerivation {
       pname = "GLM";
       version = "0.7.0.0";
       sha256 = "2af28493755e53164ffcfe236fd5e071a2591ab3130ec1645cee1fe6dec0035c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring interpolate lens mtl parsec pureMD5
         QuickCheck test-framework test-framework-quickcheck2
         test-framework-th transformers
       ];
       executableHaskellDepends = [
         aeson base bytestring interpolate lens mtl parsec pureMD5
         test-framework test-framework-quickcheck2 test-framework-th
       ];
       testHaskellDepends = [
         base lens mtl parsec test-framework test-framework-quickcheck2
         test-framework-th
       ];
       homepage = "http://github.com/sordina/GLM";
       description = "Simple Gridlab-D GLM parser and utilities";
       license = stdenv.lib.licenses.mit;
     }) {};

  "GLMatrix" = callPackage
    ({ mkDerivation, base, OpenGLRaw }:
     mkDerivation {
       pname = "GLMatrix";
       version = "0.1.0.1";
       sha256 = "64f3be373987c3fd41bfba94a68701b414e35ed2fb75862654e3504f6f06c88e";
       libraryHaskellDepends = [ base OpenGLRaw ];
       jailbreak = true;
       homepage = "https://github.com/fiendfan1/GLMatrix";
       description = "Utilities for working with OpenGL matrices";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GLURaw_1_4_0_1" = callPackage
    ({ mkDerivation, base, freeglut, mesa, OpenGLRaw }:
     mkDerivation {
       pname = "GLURaw";
       version = "1.4.0.1";
       sha256 = "9655644beb54ff8fac68f2e0fd8a8e9a1e8409272e2e4c963ccce9bcd60e0ecc";
       revision = "1";
       editedCabalFile = "d83125fb416c0619106ec557733e75e8093f4ad923a8dfd969199297bb1c8619";
       libraryHaskellDepends = [ base OpenGLRaw ];
       librarySystemDepends = [ freeglut mesa ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A raw binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

  "GLURaw_1_4_0_2" = callPackage
    ({ mkDerivation, base, freeglut, mesa, OpenGLRaw }:
     mkDerivation {
       pname = "GLURaw";
       version = "1.4.0.2";
       sha256 = "0f4ae663840ba350e0ef04dd65d60f423ff6551ffbab3302ced9f1f0d4075e83";
       revision = "1";
       editedCabalFile = "6800f1d309c8bdea4cd3a054fa69c8fdc39d8f63193136e2638a93c8a8f31308";
       libraryHaskellDepends = [ base OpenGLRaw ];
       librarySystemDepends = [ freeglut mesa ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A raw binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

  "GLURaw_1_5_0_0" = callPackage
    ({ mkDerivation, base, freeglut, mesa, OpenGLRaw, transformers }:
     mkDerivation {
       pname = "GLURaw";
       version = "1.5.0.0";
       sha256 = "92e46f714b7469fa809fded3d894302d28d9ba49942a8356a6de7685035e78f8";
       libraryHaskellDepends = [ base OpenGLRaw transformers ];
       librarySystemDepends = [ freeglut mesa ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A raw binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

  "GLURaw_1_5_0_1" = callPackage
    ({ mkDerivation, base, freeglut, mesa, OpenGLRaw, transformers }:
     mkDerivation {
       pname = "GLURaw";
       version = "1.5.0.1";
       sha256 = "1b52c2637820c2bea38f40acdd217a68c0dd3849f7ed1308959aa324b6b2c8f1";
       libraryHaskellDepends = [ base OpenGLRaw transformers ];
       librarySystemDepends = [ freeglut mesa ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A raw binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

  "GLURaw_2_0_0_0" = callPackage
    ({ mkDerivation, base, freeglut, mesa, OpenGLRaw, transformers }:
     mkDerivation {
       pname = "GLURaw";
       version = "2.0.0.0";
       sha256 = "8ddd5d1bcab6668f6a6c6cd2dccbe17ff66aa0f58e8f197d78827963621d9104";
       libraryHaskellDepends = [ base OpenGLRaw transformers ];
       librarySystemDepends = [ freeglut mesa ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A raw binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

  "GLURaw" = callPackage
    ({ mkDerivation, base, freeglut, mesa, OpenGLRaw, transformers }:
     mkDerivation {
       pname = "GLURaw";
       version = "2.0.0.1";
       sha256 = "d561b2e170e6048f7f1b18647fa569f28684291e25924b41f169ecfdc281ab40";
       libraryHaskellDepends = [ base OpenGLRaw transformers ];
       librarySystemDepends = [ freeglut mesa ];
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A raw binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

  "GLUT_2_5_1_1" = callPackage
    ({ mkDerivation, array, base, containers, freeglut, mesa, OpenGL
     , OpenGLRaw
     }:
     mkDerivation {
       pname = "GLUT";
       version = "2.5.1.1";
       sha256 = "4a8177e154ead5a7bcc110f8fe408f9cf720783dde024ac1936cd95b659b2d59";
       libraryHaskellDepends = [ array base containers OpenGL OpenGLRaw ];
       librarySystemDepends = [ freeglut mesa ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A binding for the OpenGL Utility Toolkit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

  "GLUT_2_7_0_0" = callPackage
    ({ mkDerivation, array, base, containers, freeglut, mesa, OpenGL
     , OpenGLRaw, StateVar, transformers
     }:
     mkDerivation {
       pname = "GLUT";
       version = "2.7.0.0";
       sha256 = "6d84d7a05478ffb5e7637c9eef011decc6a46a2bd3571e28bf876ad75c31c50b";
       libraryHaskellDepends = [
         array base containers OpenGL OpenGLRaw StateVar transformers
       ];
       librarySystemDepends = [ freeglut mesa ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A binding for the OpenGL Utility Toolkit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

  "GLUT_2_7_0_1" = callPackage
    ({ mkDerivation, array, base, containers, freeglut, mesa, OpenGL
     , OpenGLRaw, StateVar, transformers
     }:
     mkDerivation {
       pname = "GLUT";
       version = "2.7.0.1";
       sha256 = "fb1ed80beed6dbf1b373839224d11932c20d1c1b571bef81101483099c459c4d";
       libraryHaskellDepends = [
         array base containers OpenGL OpenGLRaw StateVar transformers
       ];
       librarySystemDepends = [ freeglut mesa ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A binding for the OpenGL Utility Toolkit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

  "GLUT_2_7_0_5" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, freeglut
     , mesa, OpenGL, OpenGLRaw, random, StateVar, transformers
     }:
     mkDerivation {
       pname = "GLUT";
       version = "2.7.0.5";
       sha256 = "72d4545ef6ca0ad473f0780d6bc934febc7dfbf0b42aad8c3a8ca67e663795bf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers OpenGL StateVar transformers
       ];
       librarySystemDepends = [ freeglut mesa ];
       executableHaskellDepends = [
         array base bytestring OpenGLRaw random
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A binding for the OpenGL Utility Toolkit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

  "GLUT" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, freeglut
     , mesa, OpenGL, OpenGLRaw, random, StateVar, transformers
     }:
     mkDerivation {
       pname = "GLUT";
       version = "2.7.0.6";
       sha256 = "c2166db513482178bd5f331a591d70f00d78e9f19afe9e1e572d222e7855d43a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers OpenGL StateVar transformers
       ];
       librarySystemDepends = [ freeglut mesa ];
       executableHaskellDepends = [
         array base bytestring OpenGLRaw random
       ];
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A binding for the OpenGL Utility Toolkit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

  "GLUtil" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , filepath, hpp, JuicyPixels, linear, OpenGL, OpenGLRaw
     , transformers, vector
     }:
     mkDerivation {
       pname = "GLUtil";
       version = "0.8.8";
       sha256 = "2ceb807d97c1c599d26be80d4bae98321cdbd59cff3af0dd68d1daa27615c7d4";
       libraryHaskellDepends = [
         array base bytestring containers directory filepath hpp JuicyPixels
         linear OpenGL OpenGLRaw transformers vector
       ];
       jailbreak = true;
       description = "Miscellaneous OpenGL utilities";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GPX" = callPackage
    ({ mkDerivation, base, comonad, comonad-transformers, containers
     , data-lens, hxt, newtype, xsd
     }:
     mkDerivation {
       pname = "GPX";
       version = "0.8.0";
       sha256 = "f306dd0720b718ccfe4a78354089947da8ae195835d36a01e9f2ad8028a11b23";
       libraryHaskellDepends = [
         base comonad comonad-transformers containers data-lens hxt newtype
         xsd
       ];
       jailbreak = true;
       homepage = "https://github.com/tonymorris/geo-gpx";
       description = "Parse GPX files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GPipe_2_1_5" = callPackage
    ({ mkDerivation, base, Boolean, containers, exception-transformers
     , gl, hashtables, linear, transformers
     }:
     mkDerivation {
       pname = "GPipe";
       version = "2.1.5";
       sha256 = "9fa21d4eb6b09374e9119a304359d337eed96aa33fbbcf6df4ee6f5ef85da290";
       libraryHaskellDepends = [
         base Boolean containers exception-transformers gl hashtables linear
         transformers
       ];
       homepage = "http://tobbebex.blogspot.se/";
       description = "Typesafe functional GPU graphics programming";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GPipe_2_1_6" = callPackage
    ({ mkDerivation, base, Boolean, containers, exception-transformers
     , gl, hashtables, linear, transformers
     }:
     mkDerivation {
       pname = "GPipe";
       version = "2.1.6";
       sha256 = "2ab8d54731b9e0a5a799cb592f83c9d131534b9d9b1dc8098c36e698d23808f6";
       libraryHaskellDepends = [
         base Boolean containers exception-transformers gl hashtables linear
         transformers
       ];
       homepage = "http://tobbebex.blogspot.se/";
       description = "Typesafe functional GPU graphics programming";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GPipe" = callPackage
    ({ mkDerivation, base, Boolean, containers, exception-transformers
     , gl, hashtables, linear, transformers
     }:
     mkDerivation {
       pname = "GPipe";
       version = "2.1.7";
       sha256 = "ebb54d9994bcb9c14064af5468c3c0f34f02db07d6033f562dd09b4718538814";
       libraryHaskellDepends = [
         base Boolean containers exception-transformers gl hashtables linear
         transformers
       ];
       homepage = "http://tobbebex.blogspot.se/";
       description = "Typesafe functional GPU graphics programming";
       license = stdenv.lib.licenses.mit;
     }) {};

  "GPipe-Collada" = callPackage
    ({ mkDerivation, array, base, containers, GPipe, HaXml, mtl, Vec }:
     mkDerivation {
       pname = "GPipe-Collada";
       version = "0.1.4";
       sha256 = "1c3ed97d4b4c0ad4b13d64d8d90af0e68efcc6e1179ccbe2e918f407caf61b2b";
       libraryHaskellDepends = [
         array base containers GPipe HaXml mtl Vec
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/GPipe";
       description = "Load GPipe meshes from Collada files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GPipe-Examples" = callPackage
    ({ mkDerivation, base, GLUT, GPipe, GPipe-TextureLoad, haskell98
     , Vec, Vec-Transform
     }:
     mkDerivation {
       pname = "GPipe-Examples";
       version = "0.1";
       sha256 = "33ecb768e19336cf88a5468da0d7d30ce7514842df6c1a71adb0cc0aba132347";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base GLUT GPipe GPipe-TextureLoad haskell98 Vec Vec-Transform
       ];
       description = "Examples for the GPipes package";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GPipe-GLFW" = callPackage
    ({ mkDerivation, base, GLFW-b, GPipe, transformers }:
     mkDerivation {
       pname = "GPipe-GLFW";
       version = "1.2.1";
       sha256 = "36b49d8350c205633e3dd3f2061553154f7a397c63bfa03be4c84bb8cc946a4a";
       libraryHaskellDepends = [ base GLFW-b GPipe transformers ];
       homepage = "https://github.com/plredmond/GPipe-GLFW";
       description = "GLFW OpenGL context creation for GPipe";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "GPipe-TextureLoad" = callPackage
    ({ mkDerivation, base, bitmap, GPipe, stb-image }:
     mkDerivation {
       pname = "GPipe-TextureLoad";
       version = "1.0.4";
       sha256 = "644d39d318636749cd206275e7fde89a77fecb656ad21dad1744deedc724c7f9";
       libraryHaskellDepends = [ base bitmap GPipe stb-image ];
       homepage = "http://www.haskell.org/haskellwiki/GPipe";
       description = "Load GPipe textures from filesystem";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GTALib" = callPackage
    ({ mkDerivation, base, containers, deepseq, HUnit, parallel
     , template-haskell, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "GTALib";
       version = "0.0.6";
       sha256 = "e837e1ee368df4a9d2bdbceea7612c27806f56ac1004c9d6ddec358e2c178782";
       libraryHaskellDepends = [
         base containers deepseq parallel template-haskell
       ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/emoto/gtalib";
       description = "A library for GTA programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Gamgine" = callPackage
    ({ mkDerivation, array, base, bytestring, composition, cpphs
     , data-lens, directory, filepath, GLFW-b, ListZipper, mtl
     , OpenGLRaw, parsec, pretty-show, StateVar, time
     , unordered-containers, utility-ht, Vec, zlib
     }:
     mkDerivation {
       pname = "Gamgine";
       version = "0.5";
       sha256 = "80833c191728fed5faec3b761e3dfd85446cd718f708abcc7c2a983e5c7c378c";
       libraryHaskellDepends = [
         array base bytestring composition cpphs data-lens directory
         filepath GLFW-b ListZipper mtl OpenGLRaw parsec pretty-show
         StateVar time unordered-containers utility-ht Vec zlib
       ];
       jailbreak = true;
       description = "Some kind of game library or set of utilities";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Ganymede" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, mtl, parsec
     , transformers
     }:
     mkDerivation {
       pname = "Ganymede";
       version = "0.0.0.5";
       sha256 = "93b385f9ddb38854b724d760fdfc7239feeab118af3dba73f7414cd7ae33abba";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath mtl parsec transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/BMeph/Ganymede";
       description = "An Io interpreter in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GaussQuadIntegration" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "GaussQuadIntegration";
       version = "0.1";
       sha256 = "a2dfacf200b0dbfafd4c76e7e0c75532d46dec59db42f2fac5680c902ac0216d";
       libraryHaskellDepends = [ base ];
       description = "Non-adaptive Gaussian quadrature for numeric integraton";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "GeBoP" = callPackage
    ({ mkDerivation, array, base, directory, random, wx, wxcore }:
     mkDerivation {
       pname = "GeBoP";
       version = "1.7.5";
       sha256 = "fdf0a97c6c81fbb88973e20167535959bbe0e781af69380ec1c44dc78b665093";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base directory random wx wxcore
       ];
       homepage = "http://www.haskell.org/haskellwiki/GeBoP";
       description = "Several games";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "GenI" = callPackage
    ({ mkDerivation, base, binary, bytestring, cabal-macosx, containers
     , deepseq, directory, errors, filepath, hslogger, HUnit, json, mtl
     , old-locale, ordered, parsec, process, QuickCheck, smallcheck, syb
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , test-framework-smallcheck, text, time, transformers, yaml-light
     }:
     mkDerivation {
       pname = "GenI";
       version = "0.24.3";
       sha256 = "17d041ad0816d799e2697ad785a479ee176c62c8e1994ae4c3bd7b25cc78b13e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring cabal-macosx containers deepseq directory
         errors filepath hslogger json mtl old-locale ordered parsec process
         syb text time transformers yaml-light
       ];
       executableHaskellDepends = [
         base containers directory errors filepath hslogger json mtl process
         yaml-light
       ];
       testHaskellDepends = [
         base containers errors filepath HUnit json mtl parsec QuickCheck
         smallcheck test-framework test-framework-hunit
         test-framework-quickcheck2 test-framework-smallcheck text
         transformers
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/GenI";
       description = "A natural language generator (specifically, an FB-LTAG surface realiser)";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GenSmsPdu" = callPackage
    ({ mkDerivation, base, haskell98, QuickCheck, random }:
     mkDerivation {
       pname = "GenSmsPdu";
       version = "0.1";
       sha256 = "7fb12d37fcddcd8f3551a677bc8701cb0711e8fd00c5a13163f5a04bd1a941ef";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskell98 QuickCheck random ];
       description = "Automatic SMS message generator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Genbank" = callPackage
    ({ mkDerivation, base, biocore, biofasta, bytestring, cmdargs
     , parsec, split
     }:
     mkDerivation {
       pname = "Genbank";
       version = "1.0.3";
       sha256 = "2baf631ac851b1c29ba531ae1c16b8ba3c4b672bac9d4840a3b9afc0a89d2b93";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base biocore biofasta bytestring parsec split
       ];
       executableHaskellDepends = [ base cmdargs ];
       description = "Libary for processing the NCBI genbank format";
       license = "GPL";
     }) {};

  "GeneralTicTacToe" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "GeneralTicTacToe";
       version = "0.1.0.1";
       sha256 = "6f128cac6cdba15f1328dbb3bb55333b7e9cbb0a277de9a99144ff32a12ecf36";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://afonso.xyz";
       description = "A general TicTacToe game implementation";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GenericPretty" = callPackage
    ({ mkDerivation, base, ghc-prim, pretty }:
     mkDerivation {
       pname = "GenericPretty";
       version = "1.2.1";
       sha256 = "175e334292904d365c630c9dfcc5a94f0c052a88a10d34513f39ebc36205672d";
       libraryHaskellDepends = [ base ghc-prim pretty ];
       homepage = "https://github.com/RazvanRanca/GenericPretty";
       description = "A generic, derivable, haskell pretty printer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "GenussFold" = callPackage
    ({ mkDerivation, ADPfusion, ansi-wl-pprint, base, bytestring
     , cmdargs, containers, data-default, FormalGrammars, lens, mtl
     , PrimitiveArray, QuickCheck, semigroups, template-haskell
     , test-framework, test-framework-quickcheck2, test-framework-th
     , text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "GenussFold";
       version = "0.0.0.2";
       sha256 = "55031cfaec4c75852f3c4796fbd97afb7d156eca00a9ceb7b56718c50785daaf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ADPfusion ansi-wl-pprint base bytestring containers data-default
         FormalGrammars lens mtl PrimitiveArray semigroups template-haskell
         text transformers unordered-containers vector
       ];
       executableHaskellDepends = [ base cmdargs FormalGrammars ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
         test-framework-th
       ];
       jailbreak = true;
       homepage = "https://github.com/choener/GenussFold";
       description = "MCFGs for Genus-1 RNA Pseudoknots";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GeoIp" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-mmap, syb }:
     mkDerivation {
       pname = "GeoIp";
       version = "0.3";
       sha256 = "a1767993ed9d3d5ac0413c23268443ec65d3c7a26f77f5165799e1c345a973e0";
       libraryHaskellDepends = [ base bytestring bytestring-mmap syb ];
       description = "Pure bindings for the MaxMind IP database";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GeocoderOpenCage" = callPackage
    ({ mkDerivation, aeson, base, bytestring, HTTP, text }:
     mkDerivation {
       pname = "GeocoderOpenCage";
       version = "0.1.0.1";
       sha256 = "ab70cbd8a73d45b6ed8c4d692e39e54180def339f29ff1ba9671f24d07e7bab0";
       libraryHaskellDepends = [ aeson base bytestring HTTP text ];
       jailbreak = true;
       homepage = "https://github.com/juergenhah/Haskell-Geocoder-OpenCage.git";
       description = "Geocoder and Reverse Geocoding Service Wrapper";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Geodetic" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Geodetic";
       version = "0.4";
       sha256 = "18a1d666a09672dcd295841a9abbdc86262797557be532f8f30fe3a461c160d9";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.google.com/p/geodetic/";
       description = "Geodetic calculations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "GeomPredicates" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "GeomPredicates";
       version = "0.1";
       sha256 = "9ef18e39d9eda521e942198917914143b3303621975d13f64c3e7928608e4ca7";
       libraryHaskellDepends = [ base ];
       description = "Geometric predicates";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "GeomPredicates-SSE" = callPackage
    ({ mkDerivation, base, GeomPredicates }:
     mkDerivation {
       pname = "GeomPredicates-SSE";
       version = "0.2";
       sha256 = "9875982121d1260ab6441e4c89771489a676808431e95ad4a473eb208553ada2";
       libraryHaskellDepends = [ base GeomPredicates ];
       description = "Geometric predicates (Intel SSE)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GiST" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "GiST";
       version = "0.0.1";
       sha256 = "2e450cc29ff9bf7b6021c35ddb1b92a0dafb98c74fd8535040ed9e78b1d47b7a";
       libraryHaskellDepends = [ base text ];
       jailbreak = true;
       description = "A Haskell implementation of a Generalized Search Tree (GiST)";
       license = "GPL";
     }) {};

  "Gifcurry" = callPackage
    ({ mkDerivation, base, directory, gtk3, process, temporary }:
     mkDerivation {
       pname = "Gifcurry";
       version = "0.1.0.5";
       sha256 = "6a862236c56993145cbcc015739a596c4ee46d5488f28544e0cf7ee8759b362c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory gtk3 process temporary
       ];
       homepage = "https://github.com/lettier/gifcurry";
       description = "Create animated GIFs, overlaid with optional text, from video files";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "GiveYouAHead" = callPackage
    ({ mkDerivation, base, directory, extra, old-time, process }:
     mkDerivation {
       pname = "GiveYouAHead";
       version = "0.2.2.3";
       sha256 = "6ec9389736df70f4b3fea2c897f0befc32cde16fceb955c1aad2f2270cf5c981";
       libraryHaskellDepends = [ base directory extra old-time process ];
       homepage = "https://github.com/Qinka/GiveYouAHead/";
       description = "to auto-do somethings";
       license = stdenv.lib.licenses.mit;
     }) {};

  "Glob" = callPackage
    ({ mkDerivation, base, containers, directory, dlist, filepath
     , transformers
     }:
     mkDerivation {
       pname = "Glob";
       version = "0.7.5";
       sha256 = "0063bbc680d90f522455c0dec1121837689da542f4d9c70924d98bfb1389be41";
       revision = "1";
       editedCabalFile = "219b9caf1aaf9c2ab69ac75242f6017f0cd804a3370e0d63ac48777888fd909b";
       libraryHaskellDepends = [
         base containers directory dlist filepath transformers
       ];
       homepage = "http://iki.fi/matti.niemenmaa/glob/";
       description = "Globbing library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "GlomeTrace" = callPackage
    ({ mkDerivation, array, base, GlomeVec }:
     mkDerivation {
       pname = "GlomeTrace";
       version = "0.3";
       sha256 = "13b85492c285586f3075758e38ecad9bf9657073db01a4869fda21a329482258";
       libraryHaskellDepends = [ array base GlomeVec ];
       homepage = "http://www.haskell.org/haskellwiki/Glome";
       description = "Ray Tracing Library";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GlomeVec" = callPackage
    ({ mkDerivation, array, base, llvm }:
     mkDerivation {
       pname = "GlomeVec";
       version = "0.2";
       sha256 = "201884b98a49cc0fa63799fc85b1852451733feebb87f242d3acce359b8a1e22";
       libraryHaskellDepends = [ array base ];
       libraryPkgconfigDepends = [ llvm ];
       homepage = "http://www.haskell.org/haskellwiki/Glome";
       description = "Simple 3D vector library";
       license = "GPL";
     }) {inherit (self.llvmPackages) llvm;};

  "GlomeView" = callPackage
    ({ mkDerivation, base, deepseq, GlomeTrace, GlomeVec, monad-par
     , random, SDL, time, vector
     }:
     mkDerivation {
       pname = "GlomeView";
       version = "0.3";
       sha256 = "784dd0a7e7b9e0b3536568012a05c5cda85e844512bf8e2b9a4dbd84c4a28f5e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base deepseq GlomeTrace GlomeVec monad-par random SDL time vector
       ];
       homepage = "http://haskell.org/haskellwiki/Glome";
       description = "SDL Frontend for Glome ray tracer";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GoogleChart" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "GoogleChart";
       version = "0.2";
       sha256 = "691b8271ce7c791ae17fffda24ed2c319f85f9b4d3669d0a79f529629b5eca71";
       libraryHaskellDepends = [ base ];
       homepage = "http://neugierig.org/software/darcs/browse/?r=google-chart;a=summary";
       description = "Generate web-based charts using the Google Chart API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "GoogleDirections" = callPackage
    ({ mkDerivation, AttoJson, base, bytestring, containers, dataenc
     , download-curl
     }:
     mkDerivation {
       pname = "GoogleDirections";
       version = "0.3.0.1";
       sha256 = "63c9350e9b970f96d5ccd57f86a0f45b954b145a38c37181c94629e4a338f3f4";
       libraryHaskellDepends = [
         AttoJson base bytestring containers dataenc download-curl
       ];
       homepage = "https://github.com/favilo/GoogleDirections.git";
       description = "Haskell Interface to Google Directions API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GoogleSB" = callPackage
    ({ mkDerivation, base, binary, Crypto, haskell98, HTTP, mtl
     , network, split
     }:
     mkDerivation {
       pname = "GoogleSB";
       version = "0.1";
       sha256 = "880bb8b2a648de24e752457711e5f65f6e154098edf3a1a08db8a72c59bfd2bd";
       libraryHaskellDepends = [
         base binary Crypto haskell98 HTTP mtl network split
       ];
       description = "Interface to Google Safe Browsing API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GoogleSuggest" = callPackage
    ({ mkDerivation, base, dataenc, download-curl, utf8-string, xml }:
     mkDerivation {
       pname = "GoogleSuggest";
       version = "0.0.4";
       sha256 = "2b4b276e2f5d2a728ac8d2e9d617febbbe5f1e6de16c034a9ee07a127f6a0ecb";
       libraryHaskellDepends = [
         base dataenc download-curl utf8-string xml
       ];
       description = "Interface to Google Suggest API";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "GoogleTranslate" = callPackage
    ({ mkDerivation, AttoJson, base, bytestring, dataenc, download-curl
     }:
     mkDerivation {
       pname = "GoogleTranslate";
       version = "0.0.5";
       sha256 = "46b1c5f78a0752cdb285383b97e8c66427a811dc8bdd028967b9747bbecc2043";
       libraryHaskellDepends = [
         AttoJson base bytestring dataenc download-curl
       ];
       description = "Interface to Google Translate API";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GotoT-transformers" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "GotoT-transformers";
       version = "1.0.0.1";
       sha256 = "1e7ed7020302f606e7a172709a2e4b50e2bf50a9900b00328db1d9cbc40d3cf0";
       libraryHaskellDepends = [ base transformers ];
       jailbreak = true;
       homepage = "http://github.com/gcross/GotoT-transformers";
       description = "A monad and monadic transformer providing \"goto\" functionality";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "GrammarProducts" = callPackage
    ({ mkDerivation, ADPfusion, ansi-wl-pprint, base, bytestring
     , containers, data-default, FormalGrammars, lens, newtype, parsers
     , PrimitiveArray, semigroups, template-haskell, transformers
     , trifecta
     }:
     mkDerivation {
       pname = "GrammarProducts";
       version = "0.1.1.1";
       sha256 = "199c7ac4127330a4b19a769d92ac9cc102dd8b434dfff74d331e3b5e1881b065";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ADPfusion ansi-wl-pprint base bytestring containers data-default
         FormalGrammars lens newtype parsers PrimitiveArray semigroups
         template-haskell transformers trifecta
       ];
       jailbreak = true;
       homepage = "https://github.com/choener/GrammarProducts";
       description = "Grammar products and higher-dimensional grammars";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Graph500" = callPackage
    ({ mkDerivation, array, base, containers, mersenne-random-pure64
     , mtl, random
     }:
     mkDerivation {
       pname = "Graph500";
       version = "0.4.0";
       sha256 = "a99c2fdf01f89b35a3060691e16eca607c21337faed4025f220921424a161652";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers mersenne-random-pure64 mtl random
       ];
       executableHaskellDepends = [ array base mtl ];
       description = "Graph500 benchmark-related definitions and data set generator";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GraphHammer" = callPackage
    ({ mkDerivation, array, base, containers, Graph500, mtl, stm, time
     }:
     mkDerivation {
       pname = "GraphHammer";
       version = "0.3";
       sha256 = "f5df913589a8c32d94c30385866097efb0bc8a24f094f866ddd4a3e1c51bea39";
       libraryHaskellDepends = [
         array base containers Graph500 mtl stm time
       ];
       description = "GraphHammer Haskell graph analyses framework inspired by STINGER";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GraphHammer-examples" = callPackage
    ({ mkDerivation, array, base, containers, Graph500, GraphHammer
     , mtl
     }:
     mkDerivation {
       pname = "GraphHammer-examples";
       version = "0.3";
       sha256 = "bbd93fe66d79ca604a9dabafa43050325da0f28711ea09dfb60d618b406ee1a2";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers Graph500 GraphHammer mtl
       ];
       description = "Test harness for TriangleCount analysis";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GraphSCC" = callPackage
    ({ mkDerivation, array, base, containers }:
     mkDerivation {
       pname = "GraphSCC";
       version = "1.0.4";
       sha256 = "789d93e6188845f009779b1c800b043f524587a21d324be8594d09b0f8e86cf1";
       libraryHaskellDepends = [ array base containers ];
       description = "Tarjan's algorithm for computing the strongly connected components of a graph";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Graphalyze" = callPackage
    ({ mkDerivation, array, base, bktrees, containers, directory, fgl
     , filepath, graphviz, old-locale, pandoc, process, random, text
     , time
     }:
     mkDerivation {
       pname = "Graphalyze";
       version = "0.14.1.1";
       sha256 = "9792207d74f5aff52b3e5b83378db480702b8b5e1b13e65113e2f32e7687ce9f";
       libraryHaskellDepends = [
         array base bktrees containers directory fgl filepath graphviz
         old-locale pandoc process random text time
       ];
       jailbreak = true;
       description = "Graph-Theoretic Analysis library";
       license = "unknown";
     }) {};

  "Grempa" = callPackage
    ({ mkDerivation, array, base, containers, mtl, QuickCheck
     , template-haskell, th-lift
     }:
     mkDerivation {
       pname = "Grempa";
       version = "0.2.2";
       sha256 = "2eec38e7f2da31c08dbbd830fabb5ef5fbb8bbbd7de77b172ba57088e6ba0a70";
       libraryHaskellDepends = [
         array base containers mtl QuickCheck template-haskell th-lift
       ];
       description = "Embedded grammar DSL and LALR parser generator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GroteTrap" = callPackage
    ({ mkDerivation, base, mtl, parsec, QuickCheck, syb }:
     mkDerivation {
       pname = "GroteTrap";
       version = "0.5.1";
       sha256 = "f38863a54d907ec32193f0a2be684fe184b7b0d34cd58d6d5bed2aa5ee30318c";
       libraryHaskellDepends = [ base mtl parsec QuickCheck syb ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/GroteTrap";
       description = "Parser and selection library for expression languages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Grow" = callPackage
    ({ mkDerivation, array, base, bytestring, clock, containers
     , deepseq, definitive-base, definitive-filesystem
     , definitive-parser, definitive-reactive, directory, filepath
     , old-locale, primitive, process, time, unix, vector
     }:
     mkDerivation {
       pname = "Grow";
       version = "1.1.0.3";
       sha256 = "74acf9500f2a221b8cf9372739839516326c5845dc5b4531329bedef8aa584ed";
       revision = "3";
       editedCabalFile = "e599aab8eefc612bbf1dbae0b60308305a9d3009dda186b228e4e8aeeda1f36a";
       libraryHaskellDepends = [
         array base bytestring clock containers deepseq definitive-base
         definitive-filesystem definitive-parser definitive-reactive
         directory filepath old-locale primitive process time unix vector
       ];
       jailbreak = true;
       homepage = "http://coiffier.net/projects/grow.html";
       description = "A declarative make-like interpreter";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GrowlNotify" = callPackage
    ({ mkDerivation, base, binary, bytestring, Crypto, haskell98
     , network
     }:
     mkDerivation {
       pname = "GrowlNotify";
       version = "0.4";
       sha256 = "055ae38bf888d1dd11a131e86c1d6cc0a4df85458faf25790433206ada08a28e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring Crypto haskell98 network
       ];
       executableHaskellDepends = [
         base binary bytestring Crypto haskell98 network
       ];
       description = "Notification utility for Growl";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Gtk2hsGenerics" = callPackage
    ({ mkDerivation, array, base, cairo, containers, glib, gtk
     , haskell98, mtl
     }:
     mkDerivation {
       pname = "Gtk2hsGenerics";
       version = "0.1";
       sha256 = "89166eb91f8af40e203b7fd158ea0065abe0bd6168301b47dc781c6f7d3947be";
       libraryHaskellDepends = [
         array base cairo containers glib gtk haskell98 mtl
       ];
       description = "Convenience functions to extend Gtk2hs";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GtkGLTV" = callPackage
    ({ mkDerivation, base, bitmap, bitmap-opengl, gtk, gtkglext, GtkTV
     , OpenGL, stb-image, time
     }:
     mkDerivation {
       pname = "GtkGLTV";
       version = "0.2.0";
       sha256 = "e2d669c240b5d22cce22350b2808a3c0ed6a5de535564fbf742edf62d41b6cf6";
       libraryHaskellDepends = [
         base bitmap bitmap-opengl gtk gtkglext GtkTV OpenGL stb-image time
       ];
       description = "OpenGL support for Gtk-based GUIs for Tangible Values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GtkTV" = callPackage
    ({ mkDerivation, base, gtk, time, TV, TypeCompose, vector-space }:
     mkDerivation {
       pname = "GtkTV";
       version = "0.2.0";
       sha256 = "2898ec9cd89c8aa6efda5578bdd46537c9bef19624771df096738cf21e45bd4b";
       libraryHaskellDepends = [
         base gtk time TV TypeCompose vector-space
       ];
       homepage = "http://haskell.org/haskellwiki/GtkTV";
       description = "Gtk-based GUIs for Tangible Values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "GuiHaskell" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, glade, gtk
     , parsec, process, proplang
     }:
     mkDerivation {
       pname = "GuiHaskell";
       version = "0.1.1";
       sha256 = "214c2fd5d3bf0c49006e597c2a90b142f68f0f66cc9951517b58ef45edcafee5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath glade gtk parsec process
         proplang
       ];
       homepage = "http://www-users.cs.york.ac.uk/~ndm/guihaskell/";
       description = "A graphical REPL and development environment for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "GuiTV" = callPackage
    ({ mkDerivation, base, DeepArrow, phooey, TV, TypeCompose }:
     mkDerivation {
       pname = "GuiTV";
       version = "0.4";
       sha256 = "b1ac48b2769fee02b86260635f627180fe9af90f45ee11196a000f54fb6ab696";
       libraryHaskellDepends = [ base DeepArrow phooey TV TypeCompose ];
       homepage = "http://haskell.org/haskellwiki/GuiTV";
       description = "GUIs for Tangible Values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "H" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, directory, file-embed
     , inline-r, pretty, process, singletons, tasty, tasty-golden
     , tasty-hunit, temporary, text, vector
     }:
     mkDerivation {
       pname = "H";
       version = "0.8.0.0";
       sha256 = "b679dc140f783afa598da1bc2d111d603ad94b5f04d7db912452194635d47484";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs file-embed inline-r pretty process
         temporary vector
       ];
       testHaskellDepends = [
         base bytestring directory inline-r process singletons tasty
         tasty-golden tasty-hunit text vector
       ];
       doCheck = false;
       description = "The Haskell/R mixed programming environment";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HARM" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "HARM";
       version = "0.1.4";
       sha256 = "568e218d1f488b5aea1a6287a03fb48334dea9d0e3c6455dcada625025208d56";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base ];
       executableHaskellDepends = [ array base ];
       homepage = "http://www.engr.uconn.edu/~jeffm/Classes/CSE240-Spring-2001/Lectures/index.html";
       description = "A simple ARM emulator in haskell";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HAppS-Data" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, HAppS-Util
     , HaXml, mtl, pretty, syb, syb-with-class, template-haskell
     }:
     mkDerivation {
       pname = "HAppS-Data";
       version = "0.9.3";
       sha256 = "b23c6f4a949927194e47f9781edc3b7d38513210de4a24987859d68b375bc335";
       libraryHaskellDepends = [
         base binary bytestring containers HAppS-Util HaXml mtl pretty syb
         syb-with-class template-haskell
       ];
       jailbreak = true;
       description = "HAppS data manipulation libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HAppS-IxSet" = callPackage
    ({ mkDerivation, base, containers, HAppS-Data, HAppS-State
     , HAppS-Util, hslogger, mtl, syb, syb-with-class, template-haskell
     }:
     mkDerivation {
       pname = "HAppS-IxSet";
       version = "0.9.3";
       sha256 = "ebacd72e153bbcafb18bf4fa607550de98f8a991e9cfd8314b572cacf155a372";
       libraryHaskellDepends = [
         base containers HAppS-Data HAppS-State HAppS-Util hslogger mtl syb
         syb-with-class template-haskell
       ];
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HAppS-Server" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory
     , HAppS-Data, HAppS-IxSet, HAppS-State, HAppS-Util, HaXml, hslogger
     , html, HTTP, mtl, network, old-locale, old-time, parsec, process
     , random, syb, template-haskell, unix, xhtml
     }:
     mkDerivation {
       pname = "HAppS-Server";
       version = "0.9.3.1";
       sha256 = "b03129f332c35cd558b0f32bc626321dcfa2647dd7ddf67f3403eca8c4c52038";
       libraryHaskellDepends = [
         base bytestring containers directory HAppS-Data HAppS-IxSet
         HAppS-State HAppS-Util HaXml hslogger html HTTP mtl network
         old-locale old-time parsec process random syb template-haskell unix
         xhtml
       ];
       jailbreak = true;
       description = "Web related tools and services";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HAppS-State" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , filepath, HAppS-Data, HAppS-Util, HaXml, hslogger, hspread, mtl
     , network, old-locale, old-time, random, stm, syb, template-haskell
     , unix
     }:
     mkDerivation {
       pname = "HAppS-State";
       version = "0.9.3";
       sha256 = "5099e635f8fcf56f775947a241a24e1aab6eb6d9fee0406e6a2169c4c8b331e4";
       libraryHaskellDepends = [
         base binary bytestring containers directory filepath HAppS-Data
         HAppS-Util HaXml hslogger hspread mtl network old-locale old-time
         random stm syb template-haskell unix
       ];
       jailbreak = true;
       description = "Event-based distributed state";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HAppS-Util" = callPackage
    ({ mkDerivation, array, base, bytestring, directory, hslogger, mtl
     , old-time, process, template-haskell
     }:
     mkDerivation {
       pname = "HAppS-Util";
       version = "0.9.3";
       sha256 = "f9120d256e37111b6203dfc4eb598dd438c87e53bb9eb37258c999dd49b8e655";
       libraryHaskellDepends = [
         array base bytestring directory hslogger mtl old-time process
         template-haskell
       ];
       description = "Web framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HAppSHelpers" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "HAppSHelpers";
       version = "0.11";
       sha256 = "436125f649254804fdedae02429d6d558f0e0feb976e6348639019b180819dc3";
       doHaddock = false;
       description = "OBSOLETE. Please use happstack-helpers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HCL" = callPackage
    ({ mkDerivation, base, containers, mtl, QuickCheck, random }:
     mkDerivation {
       pname = "HCL";
       version = "1.4";
       sha256 = "34678e9e5c122544751a4d9a75585720c5ad68c0b6a772f071a4dac0dab6ee37";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers mtl QuickCheck random ];
       executableHaskellDepends = [
         base containers mtl QuickCheck random
       ];
       jailbreak = true;
       homepage = "http://github.com/m4dc4p/hcl/tree/master";
       description = "High-level library for building command line interfaces";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HCard" = callPackage
    ({ mkDerivation, base, mtl, QuickCheck, random, random-shuffle }:
     mkDerivation {
       pname = "HCard";
       version = "0.0";
       sha256 = "8b8489edeb912833eb024bb9492e5e9db475d7b26475f4a5d52b998ad80e722f";
       libraryHaskellDepends = [
         base mtl QuickCheck random random-shuffle
       ];
       homepage = "http://patch-tag.com/publicrepos/HCard";
       description = "A library for implementing a Deck of Cards";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HCodecs" = callPackage
    ({ mkDerivation, array, base, bytestring, QuickCheck, random }:
     mkDerivation {
       pname = "HCodecs";
       version = "0.5";
       sha256 = "b1bf109a5e0877b47eb2f942ad0d1aa2368b9c006882ba07fe345dd0a90a1756";
       libraryHaskellDepends = [
         array base bytestring QuickCheck random
       ];
       testHaskellDepends = [ array base bytestring QuickCheck random ];
       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, text, time, utf8-string
     }:
     mkDerivation {
       pname = "HDBC";
       version = "2.4.0.1";
       sha256 = "7a3ee21c41e716111c4a3742a66eb448683719a9384afbf7021c5942ac73d2ad";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers convertible mtl old-time text time
         utf8-string
       ];
       homepage = "https://github.com/hdbc/hdbc";
       description = "Haskell Database Connectivity";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HDBC-mysql" = callPackage
    ({ mkDerivation, base, bytestring, HDBC, time, utf8-string }:
     mkDerivation {
       pname = "HDBC-mysql";
       version = "0.6.6.1";
       sha256 = "35f1f32f20e9122800cde9eaf07d41e17b8786269f79125e31502cadacefa0e0";
       libraryHaskellDepends = [ base bytestring HDBC time utf8-string ];
       homepage = "http://github.com/bos/hdbc-mysql";
       description = "MySQL driver for HDBC";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HDBC-odbc" = callPackage
    ({ mkDerivation, base, bytestring, concurrent-extra, HDBC, mtl
     , time, unixODBC, utf8-string
     }:
     mkDerivation {
       pname = "HDBC-odbc";
       version = "2.5.0.0";
       sha256 = "729982fb31e2d7816e8600212236f32d9d9a59191d73ce57fce097be2234953b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring concurrent-extra HDBC mtl time utf8-string
       ];
       librarySystemDepends = [ unixODBC ];
       homepage = "https://github.com/hdbc/hdbc-odbc";
       description = "ODBC driver for HDBC";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) unixODBC;};

  "HDBC-postgresql" = callPackage
    ({ mkDerivation, base, bytestring, convertible, HDBC, mtl, old-time
     , parsec, postgresql, time, utf8-string
     }:
     mkDerivation {
       pname = "HDBC-postgresql";
       version = "2.3.2.3";
       sha256 = "4396038e1a66ba14b6b3388f2ee303c938e55c3fe0fe5df059a70335761e64cb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring convertible HDBC mtl old-time parsec time
         utf8-string
       ];
       librarySystemDepends = [ postgresql ];
       executableSystemDepends = [ postgresql ];
       homepage = "http://github.com/hdbc/hdbc-postgresql";
       description = "PostgreSQL driver for HDBC";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) postgresql;};

  "HDBC-postgresql-hstore" = callPackage
    ({ mkDerivation, attoparsec, base, containers, HDBC, text }:
     mkDerivation {
       pname = "HDBC-postgresql-hstore";
       version = "0.0.1.2";
       sha256 = "2dc856b0f467b0d51c93965e31784606b247eac597dffd12847185e27150a718";
       libraryHaskellDepends = [ attoparsec base containers HDBC text ];
       jailbreak = true;
       homepage = "https://bitbucket.org/dpwiz/hdbc-postgresql-hstore";
       description = "Manipulate data in PostgreSQL \"hstore\" columns";
       license = stdenv.lib.licenses.mit;
     }) {};

  "HDBC-session" = callPackage
    ({ mkDerivation, base, HDBC }:
     mkDerivation {
       pname = "HDBC-session";
       version = "0.1.0.0";
       sha256 = "bcf462a335c35d2a6f849689b3524ec86d3a2ca83662f1f48e9a770b1306bdbb";
       libraryHaskellDepends = [ base HDBC ];
       homepage = "http://khibino.github.io/haskell-relational-record/";
       description = "Bracketed connection for HDBC";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HDBC-sqlite3" = callPackage
    ({ mkDerivation, base, bytestring, HDBC, mtl, sqlite, utf8-string
     }:
     mkDerivation {
       pname = "HDBC-sqlite3";
       version = "2.3.3.1";
       sha256 = "a783d9ab707ebfc68e3e46bd1bbb5d3d5493f50a7ccf31223d9848cff986ebea";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring HDBC mtl utf8-string ];
       librarySystemDepends = [ sqlite ];
       executableSystemDepends = [ sqlite ];
       homepage = "https://github.com/hdbc/hdbc-sqlite3";
       description = "Sqlite v3 driver for HDBC";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) sqlite;};

  "HDRUtils" = callPackage
    ({ mkDerivation, array, base, colour, containers, mtl, pfstools
     , unix
     }:
     mkDerivation {
       pname = "HDRUtils";
       version = "1.0.2";
       sha256 = "0f78820cedd8e9d8a5aa4d2a0f75116bce9d73daa0b94dfba62ce28b6b9f7e66";
       libraryHaskellDepends = [ array base colour containers mtl unix ];
       librarySystemDepends = [ pfstools ];
       jailbreak = true;
       homepage = "http://vis.renci.org/jeff/pfs";
       description = "Utilities for reading, manipulating, and writing HDR images";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) pfstools;};

  "HERA" = callPackage
    ({ mkDerivation, base, mpfr }:
     mkDerivation {
       pname = "HERA";
       version = "0.2";
       sha256 = "5e0f047c7dccdd23c66f0992d8154d7931c8c0bf329f967040f2ac4ff8f19922";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ mpfr ];
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mpfr;};

  "HFrequencyQueue" = callPackage
    ({ mkDerivation, base, c-storable-deriving }:
     mkDerivation {
       pname = "HFrequencyQueue";
       version = "0.2.0.0";
       sha256 = "b03c5de4cbb14d379f3555698a03a076fb2d10c748c2a7054b83c74f95e30626";
       libraryHaskellDepends = [ base c-storable-deriving ];
       jailbreak = true;
       homepage = "https://github.com/Bellaz/HfrequencyList";
       description = "A Queue with a random (weighted) pick function";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HFuse" = callPackage
    ({ mkDerivation, base, bytestring, fuse, unix }:
     mkDerivation {
       pname = "HFuse";
       version = "0.2.4.5";
       sha256 = "e28e0689dfe5f7bc312b842adb02e172b56c3f53a1819ebda7ab39eace6c24a1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring unix ];
       librarySystemDepends = [ fuse ];
       preConfigure = ''
         sed -i -e "s@  Extra-Lib-Dirs:         /usr/local/lib@  Extra-Lib-Dirs:         ${fuse}/lib@" HFuse.cabal
       '';
       homepage = "https://github.com/m15k/hfuse";
       description = "HFuse is a binding for the Linux FUSE library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) fuse;};

  "HGL" = callPackage
    ({ mkDerivation, array, base, X11 }:
     mkDerivation {
       pname = "HGL";
       version = "3.2.3.1";
       sha256 = "d05dee7a9ebc45aba82922707c29033ca491a58adb88a63ab180d7459b163e55";
       libraryHaskellDepends = [ array base X11 ];
       description = "A simple graphics library based on X11 or Win32";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HGamer3D" = callPackage
    ({ mkDerivation, base, bytestring, cereal, clock, containers
     , directory, filepath, hgamer3d062, messagepack, text, Urho3D, vect
     }:
     mkDerivation {
       pname = "HGamer3D";
       version = "0.6.2";
       sha256 = "28076dcd6bf141b4d88939be49f3e2f370eae02d53e3845521715dfa36aac1ba";
       libraryHaskellDepends = [
         base bytestring cereal clock containers directory filepath
         messagepack text vect
       ];
       librarySystemDepends = [ hgamer3d062 Urho3D ];
       jailbreak = true;
       homepage = "http://www.hgamer3d.org";
       description = "Toolset for the Haskell Game Programmer";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {Urho3D = null; hgamer3d062 = null;};

  "HGamer3D-API" = callPackage
    ({ mkDerivation, base, haskell98, HGamer3D-Data
     , HGamer3D-Ogre-Binding, HGamer3D-SFML-Binding
     }:
     mkDerivation {
       pname = "HGamer3D-API";
       version = "0.1.6";
       sha256 = "b4603062e5a57617161bcf481a43bdebaeab23bbe518964996d98d3fc0889293";
       libraryHaskellDepends = [
         base haskell98 HGamer3D-Data HGamer3D-Ogre-Binding
         HGamer3D-SFML-Binding
       ];
       jailbreak = true;
       homepage = "http://www.althainz.de/HGamer3D.html";
       description = "Library to enable 3D game development for Haskell - API";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HGamer3D-Audio" = callPackage
    ({ mkDerivation, base, containers, HGamer3D-Common, HGamer3D-Data
     , HGamer3D-SFML-Binding
     }:
     mkDerivation {
       pname = "HGamer3D-Audio";
       version = "0.5.0";
       sha256 = "6d296833e48616d0b5185b28108755814b235123e669d6db11810b2b3798df7d";
       libraryHaskellDepends = [
         base containers HGamer3D-Common HGamer3D-Data HGamer3D-SFML-Binding
       ];
       homepage = "http://www.hgamer3d.org";
       description = "Toolset for the Haskell Game Programmer - Audio Functionality";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HGamer3D-Bullet-Binding" = callPackage
    ({ mkDerivation, base, HGamer3D-Data }:
     mkDerivation {
       pname = "HGamer3D-Bullet-Binding";
       version = "0.2.1";
       sha256 = "1e92883b5f9233a0d38b6a7382b42955d9ab9f911824cda273cd94fac24592c6";
       libraryHaskellDepends = [ base HGamer3D-Data ];
       homepage = "http://www.hgamer3d.org";
       description = "Windows Game Engine for the Haskell Programmer - Bullet Bindings";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HGamer3D-CAudio-Binding" = callPackage
    ({ mkDerivation, base, haskell98, HGamer3D-Data, HGamer3DCAudio015
     }:
     mkDerivation {
       pname = "HGamer3D-CAudio-Binding";
       version = "0.1.5";
       sha256 = "41f9a22c27d9e64bc9bbbbdca58b97c7674df1321abdb0e05391406ba173c9e0";
       libraryHaskellDepends = [ base haskell98 HGamer3D-Data ];
       librarySystemDepends = [ HGamer3DCAudio015 ];
       jailbreak = true;
       homepage = "http://www.althainz.de/HGamer3D.html";
       description = "Library to enable 3D game development for Haskell - cAudio Bindings";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {HGamer3DCAudio015 = null;};

  "HGamer3D-CEGUI-Binding" = callPackage
    ({ mkDerivation, base, CEGUIBase, CEGUIOgreRenderer, hg3dcegui050
     , HGamer3D-Data
     }:
     mkDerivation {
       pname = "HGamer3D-CEGUI-Binding";
       version = "0.5.0";
       sha256 = "a0a16eb06532ce9b3913eb6e56405ee485e1ae16a5ec4d05f4882663a57a07d2";
       libraryHaskellDepends = [ base HGamer3D-Data ];
       librarySystemDepends = [
         CEGUIBase CEGUIOgreRenderer hg3dcegui050
       ];
       homepage = "http://www.hgamer3d.org";
       description = "A Toolset for the Haskell Game Programmer - CEGUI Bindings";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {CEGUIBase = null; CEGUIOgreRenderer = null; 
         hg3dcegui050 = null;};

  "HGamer3D-Common" = callPackage
    ({ mkDerivation, base, clock, containers, directory, filepath
     , FindBin, HGamer3D-Data, stm, vect
     }:
     mkDerivation {
       pname = "HGamer3D-Common";
       version = "0.5.0";
       sha256 = "706a8256cdeaa39e8c6df5aa13323777ed3be854e17169c0934b53484e428bce";
       libraryHaskellDepends = [
         base clock containers directory filepath FindBin HGamer3D-Data stm
         vect
       ];
       homepage = "http://www.hgamer3d.org";
       description = "Toolset for the Haskell Game Programmer - Game Engine and Utilities";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HGamer3D-Data" = callPackage
    ({ mkDerivation, base, clock, containers, directory, filepath
     , FindBin, stm, vect
     }:
     mkDerivation {
       pname = "HGamer3D-Data";
       version = "0.5.0";
       sha256 = "ffad03adf90ccf28d1f0237de6267247c637a5badd11203c1e66a7914609c10c";
       libraryHaskellDepends = [
         base clock containers directory filepath FindBin stm vect
       ];
       homepage = "http://www.hgamer3d.org";
       description = "Toolset for the Haskell Game Programmer - Data Definitions";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HGamer3D-Enet-Binding" = callPackage
    ({ mkDerivation, base, enet, hg3denet050, HGamer3D-Data }:
     mkDerivation {
       pname = "HGamer3D-Enet-Binding";
       version = "0.5.0";
       sha256 = "8d7785b24bf4f73b854ee01ecb8568eb5f35f393e7ad6953deac6a3f0e50b628";
       libraryHaskellDepends = [ base HGamer3D-Data ];
       librarySystemDepends = [ enet hg3denet050 ];
       homepage = "http://www.hgamer3d.org";
       description = "Enet Binding for HGamer3D";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) enet; hg3denet050 = null;};

  "HGamer3D-GUI" = callPackage
    ({ mkDerivation, base, HGamer3D-CEGUI-Binding, HGamer3D-Data
     , HGamer3D-WinEvent, split
     }:
     mkDerivation {
       pname = "HGamer3D-GUI";
       version = "0.4.0";
       sha256 = "4daf0c73e79ed5816f9e8c4705c55bb46a788ea69bdf37c1a011a4c4cd33d200";
       libraryHaskellDepends = [
         base HGamer3D-CEGUI-Binding HGamer3D-Data HGamer3D-WinEvent split
       ];
       jailbreak = true;
       homepage = "http://www.hgamer3d.org";
       description = "GUI Functionality for HGamer3D";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HGamer3D-Graphics3D" = callPackage
    ({ mkDerivation, base, containers, directory, filepath
     , HGamer3D-CEGUI-Binding, HGamer3D-Common, HGamer3D-Data
     , HGamer3D-Ogre-Binding, HGamer3D-SDL2-Binding, mtl, split
     , transformers
     }:
     mkDerivation {
       pname = "HGamer3D-Graphics3D";
       version = "0.5.0";
       sha256 = "bec8d9b65641016d5907c1262afc4c107ad43efd13fd034838c250e0d48fcea8";
       libraryHaskellDepends = [
         base containers directory filepath HGamer3D-CEGUI-Binding
         HGamer3D-Common HGamer3D-Data HGamer3D-Ogre-Binding
         HGamer3D-SDL2-Binding mtl split transformers
       ];
       homepage = "http://www.hgamer3d.org";
       description = "Toolset for the Haskell Game Programmer - 3D Graphics Functionality";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HGamer3D-InputSystem" = callPackage
    ({ mkDerivation, base, HGamer3D-Common, HGamer3D-Data
     , HGamer3D-SDL2-Binding, HGamer3D-SFML-Binding
     }:
     mkDerivation {
       pname = "HGamer3D-InputSystem";
       version = "0.5.0";
       sha256 = "d0796ae39bbe6a4aafe25a5ebbaf6405d708d989f362fc86f3ca25c6ec2fecb6";
       libraryHaskellDepends = [
         base HGamer3D-Common HGamer3D-Data HGamer3D-SDL2-Binding
         HGamer3D-SFML-Binding
       ];
       homepage = "http://www.hgamer3d.org";
       description = "Joystick, Mouse and Keyboard Functionality for HGamer3D";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HGamer3D-Network" = callPackage
    ({ mkDerivation, base, HGamer3D-Common, HGamer3D-Data
     , HGamer3D-Enet-Binding
     }:
     mkDerivation {
       pname = "HGamer3D-Network";
       version = "0.5.0";
       sha256 = "d4fefd9198ad8e84aa245b5b0a870ac7682268d2e0ca042333496311c234b580";
       libraryHaskellDepends = [
         base HGamer3D-Common HGamer3D-Data HGamer3D-Enet-Binding
       ];
       homepage = "http://www.hgamer3d.org";
       description = "Networking Functionality for HGamer3D";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HGamer3D-OIS-Binding" = callPackage
    ({ mkDerivation, base, haskell98, HGamer3D-Data
     , HGamer3D-Ogre-Binding, HGamer3DOIS015
     }:
     mkDerivation {
       pname = "HGamer3D-OIS-Binding";
       version = "0.1.5";
       sha256 = "ceeb51d04ecadfc00b80b253af078486a3c41ef3e67dac15fb887b7eb7d100d8";
       libraryHaskellDepends = [
         base haskell98 HGamer3D-Data HGamer3D-Ogre-Binding
       ];
       librarySystemDepends = [ HGamer3DOIS015 ];
       jailbreak = true;
       homepage = "http://www.althainz.de/HGamer3D.html";
       description = "Library to enable 3D game development for Haskell - OIS Bindings";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {HGamer3DOIS015 = null;};

  "HGamer3D-Ogre-Binding" = callPackage
    ({ mkDerivation, base, hg3dogre050, HGamer3D-Data, mtl, OgreMain
     , OgrePaging, OgreProperty, OgreRTShaderSystem, OgreTerrain
     , transformers
     }:
     mkDerivation {
       pname = "HGamer3D-Ogre-Binding";
       version = "0.5.0";
       sha256 = "3c781efee88f3e18e1ec14ead9f288c535526dede7d6f9a6e65c2fe1277e55d4";
       libraryHaskellDepends = [ base HGamer3D-Data mtl transformers ];
       librarySystemDepends = [
         hg3dogre050 OgreMain OgrePaging OgreProperty OgreRTShaderSystem
         OgreTerrain
       ];
       homepage = "http://www.hgamer3d.org";
       description = "Ogre Binding for HGamer3D";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {OgreMain = null; OgrePaging = null; OgreProperty = null; 
         OgreRTShaderSystem = null; OgreTerrain = null; 
         hg3dogre050 = null;};

  "HGamer3D-SDL2-Binding" = callPackage
    ({ mkDerivation, base, bytestring, hg3dsdl2050, HGamer3D-Data
     , libX11, SDL2, utf8-string
     }:
     mkDerivation {
       pname = "HGamer3D-SDL2-Binding";
       version = "0.5.0";
       sha256 = "1096cc9a78d19343d48fc56c78e4c4b7f6f5371eeec1a3e2e68869d3b47f4986";
       libraryHaskellDepends = [
         base bytestring HGamer3D-Data utf8-string
       ];
       librarySystemDepends = [ hg3dsdl2050 libX11 SDL2 ];
       homepage = "http://www.hgamer3d.org";
       description = "SDL2 Binding for HGamer3D";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) SDL2; hg3dsdl2050 = null; 
         inherit (pkgs.xorg) libX11;};

  "HGamer3D-SFML-Binding" = callPackage
    ({ mkDerivation, base, hg3dsfml050, HGamer3D-Data, sfml-audio
     , sfml-network, sfml-system, sfml-window
     }:
     mkDerivation {
       pname = "HGamer3D-SFML-Binding";
       version = "0.5.0";
       sha256 = "9bb04dc08486f61dc2b60c295fb1abc4515d341707aed377ff17bdde80790781";
       libraryHaskellDepends = [ base HGamer3D-Data ];
       librarySystemDepends = [
         hg3dsfml050 sfml-audio sfml-network sfml-system sfml-window
       ];
       homepage = "http://www.hgamer3d.org";
       description = "SFML Binding for HGamer3D";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {hg3dsfml050 = null; sfml-audio = null; sfml-network = null; 
         sfml-system = null; sfml-window = null;};

  "HGamer3D-WinEvent" = callPackage
    ({ mkDerivation, base, HGamer3D-Data, HGamer3D-SDL2-Binding, text
     }:
     mkDerivation {
       pname = "HGamer3D-WinEvent";
       version = "0.4.0";
       sha256 = "2a69a5cccddc774f24fd7135f73608005a5a40dc9d5258db3864fd7f1f957b34";
       libraryHaskellDepends = [
         base HGamer3D-Data HGamer3D-SDL2-Binding text
       ];
       jailbreak = true;
       homepage = "http://www.hgamer3d.org";
       description = "Windowing and Event Functionality for HGamer3D";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HGamer3D-Wire" = callPackage
    ({ mkDerivation, base, containers, HGamer3D, HGamer3D-Audio
     , HGamer3D-Data, HGamer3D-GUI, HGamer3D-InputSystem
     , HGamer3D-WinEvent, mtl, netwire, transformers
     }:
     mkDerivation {
       pname = "HGamer3D-Wire";
       version = "0.3.3";
       sha256 = "e77c5309cbae5f19d598ca9ec4d335e63c1ba6a56a04fce7604e359ab453b170";
       libraryHaskellDepends = [
         base containers HGamer3D HGamer3D-Audio HGamer3D-Data HGamer3D-GUI
         HGamer3D-InputSystem HGamer3D-WinEvent mtl netwire transformers
       ];
       jailbreak = true;
       homepage = "http://www.hgamer3d.org";
       description = "Wire Functionality for HGamer3D";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HGraphStorage" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, data-default
     , directory, filepath, HUnit, lifted-base, monad-control
     , monad-logger, QuickCheck, resourcet, tasty, tasty-hunit
     , tasty-quickcheck, text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "HGraphStorage";
       version = "0.0.3";
       sha256 = "ccb58118b1aef79d4ed66c3f89eba43c9dddc2e18393b14afaaa4b8d78fe70e1";
       libraryHaskellDepends = [
         base binary bytestring containers data-default directory filepath
         lifted-base monad-control monad-logger resourcet text transformers
         transformers-base
       ];
       testHaskellDepends = [
         base bytestring containers data-default directory filepath HUnit
         lifted-base monad-control monad-logger QuickCheck resourcet tasty
         tasty-hunit tasty-quickcheck text transformers transformers-base
       ];
       homepage = "https://github.com/JPMoresmau/HGraphStorage";
       description = "Graph database stored on disk";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HHDL" = callPackage
    ({ mkDerivation, base, containers, mtl, template-haskell }:
     mkDerivation {
       pname = "HHDL";
       version = "0.1.0.0";
       sha256 = "183c5e1307e60a255fc7cafeadf0261c13de49224c63ec44a373ad41cdb72588";
       libraryHaskellDepends = [ base containers mtl template-haskell ];
       jailbreak = true;
       homepage = "http://thesz.mskhug.ru/svn/hhdl/hackage/hhdl/";
       description = "Hardware Description Language embedded in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HJScript" = callPackage
    ({ mkDerivation, base, HJavaScript, hsp, mtl, text }:
     mkDerivation {
       pname = "HJScript";
       version = "0.7.0";
       sha256 = "48b95ad85006d0229911a402eba89db7da453fa10ccaadcda8d1fc4075fd7077";
       libraryHaskellDepends = [ base HJavaScript hsp mtl text ];
       homepage = "http://patch-tag.com/r/nibro/hjscript";
       description = "HJScript is a Haskell EDSL for writing JavaScript programs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HJVM" = callPackage
    ({ mkDerivation, base, Cabal, containers, filepath
     , haskell-src-exts, HUnit, jvm, mtl, parsec, process
     , test-framework, test-framework-hunit, transformers
     }:
     mkDerivation {
       pname = "HJVM";
       version = "0.1";
       sha256 = "99ce25c934bc43db62a9f752d54b34c2164ec4518cbbfad0b5474ab1f283bf47";
       libraryHaskellDepends = [
         base containers filepath haskell-src-exts mtl parsec process
         transformers
       ];
       librarySystemDepends = [ jvm ];
       testHaskellDepends = [
         base Cabal haskell-src-exts HUnit mtl parsec test-framework
         test-framework-hunit transformers
       ];
       homepage = "https://github.com/JPMoresmau/HJVM";
       description = "A library to create a Java Virtual Machine and manipulate Java objects";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {jvm = null;};

  "HJavaScript" = callPackage
    ({ mkDerivation, base, pretty }:
     mkDerivation {
       pname = "HJavaScript";
       version = "0.4.7";
       sha256 = "705f122cdf80d05ec3e345752cdb38268cfcc094267612482bb44ee316e66269";
       libraryHaskellDepends = [ base pretty ];
       description = "HJavaScript is an abstract syntax for a typed subset of JavaScript";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HLearn-algebra" = callPackage
    ({ mkDerivation, base, ConstraintKinds, containers, deepseq
     , hashable, MonadRandom, parallel, random, template-haskell, vector
     , vector-heterogenous
     }:
     mkDerivation {
       pname = "HLearn-algebra";
       version = "1.1.0.1";
       sha256 = "aa04d725af69ba78d7c474c52ebd8de7aa7a25db7e0013cde5c42b8559000acc";
       libraryHaskellDepends = [
         base ConstraintKinds containers deepseq hashable MonadRandom
         parallel random template-haskell vector vector-heterogenous
       ];
       jailbreak = true;
       homepage = "http://github.com/mikeizbicki/HLearn/";
       description = "Algebraic foundation for homomorphic learning";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HLearn-approximation" = callPackage
    ({ mkDerivation, base, ConstraintKinds, containers, heap
     , HLearn-algebra, HLearn-datastructures, HLearn-distributions
     , list-extras, vector
     }:
     mkDerivation {
       pname = "HLearn-approximation";
       version = "1.1.0";
       sha256 = "76a315bd7ce257fcfea4b06428287fce5281f7f3fb44d8209558121fa9bd19bf";
       libraryHaskellDepends = [
         base ConstraintKinds containers heap HLearn-algebra
         HLearn-datastructures HLearn-distributions list-extras vector
       ];
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HLearn-classification" = callPackage
    ({ mkDerivation, base, binary, bytestring, ConstraintKinds
     , containers, deepseq, dlist, hashable, HLearn-algebra
     , HLearn-distributions, list-extras, logfloat, math-functions
     , MonadRandom, normaldistribution, parsec, primitive, QuickCheck
     , statistics, vector, vector-th-unbox
     }:
     mkDerivation {
       pname = "HLearn-classification";
       version = "1.0.1.3";
       sha256 = "0d6e4d8eb596aaa1395f8508f1c08f802e15cf2aff2bfa73ab9341684d008185";
       libraryHaskellDepends = [
         base binary bytestring ConstraintKinds containers deepseq dlist
         hashable HLearn-algebra HLearn-distributions list-extras logfloat
         math-functions MonadRandom normaldistribution parsec primitive
         QuickCheck statistics vector vector-th-unbox
       ];
       jailbreak = true;
       homepage = "http://github.com/mikeizbicki/HLearn/";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HLearn-datastructures" = callPackage
    ({ mkDerivation, base, ConstraintKinds, containers, deepseq
     , HLearn-algebra, list-extras, MonadRandom, QuickCheck, vector
     }:
     mkDerivation {
       pname = "HLearn-datastructures";
       version = "1.1.0";
       sha256 = "8b0f87a003feaccb557b055cf323dc6b85829ef22ffaa769336b2d7b1ad36b1a";
       libraryHaskellDepends = [
         base ConstraintKinds containers deepseq HLearn-algebra list-extras
         MonadRandom QuickCheck vector
       ];
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HLearn-distributions" = callPackage
    ({ mkDerivation, array, base, ConstraintKinds, containers, deepseq
     , erf, gamma, graphviz, HLearn-algebra, HLearn-datastructures
     , hmatrix, list-extras, math-functions, MonadRandom
     , normaldistribution, process, QuickCheck, statistics
     , template-haskell, vector, vector-th-unbox
     }:
     mkDerivation {
       pname = "HLearn-distributions";
       version = "1.1.0.2";
       sha256 = "eef328acd2739a3022972a0c2de48e4b4325c5810543b60a207b3136a75669a7";
       libraryHaskellDepends = [
         array base ConstraintKinds containers deepseq erf gamma graphviz
         HLearn-algebra HLearn-datastructures hmatrix list-extras
         math-functions MonadRandom normaldistribution process QuickCheck
         statistics template-haskell vector vector-th-unbox
       ];
       homepage = "http://github.com/mikeizbicki/HLearn/";
       description = "Distributions for use with the HLearn library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HList_0_4_1_0" = callPackage
    ({ mkDerivation, array, base, cmdargs, directory, doctest, filepath
     , ghc-prim, hspec, lens, mtl, process, profunctors, QuickCheck, syb
     , tagged, template-haskell
     }:
     mkDerivation {
       pname = "HList";
       version = "0.4.1.0";
       sha256 = "204c5592824617caf013f1ba72a29df0700669eedf53970ab06dd4e6a4c06e6d";
       libraryHaskellDepends = [
         array base ghc-prim mtl profunctors tagged template-haskell
       ];
       testHaskellDepends = [
         array base cmdargs directory doctest filepath hspec lens mtl
         process QuickCheck syb template-haskell
       ];
       doCheck = false;
       description = "Heterogeneous lists";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HList" = callPackage
    ({ mkDerivation, array, base, base-orphans, cmdargs, directory
     , doctest, filepath, ghc-prim, hspec, lens, mtl, process
     , profunctors, QuickCheck, syb, tagged, template-haskell
     }:
     mkDerivation {
       pname = "HList";
       version = "0.4.2.0";
       sha256 = "cd99545a1dc4df7ceca09a93e4c4d391654a337882a25791f1c48e21317d7795";
       libraryHaskellDepends = [
         array base base-orphans ghc-prim mtl profunctors tagged
         template-haskell
       ];
       testHaskellDepends = [
         array base cmdargs directory doctest filepath hspec lens mtl
         process QuickCheck syb template-haskell
       ];
       doCheck = false;
       description = "Heterogeneous lists";
       license = stdenv.lib.licenses.mit;
     }) {};

  "HListPP" = callPackage
    ({ mkDerivation, applicative-quoters, base, regex-applicative }:
     mkDerivation {
       pname = "HListPP";
       version = "0.2.1";
       sha256 = "0815e29c2828f4e43bda9ee0c809a0c932ba32c69441ecbd41b182bb7c461667";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         applicative-quoters base regex-applicative
       ];
       homepage = "http://code.haskell.org/~aavogt/HListPP";
       description = "A preprocessor for HList labelable labels";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HLogger" = callPackage
    ({ mkDerivation, base, old-locale, time }:
     mkDerivation {
       pname = "HLogger";
       version = "0.0.1.0";
       sha256 = "97590a9d49facb51f368d39f6f923471d75ec3106026c8c543053a23d3f3bd2a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base old-locale time ];
       executableHaskellDepends = [ base old-locale time ];
       jailbreak = true;
       homepage = "http://www.pontarius.org/sub-projects/hlogger/";
       description = "Simple, concurrent and easy-to-use logging library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HMM" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "HMM";
       version = "0.2.1";
       sha256 = "4687a3304af6569734e2511341611281390eb017e3d2b8acd7fe99c2cca1c807";
       homepage = "https://github.com/mikeizbicki/hmm";
       description = "A hidden markov model library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HMap" = callPackage
    ({ mkDerivation, base, data-default, hashable, mtl
     , unordered-containers
     }:
     mkDerivation {
       pname = "HMap";
       version = "1.2.7";
       sha256 = "806cbac1e1571c814af76ccf4058c5d9577b99018fd0c7ee5de993b343c60577";
       libraryHaskellDepends = [
         base data-default hashable mtl unordered-containers
       ];
       homepage = "https://github.com/atzeus/HMap";
       description = "Fast heterogeneous maps and unconstrained typeable like functionality";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HNM" = callPackage
    ({ mkDerivation, base, containers, directory, glib, gtk, haskell98
     , mtl, process, regex-posix, unix
     }:
     mkDerivation {
       pname = "HNM";
       version = "0.1.2";
       sha256 = "3271e300282e539a8d532693dcfc789368d804577f2760928fa4675af92b6210";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory glib gtk haskell98 mtl process
         regex-posix unix
       ];
       executableHaskellDepends = [
         base containers glib gtk haskell98 mtl process regex-posix unix
       ];
       homepage = "http://sert.homedns.org/hs/hnm/";
       description = "Happy Network Manager";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HODE" = callPackage
    ({ mkDerivation, array, base, ode }:
     mkDerivation {
       pname = "HODE";
       version = "2008.10.27";
       sha256 = "fbd9480f45fa79eacd433a3857cc594dc586a84115e615d46231325a775c233b";
       libraryHaskellDepends = [ array base ];
       librarySystemDepends = [ ode ];
       description = "Binding to libODE";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) ode;};

  "HOpenCV" = callPackage
    ({ mkDerivation, allocated-processor, base, opencv, vector-space }:
     mkDerivation {
       pname = "HOpenCV";
       version = "0.4.0.1";
       sha256 = "7e7be492466e675ceb60b823252fcb0e8a5d0847a76c680c2dfa2ea7e59cbec7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ allocated-processor base vector-space ];
       libraryPkgconfigDepends = [ opencv ];
       executableHaskellDepends = [ base ];
       executablePkgconfigDepends = [ opencv ];
       description = "A binding for the OpenCV computer vision library";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) opencv;};

  "HPDF" = callPackage
    ({ mkDerivation, array, base, base64-bytestring, binary, bytestring
     , containers, errors, HTF, mtl, random, vector, zlib
     }:
     mkDerivation {
       pname = "HPDF";
       version = "1.4.10";
       sha256 = "de2bfddd93eeef2129a2378e8dce486d086bec3c48ee2a1bf1a5fb01581607d4";
       libraryHaskellDepends = [
         array base base64-bytestring binary bytestring containers errors
         mtl random vector zlib
       ];
       testHaskellDepends = [ base HTF ];
       homepage = "http://www.alpheccar.org";
       description = "Generation of PDF documents";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HPath" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, filepath
     , haskell-src-exts, mtl, parsec, utf8-string
     }:
     mkDerivation {
       pname = "HPath";
       version = "0.0.2";
       sha256 = "9307edb3192efe5f81ea1b87bf9814887d9839086d2c2e398ed3becba0c71482";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers directory filepath haskell-src-exts mtl
         parsec utf8-string
       ];
       executableHaskellDepends = [
         base Cabal containers directory filepath haskell-src-exts mtl
         parsec utf8-string
       ];
       jailbreak = true;
       homepage = "http://github.com/solidsnack/HPath";
       description = "Extract Haskell declarations by name";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HPi" = callPackage
    ({ mkDerivation, base, bcm2835, bytestring }:
     mkDerivation {
       pname = "HPi";
       version = "0.5.1";
       sha256 = "c9c6db4f2653826163dbf03a73423c78dc72c3764008281df8cd553b655905c2";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ bcm2835 ];
       homepage = "https://github.com/WJWH/HPi";
       description = "GPIO, I2C and SPI functions for the Raspberry Pi";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {bcm2835 = null;};

  "HPlot" = callPackage
    ({ mkDerivation, base, c2hs, glade, glib, gtk, plplotd-gnome2 }:
     mkDerivation {
       pname = "HPlot";
       version = "0.3";
       sha256 = "1e6bb646a8c768ececb0af3ff233ecde02dbe791c492823c19d48d70bb204608";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base glade glib gtk ];
       libraryPkgconfigDepends = [ plplotd-gnome2 ];
       libraryToolDepends = [ c2hs ];
       executableHaskellDepends = [ base glade glib gtk ];
       executablePkgconfigDepends = [ plplotd-gnome2 ];
       jailbreak = true;
       homepage = "http://yakov.cc/HPlot.html";
       description = "A minimal monadic PLplot interface for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {plplotd-gnome2 = null;};

  "HPong" = callPackage
    ({ mkDerivation, base, data-accessor, data-accessor-template, GLFW
     , OpenGL
     }:
     mkDerivation {
       pname = "HPong";
       version = "0.1.2";
       sha256 = "f1efbbaf1140674d105e4e3648e720415b219f0cccbc50c23aa378ab27c1ff37";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base data-accessor data-accessor-template GLFW OpenGL
       ];
       homepage = "http://bonsaicode.wordpress.com/2009/04/23/hpong-012/";
       description = "A simple OpenGL Pong game based on GLFW";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HROOT" = callPackage
    ({ mkDerivation, base, fficxx-runtime, HROOT-core, HROOT-graf
     , HROOT-hist, HROOT-io, HROOT-math
     }:
     mkDerivation {
       pname = "HROOT";
       version = "0.8";
       sha256 = "0e6fa9e42e8843bbd7cb0af48e3f86ba8412a2fb12c70f94990ed10f832cd660";
       revision = "1";
       editedCabalFile = "43058ba39e0517740c45b1087a39e4f84912c1a3c500504850395d4f2fda0917";
       libraryHaskellDepends = [
         base fficxx-runtime HROOT-core HROOT-graf HROOT-hist HROOT-io
         HROOT-math
       ];
       homepage = "http://ianwookim.org/HROOT";
       description = "Haskell binding to ROOT RooFit modules";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HROOT-core" = callPackage
    ({ mkDerivation, base, fficxx-runtime }:
     mkDerivation {
       pname = "HROOT-core";
       version = "0.8";
       sha256 = "161807e042e440c6b00d87dda1bb1a945ec9aee53375f2c66d80984c84b080b8";
       libraryHaskellDepends = [ base fficxx-runtime ];
       homepage = "http://ianwookim.org/HROOT";
       description = "Haskell binding to ROOT Core modules";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HROOT-graf" = callPackage
    ({ mkDerivation, base, fficxx-runtime, HROOT-core, HROOT-hist }:
     mkDerivation {
       pname = "HROOT-graf";
       version = "0.8";
       sha256 = "7c817f7c174a2ad026dd494391427719da23addcda9dc3e7fa59aa9fb96102ca";
       libraryHaskellDepends = [
         base fficxx-runtime HROOT-core HROOT-hist
       ];
       homepage = "http://ianwookim.org/HROOT";
       description = "Haskell binding to ROOT Graf modules";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HROOT-hist" = callPackage
    ({ mkDerivation, base, fficxx-runtime, HROOT-core }:
     mkDerivation {
       pname = "HROOT-hist";
       version = "0.8";
       sha256 = "01ce1810bcdd1dbf53d2b7f7c5923f7409d1388ceaa328549046f06fc5c3f47b";
       libraryHaskellDepends = [ base fficxx-runtime HROOT-core ];
       homepage = "http://ianwookim.org/HROOT";
       description = "Haskell binding to ROOT Hist modules";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HROOT-io" = callPackage
    ({ mkDerivation, base, fficxx-runtime, HROOT-core }:
     mkDerivation {
       pname = "HROOT-io";
       version = "0.8";
       sha256 = "621adb74a41241cb7678e4a28ba3aff3bb21b132c2890ae0be627722be347069";
       libraryHaskellDepends = [ base fficxx-runtime HROOT-core ];
       homepage = "http://ianwookim.org/HROOT";
       description = "Haskell binding to ROOT IO modules";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HROOT-math" = callPackage
    ({ mkDerivation, base, fficxx-runtime, HROOT-core }:
     mkDerivation {
       pname = "HROOT-math";
       version = "0.8";
       sha256 = "95ff6a0125141818f4bdb3946dcfa9dd8cbeb4a00674c429b082b7df61deba62";
       libraryHaskellDepends = [ base fficxx-runtime HROOT-core ];
       homepage = "http://ianwookim.org/HROOT";
       description = "Haskell binding to ROOT Math modules";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HRay" = callPackage
    ({ mkDerivation, array, base, directory, haskell98 }:
     mkDerivation {
       pname = "HRay";
       version = "1.2.3";
       sha256 = "ce12a6f6537a651870512087ede2ac897c1f1ee632327630a2a23160045ae02d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base directory haskell98 ];
       homepage = "http://boegel.kejo.be/ELIS/Haskell/HRay/";
       description = "Haskell raytracer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HSFFIG" = callPackage
    ({ mkDerivation, array, base, Cabal, containers, directory
     , filepath, parsec, process, unix
     }:
     mkDerivation {
       pname = "HSFFIG";
       version = "1.1.3";
       sha256 = "060120042cce5e48107a1772502330aa85d6079f08aaec3533b1ff0da978f383";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base Cabal containers directory filepath parsec process unix
       ];
       executableHaskellDepends = [
         array base Cabal containers directory filepath parsec process unix
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/HSFFIG";
       description = "Generate FFI import declarations from C include files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HSGEP" = callPackage
    ({ mkDerivation, base, csv, mersenne-random-pure64
     , monad-mersenne-random, mtl, split, vector
     }:
     mkDerivation {
       pname = "HSGEP";
       version = "0.1.5";
       sha256 = "37bda533cc8a0dc1180c066a2d78923592b0e5af0332c4ab16ae6a80c228689a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base mersenne-random-pure64 monad-mersenne-random mtl split vector
       ];
       executableHaskellDepends = [ csv ];
       homepage = "http://github.com/mjsottile/hsgep/";
       description = "Gene Expression Programming evolutionary algorithm in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HSH" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, hslogger
     , MissingH, mtl, process, regex-base, regex-compat, regex-posix
     , unix
     }:
     mkDerivation {
       pname = "HSH";
       version = "2.1.2";
       sha256 = "788a7f25336e7fe9c7d38b68bb4cc0030712fc47e0cdf282267dea1e46b0da9f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring directory filepath hslogger MissingH mtl process
         regex-base regex-compat regex-posix unix
       ];
       homepage = "http://software.complete.org/hsh";
       description = "Library to mix shell scripting with Haskell programs";
       license = "LGPL";
     }) {};

  "HSHHelpers" = callPackage
    ({ mkDerivation, base, bytestring, DebugTraceHelpers, directory
     , filepath, HSH, HStringTemplateHelpers, MissingH, mtl, regex-pcre
     , unix
     }:
     mkDerivation {
       pname = "HSHHelpers";
       version = "0.24";
       sha256 = "8d04c19dd975c4d945c5ed4c17e18e85a6eaf370f95fd61bcb71ba34552fe257";
       libraryHaskellDepends = [
         base bytestring DebugTraceHelpers directory filepath HSH
         HStringTemplateHelpers MissingH mtl regex-pcre unix
       ];
       jailbreak = true;
       description = "Convenience functions that use HSH, instances for HSH";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HSlippyMap" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "HSlippyMap";
       version = "2.2";
       sha256 = "a9943b4a20f22c3c0ac34f097abbc18c53ec5639e8e82d1e879c9ea4f69dc19e";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/j4/HSlippyMap";
       description = "OpenStreetMap Slippy Map";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HSmarty" = callPackage
    ({ mkDerivation, aeson, attoparsec, attoparsec-expr, base, HTF
     , HTTP, mtl, scientific, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "HSmarty";
       version = "0.2.0.3";
       sha256 = "3883bd35c5ed53264bd9fa2284ad3c4bd0bbd4326d628fd171ac98b2f9eda71e";
       libraryHaskellDepends = [
         aeson attoparsec attoparsec-expr base HTTP mtl scientific text
         unordered-containers vector
       ];
       testHaskellDepends = [ aeson attoparsec base HTF text ];
       homepage = "https://github.com/agrafix/HSmarty";
       description = "Small template engine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HSoundFile" = callPackage
    ({ mkDerivation, base, binary, bytestring, filepath, haskell98, mtl
     , parallel
     }:
     mkDerivation {
       pname = "HSoundFile";
       version = "0.2.2";
       sha256 = "eb437d156e51e5288c604bd967ae6b39e5e636ff0de9f1bf19527bfadb099f62";
       libraryHaskellDepends = [
         base binary bytestring filepath haskell98 mtl parallel
       ];
       homepage = "http://mml.music.utexas.edu/jwlato/HSoundFile";
       description = "Audio file reading/writing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HStringTemplate_0_7_3" = callPackage
    ({ mkDerivation, array, base, blaze-builder, bytestring, containers
     , deepseq, directory, filepath, mtl, old-locale, old-time, parsec
     , pretty, syb, template-haskell, text, time, utf8-string, void
     }:
     mkDerivation {
       pname = "HStringTemplate";
       version = "0.7.3";
       sha256 = "883fbfd35c14ab46cd1545a8643da700094297f0cb74462f460781694dd884bf";
       revision = "2";
       editedCabalFile = "f3b42ea4e5c29507d6d186ccd34c83425d2e16a55ca3af95fd8bb1a71e3f54cb";
       libraryHaskellDepends = [
         array base blaze-builder bytestring containers deepseq directory
         filepath mtl old-locale old-time parsec pretty syb template-haskell
         text time utf8-string void
       ];
       jailbreak = true;
       description = "StringTemplate implementation in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HStringTemplate_0_8_3" = callPackage
    ({ mkDerivation, array, base, blaze-builder, bytestring, containers
     , deepseq, directory, filepath, mtl, old-locale, parsec, pretty
     , syb, template-haskell, text, time, void
     }:
     mkDerivation {
       pname = "HStringTemplate";
       version = "0.8.3";
       sha256 = "63d6b1c993f5612ef370b92bb8fab05323657ec34a0f35110b967eb853239d18";
       revision = "1";
       editedCabalFile = "e333f201de7b501fda8bf4868be8aa4565a6c57abd0517844dffb0df37d18308";
       libraryHaskellDepends = [
         array base blaze-builder bytestring containers deepseq directory
         filepath mtl old-locale parsec pretty syb template-haskell text
         time void
       ];
       description = "StringTemplate implementation in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HStringTemplate" = callPackage
    ({ mkDerivation, array, base, blaze-builder, bytestring, containers
     , deepseq, directory, filepath, mtl, old-locale, parsec, pretty
     , syb, template-haskell, text, time, void
     }:
     mkDerivation {
       pname = "HStringTemplate";
       version = "0.8.5";
       sha256 = "e02b3043f1a5f72db3a1a1075e7b641f266329b954ea7f2f6bd20266295b35ff";
       libraryHaskellDepends = [
         array base blaze-builder bytestring containers deepseq directory
         filepath mtl old-locale parsec pretty syb template-haskell text
         time void
       ];
       description = "StringTemplate implementation in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HStringTemplateHelpers" = callPackage
    ({ mkDerivation, base, containers, directory, FileManipCompat
     , filepath, HSH, HStringTemplate, mtl, safe, strict
     }:
     mkDerivation {
       pname = "HStringTemplateHelpers";
       version = "0.0.14";
       sha256 = "90eb59f9175e68bb26c0467b3f9751bed49587b135e93a02edf4a7da2112f9b5";
       libraryHaskellDepends = [
         base containers directory FileManipCompat filepath HSH
         HStringTemplate mtl safe strict
       ];
       homepage = "http://patch-tag.com/tphyahoo/r/tphyahoo/HStringTemplateHelpers";
       description = "Convenience functions and instances for HStringTemplate";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HSvm" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "HSvm";
       version = "0.1.0.2.89";
       sha256 = "49a9007eb3fb28d5c499ac64e3d3e796a1725c6be59932248c6198b3289b68d5";
       libraryHaskellDepends = [ base containers ];
       description = "Haskell Bindings for libsvm";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HTF_0_12_2_3" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, array, base
     , base64-bytestring, bytestring, containers, cpphs, Diff, directory
     , filepath, haskell-lexer, haskell-src, HUnit, lifted-base
     , monad-control, mtl, old-time, pretty, process, QuickCheck, random
     , regex-compat, temporary, text, time, unix, unordered-containers
     , vector, xmlgen
     }:
     mkDerivation {
       pname = "HTF";
       version = "0.12.2.3";
       sha256 = "7555c2f743195909197f5352f50d5a825314abc486a541c2bffc4463af17bf3c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array base base64-bytestring bytestring containers cpphs Diff
         directory haskell-lexer 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 haskell-lexer HUnit mtl old-time random
         text
       ];
       testHaskellDepends = [
         aeson aeson-pretty base bytestring directory filepath HUnit mtl
         process random regex-compat temporary text unordered-containers
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/skogsbaer/HTF/";
       description = "The Haskell Test Framework";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HTF_0_12_2_4" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, array, base
     , base64-bytestring, bytestring, containers, cpphs, Diff, directory
     , filepath, haskell-lexer, haskell-src, HUnit, lifted-base
     , monad-control, mtl, old-time, pretty, process, QuickCheck, random
     , regex-compat, temporary, text, time, unix, unordered-containers
     , vector, xmlgen
     }:
     mkDerivation {
       pname = "HTF";
       version = "0.12.2.4";
       sha256 = "d5f8c72e7ca9ffaf30bae0fd54d7386f77ad823d3f3235b40f1149183147a338";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array base base64-bytestring bytestring containers cpphs Diff
         directory haskell-lexer 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 haskell-lexer HUnit mtl old-time random
         text
       ];
       testHaskellDepends = [
         aeson aeson-pretty base bytestring directory filepath HUnit mtl
         process random regex-compat temporary text unordered-containers
       ];
       doCheck = false;
       homepage = "https://github.com/skogsbaer/HTF/";
       description = "The Haskell Test Framework";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HTF_0_13_0_0" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, array, base
     , base64-bytestring, bytestring, containers, cpphs, Diff, directory
     , filepath, haskell-src, HUnit, lifted-base, monad-control, mtl
     , old-time, pretty, process, QuickCheck, random, regex-compat
     , template-haskell, temporary, text, time, unix
     , unordered-containers, vector, xmlgen
     }:
     mkDerivation {
       pname = "HTF";
       version = "0.13.0.0";
       sha256 = "a4b066e8589ee0f2574af6d592d6906c85cc2cf75846dff2f83f6adc3c302c53";
       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
       ];
       testHaskellDepends = [
         aeson aeson-pretty base bytestring directory filepath HUnit mtl
         process random regex-compat template-haskell temporary text
         unordered-containers
       ];
       doCheck = false;
       homepage = "https://github.com/skogsbaer/HTF/";
       description = "The Haskell Test Framework";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HTF" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, array, base
     , base64-bytestring, bytestring, containers, cpphs, Diff, directory
     , filepath, haskell-src, HUnit, lifted-base, monad-control, mtl
     , old-time, pretty, process, QuickCheck, random, regex-compat
     , template-haskell, temporary, text, time, unix
     , unordered-containers, vector, xmlgen
     }:
     mkDerivation {
       pname = "HTF";
       version = "0.13.1.0";
       sha256 = "1cb469ee21766fb7ad56fb42469709fac06214f7a33c39880134dfc2ea0de847";
       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
       ];
       testHaskellDepends = [
         aeson aeson-pretty base bytestring directory filepath HUnit mtl
         process random regex-compat template-haskell temporary text
         unordered-containers
       ];
       doCheck = false;
       homepage = "https://github.com/skogsbaer/HTF/";
       description = "The Haskell Test Framework";
       license = "LGPL";
     }) {};

  "HTTP_4000_2_18" = callPackage
    ({ mkDerivation, array, base, bytestring, case-insensitive, conduit
     , conduit-extra, deepseq, http-types, httpd-shed, HUnit, mtl
     , network, network-uri, old-time, parsec, pureMD5, split
     , test-framework, test-framework-hunit, wai, warp
     }:
     mkDerivation {
       pname = "HTTP";
       version = "4000.2.18";
       sha256 = "93c8228f7521cdd85d0c0521071dafb037e0abbd55dbcb2516a341ded68cc0ca";
       libraryHaskellDepends = [
         array base bytestring mtl network network-uri old-time parsec
       ];
       testHaskellDepends = [
         base bytestring case-insensitive conduit conduit-extra deepseq
         http-types httpd-shed HUnit mtl network network-uri pureMD5 split
         test-framework test-framework-hunit wai warp
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/haskell/HTTP";
       description = "A library for client-side HTTP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HTTP_4000_2_19" = callPackage
    ({ mkDerivation, array, base, bytestring, case-insensitive, conduit
     , conduit-extra, deepseq, http-types, httpd-shed, HUnit, mtl
     , network, network-uri, old-time, parsec, pureMD5, split
     , test-framework, test-framework-hunit, wai, warp
     }:
     mkDerivation {
       pname = "HTTP";
       version = "4000.2.19";
       sha256 = "5ffb97b7a916a70e742d65273e4c7c7b50b281797db11e17e7e02158e343f5fb";
       libraryHaskellDepends = [
         array base bytestring mtl network network-uri old-time parsec
       ];
       testHaskellDepends = [
         base bytestring case-insensitive conduit conduit-extra deepseq
         http-types httpd-shed HUnit mtl network network-uri pureMD5 split
         test-framework test-framework-hunit wai warp
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/haskell/HTTP";
       description = "A library for client-side HTTP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HTTP_4000_2_20" = callPackage
    ({ mkDerivation, array, base, bytestring, case-insensitive, conduit
     , conduit-extra, deepseq, http-types, httpd-shed, HUnit, mtl
     , network, network-uri, old-time, parsec, pureMD5, split
     , test-framework, test-framework-hunit, wai, warp
     }:
     mkDerivation {
       pname = "HTTP";
       version = "4000.2.20";
       sha256 = "4407cc863699720d179b36257baf21b5f1df4be8c30545dcec4d685a726fd85b";
       libraryHaskellDepends = [
         array base bytestring mtl network network-uri old-time parsec
       ];
       testHaskellDepends = [
         base bytestring case-insensitive conduit conduit-extra deepseq
         http-types httpd-shed HUnit mtl network network-uri pureMD5 split
         test-framework test-framework-hunit wai warp
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/haskell/HTTP";
       description = "A library for client-side HTTP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HTTP_4000_2_21" = callPackage
    ({ mkDerivation, array, base, bytestring, case-insensitive, conduit
     , conduit-extra, deepseq, http-types, httpd-shed, HUnit, mtl
     , network, network-uri, old-time, parsec, pureMD5, split
     , test-framework, test-framework-hunit, wai, warp
     }:
     mkDerivation {
       pname = "HTTP";
       version = "4000.2.21";
       sha256 = "fc060577d4c9bd4a198789b936ae0c71da0f4e74bfb389a226521736937bbd91";
       libraryHaskellDepends = [
         array base bytestring mtl network network-uri old-time parsec
       ];
       testHaskellDepends = [
         base bytestring case-insensitive conduit conduit-extra deepseq
         http-types httpd-shed HUnit mtl network network-uri pureMD5 split
         test-framework test-framework-hunit wai warp
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/haskell/HTTP";
       description = "A library for client-side HTTP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HTTP_4000_2_22" = callPackage
    ({ mkDerivation, array, base, bytestring, case-insensitive, conduit
     , conduit-extra, deepseq, http-types, httpd-shed, HUnit, mtl
     , network, network-uri, old-time, parsec, pureMD5, split
     , test-framework, test-framework-hunit, wai, warp
     }:
     mkDerivation {
       pname = "HTTP";
       version = "4000.2.22";
       sha256 = "3e212c927aa4524b95425fdd6500c06d3dea145c5b3f46ce6634bc1d1769469c";
       libraryHaskellDepends = [
         array base bytestring mtl network network-uri old-time parsec
       ];
       testHaskellDepends = [
         base bytestring case-insensitive conduit conduit-extra deepseq
         http-types httpd-shed HUnit mtl network network-uri pureMD5 split
         test-framework test-framework-hunit wai warp
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/haskell/HTTP";
       description = "A library for client-side HTTP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HTTP_4000_2_23" = callPackage
    ({ mkDerivation, array, base, bytestring, case-insensitive, conduit
     , conduit-extra, deepseq, http-types, httpd-shed, HUnit, mtl
     , network, network-uri, old-time, parsec, pureMD5, split
     , test-framework, test-framework-hunit, wai, warp
     }:
     mkDerivation {
       pname = "HTTP";
       version = "4000.2.23";
       sha256 = "ab04f8126196b96b02d10efcef49c4b73a14e7254cb6515cb10c87658c2e103c";
       libraryHaskellDepends = [
         array base bytestring mtl network network-uri old-time parsec
       ];
       testHaskellDepends = [
         base bytestring case-insensitive conduit conduit-extra deepseq
         http-types httpd-shed HUnit mtl network network-uri pureMD5 split
         test-framework test-framework-hunit wai warp
       ];
       doCheck = false;
       homepage = "https://github.com/haskell/HTTP";
       description = "A library for client-side HTTP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HTTP_4000_3_2" = callPackage
    ({ mkDerivation, array, base, bytestring, case-insensitive, conduit
     , conduit-extra, deepseq, http-types, httpd-shed, HUnit, mtl
     , network, network-uri, parsec, pureMD5, split, test-framework
     , test-framework-hunit, time, wai, warp
     }:
     mkDerivation {
       pname = "HTTP";
       version = "4000.3.2";
       sha256 = "15ee93db252703f87c114bf848eda04ed0c8e3d7411aeb9dc911201aa4f756ae";
       libraryHaskellDepends = [
         array base bytestring mtl network network-uri parsec time
       ];
       testHaskellDepends = [
         base bytestring case-insensitive conduit conduit-extra deepseq
         http-types httpd-shed HUnit mtl network network-uri pureMD5 split
         test-framework test-framework-hunit wai warp
       ];
       doCheck = false;
       homepage = "https://github.com/haskell/HTTP";
       description = "A library for client-side HTTP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HTTP" = callPackage
    ({ mkDerivation, array, base, bytestring, case-insensitive, conduit
     , conduit-extra, deepseq, http-types, httpd-shed, HUnit, mtl
     , network, network-uri, parsec, pureMD5, split, test-framework
     , test-framework-hunit, time, wai, warp
     }:
     mkDerivation {
       pname = "HTTP";
       version = "4000.3.3";
       sha256 = "bbada3c2088dc1384234cdbc1bb6089ea588da068a6a38878ea259dd19de9bf2";
       libraryHaskellDepends = [
         array base bytestring mtl network network-uri parsec time
       ];
       testHaskellDepends = [
         base bytestring case-insensitive conduit conduit-extra deepseq
         http-types httpd-shed HUnit mtl network network-uri pureMD5 split
         test-framework test-framework-hunit wai warp
       ];
       doCheck = false;
       homepage = "https://github.com/haskell/HTTP";
       description = "A library for client-side HTTP";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HTTP-Simple" = callPackage
    ({ mkDerivation, base, HTTP, network }:
     mkDerivation {
       pname = "HTTP-Simple";
       version = "0.2";
       sha256 = "3c497bd3f970615d3a6ba03c20874fb42cc5c38879c02ab87b532f2790bd2489";
       libraryHaskellDepends = [ base HTTP network ];
       doHaddock = false;
       homepage = "http://www.b7j0c.org/content/haskell-http.html";
       description = "DEPRECATED Enable simple wrappers to Network.HTTP";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HTab" = callPackage
    ({ mkDerivation, base, cmdargs, containers, deepseq, hylolib, mtl
     , strict
     }:
     mkDerivation {
       pname = "HTab";
       version = "1.6.3";
       sha256 = "fb135a114a105f719a47799fce96bf13aebff4bdeaed5d9782f89967997e1130";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs containers deepseq hylolib mtl strict
       ];
       homepage = "http://www.glyc.dc.uba.ar/intohylo/htab.php";
       description = "Tableau based theorem prover for hybrid logics";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HTicTacToe" = callPackage
    ({ mkDerivation, array, base, mtl, random, SDL, SDL-image, SDL-ttf
     }:
     mkDerivation {
       pname = "HTicTacToe";
       version = "0.2";
       sha256 = "0c3bef9d5462137f31bb06429c02d604e9f13452ab68b578b39f84ee29c97740";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base mtl random SDL SDL-image SDL-ttf
       ];
       homepage = "http://github.com/snkkid/HTicTacToe";
       description = "An SDL tic-tac-toe game";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HUnit_1_2_5_2" = callPackage
    ({ mkDerivation, base, deepseq }:
     mkDerivation {
       pname = "HUnit";
       version = "1.2.5.2";
       sha256 = "0af5ad34dba27de48b94ce6d5f7ee3aa6af6183bdc4a3967b811e28520369a41";
       libraryHaskellDepends = [ base deepseq ];
       homepage = "http://hunit.sourceforge.net/";
       description = "A unit testing framework for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HUnit_1_3_0_0" = callPackage
    ({ mkDerivation, base, deepseq, filepath }:
     mkDerivation {
       pname = "HUnit";
       version = "1.3.0.0";
       sha256 = "e130db953a2310d2c256a3923af0250be6ea19317f7d369b56d48f84cf96a55c";
       revision = "1";
       editedCabalFile = "23bdbafd3d38f0ae610df6e9768eddef4fdd902de5a6d9b51f23aab1ab22595d";
       libraryHaskellDepends = [ base deepseq ];
       testHaskellDepends = [ base deepseq filepath ];
       homepage = "http://hunit.sourceforge.net/";
       description = "A unit testing framework for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HUnit_1_3_1_0" = callPackage
    ({ mkDerivation, base, deepseq, filepath }:
     mkDerivation {
       pname = "HUnit";
       version = "1.3.1.0";
       sha256 = "8d8075152b5123ca20523d86f2f33c3523ee6857cc748cec88f1e30be47abe0f";
       libraryHaskellDepends = [ base deepseq ];
       testHaskellDepends = [ base deepseq filepath ];
       homepage = "http://hunit.sourceforge.net/";
       description = "A unit testing framework for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HUnit" = callPackage
    ({ mkDerivation, base, deepseq, filepath }:
     mkDerivation {
       pname = "HUnit";
       version = "1.3.1.1";
       sha256 = "93e5fc4290ab685b469209f04d9858338ffff486e15c23a11260c47e32da8ef8";
       libraryHaskellDepends = [ base deepseq ];
       testHaskellDepends = [ base deepseq filepath ];
       homepage = "https://github.com/hspec/HUnit#readme";
       description = "A unit testing framework for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HUnit-Diff" = callPackage
    ({ mkDerivation, ansi-terminal, base, Diff, groom, HUnit }:
     mkDerivation {
       pname = "HUnit-Diff";
       version = "0.1";
       sha256 = "a61bb6cdc8d8baf196c9af502f06ecd478e0c2806f4951169c385b16b1e99a36";
       libraryHaskellDepends = [ ansi-terminal base Diff groom HUnit ];
       jailbreak = true;
       homepage = "https://github.com/dag/HUnit-Diff";
       description = "Assertions for HUnit with difference reporting";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HUnit-Plus" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, cmdargs, containers
     , directory, hashable, hexpat, hostname, parsec, time, timeit
     }:
     mkDerivation {
       pname = "HUnit-Plus";
       version = "1.1.0";
       sha256 = "9cde0930c46c02833e82b10519bcc841ce5186a62be3bb29971538e85a5fcb74";
       libraryHaskellDepends = [
         base bytestring Cabal cmdargs containers hashable hexpat hostname
         parsec time timeit
       ];
       testHaskellDepends = [
         base bytestring Cabal cmdargs containers directory hashable hexpat
         hostname parsec time timeit
       ];
       homepage = "https://github.com/emc2/HUnit-Plus";
       description = "A test framework building on HUnit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HUnit-approx" = callPackage
    ({ mkDerivation, base, HUnit }:
     mkDerivation {
       pname = "HUnit-approx";
       version = "1.0";
       sha256 = "618f492b3f55d7a2c332d2e3916b2cd79af1229421ad64e12a514babd896736b";
       libraryHaskellDepends = [ base HUnit ];
       testHaskellDepends = [ base HUnit ];
       homepage = "https://github.com/goldfirere/HUnit-approx";
       description = "Approximate equality for floating point numbers with HUnit";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HXMPP" = callPackage
    ({ mkDerivation, base, base64-string, binary, bytestring
     , crypto-api, enumerator, HLogger, network, pureMD5, random
     , regex-posix, text, transformers, utf8-string, xml-enumerator
     , xml-types
     }:
     mkDerivation {
       pname = "HXMPP";
       version = "0.0.1.0";
       sha256 = "5a8343984de524e45e624249882d71862331e6f92dbaf1756920f3ecd42a9224";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-string binary bytestring crypto-api enumerator HLogger
         network pureMD5 random regex-posix text transformers utf8-string
         xml-enumerator xml-types
       ];
       executableHaskellDepends = [
         base base64-string binary bytestring crypto-api enumerator HLogger
         network pureMD5 random regex-posix text transformers utf8-string
         xml-enumerator xml-types
       ];
       jailbreak = true;
       homepage = "http://www.pontarius.org/sub-projects/hxmpp/";
       description = "A (prototyped) easy to use XMPP library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HXQ" = callPackage
    ({ mkDerivation, array, base, haskeline, HTTP, mtl, regex-base
     , regex-compat, template-haskell
     }:
     mkDerivation {
       pname = "HXQ";
       version = "0.20.1";
       sha256 = "b7c385aff2e6f1c048eeffcae86b08e7ea5d432a9ca5975e6138c090d45943ad";
       libraryHaskellDepends = [
         array base haskeline HTTP mtl regex-base regex-compat
         template-haskell
       ];
       homepage = "http://lambda.uta.edu/HXQ/";
       description = "A Compiler from XQuery to Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaLeX" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "HaLeX";
       version = "1.2.1";
       sha256 = "1ab0d64eeedec08d9b72c423712437a656fae8ce46ae839bff7778e59f843309";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://www.di.uminho.pt/~jas/Research/HaLeX/HaLeX.html";
       description = "HaLeX enables modelling, manipulation and animation of regular languages";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaMinitel" = callPackage
    ({ mkDerivation, base, bytestring, serialport, stm }:
     mkDerivation {
       pname = "HaMinitel";
       version = "0.1.0.0";
       sha256 = "a810ac58ba5089b7fa5e1347f3c6a1b71571fd18a08463d3c362660e7ec1ee60";
       libraryHaskellDepends = [ base bytestring serialport stm ];
       jailbreak = true;
       homepage = "https://github.com/Zigazou/HaMinitel";
       description = "An Haskell library to drive the french Minitel through a serial port";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "HaPy" = callPackage
    ({ mkDerivation, base, template-haskell, th-lift }:
     mkDerivation {
       pname = "HaPy";
       version = "0.1.1.1";
       sha256 = "9fd74b2ce999bbf8b52cc2dbe2b17c84ee2804a09a74d7426407cf7bc4242052";
       libraryHaskellDepends = [ base template-haskell th-lift ];
       homepage = "https://github.com/sakana/HaPy";
       description = "Haskell bindings for Python";
       license = stdenv.lib.licenses.mit;
     }) {};

  "HaRe_0_8_2_1" = callPackage
    ({ mkDerivation, array, base, Cabal, cabal-helper, containers
     , deepseq, Diff, directory, filepath, ghc, ghc-exactprint, ghc-mod
     , ghc-paths, ghc-prim, ghc-syb-utils, hslogger, hspec, HUnit
     , monad-control, monoid-extras, mtl, old-time, parsec, pretty
     , process, QuickCheck, rosezipper, semigroups, silently
     , Strafunski-StrategyLib, stringbuilder, syb, syz, time
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "HaRe";
       version = "0.8.2.1";
       sha256 = "46045a8bac33e3396e3ce8aec1d2d2545098aae3d0dd7bf2e48935c9aabc1bbe";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal cabal-helper containers directory filepath ghc
         ghc-exactprint ghc-mod ghc-paths ghc-prim ghc-syb-utils hslogger
         monad-control monoid-extras mtl old-time pretty rosezipper
         semigroups Strafunski-StrategyLib syb syz time transformers
         transformers-base
       ];
       executableHaskellDepends = [
         array base Cabal cabal-helper containers directory filepath ghc
         ghc-exactprint ghc-mod ghc-paths ghc-prim ghc-syb-utils hslogger
         monad-control monoid-extras mtl old-time parsec pretty rosezipper
         semigroups Strafunski-StrategyLib syb syz time transformers
         transformers-base
       ];
       testHaskellDepends = [
         base Cabal cabal-helper containers deepseq Diff directory filepath
         ghc ghc-exactprint ghc-mod ghc-paths ghc-prim ghc-syb-utils
         hslogger hspec HUnit monad-control monoid-extras mtl old-time
         process QuickCheck rosezipper semigroups silently
         Strafunski-StrategyLib stringbuilder syb syz time transformers
         transformers-base
       ];
       doCheck = false;
       homepage = "https://github.com/RefactoringTools/HaRe/wiki";
       description = "the Haskell Refactorer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaRe_0_8_2_2" = callPackage
    ({ mkDerivation, array, base, Cabal, cabal-helper, containers
     , deepseq, Diff, directory, filepath, ghc, ghc-exactprint, ghc-mod
     , ghc-paths, ghc-prim, ghc-syb-utils, hslogger, hspec, HUnit
     , monad-control, monoid-extras, mtl, old-time, parsec, pretty
     , process, QuickCheck, rosezipper, semigroups, silently
     , Strafunski-StrategyLib, stringbuilder, syb, syz, time
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "HaRe";
       version = "0.8.2.2";
       sha256 = "27027032f71c8c9f24f64b22655012a3306be60526ee2abff191670cc75d817b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal cabal-helper containers directory filepath ghc
         ghc-exactprint ghc-mod ghc-paths ghc-prim ghc-syb-utils hslogger
         monad-control monoid-extras mtl old-time pretty rosezipper
         semigroups Strafunski-StrategyLib syb syz time transformers
         transformers-base
       ];
       executableHaskellDepends = [
         array base Cabal cabal-helper containers directory filepath ghc
         ghc-exactprint ghc-mod ghc-paths ghc-prim ghc-syb-utils hslogger
         monad-control monoid-extras mtl old-time parsec pretty rosezipper
         semigroups Strafunski-StrategyLib syb syz time transformers
         transformers-base
       ];
       testHaskellDepends = [
         base Cabal cabal-helper containers deepseq Diff directory filepath
         ghc ghc-exactprint ghc-mod ghc-paths ghc-prim ghc-syb-utils
         hslogger hspec HUnit monad-control monoid-extras mtl old-time
         process QuickCheck rosezipper semigroups silently
         Strafunski-StrategyLib stringbuilder syb syz time transformers
         transformers-base
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/RefactoringTools/HaRe/wiki";
       description = "the Haskell Refactorer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaRe" = callPackage
    ({ mkDerivation, array, base, Cabal, cabal-helper, containers
     , deepseq, Diff, directory, filepath, ghc, ghc-exactprint, ghc-mod
     , ghc-paths, ghc-prim, ghc-syb-utils, hslogger, hspec, HUnit
     , monad-control, monoid-extras, mtl, old-time, parsec, pretty
     , process, QuickCheck, rosezipper, semigroups, silently
     , Strafunski-StrategyLib, stringbuilder, syb, syz, time
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "HaRe";
       version = "0.8.2.3";
       sha256 = "8ccd728cd666929cc59ac1ad9fc16a5a462454a6c04c7c5019767f0b490a0e04";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal cabal-helper containers directory filepath ghc
         ghc-exactprint ghc-mod ghc-paths ghc-prim ghc-syb-utils hslogger
         monad-control monoid-extras mtl old-time pretty rosezipper
         semigroups Strafunski-StrategyLib syb syz time transformers
         transformers-base
       ];
       executableHaskellDepends = [
         array base Cabal cabal-helper containers directory filepath ghc
         ghc-exactprint ghc-mod ghc-paths ghc-prim ghc-syb-utils hslogger
         monad-control monoid-extras mtl old-time parsec pretty rosezipper
         semigroups Strafunski-StrategyLib syb syz time transformers
         transformers-base
       ];
       testHaskellDepends = [
         base Cabal cabal-helper containers deepseq Diff directory filepath
         ghc ghc-exactprint ghc-mod ghc-paths ghc-prim ghc-syb-utils
         hslogger hspec HUnit monad-control monoid-extras mtl old-time
         process QuickCheck rosezipper semigroups silently
         Strafunski-StrategyLib stringbuilder syb syz time transformers
         transformers-base
       ];
       doCheck = false;
       homepage = "https://github.com/RefactoringTools/HaRe/wiki";
       description = "the Haskell Refactorer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaTeX_3_15_0_0" = callPackage
    ({ mkDerivation, base, bytestring, containers, matrix, parsec
     , QuickCheck, tasty, tasty-quickcheck, text, transformers
     , wl-pprint-extras
     }:
     mkDerivation {
       pname = "HaTeX";
       version = "3.15.0.0";
       sha256 = "7ecef28c1dc5d4194e0c68a95d4d22c64cb7bd39370b6dfb061e355408ad1de6";
       libraryHaskellDepends = [
         base bytestring containers matrix parsec QuickCheck text
         transformers wl-pprint-extras
       ];
       testHaskellDepends = [
         base QuickCheck tasty tasty-quickcheck text
       ];
       homepage = "http://wrongurl.net/haskell/HaTeX";
       description = "The Haskell LaTeX library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaTeX_3_16_0_0" = callPackage
    ({ mkDerivation, base, bytestring, containers, matrix, parsec
     , QuickCheck, tasty, tasty-quickcheck, text, transformers
     , wl-pprint-extras
     }:
     mkDerivation {
       pname = "HaTeX";
       version = "3.16.0.0";
       sha256 = "ea1608e1092b09919cafb040565334754e714c6054c4e8da28c16ba894526399";
       libraryHaskellDepends = [
         base bytestring containers matrix parsec QuickCheck text
         transformers wl-pprint-extras
       ];
       testHaskellDepends = [
         base QuickCheck tasty tasty-quickcheck text
       ];
       homepage = "http://wrongurl.net/haskell/HaTeX";
       description = "The Haskell LaTeX library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaTeX_3_16_1_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, matrix, parsec
     , QuickCheck, tasty, tasty-quickcheck, text, transformers
     , wl-pprint-extras
     }:
     mkDerivation {
       pname = "HaTeX";
       version = "3.16.1.1";
       sha256 = "5710f05fcbb9bea6d2cbe052520310520980ded6bbfa41e509344f4b194f2876";
       libraryHaskellDepends = [
         base bytestring containers matrix parsec QuickCheck text
         transformers wl-pprint-extras
       ];
       testHaskellDepends = [
         base QuickCheck tasty tasty-quickcheck text
       ];
       homepage = "http://wrongurl.net/haskell/HaTeX";
       description = "The Haskell LaTeX library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaTeX" = callPackage
    ({ mkDerivation, base, bytestring, containers, matrix, parsec
     , QuickCheck, tasty, tasty-quickcheck, text, transformers
     , wl-pprint-extras
     }:
     mkDerivation {
       pname = "HaTeX";
       version = "3.16.2.0";
       sha256 = "e829ab2354d0647142bacc16edb56802e427a1f12c018550a7ff8989ac3a5b5b";
       libraryHaskellDepends = [
         base bytestring containers matrix parsec QuickCheck text
         transformers wl-pprint-extras
       ];
       testHaskellDepends = [
         base QuickCheck tasty tasty-quickcheck text
       ];
       homepage = "https://github.com/Daniel-Diaz/HaTeX/blob/master/README.md";
       description = "The Haskell LaTeX library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HaTeX-meta" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, filepath, ghc
     , haddock, haskell-src-exts, mtl, parsec
     }:
     mkDerivation {
       pname = "HaTeX-meta";
       version = "1.2.1";
       sha256 = "b48b75ad94f50ebc2c5a40a8ce0178d39e002a576d704eba30895cd78740d6b1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers directory filepath ghc haddock
         haskell-src-exts mtl parsec
       ];
       jailbreak = true;
       description = "This package is deprecated. From version 3, HaTeX does not need this anymore.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaTeX-qq" = callPackage
    ({ mkDerivation, antiquoter, base, haskell-src-meta, HaTeX
     , template-haskell, text, uniplate
     }:
     mkDerivation {
       pname = "HaTeX-qq";
       version = "0.0.1.2";
       sha256 = "60db927820811c1bbc17890e21188caeb9441f40c6a5fb5c5436101eca4a0c61";
       libraryHaskellDepends = [
         antiquoter base haskell-src-meta HaTeX template-haskell text
         uniplate
       ];
       description = "Quasiquoters for HaTeX";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HaVSA" = callPackage
    ({ mkDerivation, base, HUnit, logict, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck
     }:
     mkDerivation {
       pname = "HaVSA";
       version = "0.1.0.2";
       sha256 = "f32a70eb352e2e571bfae1a12916ef140a180854bfba3deaa45fed77221103c2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base logict ];
       executableHaskellDepends = [
         base HUnit logict QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck
       ];
       jailbreak = true;
       description = "An implementation of the Version Space Algebra learning framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaXml_1_24_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , polyparse, pretty, random
     }:
     mkDerivation {
       pname = "HaXml";
       version = "1.24.1";
       sha256 = "5f258c7c6291ad54bb9a65280dd30efcbca3fc79a499d5b6575a753d3f7b78df";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers filepath polyparse pretty random
       ];
       executableHaskellDepends = [ directory ];
       homepage = "http://www.cs.york.ac.uk/fp/HaXml/";
       description = "Utilities for manipulating XML documents";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaXml_1_25" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , polyparse, pretty, random
     }:
     mkDerivation {
       pname = "HaXml";
       version = "1.25";
       sha256 = "936abb254607aa270a1a3d4102a098041f71ef38290cfd7fb9f363c4d21e850a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers filepath polyparse pretty random
       ];
       executableHaskellDepends = [ directory ];
       doHaddock = false;
       homepage = "http://projects.haskell.org/HaXml/";
       description = "Utilities for manipulating XML documents";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaXml_1_25_2" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , polyparse, pretty, random
     }:
     mkDerivation {
       pname = "HaXml";
       version = "1.25.2";
       sha256 = "f0e271243330b87822d13298f6ad60947f285b5794d620ab325caf3ef9258358";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers filepath polyparse pretty random
       ];
       executableHaskellDepends = [ directory ];
       doHaddock = false;
       homepage = "http://projects.haskell.org/HaXml/";
       description = "Utilities for manipulating XML documents";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaXml" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , polyparse, pretty, random
     }:
     mkDerivation {
       pname = "HaXml";
       version = "1.25.3";
       sha256 = "6448a7ee1c26159c6c10db93757ed9248f647b1c0c431e7aead6aadd6d2307c7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers filepath polyparse pretty random
       ];
       executableHaskellDepends = [ base directory polyparse pretty ];
       doHaddock = false;
       homepage = "http://projects.haskell.org/HaXml/";
       description = "Utilities for manipulating XML documents";
       license = "LGPL";
     }) {};

  "Hach" = callPackage
    ({ mkDerivation, base, containers, network, old-locale, text, time
     , vty, vty-ui
     }:
     mkDerivation {
       pname = "Hach";
       version = "0.1.2";
       sha256 = "7e2b2fa79697ccf2f173c08207abb9e3dd89b5b070a1555504bd1403f5b3e7ae";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers network old-locale ];
       executableHaskellDepends = [ text time vty vty-ui ];
       homepage = "http://github.com/dmalikov/HaCh";
       description = "Simple chat";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HackMail" = callPackage
    ({ mkDerivation, base, Crypto, directory, hdaemonize, hint, mtl
     , old-time, parsec
     }:
     mkDerivation {
       pname = "HackMail";
       version = "0.0.1";
       sha256 = "7cfd276ad164932459f1d997e20cc1e0039642b4a6bdf49403a46b5558e014c9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Crypto directory hint mtl old-time parsec
       ];
       executableHaskellDepends = [
         base Crypto directory hdaemonize hint mtl old-time parsec
       ];
       homepage = "http://patch-tag.com/publicrepos/Hackmail";
       description = "A Procmail Replacement as Haskell EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Haggressive" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, cassava, containers
     , directory, HUnit, PSQueue, text, tokenize, tuple, vector
     }:
     mkDerivation {
       pname = "Haggressive";
       version = "0.1.0.4";
       sha256 = "e1ef43ae373cd6662cd335912ab140d00dd4723b4aabfb7b29624b5b178ac821";
       libraryHaskellDepends = [
         base bytestring Cabal cassava containers directory HUnit PSQueue
         text tokenize tuple vector
       ];
       testHaskellDepends = [ base Cabal containers HUnit tuple vector ];
       homepage = "https://github.com/Pold87/Haggressive";
       description = "Aggression analysis for Tweets on Twitter";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HandlerSocketClient" = callPackage
    ({ mkDerivation, base, bytestring, network }:
     mkDerivation {
       pname = "HandlerSocketClient";
       version = "0.0.5";
       sha256 = "7b1fcafa55e0b32d35dbdb1ef6fb6487f54f471c018503e7de3c40732967e8ca";
       libraryHaskellDepends = [ base bytestring network ];
       homepage = "https://github.com/wuxb45/HandlerSocket-Haskell-Client";
       description = "Haskell implementation of a HandlerSocket client (API)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HandsomeSoup_0_3_5" = callPackage
    ({ mkDerivation, base, containers, hspec, HTTP, hxt, hxt-http
     , MaybeT, mtl, network, network-uri, parsec, transformers
     }:
     mkDerivation {
       pname = "HandsomeSoup";
       version = "0.3.5";
       sha256 = "35cf24eb6330bfd1c3a2460293da4380ad6267797ded9e0c93bdd590a9553fb4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers HTTP hxt hxt-http MaybeT mtl network network-uri
         parsec transformers
       ];
       executableHaskellDepends = [ base hxt ];
       testHaskellDepends = [ base hspec hxt ];
       homepage = "https://github.com/egonSchiele/HandsomeSoup";
       description = "Work with HTML more easily in HXT";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HandsomeSoup" = callPackage
    ({ mkDerivation, base, containers, hspec, HTTP, hxt, hxt-http, mtl
     , network, network-uri, parsec, transformers
     }:
     mkDerivation {
       pname = "HandsomeSoup";
       version = "0.4.2";
       sha256 = "0ae2dad3fbde1efee9e45b84b2aeb5b526cc7b3ea2cbc5715494f7bde3ceeefb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers HTTP hxt hxt-http mtl network network-uri parsec
         transformers
       ];
       executableHaskellDepends = [ base hxt ];
       testHaskellDepends = [ base hspec hxt ];
       homepage = "https://github.com/egonSchiele/HandsomeSoup";
       description = "Work with HTML more easily in HXT";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Hangman" = callPackage
    ({ mkDerivation, base, hspec, random, transformers }:
     mkDerivation {
       pname = "Hangman";
       version = "0.1.0.2";
       sha256 = "b057343ce4b95177c01f3eec7a0c6c83190e2c0758d93bcaea437e70a1e88307";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base random transformers ];
       testHaskellDepends = [ base hspec transformers ];
       jailbreak = true;
       homepage = "https://github.com/lf94/Hangman";
       description = "The classic game of Hangman";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "HarmTrace" = callPackage
    ({ mkDerivation, array, base, binary, cmdargs, deepseq, Diff
     , directory, filepath, ghc-prim, HarmTrace-Base, HCodecs, hmatrix
     , hmatrix-gsl-stats, instant-generics, ListLike, mtl, parallel
     , parseargs, process, sox, template-haskell, uu-parsinglib, vector
     }:
     mkDerivation {
       pname = "HarmTrace";
       version = "2.2.0";
       sha256 = "dba4b284ea76b47ff3911129341037f54b4b1273d6dbae5a78faf0abe3285cd0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary deepseq Diff directory filepath ghc-prim
         HarmTrace-Base HCodecs hmatrix hmatrix-gsl-stats instant-generics
         ListLike mtl parallel parseargs process template-haskell
         uu-parsinglib vector
       ];
       executableHaskellDepends = [
         array base binary cmdargs deepseq Diff directory filepath ghc-prim
         HarmTrace-Base hmatrix hmatrix-gsl-stats instant-generics ListLike
         mtl parallel process sox template-haskell uu-parsinglib vector
       ];
       jailbreak = true;
       homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/HarmTrace";
       description = "Harmony Analysis and Retrieval of Music";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HarmTrace-Base" = callPackage
    ({ mkDerivation, base, binary, containers, ghc-prim, ListLike
     , QuickCheck, uu-parsinglib
     }:
     mkDerivation {
       pname = "HarmTrace-Base";
       version = "1.4.0.1";
       sha256 = "121c6b164587b95b487aad0ff197ae2ff3b4065ee567e3bcdfe7947148018a9c";
       libraryHaskellDepends = [
         base binary containers ghc-prim ListLike uu-parsinglib
       ];
       testHaskellDepends = [
         base binary containers ghc-prim ListLike QuickCheck uu-parsinglib
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/bash/harmtrace-base";
       description = "Parsing and unambiguously representing musical chords";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HasGP" = callPackage
    ({ mkDerivation, base, haskell98, hmatrix, hmatrix-special, mtl
     , parsec, random
     }:
     mkDerivation {
       pname = "HasGP";
       version = "0.1";
       sha256 = "fdbdc7e243eeb2a3bbfc2a074b502ca2acc52d73b1070630e4a45571c9a185eb";
       libraryHaskellDepends = [
         base haskell98 hmatrix hmatrix-special mtl parsec random
       ];
       jailbreak = true;
       homepage = "http://www.cl.cam.ac.uk/~sbh11/HasGP";
       description = "A Haskell library for inference using Gaussian processes";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Haschoo" = callPackage
    ({ mkDerivation, array, base, list-tries, monad-loops, mtl, numbers
     , parsec
     }:
     mkDerivation {
       pname = "Haschoo";
       version = "0.1.2";
       sha256 = "926122c6e49b5bb811a3c3cf5d7ed5869fdb0b5b8fc2cc79599e5306ae01054a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base list-tries monad-loops mtl numbers parsec
       ];
       jailbreak = true;
       homepage = "http://iki.fi/matti.niemenmaa/misc-projects.html#haschoo";
       description = "Minimalist R5RS Scheme interpreter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Hashell" = callPackage
    ({ mkDerivation, base, directory, ghc, haskell98, parsec, process
     , readline, regex-compat, unix
     }:
     mkDerivation {
       pname = "Hashell";
       version = "1.0";
       sha256 = "f4762565b0c18128b2c4ea8b0312b2f05aae15006a13e289e356c4937511c57a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory ghc haskell98 parsec process readline regex-compat
         unix
       ];
       jailbreak = true;
       description = "Simple shell written in Haskell";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaskRel" = callPackage
    ({ mkDerivation, base, containers, directory, ghc-prim, HList
     , tagged
     }:
     mkDerivation {
       pname = "HaskRel";
       version = "0.1.0.2";
       sha256 = "e7ce026b9791b8fcdea89555a7545d0b4e212982b0aed4e67946a7970ae907a7";
       libraryHaskellDepends = [
         base containers directory ghc-prim HList tagged
       ];
       description = "HaskRel, Haskell as a DBMS with support for the relational algebra";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "HaskellForMaths" = callPackage
    ({ mkDerivation, array, base, containers, random }:
     mkDerivation {
       pname = "HaskellForMaths";
       version = "0.4.8";
       sha256 = "9298592ca32f853233abb0f1d0d34b6e51118dc0d66ed9822442d61c8db4c27a";
       libraryHaskellDepends = [ array base containers random ];
       homepage = "http://haskellformaths.blogspot.com/";
       description = "Combinatorics, group theory, commutative algebra, non-commutative algebra";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HaskellLM" = callPackage
    ({ mkDerivation, base, hmatrix }:
     mkDerivation {
       pname = "HaskellLM";
       version = "0.1.2";
       sha256 = "98690014b2f5a577bc331ce4fb86a97c2c5b002044b0b189b391c2f64bb0582d";
       libraryHaskellDepends = [ base hmatrix ];
       description = "Pure Haskell implementation of the Levenberg-Marquardt algorithm";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaskellNN" = callPackage
    ({ mkDerivation, base, hmatrix, random }:
     mkDerivation {
       pname = "HaskellNN";
       version = "0.1.3";
       sha256 = "b9c28beee5b16df75e7a28a17b053ab57cd2c140c64018ccc03328db27c4b244";
       libraryHaskellDepends = [ base hmatrix random ];
       description = "High Performance Neural Network in Haskell";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaskellNet_0_4_2" = callPackage
    ({ mkDerivation, array, base, base64-string, bytestring, cryptohash
     , mime-mail, mtl, network, old-time, pretty, text
     }:
     mkDerivation {
       pname = "HaskellNet";
       version = "0.4.2";
       sha256 = "8c72ce7a0a7e467b84f0d70ff5606784b0a669ac01314a4fc4222ed899901f56";
       libraryHaskellDepends = [
         array base base64-string bytestring cryptohash mime-mail mtl
         network old-time pretty text
       ];
       homepage = "https://github.com/jtdaugherty/HaskellNet";
       description = "Client support for POP3, SMTP, and IMAP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaskellNet_0_4_3" = callPackage
    ({ mkDerivation, array, base, base64-string, bytestring, cryptohash
     , mime-mail, mtl, network, old-time, pretty, text
     }:
     mkDerivation {
       pname = "HaskellNet";
       version = "0.4.3";
       sha256 = "bf423b16c1cf764b0988f11285a86cee7d9dff5642e60c13a2450026a23ff1f8";
       libraryHaskellDepends = [
         array base base64-string bytestring cryptohash mime-mail mtl
         network old-time pretty text
       ];
       homepage = "https://github.com/jtdaugherty/HaskellNet";
       description = "Client support for POP3, SMTP, and IMAP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaskellNet_0_4_4" = callPackage
    ({ mkDerivation, array, base, base64-string, bytestring, cryptohash
     , mime-mail, mtl, network, old-time, pretty, text
     }:
     mkDerivation {
       pname = "HaskellNet";
       version = "0.4.4";
       sha256 = "790da93acddd70fd5937f2af7206d0ad196fcd2a46d552bfcdb1f4e091c0c535";
       libraryHaskellDepends = [
         array base base64-string bytestring cryptohash mime-mail mtl
         network old-time pretty text
       ];
       homepage = "https://github.com/jtdaugherty/HaskellNet";
       description = "Client support for POP3, SMTP, and IMAP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaskellNet_0_4_5" = callPackage
    ({ mkDerivation, array, base, base64-string, bytestring, cryptohash
     , mime-mail, mtl, network, old-time, pretty, text
     }:
     mkDerivation {
       pname = "HaskellNet";
       version = "0.4.5";
       sha256 = "e58e68825176a49a03ce063a58cdc2fb1086d10f89aec103d7d24e34edfc64b4";
       libraryHaskellDepends = [
         array base base64-string bytestring cryptohash mime-mail mtl
         network old-time pretty text
       ];
       homepage = "https://github.com/jtdaugherty/HaskellNet";
       description = "Client support for POP3, SMTP, and IMAP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaskellNet" = callPackage
    ({ mkDerivation, array, base, base64-string, bytestring, cryptohash
     , mime-mail, mtl, network, old-time, pretty, text
     }:
     mkDerivation {
       pname = "HaskellNet";
       version = "0.5";
       sha256 = "b97d3d43672e0b419bee54c4333092382e1049f356eb029c3f9f1f63794ef9aa";
       libraryHaskellDepends = [
         array base base64-string bytestring cryptohash mime-mail mtl
         network old-time pretty text
       ];
       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, tls
     }:
     mkDerivation {
       pname = "HaskellNet-SSL";
       version = "0.3.2.1";
       sha256 = "aca326c924d3545d93371a06a6df2f2278eb2bdeea91a7c8acbedd230582c3db";
       libraryHaskellDepends = [
         base bytestring connection data-default HaskellNet network tls
       ];
       homepage = "https://github.com/dpwright/HaskellNet-SSL";
       description = "Helpers to connect to SSL/TLS mail servers with HaskellNet";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HaskellTorrent" = callPackage
    ({ mkDerivation, base, bytestring, cereal, cml, containers
     , directory, hopenssl, hslogger, HTTP, HUnit, mtl, network, parsec
     , pretty, QuickCheck, random, random-shuffle, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time
     }:
     mkDerivation {
       pname = "HaskellTorrent";
       version = "0.1.1";
       sha256 = "41e5569acf22bc4d0811b78b876ef50548cdb33105146f3e3f5c1604688ec937";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cereal cml containers directory hopenssl hslogger
         HTTP HUnit mtl network parsec pretty QuickCheck random
         random-shuffle test-framework test-framework-hunit
         test-framework-quickcheck2 time
       ];
       description = "A concurrent bittorrent client";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HaskellTutorials" = callPackage
    ({ mkDerivation, base, cmdargs, text }:
     mkDerivation {
       pname = "HaskellTutorials";
       version = "0.0.0.1";
       sha256 = "f82081639f548e54dc63277b06f2d0b5fe2c22c3275896a1e76b7cdc4847ce3e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base cmdargs text ];
       jailbreak = true;
       homepage = "https://github.com/mrLSD/HaskellTutorials";
       description = "Haskell Tutorials by Evgeny Ukhanov";
       license = stdenv.lib.licenses.mit;
     }) {};

  "Haskelloids" = callPackage
    ({ mkDerivation, base, containers, HGL, hmatrix, MonadRandom
     , random, Yampa
     }:
     mkDerivation {
       pname = "Haskelloids";
       version = "0.1.1";
       sha256 = "e8e32560c4b1fc56af633a99b9099f3e2838491730b1f5fb2c9cc0757f0e276c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers HGL hmatrix MonadRandom random Yampa
       ];
       jailbreak = true;
       homepage = "http://www.matthewhayden.co.uk";
       description = "A reproduction of the Atari 1979 classic \"Asteroids\"";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Hate" = callPackage
    ({ mkDerivation, base, bytestring, GLFW-b, GLUtil, hpp, JuicyPixels
     , JuicyPixels-util, lens, mtl, multimap, OpenGL, random, stm
     , transformers, vect, vect-opengl, vector
     }:
     mkDerivation {
       pname = "Hate";
       version = "0.1.4.3";
       sha256 = "527920c3f401113cf4123486fb578447916eae928923e7bb857ac14442f34e6e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring GLFW-b GLUtil hpp JuicyPixels JuicyPixels-util mtl
         multimap OpenGL stm transformers vect vect-opengl vector
       ];
       executableHaskellDepends = [
         base GLFW-b GLUtil JuicyPixels JuicyPixels-util lens mtl OpenGL
         random transformers vect vect-opengl vector
       ];
       jailbreak = true;
       homepage = "http://github.com/bananu7/Hate";
       description = "A small 2D game framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Hawk" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-trie, cgi, containers
     , convertible, data-default, dataenc, directory, filepath, hack
     , HDBC, HDBC-sqlite3, hslogger, hslogger-template, HTTP, hxt
     , json-b, MonadCatchIO-mtl, mtl, network, regex-posix, SHA
     , template-haskell, time, utf8-string
     }:
     mkDerivation {
       pname = "Hawk";
       version = "0.0.2";
       sha256 = "f831f526f793b56be5c9793dd80542fbdbfdd4b9127e3bc8938c77ad867ced3c";
       libraryHaskellDepends = [
         base bytestring bytestring-trie cgi containers convertible
         data-default dataenc directory filepath hack HDBC HDBC-sqlite3
         hslogger hslogger-template HTTP hxt json-b MonadCatchIO-mtl mtl
         network regex-posix SHA template-haskell time utf8-string
       ];
       jailbreak = true;
       description = "Haskell Web Application Kit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Hayoo" = callPackage
    ({ mkDerivation, base, binary, bytestring, bzlib, containers
     , deepseq, enummapset, filepath, Holumbus-Searchengine, hxt
     , hxt-cache, hxt-charproperties, hxt-curl, hxt-http
     , hxt-regex-xmlschema, hxt-unicode, hxt-xpath, json
     , MonadCatchIO-transformers, mtl, network, old-time, parsec
     , process, snap, snap-core, snap-server, tar, text, transformers
     , xhtml-combinators, zlib
     }:
     mkDerivation {
       pname = "Hayoo";
       version = "1.2.3";
       sha256 = "0c11fc8d3b12e9c18e8b52e00f09dd9fbe560f7841b54cee53fd38fe789bf32e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring bzlib containers deepseq enummapset filepath
         Holumbus-Searchengine hxt hxt-cache hxt-charproperties hxt-curl
         hxt-http hxt-regex-xmlschema hxt-unicode hxt-xpath json
         MonadCatchIO-transformers mtl network old-time parsec process snap
         snap-core snap-server tar text transformers xhtml-combinators zlib
       ];
       jailbreak = true;
       homepage = "http://holumbus.fh-wedel.de";
       description = "The Hayoo! search engine for Haskell API search on hackage";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Hclip" = callPackage
    ({ mkDerivation, base, mtl, process, strict, tasty, tasty-hunit }:
     mkDerivation {
       pname = "Hclip";
       version = "3.0.0.3";
       sha256 = "4e0951e1b26587ee46fe56b91e75e3d878afc3f87deecbdb2b6254b23d21d840";
       libraryHaskellDepends = [ base mtl process strict ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       homepage = "https://github.com/jetho/Hclip";
       description = "A small cross-platform library for reading and modifying the system clipboard";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Hedi" = callPackage
    ({ mkDerivation, base, editline, mtl, parsec, pretty, process
     , QuickCheck, regex-posix
     }:
     mkDerivation {
       pname = "Hedi";
       version = "0.1.1";
       sha256 = "c94e69a83b49d24590171c42d64f283b15591cb3e6cc100c32fb59878a511a7c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base editline mtl parsec pretty process QuickCheck regex-posix
       ];
       executableHaskellDepends = [
         base editline mtl parsec pretty process QuickCheck regex-posix
       ];
       description = "Line oriented editor";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HerbiePlugin" = callPackage
    ({ mkDerivation, base, deepseq, directory, ghc, linear, mtl
     , process, split, sqlite-simple, subhask, template-haskell, text
     }:
     mkDerivation {
       pname = "HerbiePlugin";
       version = "0.2.0.0";
       sha256 = "873fd791e311fb0bd0d4786ed8ef780aef6dff84ae0a2bd9626dbb8256e834ef";
       libraryHaskellDepends = [
         base deepseq directory ghc mtl process split sqlite-simple
         template-haskell text
       ];
       testHaskellDepends = [ base linear subhask ];
       homepage = "github.com/mikeizbicki/herbie-haskell";
       description = "automatically improve your code's numeric stability";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Hermes" = callPackage
    ({ mkDerivation, AES, base, bytestring, cereal, containers
     , hslogger, monads-tf, network, old-time, random, random-shuffle
     , RSA, SHA2, stm, syb, time, transformers, unamb, yjtools
     }:
     mkDerivation {
       pname = "Hermes";
       version = "0.0.4";
       sha256 = "637503bfc4c404cb64e74ec6ddd234de392ce3a9915825cddb0b12b7f378bb48";
       libraryHaskellDepends = [
         AES base bytestring cereal containers hslogger monads-tf network
         old-time random random-shuffle RSA SHA2 stm syb time transformers
         unamb yjtools
       ];
       jailbreak = true;
       description = "Message-based middleware layer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Hieroglyph" = callPackage
    ({ mkDerivation, array, base, buster, bytestring, cairo, colour
     , containers, glib, GLUT, gtk, gtkglext, IfElse, mtl, OpenGL
     , parallel, pretty, random
     }:
     mkDerivation {
       pname = "Hieroglyph";
       version = "3.89";
       sha256 = "dae82ed9d04d3a108fd5205f0f5ccf547795cd8e02033689dde2588ec7dc7b36";
       libraryHaskellDepends = [
         array base buster bytestring cairo colour containers glib GLUT gtk
         gtkglext IfElse mtl OpenGL parallel pretty random
       ];
       jailbreak = true;
       homepage = "http://vis.renci.org/jeff/hieroglyph";
       description = "Purely functional 2D graphics for visualization";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HiggsSet" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, mtl, text
     , th-expand-syns, TrieMap, vector
     }:
     mkDerivation {
       pname = "HiggsSet";
       version = "0.1.1";
       sha256 = "81fadbba216060df911181286d8aea342a618a1b6f48b08040fd4f45eaa518cc";
       libraryHaskellDepends = [
         base bytestring containers deepseq mtl text th-expand-syns TrieMap
         vector
       ];
       homepage = "http://github.com/lpeterse/HiggsSet";
       description = "A multi-index set with advanced query capabilites";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Hipmunk" = callPackage
    ({ mkDerivation, array, base, containers, StateVar, transformers }:
     mkDerivation {
       pname = "Hipmunk";
       version = "5.2.0.17";
       sha256 = "48110b843cc660fa41c9521d9f57e61acd26cce99af94dff7865ac7fd30ebafb";
       libraryHaskellDepends = [
         array base containers StateVar transformers
       ];
       homepage = "https://github.com/meteficha/Hipmunk";
       description = "A Haskell binding for Chipmunk";
       license = "unknown";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "HipmunkPlayground" = callPackage
    ({ mkDerivation, base, containers, GLFW, Hipmunk, OpenGL, StateVar
     , transformers
     }:
     mkDerivation {
       pname = "HipmunkPlayground";
       version = "5.2.1.1";
       sha256 = "47b34d8c80fe70e9c96f62e2eab6ba852f4fe072a6743157b47049085aa8aa1c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers GLFW Hipmunk OpenGL StateVar transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/meteficha/HipmunkPlayground";
       description = "A playground for testing Hipmunk";
       license = "unknown";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "Hish" = callPackage
    ({ mkDerivation, base, directory, MissingH, process, regex-tdfa
     , time
     }:
     mkDerivation {
       pname = "Hish";
       version = "0.1.2.2";
       sha256 = "5094eee275eb1d9dba7929c1bd812cb1b299dce18be5eefcfde3b2cd48d5365a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory MissingH process regex-tdfa time
       ];
       executableHaskellDepends = [
         base directory MissingH process regex-tdfa time
       ];
       jailbreak = true;
       homepage = "https://github.com/jaiyalas/Hish";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Histogram" = callPackage
    ({ mkDerivation, base, containers, gnuplot }:
     mkDerivation {
       pname = "Histogram";
       version = "0.1.0.2";
       sha256 = "b4af5f50e964e4acae2d7fb3ee2cda7eb02fe151c9d9fa2938fab0bbe850c001";
       libraryHaskellDepends = [ base containers gnuplot ];
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Hmpf" = callPackage
    ({ mkDerivation, base, ConfigFile, Crypto, HTTP, mtl, network, time
     , unix, utf8-string
     }:
     mkDerivation {
       pname = "Hmpf";
       version = "0.1";
       sha256 = "a7fb73c6f2b6b7638a7cc8b4c232987e41a52be89f99b481d8b8ffb17d6a8253";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base ConfigFile Crypto HTTP mtl network time unix utf8-string
       ];
       description = "An MPD client designed for a Home Theatre PC";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Hoed" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, containers
     , directory, filepath, FPretty, libgraph, mtl, process, RBTree
     , regex-posix, template-haskell, threepenny-gui
     }:
     mkDerivation {
       pname = "Hoed";
       version = "0.3.5";
       sha256 = "b14c654effc7d4926f73966be56de290d9b0d5159371fc184320033aabba1f1f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cereal containers directory filepath FPretty
         libgraph mtl process RBTree regex-posix template-haskell
         threepenny-gui
       ];
       homepage = "https://wiki.haskell.org/Hoed";
       description = "Lightweight algorithmic debugging";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HoleyMonoid" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "HoleyMonoid";
       version = "0.1.1";
       sha256 = "d9a5fcfc1b388dcb7533dfd6916fc007cdfb2bbab48b820740c7226e32406dfc";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/MedeaMelana/HoleyMonoid";
       description = "Monoids with holes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Holumbus-Distribution" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , deepseq, haskell98, hslogger, hxt, network, random, readline, stm
     , time, unix
     }:
     mkDerivation {
       pname = "Holumbus-Distribution";
       version = "0.1.1";
       sha256 = "e8b0c77059c59dc0103331c978c6deb8805e36b520404f85775780ed7c9714d6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers deepseq haskell98 hslogger
         hxt network random readline stm time unix
       ];
       homepage = "http://holumbus.fh-wedel.de";
       description = "intra- and inter-program communication";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Holumbus-MapReduce" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , directory, extensible-exceptions, haskell98
     , Holumbus-Distribution, Holumbus-Storage, hslogger, hxt, network
     , readline, time, unix
     }:
     mkDerivation {
       pname = "Holumbus-MapReduce";
       version = "0.1.1";
       sha256 = "081f43851af54e1d3dd3a3238005fd595fd3dde7a1ba1ecf6e91067efb911c37";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers deepseq directory
         extensible-exceptions haskell98 Holumbus-Distribution
         Holumbus-Storage hslogger hxt network readline time unix
       ];
       homepage = "http://holumbus.fh-wedel.de";
       description = "a distributed MapReduce framework";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Holumbus-Searchengine" = callPackage
    ({ mkDerivation, base, binary, bytestring, bzlib, containers
     , deepseq, directory, enummapset, filepath, hslogger, hxt
     , hxt-cache, hxt-curl, hxt-regex-xmlschema, hxt-unicode, mtl
     , network, parallel, parsec, process, SHA, unix
     }:
     mkDerivation {
       pname = "Holumbus-Searchengine";
       version = "1.2.3";
       sha256 = "18afe54d818279e4fd08e96ad0b0df657c7a16adac4048fb9846ba111c91a0cf";
       libraryHaskellDepends = [
         base binary bytestring bzlib containers deepseq directory
         enummapset filepath hslogger hxt hxt-cache hxt-curl
         hxt-regex-xmlschema hxt-unicode mtl network parallel parsec process
         SHA unix
       ];
       homepage = "http://holumbus.fh-wedel.de";
       description = "A search and indexing engine";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Holumbus-Storage" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , haskell98, Holumbus-Distribution, hslogger, hxt, network, random
     , time, unix
     }:
     mkDerivation {
       pname = "Holumbus-Storage";
       version = "0.1.0";
       sha256 = "9814a8e05f979da49cc6c20ef728f569ff650aa81858d6a24168c0aef3a846ff";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers directory haskell98
         Holumbus-Distribution hslogger hxt network random time unix
       ];
       homepage = "http://holumbus.fh-wedel.de";
       description = "a distributed storage system";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Homology" = callPackage
    ({ mkDerivation, base, containers, vector }:
     mkDerivation {
       pname = "Homology";
       version = "0.1.1";
       sha256 = "36656dabe90374fd548150a101322f9a24b0a0bd9f32f972f014eabb85779889";
       libraryHaskellDepends = [ base containers vector ];
       homepage = "http://www.math.ucla.edu/~damek";
       description = "Compute the homology of a chain complex";
       license = "GPL";
     }) {};

  "HongoDB" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-binary, base, blaze-builder
     , bytestring, directory, enumerator, hashable, monad-control, mtl
     , process, random, unix, unix-bytestring, unordered-containers
     }:
     mkDerivation {
       pname = "HongoDB";
       version = "0.0.1";
       sha256 = "3b15d27be5f106d99e482280e7cfc93b5d59ba7c82e9d76b29534ce9ceeebca5";
       libraryHaskellDepends = [
         attoparsec attoparsec-binary base blaze-builder bytestring
         directory enumerator hashable monad-control mtl unix
         unix-bytestring unordered-containers
       ];
       testHaskellDepends = [ base process random ];
       jailbreak = true;
       description = "A Simple Key Value Store";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HostAndPort" = callPackage
    ({ mkDerivation, base, doctest, hspec, parsec }:
     mkDerivation {
       pname = "HostAndPort";
       version = "0.2.0";
       sha256 = "15a625f5e0f1a510fa1a307127abae2ae2589d9525ff60ed33be39230f335be6";
       libraryHaskellDepends = [ base parsec ];
       testHaskellDepends = [ base doctest hspec ];
       homepage = "https://github.com/bacher09/hostandport";
       description = "Parser for host and port pairs like localhost:22";
       license = stdenv.lib.licenses.mit;
     }) {};

  "Hricket" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "Hricket";
       version = "0.1";
       sha256 = "028961465c34065ca179388435ef37f95d365465422bb44d9e43ac472585b532";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers ];
       jailbreak = true;
       homepage = "http://github.com/Raynes/Hricket";
       description = "A Cricket scoring application";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Hs2lib" = callPackage
    ({ mkDerivation, array, base, cereal, containers, cpphs, directory
     , filepath, ghc, ghc-paths, haddock, haskell-src-exts, mtl
     , old-locale, process, QuickCheck, random, syb, time
     }:
     mkDerivation {
       pname = "Hs2lib";
       version = "0.6.3";
       sha256 = "b6a26938cb1385904abccebd2b224e1101d351c6c3c33256946ab505357c537a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory filepath ghc haskell-src-exts old-locale random syb
         time
       ];
       libraryToolDepends = [ cpphs ];
       executableHaskellDepends = [
         array base cereal containers directory filepath ghc ghc-paths
         haddock haskell-src-exts mtl old-locale process QuickCheck random
         syb time
       ];
       testHaskellDepends = [ base directory filepath process ];
       jailbreak = true;
       homepage = "http://blog.zhox.com/category/hs2lib/";
       description = "A Library and Preprocessor that makes it easier to create shared libs from Haskell programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HsASA" = callPackage
    ({ mkDerivation, array, base, random }:
     mkDerivation {
       pname = "HsASA";
       version = "0.2";
       sha256 = "c18c8864aca2f11215f9b2cfb50b32d9e1bc4d6c3eb82b204199a23db017aecd";
       libraryHaskellDepends = [ array base random ];
       homepage = "http://repetae.net/recent/out/HsASA.html";
       description = "A haskell interface to Lester Ingber's adaptive simulating annealing code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HsHaruPDF" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "HsHaruPDF";
       version = "0.0.0";
       sha256 = "fa9e9f1a478a2d9f8ad5c45b87fa5d578bcdccac94bfaede89e28f1a66872efa";
       libraryHaskellDepends = [ base ];
       description = "Haskell binding to libharu (http://libharu.sourceforge.net/)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HsHyperEstraier" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, bytestring
     , hyperestraier, network, qdbm, text
     }:
     mkDerivation {
       pname = "HsHyperEstraier";
       version = "0.4";
       sha256 = "68e2dbcbe3e72b0f8c009bcd4d63be8b16d5e39cd8abca0a3e89d30bdfb3f660";
       libraryHaskellDepends = [
         base base-unicode-symbols bytestring network text
       ];
       libraryPkgconfigDepends = [ hyperestraier qdbm ];
       jailbreak = true;
       homepage = "http://cielonegro.org/HsHyperEstraier.html";
       description = "HyperEstraier binding for Haskell";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {hyperestraier = null; qdbm = null;};

  "HsJudy" = callPackage
    ({ mkDerivation, base, bytestring, containers, Judy }:
     mkDerivation {
       pname = "HsJudy";
       version = "0.2";
       sha256 = "704aca42fe2663025d917754a8e4096060fe72bccc9d60ad1fcbd877bcd4edfa";
       libraryHaskellDepends = [ base bytestring containers ];
       librarySystemDepends = [ Judy ];
       homepage = "http://www.pugscode.org/";
       description = "Judy bindings, and some nice APIs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {Judy = null;};

  "HsOpenSSL" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, integer-gmp, network
     , old-locale, openssl, test-framework, test-framework-hunit, time
     }:
     mkDerivation {
       pname = "HsOpenSSL";
       version = "0.11.1.1";
       sha256 = "4a61e074e968a9863e0f3440b3be8ac131457b3d34eb983ca8102122d8ebc4c1";
       revision = "1";
       editedCabalFile = "be351c277db7ddbc2ece8fb2d10b8f1f686b91000a552dd9d8155b79f8db9a5f";
       libraryHaskellDepends = [
         base bytestring integer-gmp network old-locale time
       ];
       librarySystemDepends = [ openssl ];
       testHaskellDepends = [
         base bytestring HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/phonohawk/HsOpenSSL";
       description = "Partial OpenSSL binding for Haskell";
       license = stdenv.lib.licenses.publicDomain;
     }) {inherit (pkgs) openssl;};

  "HsOpenSSL-x509-system" = callPackage
    ({ mkDerivation, base, bytestring, HsOpenSSL, unix }:
     mkDerivation {
       pname = "HsOpenSSL-x509-system";
       version = "0.1.0.2";
       sha256 = "ecc942c69f4c25fa52dec70f34d3e324de62596826b0bdc1ba8196594d13289b";
       libraryHaskellDepends = [ base bytestring HsOpenSSL unix ];
       homepage = "https://github.com/redneb/HsOpenSSL-x509-system";
       description = "Use the system's native CA certificate store with HsOpenSSL";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HsParrot" = callPackage
    ({ mkDerivation, base, bytestring, HsSyck, pretty, pugs-DrIFT }:
     mkDerivation {
       pname = "HsParrot";
       version = "0.0.2.20150805";
       sha256 = "ea98d38cd15d82689a3f0b3010b00cf07d93a94820d11781c122af5fa89b3d34";
       libraryHaskellDepends = [
         base bytestring HsSyck pretty pugs-DrIFT
       ];
       description = "Haskell integration with Parrot virtual machine";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HsPerl5" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "HsPerl5";
       version = "0.0.6.20150815";
       sha256 = "5f7c198b47a9aca65d6ca201fb3cad78327c7c1f3cb23a517de4322a42fd4896";
       libraryHaskellDepends = [ base ];
       description = "Haskell interface to embedded Perl 5 interpreter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HsSVN" = callPackage
    ({ mkDerivation, base, bytestring, mtl, stm }:
     mkDerivation {
       pname = "HsSVN";
       version = "0.4.3.3";
       sha256 = "87ddd1a22d3e2a6a5f3ee29d7e5b19a6a3352394082198bf2573fa2ad96fa4fb";
       libraryHaskellDepends = [ base bytestring mtl stm ];
       jailbreak = true;
       homepage = "https://github.com/phonohawk/HsSVN";
       description = "Partial Subversion (SVN) binding for Haskell";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HsSyck" = callPackage
    ({ mkDerivation, base, bytestring, hashtables, syb, utf8-string }:
     mkDerivation {
       pname = "HsSyck";
       version = "0.53";
       sha256 = "8efbb26aba294f495fa3615b496fe569fbc6189799899af8fdd546392d97249f";
       libraryHaskellDepends = [
         base bytestring hashtables syb utf8-string
       ];
       description = "Fast, lightweight YAML loader and dumper";
       license = stdenv.lib.licenses.mit;
     }) {};

  "HsTools" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "HsTools";
       version = "0.0.1.1";
       sha256 = "b4d879266ddb09abea653f7e27c2d318e7bd5f18aa551cd8908075d27774562d";
       libraryHaskellDepends = [ base ghc-prim ];
       description = "Haskell helper functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Hsed" = callPackage
    ({ mkDerivation, array, base, bytestring, cmdargs, data-accessor
     , data-accessor-template, data-accessor-transformers, directory
     , filepath, Glob, GotoT-transformers, haskell98, mtl, parsec
     , regex-base, regex-compat, regex-posix
     }:
     mkDerivation {
       pname = "Hsed";
       version = "0.2.2";
       sha256 = "4a64103818e4896b61e260dce19dcd756419beaeff7fac8f3cbc52fc157b6227";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cmdargs data-accessor data-accessor-template
         data-accessor-transformers directory filepath Glob
         GotoT-transformers haskell98 mtl parsec regex-base regex-compat
         regex-posix
       ];
       homepage = "http://github.com/rukav/Hsed";
       description = "Stream Editor in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Hsmtlib" = callPackage
    ({ mkDerivation, base, containers, parsec, pretty, process, smtLib
     , transformers
     }:
     mkDerivation {
       pname = "Hsmtlib";
       version = "2.8.8.8";
       sha256 = "4bc1d1af5f7d514b154691619beeb323d0730999628cfd07038961c673d165fd";
       revision = "1";
       editedCabalFile = "01f30561cce8648a656f075ba1e1f8c23144e7f10c6377a7949881dc513f8a89";
       libraryHaskellDepends = [
         base containers parsec pretty process smtLib transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/MfesGA/Hsmtlib";
       description = "Haskell library for easy interaction with SMT-LIB 2 compliant solvers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "HueAPI" = callPackage
    ({ mkDerivation, aeson, base, containers, lens, lens-aeson, mtl
     , transformers, wreq
     }:
     mkDerivation {
       pname = "HueAPI";
       version = "0.2.7";
       sha256 = "041a08272fadadeac496f04d5fd3f9a4da8a4122fed2c0b9ec3e875d5273b900";
       libraryHaskellDepends = [
         aeson base containers lens lens-aeson mtl transformers wreq
       ];
       homepage = "https://github.com/sjoerdvisscher/HueAPI";
       description = "API for controlling Philips Hue lights";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "HulkImport" = callPackage
    ({ mkDerivation, attoparsec, base, pretty, tasty, tasty-golden
     , text
     }:
     mkDerivation {
       pname = "HulkImport";
       version = "0.1.0.3";
       sha256 = "70d0a2a086dab3c2f08592cc421f2f005ec65dd00b83a42c957a54bfd39496cd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ attoparsec base pretty text ];
       executableHaskellDepends = [ base text ];
       testHaskellDepends = [ base tasty tasty-golden ];
       homepage = "http://github.com/tobs169/HulkImport#readme";
       description = "Easily bulk import CSV data to SQL Server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Hungarian-Munkres" = callPackage
    ({ mkDerivation, array, base, Munkres, random, tasty
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "Hungarian-Munkres";
       version = "0.1.5";
       sha256 = "0d138c6c8247c4c503724e75651668f85d4f4fe4dbbc5f07271773a7337b503c";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         array base Munkres random tasty tasty-quickcheck
       ];
       description = "A Linear Sum Assignment Problem (LSAP) solver";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "IDynamic" = callPackage
    ({ mkDerivation, base, containers, directory }:
     mkDerivation {
       pname = "IDynamic";
       version = "0.1";
       sha256 = "e83b1962e9cacd32779a0ce7c184041132cf179e9b1804ffec0bdccf3b1490dc";
       libraryHaskellDepends = [ base containers directory ];
       jailbreak = true;
       description = "Indexable, serializable form of Data.Dynamic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "IFS" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, random }:
     mkDerivation {
       pname = "IFS";
       version = "0.1.1";
       sha256 = "b9033330795053590b313ea72cceb58a3bcffa27e56be60759fde95af55d4de4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers random
       ];
       homepage = "http://www.alpheccar.org";
       description = "Iterated Function System generation for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "INblobs" = callPackage
    ({ mkDerivation, base, containers, directory, haskell98, HaXml
     , polyparse, pretty, process, wx, wxcore
     }:
     mkDerivation {
       pname = "INblobs";
       version = "0.1.1";
       sha256 = "20ace703a9b87ff6c9495f6f99213737bbde47b250415287954060a7fa303412";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory haskell98 HaXml polyparse pretty process
         wx wxcore
       ];
       homepage = "http://haskell.di.uminho.pt/jmvilaca/INblobs/";
       description = "Editor and interpreter for Interaction Nets";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "IOR" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "IOR";
       version = "0.1";
       sha256 = "0a61884f2c134f9bd0a5ebff0103b539118a7845fd4d4adecdeaf20bd4d63646";
       libraryHaskellDepends = [ base mtl ];
       description = "Region based resource management for the IO monad";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "IORefCAS" = callPackage
    ({ mkDerivation, base, bits-atomic, ghc-prim, HUnit, QuickCheck
     , time
     }:
     mkDerivation {
       pname = "IORefCAS";
       version = "0.2.0.1";
       sha256 = "abb984358deedcbc904899f19756487a86ce44264d520193c2158c9eca646e1b";
       libraryHaskellDepends = [ base bits-atomic ghc-prim ];
       testHaskellDepends = [
         base bits-atomic ghc-prim HUnit QuickCheck time
       ];
       homepage = "https://github.com/rrnewton/haskell-lockfree-queue/wiki";
       description = "Atomic compare and swap for IORefs and STRefs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "IOSpec" = callPackage
    ({ mkDerivation, base, mtl, QuickCheck, Stream }:
     mkDerivation {
       pname = "IOSpec";
       version = "0.3";
       sha256 = "dedf2b3b1b25e07b30e9228c446d911414c58101a3f1f7bc0e544787ba159437";
       libraryHaskellDepends = [ base mtl QuickCheck Stream ];
       description = "A pure specification of the IO monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "IPv6Addr" = callPackage
    ({ mkDerivation, attoparsec, base, HUnit, iproute, network
     , network-info, random, test-framework, test-framework-hunit, text
     }:
     mkDerivation {
       pname = "IPv6Addr";
       version = "0.6.0.2";
       sha256 = "8d5e334be1ca394f4f76daa12f23d352dab8c76b57569bf3b3225934548bf963";
       libraryHaskellDepends = [
         attoparsec base iproute network network-info random text
       ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit text
       ];
       homepage = "https://github.com/MichelBoucey/IPv6Addr";
       description = "Library to deal with IPv6 address text representations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "IcoGrid" = callPackage
    ({ mkDerivation, array, base, GlomeVec }:
     mkDerivation {
       pname = "IcoGrid";
       version = "0.1.2";
       sha256 = "16317e247510e2bc1e4920f21299e06af7c394543205f0b0e8ac35d70b16cb67";
       libraryHaskellDepends = [ array base GlomeVec ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/IcoGrid";
       description = "Library for generating grids of hexagons and pentagons mapped to a sphere";
       license = "GPL";
     }) {};

  "IfElse" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "IfElse";
       version = "0.85";
       sha256 = "8ad3bfc3e2c867e6330d9bff874b3105476c35b2e1638fd448f233e9f80addcd";
       libraryHaskellDepends = [ base mtl ];
       description = "Anaphoric and miscellaneous useful control-flow";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Imlib" = callPackage
    ({ mkDerivation, array, base, imlib2, X11 }:
     mkDerivation {
       pname = "Imlib";
       version = "0.1.2";
       sha256 = "3ed318a7777a3b0752327b7b128edb3a1d562202b480a6d6b793b79ed90ebd1c";
       libraryHaskellDepends = [ array base X11 ];
       librarySystemDepends = [ imlib2 ];
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) imlib2;};

  "ImperativeHaskell" = callPackage
    ({ mkDerivation, base, mtl, template-haskell }:
     mkDerivation {
       pname = "ImperativeHaskell";
       version = "2.0.0.1";
       sha256 = "8b5f0b73ec0b16fba40aaaccd1e053408b2d1ec0eb6e2aceb0e73fc3e041fd1a";
       libraryHaskellDepends = [ base mtl template-haskell ];
       homepage = "https://github.com/mmirman/ImperativeHaskell";
       description = "A library for writing Imperative style haskell";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "IndentParser" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "IndentParser";
       version = "0.2.1";
       sha256 = "520c9d235ff0afb9ce771bf1b596a5096c46e2204eb1be299670032b5a453351";
       libraryHaskellDepends = [ base parsec ];
       homepage = "http://www.cse.iitk.ac.in/~ppk";
       description = "Combinators for parsing indentation based syntatic structures";
       license = "GPL";
     }) {};

  "IndexedList" = callPackage
    ({ mkDerivation, base, PeanoWitnesses }:
     mkDerivation {
       pname = "IndexedList";
       version = "0.1.0.1";
       sha256 = "d57539709179de74c116781907d6a31d7b79979e957b308d00924889e3d8efc4";
       libraryHaskellDepends = [ base PeanoWitnesses ];
       jailbreak = true;
       homepage = "https://github.com/kwf/IndexedList";
       description = "Length- and element-indexed lists sitting somewhere between homogeneous and fully heterogeneous";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "InfixApplicative" = callPackage
    ({ mkDerivation, base, haskell98 }:
     mkDerivation {
       pname = "InfixApplicative";
       version = "1.1";
       sha256 = "f7398e1b1b6c9337b6e238cfafd400d339a9fe04cf35aba272a6624b2d95800d";
       libraryHaskellDepends = [ base haskell98 ];
       description = "liftA2 for infix operators";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Interpolation" = callPackage
    ({ mkDerivation, base, haskell-src-meta, syb, template-haskell }:
     mkDerivation {
       pname = "Interpolation";
       version = "0.3.0";
       sha256 = "1bf68489dafd52f25d93a3aad672a2dc7110d77ffb85348cb82c3e5a51e8cb10";
       libraryHaskellDepends = [
         base haskell-src-meta syb template-haskell
       ];
       description = "Multiline strings, interpolation and templating";
       license = "unknown";
     }) {};

  "Interpolation-maxs" = callPackage
    ({ mkDerivation, base, syb, template-haskell }:
     mkDerivation {
       pname = "Interpolation-maxs";
       version = "0.3.0";
       sha256 = "f6ed200a65ee53f60c0fc2698fb6dc6154e891b37d2764d5b3f2101890690836";
       libraryHaskellDepends = [ base syb template-haskell ];
       description = "Multiline strings, interpolation and templating";
       license = "unknown";
     }) {};

  "IntervalMap_0_4_1_1" = callPackage
    ({ mkDerivation, base, Cabal, containers, deepseq, QuickCheck }:
     mkDerivation {
       pname = "IntervalMap";
       version = "0.4.1.1";
       sha256 = "eda9176e35ae9988770af216ba69d7a714f1baec7344789c03f3eaec0a4af423";
       libraryHaskellDepends = [ base containers deepseq ];
       testHaskellDepends = [ base Cabal containers deepseq QuickCheck ];
       homepage = "http://www.chr-breitkopf.de/comp/IntervalMap";
       description = "Maps from Intervals to values, with efficient search";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "IntervalMap_0_5_0_0" = callPackage
    ({ mkDerivation, base, Cabal, containers, deepseq, QuickCheck }:
     mkDerivation {
       pname = "IntervalMap";
       version = "0.5.0.0";
       sha256 = "c4d156c11b6433cf3d31204bd0e6d81aafa9bc9cf6c07ea0a6eac874cea13b1d";
       libraryHaskellDepends = [ base containers deepseq ];
       testHaskellDepends = [ base Cabal containers deepseq QuickCheck ];
       homepage = "http://www.chr-breitkopf.de/comp/IntervalMap";
       description = "Containers for intervals, with efficient search";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "IntervalMap" = callPackage
    ({ mkDerivation, base, Cabal, containers, deepseq, QuickCheck }:
     mkDerivation {
       pname = "IntervalMap";
       version = "0.5.0.1";
       sha256 = "5c4a44fc5091f1e7a879cdd937a3fc3de28696e21d247250a4b2c0cf12e160bc";
       libraryHaskellDepends = [ base containers deepseq ];
       testHaskellDepends = [ base Cabal containers deepseq QuickCheck ];
       homepage = "http://www.chr-breitkopf.de/comp/IntervalMap";
       description = "Containers for intervals, with efficient search";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Irc" = callPackage
    ({ mkDerivation, base, data-default, doctest, mtl, network
     , transformers
     }:
     mkDerivation {
       pname = "Irc";
       version = "0.1.0.2";
       sha256 = "f18a2c7eb198c6223f02da7f5bea13f89652b8bebe1adb65fbd779e07f920162";
       libraryHaskellDepends = [
         base data-default mtl network transformers
       ];
       testHaskellDepends = [ base doctest ];
       jailbreak = true;
       homepage = "https://github.com/yunxing/Irc";
       description = "DSL for IRC bots";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "IrrHaskell" = callPackage
    ({ mkDerivation, base, random, time }:
     mkDerivation {
       pname = "IrrHaskell";
       version = "0.2";
       sha256 = "8c75f12f9ef896886d4eea118aab5003c7cfc6ae170f0dd85993a02c562415c8";
       libraryHaskellDepends = [ base random time ];
       doHaddock = false;
       description = "Haskell FRP binding to the Irrlicht game engine";
       license = "LGPL";
     }) {};

  "IsNull" = callPackage
    ({ mkDerivation, base, bytestring, containers, hspec, HUnit
     , QuickCheck, quickcheck-instances, system-filepath, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "IsNull";
       version = "0.4.0.0";
       sha256 = "757a5088cc81795afd06410cbbe7e3ee27a734602c6db65de9111e5fd31ac019";
       libraryHaskellDepends = [ base bytestring containers text ];
       testHaskellDepends = [
         base bytestring containers hspec HUnit QuickCheck
         quickcheck-instances system-filepath text unordered-containers
         vector
       ];
       jailbreak = true;
       homepage = "https://github.com/jcristovao/IsNull";
       description = "A typeclass to determine if a given value is null";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "JSON-Combinator" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , bytestring-trie, containers, failure, hjson, json, JSONb, parsec
     , text, vector
     }:
     mkDerivation {
       pname = "JSON-Combinator";
       version = "0.2.8";
       sha256 = "d8782aba8b5fb2fff5f6988722090d5d734da9e9e705d8c6f8ea6a5e82dab165";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring bytestring-trie containers failure
         hjson json JSONb parsec text vector
       ];
       description = "A combinator library on top of a generalised JSON type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JSON-Combinator-Examples" = callPackage
    ({ mkDerivation, base, bytestring, json, JSON-Combinator, JSONb }:
     mkDerivation {
       pname = "JSON-Combinator-Examples";
       version = "0.0.1";
       sha256 = "8f7b52806a57cd9788391a7378a2e8f5d4b6a278b416eb4b81dcd2699fcbafe8";
       libraryHaskellDepends = [
         base bytestring json JSON-Combinator JSONb
       ];
       description = "Example uses of the JSON-Combinator library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JSONb" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, bytestring-nums
     , bytestring-trie, containers, utf8-string
     }:
     mkDerivation {
       pname = "JSONb";
       version = "1.0.8";
       sha256 = "477eecd8af2f070ff648f576ee81ee04efa45cc77b606f7fc09b6f2c156df299";
       revision = "1";
       editedCabalFile = "47b2855a9c5769eadfdbb4eaddca6c66e6de21432d555162f2cc4dcde6e0861a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-nums bytestring-trie
         containers utf8-string
       ];
       executableHaskellDepends = [
         attoparsec base bytestring bytestring-nums bytestring-trie
         containers utf8-string
       ];
       jailbreak = true;
       homepage = "http://github.com/solidsnack/JSONb/";
       description = "JSON parser that uses byte strings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JYU-Utils" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , deepseq, directory, filepath, lazysmallcheck, mtl, mwc-random
     , parallel, process, QuickCheck, random, stm, template-haskell
     , unix, zlib
     }:
     mkDerivation {
       pname = "JYU-Utils";
       version = "0.1.1.2";
       sha256 = "895f8339b36ffa6a146209be8b08dfa8caf84178bb13bf71f0bbeeb67eeb6cb0";
       libraryHaskellDepends = [
         array base binary bytestring containers deepseq directory filepath
         lazysmallcheck mtl mwc-random parallel process QuickCheck random
         stm template-haskell unix zlib
       ];
       jailbreak = true;
       description = "Some utility functions for JYU projects";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JackMiniMix" = callPackage
    ({ mkDerivation, base, hosc }:
     mkDerivation {
       pname = "JackMiniMix";
       version = "0.1";
       sha256 = "17f335f1f374982adc4bb8553258bc1c4b5f2abb4b536b64d9303095c3747847";
       libraryHaskellDepends = [ base hosc ];
       homepage = "http://www.renickbell.net/doku.php?id=jackminimix";
       description = "control JackMiniMix";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Javasf" = callPackage
    ({ mkDerivation, base, binary, bytestring, language-java-classfile
     }:
     mkDerivation {
       pname = "Javasf";
       version = "0.0.1";
       sha256 = "50297780db65f009fa8f8b90680bcb8c96ed03949db5c7f494a4e8e0f0d46093";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring language-java-classfile
       ];
       description = "A utility to print the SourceFile attribute of one or more Java class files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Javav" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Javav";
       version = "0.0.4";
       sha256 = "098e1179abf010ac4a5d2485ea0b53c6e18cabce623e2526dc0f51b8028e5119";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       description = "A utility to print the target version of Java class files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JsContracts" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, mtl, parsec
     , pretty, syb, WebBits, WebBits-Html
     }:
     mkDerivation {
       pname = "JsContracts";
       version = "0.5.3";
       sha256 = "0915ab4d92f72c4148bc1f1a2f19d494dd49e7364b342253bb991ed66e9b869e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory filepath mtl parsec pretty syb WebBits
         WebBits-Html
       ];
       executableHaskellDepends = [
         base containers mtl parsec pretty syb WebBits WebBits-Html
       ];
       jailbreak = true;
       homepage = "http://www.cs.brown.edu/research/plt/";
       description = "Design-by-contract for JavaScript";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JsonGrammar" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , hashable, HUnit, language-typescript, mtl, semigroups
     , stack-prism, template-haskell, test-framework
     , test-framework-hunit, text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "JsonGrammar";
       version = "1.0.3";
       sha256 = "0d3879f9735dce25bdd52b01d0fb07c92eaf32a79aed1a16a67429cae3b297ee";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers hashable
         language-typescript mtl semigroups stack-prism template-haskell
         text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base HUnit language-typescript stack-prism test-framework
         test-framework-hunit text
       ];
       jailbreak = true;
       homepage = "https://github.com/MedeaMelana/JsonGrammar2";
       description = "Combinators for bidirectional JSON parsing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JuicyPixels_3_1_7_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
     , primitive, transformers, vector, zlib
     }:
     mkDerivation {
       pname = "JuicyPixels";
       version = "3.1.7.1";
       sha256 = "5751e984068e7a325f6b45a3d00f827aee49e4e63abf2a84a9b6c3dcb09d1a56";
       revision = "1";
       editedCabalFile = "9c9bd1f8226e4c8b9c48c9ce8fb23997e366dd7cdf8e3dc333585376a70e12fc";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq mtl primitive
         transformers vector zlib
       ];
       jailbreak = true;
       homepage = "https://github.com/Twinside/Juicy.Pixels";
       description = "Picture loading/serialization (in png, jpeg, bitmap, gif, tiff and radiance)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JuicyPixels_3_2_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
     , primitive, transformers, vector, zlib
     }:
     mkDerivation {
       pname = "JuicyPixels";
       version = "3.2.1";
       sha256 = "30976e462dd14a1fb4cefbc9841c612f7621445ac1107dd37c7ce5d54a9d002b";
       revision = "1";
       editedCabalFile = "2874e7dbd0456c451bb76d1b4a9a5716096fa4ab6bc34b393c05b6940d5db096";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq mtl primitive
         transformers vector zlib
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JuicyPixels_3_2_2" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
     , primitive, transformers, vector, zlib
     }:
     mkDerivation {
       pname = "JuicyPixels";
       version = "3.2.2";
       sha256 = "1f3958b348eeecf928c91049af67cb504110e351b3f0b5225de3c403df21ad90";
       revision = "1";
       editedCabalFile = "8ea17e0a129b07efdf7006ecd8327f46aaf2ef9ef1baa8417b16c7622ba161ef";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq mtl primitive
         transformers vector zlib
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JuicyPixels_3_2_3" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
     , primitive, transformers, vector, zlib
     }:
     mkDerivation {
       pname = "JuicyPixels";
       version = "3.2.3";
       sha256 = "9553b11222935f00e5f815f2c1305a778be232b9cb2003849481d7370333d859";
       revision = "1";
       editedCabalFile = "af647947ca44f071c31a52fb67877909d201721b501895400cf95325d883ee52";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq mtl primitive
         transformers vector zlib
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JuicyPixels_3_2_3_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
     , primitive, transformers, vector, zlib
     }:
     mkDerivation {
       pname = "JuicyPixels";
       version = "3.2.3.1";
       sha256 = "212a11cb158da4b18160a9a2af13b91b77b39edf07ec7e245c5be4097ed900d3";
       revision = "1";
       editedCabalFile = "fd215f12a2763abe8b69471998965460a1a6b8d965d5cbc7b78fbbd970a58c93";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq mtl primitive
         transformers vector zlib
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JuicyPixels_3_2_4" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
     , primitive, transformers, vector, zlib
     }:
     mkDerivation {
       pname = "JuicyPixels";
       version = "3.2.4";
       sha256 = "801b23de9aa5e81c27f23ed161738525b83b462703e2b93ee80440d3b2317c84";
       revision = "1";
       editedCabalFile = "0ea6de6b2defec5f1be0f98fc995b3a9654fbf8d3b34cd3fa77a0f2e3919dc2b";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq mtl primitive
         transformers vector zlib
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JuicyPixels_3_2_5_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
     , primitive, transformers, vector, zlib
     }:
     mkDerivation {
       pname = "JuicyPixels";
       version = "3.2.5.1";
       sha256 = "b89909006533da86a81fd83ab1e3967f731e703b222242613dfac09329999787";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq mtl primitive
         transformers vector zlib
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JuicyPixels_3_2_5_2" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
     , primitive, transformers, vector, zlib
     }:
     mkDerivation {
       pname = "JuicyPixels";
       version = "3.2.5.2";
       sha256 = "54ea503915616808069cd94e765c8bc56d4f92d9e1c9a02e56c6bca12db0de1d";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq mtl primitive
         transformers vector zlib
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JuicyPixels_3_2_5_3" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
     , primitive, transformers, vector, zlib
     }:
     mkDerivation {
       pname = "JuicyPixels";
       version = "3.2.5.3";
       sha256 = "fc36f130e678119475434febcdfe75e1e083062a4729a3104cc5bdc7972cd8ce";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq mtl primitive
         transformers vector zlib
       ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JuicyPixels_3_2_6" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
     , primitive, transformers, vector, zlib
     }:
     mkDerivation {
       pname = "JuicyPixels";
       version = "3.2.6";
       sha256 = "f99e82c84d8eeff23ba57332ed4b89530bc1a739c3a8f4b670b07ac33bfc9a46";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq mtl primitive
         transformers vector zlib
       ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JuicyPixels_3_2_6_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
     , primitive, transformers, vector, zlib
     }:
     mkDerivation {
       pname = "JuicyPixels";
       version = "3.2.6.1";
       sha256 = "8ca8a8ba99c3edc0d565dd2f5974888c79823e38f8e5a7a8ebf1fd32aa35d213";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq mtl primitive
         transformers vector zlib
       ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JuicyPixels_3_2_6_2" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
     , primitive, transformers, vector, zlib
     }:
     mkDerivation {
       pname = "JuicyPixels";
       version = "3.2.6.2";
       sha256 = "22952ab2e1152dcb2af1b0340ee4999516a6605b8ecbcbfd37e8dbd9d829aa43";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq mtl primitive
         transformers vector zlib
       ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JuicyPixels_3_2_6_4" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
     , primitive, transformers, vector, zlib
     }:
     mkDerivation {
       pname = "JuicyPixels";
       version = "3.2.6.4";
       sha256 = "6268583fd7915913b3d68a399184bfcfebfaa010be9aa10232d76324df65a6ac";
       revision = "1";
       editedCabalFile = "98af5e6f6f65e399f518466813f6ada6cfa80ebc1eae6ba98525065f985ced15";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq mtl primitive
         transformers vector zlib
       ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JuicyPixels" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, mtl
     , primitive, transformers, vector, zlib
     }:
     mkDerivation {
       pname = "JuicyPixels";
       version = "3.2.7";
       sha256 = "0126ff02d78045a299e76a35e2a3d3d188e7512f08d57e89bf1e0a94eb6ff14b";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq mtl primitive
         transformers vector zlib
       ];
       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-canvas" = callPackage
    ({ mkDerivation, base, containers, JuicyPixels }:
     mkDerivation {
       pname = "JuicyPixels-canvas";
       version = "0.1.0.0";
       sha256 = "95f5c368a7b6a7f9a5776abfca575925e3c84ffbfa2e5d3eb583bdf4f80ce978";
       libraryHaskellDepends = [ base containers JuicyPixels ];
       jailbreak = true;
       homepage = "http://eax.me/";
       description = "Functions for drawing lines, squares and so on pixel by pixel";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "JuicyPixels-repa_0_7" = callPackage
    ({ mkDerivation, base, bytestring, JuicyPixels, repa, vector }:
     mkDerivation {
       pname = "JuicyPixels-repa";
       version = "0.7";
       sha256 = "a556109f053d1dfd1eebd23080d5f285816a03f73e37fdc1f32e0a8df888c93a";
       revision = "1";
       editedCabalFile = "b0dcd6dae60b506057721d2732aebbece6ce380b5d7df4b2ba64592e6e3a88a8";
       libraryHaskellDepends = [
         base bytestring JuicyPixels repa vector
       ];
       jailbreak = true;
       description = "Convenience functions to obtain array representations of images";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JuicyPixels-repa" = callPackage
    ({ mkDerivation, base, bytestring, JuicyPixels, repa, vector }:
     mkDerivation {
       pname = "JuicyPixels-repa";
       version = "0.7.0.1";
       sha256 = "767c5f7ab39b660f0a9e4c8a5af0564060f5319dee7f68306523344ddfdf3837";
       libraryHaskellDepends = [
         base bytestring JuicyPixels repa vector
       ];
       description = "Convenience functions to obtain array representations of images";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "JuicyPixels-scale-dct" = callPackage
    ({ mkDerivation, base, base-compat, carray, fft, JuicyPixels
     , JuicyPixels-util, time
     }:
     mkDerivation {
       pname = "JuicyPixels-scale-dct";
       version = "0.1.1.0";
       sha256 = "dc7ee68f2e28e2b2344bdaabd5810ebfc15353d4013cd10387289189e8bae9f9";
       revision = "1";
       editedCabalFile = "5b187d4f46adbd5ff68ddda4f2f0221370dc3f4f47d7a95f652d147a7bd9f36a";
       libraryHaskellDepends = [
         base base-compat carray fft JuicyPixels
       ];
       testHaskellDepends = [
         base base-compat carray fft JuicyPixels JuicyPixels-util time
       ];
       homepage = "https://github.com/phadej/JuicyPixels-scale-dct#readme";
       description = "Scale JuicyPixels images with DCT";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "JuicyPixels-util" = callPackage
    ({ mkDerivation, base, JuicyPixels, vector }:
     mkDerivation {
       pname = "JuicyPixels-util";
       version = "0.2";
       sha256 = "2c7b3fb6f3da6d77870bbc356db59afb05f1ab00392b060a8503b5895ee959ac";
       libraryHaskellDepends = [ base JuicyPixels vector ];
       homepage = "https://github.com/fumieval/JuicyPixels-util";
       description = "Convert JuicyPixel images into RGBA format, flip, trim and so on";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "JunkDB" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, conduit
     , data-default, directory, filepath, mtl, network, resourcet
     }:
     mkDerivation {
       pname = "JunkDB";
       version = "0.1.1.0";
       sha256 = "bd093833eee79c6ec905cd7d0647b31a0e53c06a67c3a338c776f2e82e9cc83c";
       libraryHaskellDepends = [
         aeson base binary bytestring conduit data-default directory
         filepath mtl network resourcet
       ];
       jailbreak = true;
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "JunkDB-driver-gdbm" = callPackage
    ({ mkDerivation, base, bytestring, conduit, directory, filepath
     , JunkDB, mtl, resourcet
     }:
     mkDerivation {
       pname = "JunkDB-driver-gdbm";
       version = "0.1.1.0";
       sha256 = "528e24769b026f63aeaf60d84bbb78f9af2daff4e8fd13dcab675f6038511ae1";
       libraryHaskellDepends = [
         base bytestring conduit directory filepath JunkDB mtl resourcet
       ];
       jailbreak = true;
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "JunkDB-driver-hashtables" = callPackage
    ({ mkDerivation, base, bytestring, conduit, hashable, hashtables
     , JunkDB, mtl, resourcet
     }:
     mkDerivation {
       pname = "JunkDB-driver-hashtables";
       version = "0.1.1.0";
       sha256 = "602f6c1d276a5aa257e62b4d89ff57ee807edfc95940cc524ebe917b3770050d";
       libraryHaskellDepends = [
         base bytestring conduit hashable hashtables JunkDB mtl resourcet
       ];
       jailbreak = true;
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "JustParse" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "JustParse";
       version = "2.1";
       sha256 = "4ac9bd0dbcd8ce638fc5bb28ce26600ef4734fef584b6b60348b2c177411349a";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/grantslatton/JustParse";
       description = "A simple and comprehensive Haskell parsing library";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "KMP" = callPackage
    ({ mkDerivation, array, base, Cabal }:
     mkDerivation {
       pname = "KMP";
       version = "0.1.0.2";
       sha256 = "16ee3b3c6515edce33355697297d9e3c5e78770c0dd1045816580210a5c3b791";
       libraryHaskellDepends = [ array base ];
       testHaskellDepends = [ base Cabal ];
       homepage = "https://github.com/CindyLinz/Haskell-KMP";
       description = "Knuth–Morris–Pratt string searching algorithm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "KSP" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "KSP";
       version = "0.1";
       sha256 = "c662e788017fb8122c3ac36946e95202871f8d7f0130717dd9cbf6ad76ca52a7";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/frosch03/kerbal";
       description = "A library with the kerbal space program universe and demo code";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "Kalman" = callPackage
    ({ mkDerivation, base, hmatrix }:
     mkDerivation {
       pname = "Kalman";
       version = "0.1.0.1";
       sha256 = "85e7a6a2a6b7edb257315ddfdb3454f893d6d92ff84f66b91b3a06018d54edd7";
       libraryHaskellDepends = [ base hmatrix ];
       jailbreak = true;
       homepage = "https://github.com/idontgetoutmuch/Kalman";
       description = "A slightly extended Kalman filter";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "KdTree" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "KdTree";
       version = "0.2.1";
       sha256 = "c1445c42b83a36eb03fa24116bdcda08943e956fceec943dff1d40ece19a41ee";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ QuickCheck ];
       homepage = "https://github.com/ijt/kdtree";
       description = "KdTree, for efficient search in K-dimensional point clouds";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Ketchup" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, directory
     , mime-types, network, text
     }:
     mkDerivation {
       pname = "Ketchup";
       version = "0.4.3";
       sha256 = "a11d258c574ac8be37b42cb2f1af0b9d2a7ae46f8a1cfb5687b90fc85cb7adb8";
       libraryHaskellDepends = [
         base base64-bytestring bytestring directory mime-types network text
       ];
       jailbreak = true;
       homepage = "https://github.com/Hamcha/Ketchup";
       description = "A super small web framework for those who don't like big and fancy codebases";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "KiCS" = callPackage
    ({ mkDerivation, base, containers, curry-base, curry-frontend
     , directory, filepath, ghc-paths, kics, network, old-time, process
     , random, readline, syb, unix
     }:
     mkDerivation {
       pname = "KiCS";
       version = "0.9.3";
       sha256 = "767f1aa98dff677686aff38b5bb1962362ab27bed64d5eea6a66907c55d1b77c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers curry-frontend directory filepath network old-time
         process random syb unix
       ];
       libraryToolDepends = [ kics ];
       executableHaskellDepends = [
         base containers curry-base curry-frontend directory filepath
         ghc-paths old-time process readline
       ];
       homepage = "http://www.curry-language.org";
       description = "A compiler from Curry to Haskell";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {kics = null;};

  "KiCS-debugger" = callPackage
    ({ mkDerivation, base, containers, curry-base, directory, filepath
     , haskell-src, haskell98, KiCS, KiCS-prophecy, mtl, readline, syb
     }:
     mkDerivation {
       pname = "KiCS-debugger";
       version = "0.1.1";
       sha256 = "6156d3b57cec36347695e8d5c592f0ae6070c4002f1220c565cb3b8a68c46dc3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers filepath haskell98 KiCS mtl readline syb
       ];
       executableHaskellDepends = [
         base curry-base directory haskell-src KiCS KiCS-prophecy
       ];
       jailbreak = true;
       homepage = "http://curry-language.org";
       description = "debug features for kics";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "KiCS-prophecy" = callPackage
    ({ mkDerivation, base, filepath, KiCS }:
     mkDerivation {
       pname = "KiCS-prophecy";
       version = "0.1.1";
       sha256 = "593fb10ad3c59e45cbf8f6f8bfcff8556dcfd949014c5257b3a06ef544474750";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base filepath KiCS ];
       executableHaskellDepends = [ base KiCS ];
       jailbreak = true;
       homepage = "http://curry-language.org";
       description = "a transformation used by the kics debugger";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Kleislify" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Kleislify";
       version = "0.0.4";
       sha256 = "d4f78a0d7a526398301c5e959ae61151acc2325bdcf86e7a4b909cb3ba36ee38";
       libraryHaskellDepends = [ base ];
       description = "Variants of Control.Arrow functions, specialised to kleislis.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Konf" = callPackage
    ({ mkDerivation, base, containers, parsec }:
     mkDerivation {
       pname = "Konf";
       version = "0.1.0.0";
       sha256 = "2623d1b198ae9e56ba3ea50ab7dfe876b73ff288b44fa54292272cc4d5ea7284";
       libraryHaskellDepends = [ base containers parsec ];
       jailbreak = true;
       homepage = "http://www.gkayaalp.com/p/konf.html";
       description = "A configuration language and a parser";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Kriens" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Kriens";
       version = "0.1.0.1";
       sha256 = "5c8fa68abb1db66c234dcb378cf0de08b21e3e6a2daaf888feda5a0c0c22d9ac";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/matteoprovenzano/kriens-hs.git";
       description = "Category for Continuation Passing Style";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "KyotoCabinet" = callPackage
    ({ mkDerivation, base, bytestring, extensible-exceptions
     , kyotocabinet
     }:
     mkDerivation {
       pname = "KyotoCabinet";
       version = "0.1";
       sha256 = "169597fd8e8bd3ec8702c87f429d5eb33c8d5e2a49eb63266ab67c27efbdecd0";
       libraryHaskellDepends = [ base bytestring extensible-exceptions ];
       librarySystemDepends = [ kyotocabinet ];
       homepage = "https://code.google.com/p/kyotocabinet-hs/";
       description = "Kyoto Cabinet DB bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) kyotocabinet;};

  "L-seed" = callPackage
    ({ mkDerivation, base, cairo, containers, gtk, mtl, old-time
     , parsec, random
     }:
     mkDerivation {
       pname = "L-seed";
       version = "0.2";
       sha256 = "62f85b5dbd84e0ff75589f8d596b634ae78a82e827fe2fcbc6b4f2eb801844b6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cairo containers gtk mtl old-time parsec random
       ];
       jailbreak = true;
       homepage = "http://www.entropia.de/wiki/L-seed";
       description = "Plant growing programming game";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "LDAP" = callPackage
    ({ mkDerivation, base, lber, openldap }:
     mkDerivation {
       pname = "LDAP";
       version = "0.6.10";
       sha256 = "4050875df6157fd71ce14bb0025499a1e9ccbb4d7a03686d68d3521dd2539f82";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ lber openldap ];
       executableHaskellDepends = [ base ];
       executableSystemDepends = [ lber openldap ];
       homepage = "https://github.com/ezyang/ldap-haskell";
       description = "Haskell binding for C LDAP API";
       license = stdenv.lib.licenses.bsd3;
     }) {lber = null; inherit (pkgs) openldap;};

  "LRU" = callPackage
    ({ mkDerivation, base, containers, QuickCheck }:
     mkDerivation {
       pname = "LRU";
       version = "0.1.1";
       sha256 = "16abc212ffe2e8db1044705077a098bb048995351ffb515c82be168fceeff77a";
       libraryHaskellDepends = [ base containers QuickCheck ];
       homepage = "http://www.imperialviolet.org/lru";
       description = "Implements an LRU data structure";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "LTree" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "LTree";
       version = "0.1";
       sha256 = "7c37101ce51702ab17ba716d789f63ee20d0405df5fc885ee52d322fecf83852";
       libraryHaskellDepends = [ base transformers ];
       description = "Tree with only leaves carrying the data";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "LambdaCalculator" = callPackage
    ({ mkDerivation, base, binary, bytestring, haskeline, mtl, parsec
     , pretty
     }:
     mkDerivation {
       pname = "LambdaCalculator";
       version = "0.1";
       sha256 = "9f3d4517c621c670ec8eba095728905a4ce77c3665d01b9edf56f2a82552962c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring haskeline mtl parsec pretty
       ];
       description = "A basic lambda calculator with beta reduction and a REPL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "LambdaHack" = callPackage
    ({ mkDerivation, array, assert-failure, async, base, binary
     , bytestring, containers, data-default, deepseq, directory
     , enummapset-th, filepath, ghc-prim, gtk, gtk2, hashable, hsini
     , keys, miniutter, mtl, old-time, pretty-show, random, stm
     , template-haskell, text, transformers, unordered-containers
     , vector, vector-binary-instances, zlib
     }:
     mkDerivation {
       pname = "LambdaHack";
       version = "0.5.0.0";
       sha256 = "2587949dcdd9f2336b5365031340a0e7aa7705b7ce088dafc9b14a208051f96f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array assert-failure async base binary bytestring containers
         data-default deepseq directory enummapset-th filepath ghc-prim gtk
         hashable hsini keys miniutter mtl old-time pretty-show random stm
         text transformers unordered-containers vector
         vector-binary-instances zlib
       ];
       libraryPkgconfigDepends = [ gtk2 ];
       executableHaskellDepends = [
         array assert-failure async base binary bytestring containers
         data-default deepseq directory enummapset-th filepath ghc-prim
         hashable hsini keys miniutter mtl old-time pretty-show random stm
         template-haskell text transformers unordered-containers vector
         vector-binary-instances zlib
       ];
       testHaskellDepends = [
         array assert-failure async base binary bytestring containers
         data-default deepseq directory enummapset-th filepath ghc-prim
         hashable hsini keys miniutter mtl old-time pretty-show random stm
         template-haskell text transformers unordered-containers vector
         vector-binary-instances zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/LambdaHack/LambdaHack";
       description = "A game engine library for roguelike dungeon crawlers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gtk2 = pkgs.gnome2.gtk;};

  "LambdaINet" = callPackage
    ({ mkDerivation, base, containers, GLFW, GLFW-task, monad-task, mtl
     , OpenGL, transformers, vector
     }:
     mkDerivation {
       pname = "LambdaINet";
       version = "0.2.0.0";
       sha256 = "933379242330b3f627786beae80513528e7d8cc801dfdf50962f85fd5b11b4c1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers GLFW GLFW-task monad-task mtl OpenGL transformers
         vector
       ];
       homepage = "not available";
       description = "Graphical Interaction Net Evaluator for Optimal Evaluation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "LambdaNet" = callPackage
    ({ mkDerivation, base, binary, bytestring, hmatrix, random
     , random-shuffle, split
     }:
     mkDerivation {
       pname = "LambdaNet";
       version = "0.2.0.0";
       sha256 = "e4d7e6b1ec41283b4b19ba84ff4eb333fb82d0378fca46c208dfabb581194f1b";
       libraryHaskellDepends = [
         base binary bytestring hmatrix random random-shuffle split
       ];
       jailbreak = true;
       description = "A configurable and extensible neural network library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "LambdaPrettyQuote" = callPackage
    ({ mkDerivation, base, checkers, DebugTraceHelpers, derive, HUnit
     , lambda-ast, mtl, parsec, QuickCheck, syb, template-haskell
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , th-instances, transformers, tuple, uniplate
     }:
     mkDerivation {
       pname = "LambdaPrettyQuote";
       version = "0.0.0.8";
       sha256 = "547978d457b13de9d05bd05e9f8461ed8100ffc337adf8ad391083a6fb4bb067";
       libraryHaskellDepends = [
         base DebugTraceHelpers HUnit lambda-ast mtl parsec QuickCheck syb
         template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2 transformers tuple uniplate
       ];
       testHaskellDepends = [
         base checkers DebugTraceHelpers derive HUnit lambda-ast mtl parsec
         QuickCheck syb template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2 th-instances transformers tuple uniplate
       ];
       homepage = "http://github.com/jfischoff/LambdaPrettyQuote";
       description = "Quasiquoter, and Arbitrary helpers for the lambda calculus";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "LambdaShell" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec, Shellac
     , Shellac-compatline
     }:
     mkDerivation {
       pname = "LambdaShell";
       version = "0.9.3";
       sha256 = "5b46b71a862b931da758bc8a1bb3d69c831a54956bd3bd92c50f3237b8a51fdb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers mtl parsec Shellac Shellac-compatline
       ];
       homepage = "http://rwd.rdockins.name/lambda/home/";
       description = "Simple shell for evaluating lambda expressions";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Lambdajudge" = callPackage
    ({ mkDerivation, base, filepath, hspec, mtl, process, text }:
     mkDerivation {
       pname = "Lambdajudge";
       version = "1.0.0.4";
       sha256 = "652cc0c857d0fc65d405fdc62bd4e84d8bf18e878a2fbf66d79c087d38d3436d";
       libraryHaskellDepends = [ base filepath hspec mtl process text ];
       testHaskellDepends = [ base filepath hspec mtl process text ];
       jailbreak = true;
       homepage = "http://venugangireddy.github.io/Lambdajudge/";
       description = "A library to easily host Haskell based programming competitions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "Lambdaya" = callPackage
    ({ mkDerivation, base, binary, mtl, network, pipes, pipes-binary
     , pipes-network, pipes-parse
     }:
     mkDerivation {
       pname = "Lambdaya";
       version = "0.2.0.0.1";
       sha256 = "ecb9d7490da6f3b11aaa118f271121fa3f3a940a7914e7551b8b078650ea4dcf";
       libraryHaskellDepends = [
         base binary mtl network pipes pipes-binary pipes-network
         pipes-parse
       ];
       description = "Library for RedPitaya";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "LargeCardinalHierarchy" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "LargeCardinalHierarchy";
       version = "0.0.1";
       sha256 = "e221b2bb87d0e64b98a4c134ab868cfcc7e6928ecc5b2c474ecb17385211f829";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "A transfinite cardinal arithmetic library including all known large cardinals";
       license = "unknown";
     }) {};

  "Lastik" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filemanip
     , filepath, process, pureMD5, SHA, zip-archive
     }:
     mkDerivation {
       pname = "Lastik";
       version = "0.7.0";
       sha256 = "b5e9ee213a087d5bc13574becd36bcfdf27a35907db3a882fd1ab74cc55708af";
       libraryHaskellDepends = [
         base bytestring containers directory filemanip filepath process
         pureMD5 SHA zip-archive
       ];
       homepage = "http://code.google.com/p/lastik";
       description = "A library for compiling programs in a variety of languages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Lattices" = callPackage
    ({ mkDerivation, array, base, HaskellForMaths, HUnit
     , test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "Lattices";
       version = "0.0.2";
       sha256 = "8eebdb8755fb27679b8c9dab7bbc73f46612d22c06286817414a62ac19b40430";
       libraryHaskellDepends = [ array base HaskellForMaths ];
       testHaskellDepends = [
         array base HaskellForMaths HUnit test-framework
         test-framework-hunit
       ];
       description = "A library for lattices";
       license = "GPL";
     }) {};

  "Lazy-Pbkdf2" = callPackage
    ({ mkDerivation, base, base16-bytestring, binary, bytestring, SHA
     }:
     mkDerivation {
       pname = "Lazy-Pbkdf2";
       version = "1.0.2";
       sha256 = "6318c60db0b18877c0edf0a01ba21254b44e9624210bc59834e1dc8116ca86fc";
       libraryHaskellDepends = [ base binary bytestring SHA ];
       testHaskellDepends = [
         base base16-bytestring binary bytestring SHA
       ];
       description = "Lazy PBKDF2 generator";
       license = stdenv.lib.licenses.mit;
     }) {};

  "LazyVault" = callPackage
    ({ mkDerivation, base, directory, filepath, unix }:
     mkDerivation {
       pname = "LazyVault";
       version = "0.0.1";
       sha256 = "584eec70bff76a404cdc0f838c89c521bc059c3e1059ffe69faf4c2fd95f00f9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath unix ];
       jailbreak = true;
       homepage = "https://github.com/AtticHacker/lazyvault";
       description = "A simple sandboxing tool for Haskell packages";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "Level0" = callPackage
    ({ mkDerivation, base, directory, random, SDL, SDL-ttf }:
     mkDerivation {
       pname = "Level0";
       version = "1.0";
       sha256 = "bb7fce37969af879d8788f26054d6f7f484f5d1aa46ca541b54576512f46ffce";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory random SDL SDL-ttf ];
       jailbreak = true;
       homepage = "http://quasimal.com/projects/level_0.html";
       description = "A Snake II clone written using SDL";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "LibClang" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, filepath, hashable, mtl
     , ncurses, resourcet, text, time, transformers, transformers-base
     , vector
     }:
     mkDerivation {
       pname = "LibClang";
       version = "3.4.0";
       sha256 = "b4bdd8fb7fa103b7045534ae43f00bb3d4ad53e909a49feff081f06751e4a44d";
       libraryHaskellDepends = [
         base bytestring filepath hashable mtl resourcet text time
         transformers transformers-base vector
       ];
       librarySystemDepends = [ ncurses ];
       libraryToolDepends = [ c2hs ];
       jailbreak = true;
       homepage = "https://github.com/chetant/LibClang/issues";
       description = "Haskell bindings for libclang (a C++ parsing library)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) ncurses;};

  "LibZip" = callPackage
    ({ mkDerivation, base, bindings-libzip, bytestring, filepath, mtl
     , time
     }:
     mkDerivation {
       pname = "LibZip";
       version = "0.10.2";
       sha256 = "54d81de73bd7f4acd7cebe28e26931c0afd9fece905e289aaecbe103e2ab973a";
       libraryHaskellDepends = [
         base bindings-libzip bytestring filepath mtl time
       ];
       homepage = "http://bitbucket.org/astanin/hs-libzip/";
       description = "Bindings to libzip, a library for manipulating zip archives";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "LibZip_0_11_1" = callPackage
    ({ mkDerivation, base, bindings-libzip, bytestring, directory
     , filepath, HUnit, mtl, time, utf8-string
     }:
     mkDerivation {
       pname = "LibZip";
       version = "0.11.1";
       sha256 = "cecc9b9d5f38c2f758e4f316f5dbc2c93fb2d81011791f23c44044895f82df12";
       libraryHaskellDepends = [
         base bindings-libzip bytestring filepath mtl time utf8-string
       ];
       testHaskellDepends = [
         base bindings-libzip bytestring directory filepath HUnit mtl time
         utf8-string
       ];
       jailbreak = true;
       homepage = "http://bitbucket.org/astanin/hs-libzip/";
       description = "Bindings to libzip, a library for manipulating zip archives";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Limit" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Limit";
       version = "1.0";
       sha256 = "017f92b222912828bf667dcd6dafc597cade7994290fcba26a27503c0861a8f9";
       libraryHaskellDepends = [ base ];
       description = "Wrapper for data that can be unbounded";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "LinearSplit" = callPackage
    ({ mkDerivation, array, base, cmdargs, haskell98, QuickCheck }:
     mkDerivation {
       pname = "LinearSplit";
       version = "0.2.1";
       sha256 = "b19dc6af1ee22a5dec923f32b68e1fcd678f996f4e7005d567f6fe4275a72d17";
       libraryHaskellDepends = [
         array base cmdargs haskell98 QuickCheck
       ];
       homepage = "http://github.com/rukav/LinearSplit";
       description = "Partition the sequence of items to the subsequences in the order given";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "LinguisticsTypes" = callPackage
    ({ mkDerivation, aeson, base, bimaps, binary, bytestring, cereal
     , cereal-text, deepseq, hashable, intern, log-domain, QuickCheck
     , stringable, test-framework, test-framework-quickcheck2
     , test-framework-th, text, text-binary, vector-th-unbox
     }:
     mkDerivation {
       pname = "LinguisticsTypes";
       version = "0.0.0.2";
       sha256 = "9f5a722b1f88207b42801a72b6fc95453f134b7a4252251876a4ef069b7b4bcb";
       libraryHaskellDepends = [
         aeson base bimaps binary bytestring cereal cereal-text deepseq
         hashable intern log-domain QuickCheck stringable text text-binary
         vector-th-unbox
       ];
       testHaskellDepends = [
         aeson base binary cereal QuickCheck stringable test-framework
         test-framework-quickcheck2 test-framework-th
       ];
       jailbreak = true;
       homepage = "https://github.com/choener/LinguisticsTypes";
       description = "Collection of types for natural language";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "LinkChecker" = callPackage
    ({ mkDerivation, base, containers, haskell98, HTTP, mtl, network
     , tagsoup
     }:
     mkDerivation {
       pname = "LinkChecker";
       version = "0.1";
       sha256 = "d85978754313fc5337d95723f9a6b2cdce82d8bcc4a865901fc0fe4a19f69403";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers haskell98 HTTP mtl network tagsoup
       ];
       homepage = "http://janzzstimmpfle.de/~jens/software/LinkChecker/";
       description = "Check a bunch of local html files for broken links";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "List" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "List";
       version = "0.5.2";
       sha256 = "27ddf9a9b348c3a2fc72ba8bed78ecacd32f26cc7ae1b8de8a066bd14ec8eaac";
       libraryHaskellDepends = [ base transformers ];
       homepage = "http://github.com/yairchu/generator/tree";
       description = "List monad transformer and class";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ListLike_4_2_0" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, dlist, fmlist
     , HUnit, QuickCheck, random, text, vector
     }:
     mkDerivation {
       pname = "ListLike";
       version = "4.2.0";
       sha256 = "ef9b490d3db539b1f11cdd1e88643e8256a9a4bd4869b594a1e6143bb29c00c6";
       libraryHaskellDepends = [
         array base bytestring containers dlist fmlist text vector
       ];
       testHaskellDepends = [
         array base bytestring containers dlist fmlist HUnit QuickCheck
         random text vector
       ];
       jailbreak = true;
       homepage = "http://software.complete.org/listlike";
       description = "Generic support for list-like structures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ListLike" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, dlist, fmlist
     , HUnit, QuickCheck, random, text, vector
     }:
     mkDerivation {
       pname = "ListLike";
       version = "4.2.1";
       sha256 = "d6542ae5bef685e3571cd46b018c5adac2b6c854f72777ddd35a6823bcf08859";
       libraryHaskellDepends = [
         array base bytestring containers dlist fmlist text vector
       ];
       testHaskellDepends = [
         array base bytestring containers dlist fmlist HUnit QuickCheck
         random text vector
       ];
       doCheck = false;
       homepage = "http://software.complete.org/listlike";
       description = "Generic support for list-like structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ListTree" = callPackage
    ({ mkDerivation, base, directory, filepath, List, transformers }:
     mkDerivation {
       pname = "ListTree";
       version = "0.2.2";
       sha256 = "b261ac13493c992c44156f81ad194e43f2ab5aa2ae5ea0596414280c3a8addba";
       libraryHaskellDepends = [
         base directory filepath List transformers
       ];
       homepage = "http://github.com/yairchu/generator/tree";
       description = "Trees and monadic trees expressed as monadic lists where the underlying monad is a list";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ListWriter" = callPackage
    ({ mkDerivation, base, hspec, mtl }:
     mkDerivation {
       pname = "ListWriter";
       version = "0.1.0.0";
       sha256 = "48cc8ad0a69b47f5cfcbea55f2b221eda39403b31fec620392d721a572f500c3";
       libraryHaskellDepends = [ base mtl ];
       testHaskellDepends = [ base hspec ];
       homepage = "https://github.com/YLiLarry/ListWriter";
       description = "define a list constant using Monadic syntax other than overhead [,]";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ListZipper" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "ListZipper";
       version = "1.2.0.2";
       sha256 = "491929b44628dbcff91dbbc55dee1bcbaa6292c6fff42b07f9dd05416fff717c";
       libraryHaskellDepends = [ base QuickCheck ];
       description = "Simple zipper for lists";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Logic" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Logic";
       version = "0.1.0.0";
       sha256 = "0170311de6b6f3f6bc190efd4cbb1ed29fc87920cdcf8f112d398b9880f7f44a";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://gogotanaka.me/";
       description = "Logic";
       license = stdenv.lib.licenses.mit;
     }) {};

  "LogicGrowsOnTrees" = callPackage
    ({ mkDerivation, AbortT-mtl, AbortT-transformers, base, bytestring
     , cereal, cmdtheline, composition, containers, data-ivar, derive
     , directory, hslogger, hslogger-template, HUnit, lens
     , MonadCatchIO-transformers, monoid-statistics, mtl, multiset
     , old-locale, operational, prefix-units, pretty, PSQueue
     , QuickCheck, quickcheck-instances, random, sequential-index
     , smallcheck, split, stm, test-framework, test-framework-hunit
     , test-framework-quickcheck2, test-framework-smallcheck, time
     , transformers, uuid, void, yjtools
     }:
     mkDerivation {
       pname = "LogicGrowsOnTrees";
       version = "1.1.0.2";
       sha256 = "f3f6e7ee3022a60d279eff5d27fd6d3a7ca25972f18077594f90a15ed9cf16fb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         AbortT-mtl AbortT-transformers base bytestring cereal cmdtheline
         composition containers data-ivar derive directory hslogger
         hslogger-template lens MonadCatchIO-transformers monoid-statistics
         mtl multiset old-locale operational prefix-units pretty PSQueue
         sequential-index split stm time transformers void yjtools
       ];
       executableHaskellDepends = [
         base cereal cmdtheline containers transformers
       ];
       testHaskellDepends = [
         base bytestring cereal composition containers data-ivar directory
         hslogger hslogger-template HUnit lens MonadCatchIO-transformers
         operational QuickCheck quickcheck-instances random smallcheck stm
         test-framework test-framework-hunit test-framework-quickcheck2
         test-framework-smallcheck time transformers uuid void
       ];
       jailbreak = true;
       description = "a parallel implementation of logic programming using distributed tree exploration";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "LogicGrowsOnTrees-MPI" = callPackage
    ({ mkDerivation, base, bytestring, cereal, cmdtheline, containers
     , data-ivar, derive, hslogger, hslogger-template, LogicGrowsOnTrees
     , MonadCatchIO-transformers, openmpi, stm, transformers
     }:
     mkDerivation {
       pname = "LogicGrowsOnTrees-MPI";
       version = "1.0.0.1.1";
       sha256 = "22f5bcb22e731984e40a76ae1d48b0e59329ac5d3bd633efef7cb8140de8146b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal cmdtheline containers data-ivar derive
         hslogger hslogger-template LogicGrowsOnTrees
         MonadCatchIO-transformers stm transformers
       ];
       librarySystemDepends = [ openmpi ];
       executableHaskellDepends = [
         base cereal cmdtheline hslogger LogicGrowsOnTrees
       ];
       executableSystemDepends = [ openmpi ];
       jailbreak = true;
       description = "an adapter for LogicGrowsOnTrees that uses MPI";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openmpi;};

  "LogicGrowsOnTrees-network" = callPackage
    ({ mkDerivation, base, cereal, cmdtheline, composition, containers
     , hslogger, hslogger-template, HUnit, lens, LogicGrowsOnTrees
     , MonadCatchIO-transformers, mtl, network, pretty, random, stm
     , test-framework, test-framework-hunit, transformers
     }:
     mkDerivation {
       pname = "LogicGrowsOnTrees-network";
       version = "1.0.0.3";
       sha256 = "b6893ed0a39edcb3b35e7d25d7e4d99cfac41212bfcf40dcdcaf5e57c6bac664";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cereal cmdtheline composition containers hslogger
         hslogger-template lens LogicGrowsOnTrees MonadCatchIO-transformers
         mtl network pretty transformers
       ];
       executableHaskellDepends = [
         base cereal cmdtheline LogicGrowsOnTrees
       ];
       testHaskellDepends = [
         base hslogger hslogger-template HUnit LogicGrowsOnTrees network
         random stm test-framework test-framework-hunit transformers
       ];
       jailbreak = true;
       description = "an adapter for LogicGrowsOnTrees that uses multiple processes running in a network";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "LogicGrowsOnTrees-processes" = callPackage
    ({ mkDerivation, base, bytestring, cereal, cmdtheline, containers
     , filepath, FindBin, hslogger, hslogger-template, HUnit
     , LogicGrowsOnTrees, MonadCatchIO-transformers, process, random
     , test-framework, test-framework-hunit, transformers
     }:
     mkDerivation {
       pname = "LogicGrowsOnTrees-processes";
       version = "1.0.0.2";
       sha256 = "766b912ffe650e0ab7cd23a54b51fa440b9e411b63be1d520936bb815af93334";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal cmdtheline containers filepath FindBin
         hslogger hslogger-template LogicGrowsOnTrees
         MonadCatchIO-transformers process transformers
       ];
       executableHaskellDepends = [
         base cereal cmdtheline LogicGrowsOnTrees
       ];
       testHaskellDepends = [
         base cereal hslogger hslogger-template HUnit LogicGrowsOnTrees
         random test-framework test-framework-hunit transformers
       ];
       jailbreak = true;
       description = "an adapter for LogicGrowsOnTrees that uses multiple processes for parallelism";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "LslPlus" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , filepath, haskell98, HaXml, mtl, network, old-time, parsec
     , pureMD5, random, syb, template-haskell, utf8-string
     }:
     mkDerivation {
       pname = "LslPlus";
       version = "0.4.3";
       sha256 = "d36342b35c19a8c8596a8dcc85dc6c4f1b3a8374dce5808219f2ade886e89a37";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring containers directory filepath haskell98 HaXml
         mtl network old-time parsec pureMD5 random syb template-haskell
         utf8-string
       ];
       jailbreak = true;
       homepage = "http:/lslplus.sourceforge.net/";
       description = "An execution and testing framework for the Linden Scripting Language (LSL)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Lucu" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, base64-bytestring
     , bytestring, containers, directory, filepath, haskell-src
     , HsOpenSSL, hxt, mtl, network, stm, time, time-http, unix, zlib
     }:
     mkDerivation {
       pname = "Lucu";
       version = "0.7.0.3";
       sha256 = "2b6d62567c4158723725917417718b0b5f6a30e4656e633be5b4dac45ef97027";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-unicode-symbols base64-bytestring bytestring containers
         directory filepath haskell-src HsOpenSSL hxt mtl network stm time
         time-http unix zlib
       ];
       jailbreak = true;
       homepage = "http://cielonegro.org/Lucu.html";
       description = "HTTP Daemonic Library";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MC-Fold-DP" = callPackage
    ({ mkDerivation, base, Biobase, cmdargs, PrimitiveArray, split
     , tuple, vector
     }:
     mkDerivation {
       pname = "MC-Fold-DP";
       version = "0.1.1.0";
       sha256 = "705fe0c8f5d1bb637b5c739196c8309710f942e55fc33397edeb934ba0eee640";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Biobase PrimitiveArray tuple vector
       ];
       executableHaskellDepends = [ cmdargs split ];
       homepage = "http://www.tbi.univie.ac.at/software/mcfolddp/";
       description = "Folding algorithm based on nucleotide cyclic motifs";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MFlow_0_4_5_9" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
     , case-insensitive, clientsession, conduit, conduit-extra
     , containers, cpphs, directory, extensible-exceptions, http-types
     , monadloc, mtl, old-time, parsec, pwstore-fast, random
     , RefSerialize, resourcet, stm, TCache, text, time, transformers
     , utf8-string, vector, wai, wai-extra, warp, warp-tls, Workflow
     }:
     mkDerivation {
       pname = "MFlow";
       version = "0.4.5.9";
       sha256 = "33924523f8083e18e4ff4e2146203d72a7d3f9df57de87efbdfbb9c94ff71a57";
       libraryHaskellDepends = [
         base blaze-html blaze-markup bytestring case-insensitive
         clientsession conduit conduit-extra containers directory
         extensible-exceptions http-types monadloc mtl old-time parsec
         pwstore-fast random RefSerialize resourcet stm TCache text time
         transformers utf8-string vector wai wai-extra warp warp-tls
         Workflow
       ];
       libraryToolDepends = [ cpphs ];
       description = "stateful, RESTful web framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MFlow" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
     , case-insensitive, clientsession, conduit, conduit-extra
     , containers, cpphs, directory, extensible-exceptions, http-types
     , monadloc, mtl, old-time, parsec, pwstore-fast, random
     , RefSerialize, resourcet, stm, TCache, text, time, transformers
     , utf8-string, vector, wai, wai-extra, warp, warp-tls, Workflow
     }:
     mkDerivation {
       pname = "MFlow";
       version = "0.4.6.0";
       sha256 = "4e93f7488152d88359fd100a742c2ea96788284d262f3cd1b50d936f80f1a342";
       libraryHaskellDepends = [
         base blaze-html blaze-markup bytestring case-insensitive
         clientsession conduit conduit-extra containers directory
         extensible-exceptions http-types monadloc mtl old-time parsec
         pwstore-fast random RefSerialize resourcet stm TCache text time
         transformers utf8-string vector wai wai-extra warp warp-tls
         Workflow
       ];
       libraryToolDepends = [ cpphs ];
       description = "stateful, RESTful web framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "MHask" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "MHask";
       version = "0.3.0.0";
       sha256 = "6a67398197c1958f06bbb11a3dcd230f29a0ae31191f1a3676fe46a84848925a";
       libraryHaskellDepends = [ base transformers ];
       jailbreak = true;
       homepage = "https://github.com/DanBurton/MHask#readme";
       description = "The category of monads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MSQueue" = callPackage
    ({ mkDerivation, base, ghc-prim, monad-loops, ref-mtl, stm }:
     mkDerivation {
       pname = "MSQueue";
       version = "0.0.1";
       sha256 = "5e9c85341a23a1720beaf0e8ebaef2268ab970211ddd443f3ec4b3031471db13";
       libraryHaskellDepends = [ base ghc-prim monad-loops ref-mtl stm ];
       jailbreak = true;
       homepage = "https://github.com/Julek";
       description = "Michael-Scott queue";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "MTGBuilder" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec }:
     mkDerivation {
       pname = "MTGBuilder";
       version = "0.2.0.1";
       sha256 = "77aa6e32de99cef6493a5dadd7bb2209faf16b4268ce70a46c62557f0e672843";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers mtl parsec ];
       description = "Builds decks out of a meta";
       license = stdenv.lib.licenses.mit;
     }) {};

  "MagicHaskeller" = callPackage
    ({ mkDerivation, abstract-par, array, base, bytestring, cgi
     , containers, directory, extensible-exceptions, ghc, ghc-paths
     , hashable, haskell-src, hint, html, monad-par, mtl, mueval
     , network, network-uri, pretty, process, random, syb
     , template-haskell, time, transformers, unix
     }:
     mkDerivation {
       pname = "MagicHaskeller";
       version = "0.9.6.4.7";
       sha256 = "f239c8601326293226900fc8bb15cc6bfc19f9a10e03756b1785e00a0879c680";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers directory ghc ghc-paths hashable
         haskell-src html mtl network network-uri pretty random syb
         template-haskell time
       ];
       executableHaskellDepends = [
         abstract-par array base bytestring cgi containers directory
         extensible-exceptions ghc ghc-paths hashable haskell-src hint html
         monad-par mtl mueval network network-uri pretty process random syb
         template-haskell time transformers unix
       ];
       homepage = "http://nautilus.cs.miyazaki-u.ac.jp/~skata/MagicHaskeller.html";
       description = "Automatic inductive functional programmer by systematic search";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MailchimpSimple" = callPackage
    ({ mkDerivation, aeson, aeson-lens, base, bytestring, directory
     , filepath, http-conduit, http-types, lens, text, time
     , transformers, vector
     }:
     mkDerivation {
       pname = "MailchimpSimple";
       version = "0.1.0.0";
       sha256 = "56d883bca6efde9bd9fd776d9bcf88a4f4cfba562a79687fed2bb47ea2a8eb78";
       libraryHaskellDepends = [
         aeson aeson-lens base bytestring directory filepath http-conduit
         http-types lens text time transformers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/Dananji/MailchimpSimple";
       description = "A Haskell library to handle mailing lists in MailchimpSimple using its JSON API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "MaybeT" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "MaybeT";
       version = "0.1.2";
       sha256 = "995e61165122656807d84174e5c1516340fd7ddeba6571c20751352a8476b632";
       revision = "1";
       editedCabalFile = "399ec60488680853ace716790b8ebaeee1a74da8a24ced5b5caaea4341b88580";
       libraryHaskellDepends = [ base mtl ];
       jailbreak = true;
       description = "MaybeT monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MaybeT-monads-tf" = callPackage
    ({ mkDerivation, base, monads-tf, transformers }:
     mkDerivation {
       pname = "MaybeT-monads-tf";
       version = "0.2.0.1";
       sha256 = "9d1c094635773a24e6e12b5fa1b0041dd5e997f61bde4cb686c1ca468d4d9b0c";
       libraryHaskellDepends = [ base monads-tf transformers ];
       jailbreak = true;
       description = "MaybeT monad transformer compatible with monads-tf (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MaybeT-transformers" = callPackage
    ({ mkDerivation, base, monads-fd, transformers }:
     mkDerivation {
       pname = "MaybeT-transformers";
       version = "0.2";
       sha256 = "9e4621e689c0cbcbee7f53a5c40cf8d7aabbc982084ca3989eef60df6f433ca1";
       libraryHaskellDepends = [ base monads-fd transformers ];
       jailbreak = true;
       description = "MaybeT monad transformer using transformers instead of mtl";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MazesOfMonad" = callPackage
    ({ mkDerivation, array, base, containers, directory, filepath
     , HUnit, mtl, old-locale, pretty, random, regex-posix, time
     }:
     mkDerivation {
       pname = "MazesOfMonad";
       version = "1.0.9";
       sha256 = "02075be1011adc99f69f6438a30b8da4b397aef9dcbaec23134a7524cbc73310";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory filepath HUnit mtl old-locale
         pretty random regex-posix time
       ];
       description = "Console-based Role Playing Game";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MeanShift" = callPackage
    ({ mkDerivation, base, vector }:
     mkDerivation {
       pname = "MeanShift";
       version = "0.1";
       sha256 = "3c15fad58a94bfa708398ca990179e82ca860f3f3a167effd27d303cf879cb66";
       libraryHaskellDepends = [ base vector ];
       jailbreak = true;
       description = "Mean shift algorithm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Measure" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Measure";
       version = "0.0.2";
       sha256 = "ba090d3a19d6a2426d60e738283a8eccaf5fce096263bf8231fbb2e4e5f4c8ef";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "A library for units of measurement";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MemoTrie_0_6_2" = callPackage
    ({ mkDerivation, base, void }:
     mkDerivation {
       pname = "MemoTrie";
       version = "0.6.2";
       sha256 = "9ddc11172db26a54681f14dd8ce881c87a3b0e72dcc7a15b74132f30b4408bbc";
       libraryHaskellDepends = [ base void ];
       homepage = "http://haskell.org/haskellwiki/MemoTrie";
       description = "Trie-based memo functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MemoTrie_0_6_3" = callPackage
    ({ mkDerivation, base, void }:
     mkDerivation {
       pname = "MemoTrie";
       version = "0.6.3";
       sha256 = "ca99debcd2cd4349e26e4438e8d896af3a274b8edc859a0216c2cc9e2f7b1334";
       revision = "1";
       editedCabalFile = "3a0a6ac7c3731f329b511d593e1a4cd1686080b272bb4ca64cfa046f04805fc3";
       libraryHaskellDepends = [ base void ];
       homepage = "https://github.com/conal/MemoTrie";
       description = "Trie-based memo functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MemoTrie" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "MemoTrie";
       version = "0.6.4";
       sha256 = "4238c8f7ea1ecd2497d0a948493acbdc47728b2528b6e7841ef064b783d68b1c";
       revision = "1";
       editedCabalFile = "035cea173a56cf920ebb4c84b4033d2ea270c1ee24d07ad323b9b2701ebc72e7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/conal/MemoTrie";
       description = "Trie-based memo functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "MetaHDBC" = callPackage
    ({ mkDerivation, base, convertible, hashtables, HDBC, HDBC-odbc
     , mtl, template-haskell
     }:
     mkDerivation {
       pname = "MetaHDBC";
       version = "0.1.4";
       sha256 = "d9531441f95f459a1e5bc4eb4051e6589aa099cb255d9303cefdd97599d88750";
       libraryHaskellDepends = [
         base convertible hashtables HDBC HDBC-odbc mtl template-haskell
       ];
       jailbreak = true;
       description = "Statically checked database access";
       license = "LGPL";
     }) {};

  "MetaObject" = callPackage
    ({ mkDerivation, base, containers, stringtable-atom }:
     mkDerivation {
       pname = "MetaObject";
       version = "0.0.6.20150815";
       sha256 = "4b51fa6f27dd0d687acc0220e338fd45cbe0d7d25b6f1c4799ff6c4eb6577d3d";
       libraryHaskellDepends = [ base containers stringtable-atom ];
       description = "A meta-object system for Haskell based on Perl 6";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Metrics" = callPackage
    ({ mkDerivation, base, hstats }:
     mkDerivation {
       pname = "Metrics";
       version = "0.1.2";
       sha256 = "9df832cee4d6fa42667b1ee1a985f2366a1771f84409b7b9414d284af78045cf";
       libraryHaskellDepends = [ base hstats ];
       homepage = "http://github.com/benhamner/Metrics/";
       description = "Evaluation metrics commonly used in supervised machine learning";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Mhailist" = callPackage
    ({ mkDerivation, base, binary, bytestring, directory, filepath
     , haskell98, mtl, old-locale, process, time
     }:
     mkDerivation {
       pname = "Mhailist";
       version = "0.0";
       sha256 = "939163fe285c2b2b6b2a6febc4adb21248de836690d1537c79a667370557baef";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring directory filepath haskell98 mtl old-locale
         process time
       ];
       jailbreak = true;
       description = "Haskell mailing list manager";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Michelangelo" = callPackage
    ({ mkDerivation, base, bytestring, containers, GLUtil, lens, linear
     , OpenGL, OpenGLRaw, WaveFront
     }:
     mkDerivation {
       pname = "Michelangelo";
       version = "0.2.4.0";
       sha256 = "fe8645825ceda5943c474ed5440eb2f945e8f74b00ace7ba01a339fa60cac93b";
       libraryHaskellDepends = [
         base bytestring containers GLUtil lens linear OpenGL OpenGLRaw
         WaveFront
       ];
       description = "OpenGL for dummies";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MicrosoftTranslator" = callPackage
    ({ mkDerivation, aeson, base, bytestring, datetime, exceptions
     , http-client, lens, text, transformers, url, wreq, xml
     }:
     mkDerivation {
       pname = "MicrosoftTranslator";
       version = "0.1.0.1";
       sha256 = "0855cf30d5a70c5cc908c8c84e17e2c325cbc669fe678d074ae88253d23d3120";
       libraryHaskellDepends = [
         aeson base bytestring datetime exceptions http-client lens text
         transformers url wreq xml
       ];
       jailbreak = true;
       description = "Interface for Microsoft Translator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "MiniAgda" = callPackage
    ({ mkDerivation, alex, array, base, containers, happy
     , haskell-src-exts, mtl, pretty
     }:
     mkDerivation {
       pname = "MiniAgda";
       version = "0.2014.9.12";
       sha256 = "16e457ddf76d11c05905e057381fccb0373c021dbccfbcabeb31f2929a9e0792";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers haskell-src-exts mtl pretty
       ];
       executableToolDepends = [ alex happy ];
       jailbreak = true;
       homepage = "http://www.tcs.ifi.lmu.de/~abel/miniagda/";
       description = "A toy dependently typed programming language with type-based termination";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MissingH" = callPackage
    ({ mkDerivation, array, base, containers, directory
     , errorcall-eq-instance, filepath, hslogger, HUnit, mtl, network
     , old-locale, old-time, parsec, process, QuickCheck, random
     , regex-compat, testpack, time, unix
     }:
     mkDerivation {
       pname = "MissingH";
       version = "1.3.0.1";
       sha256 = "ba0d60673e70c64c6eebe785fb4da729bcfd3dae37fba721c7318b8df1838db3";
       revision = "1";
       editedCabalFile = "5d7bf9ce1efa6e8c4a9dc43ea0dc03e66aca4c5950a420d811d2701510a038a0";
       libraryHaskellDepends = [
         array base containers directory filepath hslogger HUnit mtl network
         old-locale old-time parsec process random regex-compat time unix
       ];
       testHaskellDepends = [
         array base containers directory errorcall-eq-instance filepath
         hslogger HUnit mtl network old-locale old-time parsec process
         QuickCheck random regex-compat testpack time unix
       ];
       doCheck = false;
       homepage = "http://software.complete.org/missingh";
       description = "Large utility library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "MissingK" = callPackage
    ({ mkDerivation, base, glib, template-haskell }:
     mkDerivation {
       pname = "MissingK";
       version = "0.0.0.2";
       sha256 = "0360502acec1fbd91ca0ee5a7ed92d0a7f025b3a6e9a53647924f878cbfbd633";
       libraryHaskellDepends = [ base glib template-haskell ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Useful types and definitions missing from other libraries";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "MissingM" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "MissingM";
       version = "0.0.4";
       sha256 = "ba63ffe7543d2562624b7751908cd24414cd73474bc7ed841d1c6129809371a6";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 transformers
       ];
       description = "findM and other missing 'M's";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "MissingPy" = callPackage
    ({ mkDerivation, anydbm, base, MissingH }:
     mkDerivation {
       pname = "MissingPy";
       version = "0.10.6";
       sha256 = "467af3ec2a77529add93a716de64e3fb5d55701a306a4ae519ca485cc455200d";
       libraryHaskellDepends = [ anydbm base MissingH ];
       homepage = "http://github.com/softmechanics/missingpy";
       description = "Haskell interface to Python";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Modulo" = callPackage
    ({ mkDerivation, base, numeric-prelude }:
     mkDerivation {
       pname = "Modulo";
       version = "0.2.0.1";
       sha256 = "387e8b66b5a1c0e8a2115ea778db8af5543039d1ab531bed893664b7b3a320d9";
       libraryHaskellDepends = [ base numeric-prelude ];
       description = "Modular arithmetic via Numeric-Prelude";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "Moe" = callPackage
    ({ mkDerivation, base, GLUT, random }:
     mkDerivation {
       pname = "Moe";
       version = "0.1";
       sha256 = "63158b58fc5483a45269c37b66d92b3b980817fbcc340eca2d4f6beeed3167da";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base GLUT random ];
       executableHaskellDepends = [ base GLUT random ];
       description = "A FRP library based on signal functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "MoeDict" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, text
     , unordered-containers
     }:
     mkDerivation {
       pname = "MoeDict";
       version = "0.0.4";
       sha256 = "6896d22e1ce081b55fb461fc260ea3613218009ff2c600901a8c4f2f7feef66e";
       libraryHaskellDepends = [
         aeson base bytestring containers text unordered-containers
       ];
       homepage = "https://github.com/audreyt/MoeDict.hs";
       description = "Utilities working with MoeDict.tw JSON dataset";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "MonadCatchIO-mtl" = callPackage
    ({ mkDerivation, base, extensible-exceptions
     , MonadCatchIO-transformers
     }:
     mkDerivation {
       pname = "MonadCatchIO-mtl";
       version = "0.3.1.0";
       sha256 = "18c24e23bcb14ccfe3d46012b7935a0f7927eff298c7d6f76b087fc4c6715961";
       libraryHaskellDepends = [
         base extensible-exceptions MonadCatchIO-transformers
       ];
       jailbreak = true;
       homepage = "http://darcsden.com/jcpetruzza/MonadCatchIO-mtl";
       description = "Monad-transformer version of the Control.Exception module";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "MonadCatchIO-mtl-foreign" = callPackage
    ({ mkDerivation, base, MonadCatchIO-mtl, mtl, primitive }:
     mkDerivation {
       pname = "MonadCatchIO-mtl-foreign";
       version = "0.1";
       sha256 = "56c9f548cc2cae4a40f55997e56dd28020ec558217df6d6d4db4bf28c32ed849";
       libraryHaskellDepends = [ base MonadCatchIO-mtl mtl primitive ];
       jailbreak = true;
       description = "Polymorphic combinators for working with foreign functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MonadCatchIO-transformers_0_3_1_2" = callPackage
    ({ mkDerivation, base, extensible-exceptions, monads-tf
     , transformers
     }:
     mkDerivation {
       pname = "MonadCatchIO-transformers";
       version = "0.3.1.2";
       sha256 = "2d44fd9b0f29d5d866b1e35501bbb2ac89394b2b23b634abce385c6f3e26ace4";
       revision = "1";
       editedCabalFile = "20a6dfcdf7c16f1238a5c36fccaad394cff2b670ef46daafa2d689fe8868031d";
       libraryHaskellDepends = [
         base extensible-exceptions monads-tf transformers
       ];
       jailbreak = true;
       description = "Monad-transformer compatible version of the Control.Exception module";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MonadCatchIO-transformers" = callPackage
    ({ mkDerivation, base, extensible-exceptions, monads-tf
     , transformers
     }:
     mkDerivation {
       pname = "MonadCatchIO-transformers";
       version = "0.3.1.3";
       sha256 = "10a49c32c22123e053377fe558d0c136c2b3746d15954d60f66f6bc80f0404bd";
       libraryHaskellDepends = [
         base extensible-exceptions monads-tf transformers
       ];
       description = "Monad-transformer compatible version of the Control.Exception module";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "MonadCatchIO-transformers-foreign" = callPackage
    ({ mkDerivation, base, MonadCatchIO-transformers, primitive
     , transformers
     }:
     mkDerivation {
       pname = "MonadCatchIO-transformers-foreign";
       version = "0.1";
       sha256 = "dc8798506d027f474abb1a07b7c60dc6b5abcd107d630c031d518b8f0e77111c";
       libraryHaskellDepends = [
         base MonadCatchIO-transformers primitive transformers
       ];
       jailbreak = true;
       description = "Polymorphic combinators for working with foreign functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MonadCompose" = callPackage
    ({ mkDerivation, base, data-default, ghc-prim, kan-extensions
     , mmorph, monad-products, mtl, parallel, random, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "MonadCompose";
       version = "0.8.4.2";
       sha256 = "71c3a63f4e3592a2f918e1433fecf1f8e75293ded6369c82b12a76e3d88bac78";
       libraryHaskellDepends = [
         base data-default ghc-prim kan-extensions mmorph monad-products mtl
         parallel random transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://alkalisoftware.net";
       description = "Methods for composing monads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "MonadLab" = callPackage
    ({ mkDerivation, base, haskell98, parsec, process, template-haskell
     }:
     mkDerivation {
       pname = "MonadLab";
       version = "0.0.2";
       sha256 = "c7757b2022c9100c72397c2135b33af25d5fc40f775f94b41a2973287b871ddd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base parsec template-haskell ];
       executableHaskellDepends = [ base haskell98 process ];
       homepage = "http://monadgarden.cs.missouri.edu/MonadLab";
       description = "Automatically generate layered monads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MonadPrompt" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "MonadPrompt";
       version = "1.0.0.5";
       sha256 = "b012cbbe83650f741c7b7f6eafcc89dec299b0ac74a758b6f3a8cdfc5d3bbeda";
       libraryHaskellDepends = [ base mtl ];
       description = "MonadPrompt, implementation & examples";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "MonadRandom_0_3_0_1" = callPackage
    ({ mkDerivation, base, mtl, random, transformers }:
     mkDerivation {
       pname = "MonadRandom";
       version = "0.3.0.1";
       sha256 = "40e6a19cecf9c72a5281e813c982e037104c287eef3e4b49a03b4fdd6736722d";
       revision = "2";
       editedCabalFile = "51fe20cc3b144ba6d33bb082f1eb387ee41de06d9f694d4fc368ff1785637db1";
       libraryHaskellDepends = [ base mtl random transformers ];
       description = "Random-number generation monad";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MonadRandom_0_3_0_2" = callPackage
    ({ mkDerivation, base, mtl, random, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "MonadRandom";
       version = "0.3.0.2";
       sha256 = "71afdea34f7836678d989cef3373f76a62cca5f47440aa0185c85fff5694eaa1";
       revision = "2";
       editedCabalFile = "35d3a9af010fbf89a42e8d49bd4ac8d163625753a5710d82378c2d17dee2caf2";
       libraryHaskellDepends = [
         base mtl random transformers transformers-compat
       ];
       jailbreak = true;
       description = "Random-number generation monad";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MonadRandom_0_4" = callPackage
    ({ mkDerivation, base, mtl, random, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "MonadRandom";
       version = "0.4";
       sha256 = "d32f3f7a8390125f43a67b78741c6655452dfc4388009ab4ca5a265ab5b86f93";
       revision = "2";
       editedCabalFile = "2e218afd5b29c8682b4fb9859ceec1809ac680b2f27eb17107b18cf84fcc00f2";
       libraryHaskellDepends = [
         base mtl random transformers transformers-compat
       ];
       jailbreak = true;
       description = "Random-number generation monad";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MonadRandom_0_4_1" = callPackage
    ({ mkDerivation, base, mtl, random, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "MonadRandom";
       version = "0.4.1";
       sha256 = "71fbc82f2cec58795b28a1c4820127b64939d3fa710e465a86764413b891554b";
       libraryHaskellDepends = [
         base mtl random transformers transformers-compat
       ];
       jailbreak = true;
       description = "Random-number generation monad";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MonadRandom_0_4_2_1" = callPackage
    ({ mkDerivation, base, mtl, random, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "MonadRandom";
       version = "0.4.2.1";
       sha256 = "635871e4f20bb01c6476a0361cc7069b6242d86c87524b0b8b3fad60ebf1fa6d";
       libraryHaskellDepends = [
         base mtl random transformers transformers-compat
       ];
       description = "Random-number generation monad";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MonadRandom" = callPackage
    ({ mkDerivation, base, mtl, random, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "MonadRandom";
       version = "0.4.2.2";
       sha256 = "07cdf3801ae55a3e89298e902aecfc78d6d34096f7adefd4a826175dcd892a10";
       libraryHaskellDepends = [
         base mtl random transformers transformers-compat
       ];
       description = "Random-number generation monad";
       license = "unknown";
     }) {};

  "MonadRandomLazy" = callPackage
    ({ mkDerivation, base, MonadRandom, mtl, random }:
     mkDerivation {
       pname = "MonadRandomLazy";
       version = "0.1.1.1";
       sha256 = "0289455d870512953d9e9f30e21d31f26469c0de4fca55abcce2f496cc1b1c7f";
       libraryHaskellDepends = [ base MonadRandom mtl random ];
       description = "Lazy monad for psuedo random-number generation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MonadStack" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "MonadStack";
       version = "0.1.0.3";
       sha256 = "9fbd6311057ae23e48894ea61b87b8af2a263c1ffc91f2abc563d7de4e60563b";
       libraryHaskellDepends = [ base mtl ];
       homepage = "https://github.com/bhurt/MonadStack";
       description = "Generalizing lift to monad stacks";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "Monadius" = callPackage
    ({ mkDerivation, array, base, directory, GLUT, OpenGL }:
     mkDerivation {
       pname = "Monadius";
       version = "0.99";
       sha256 = "1db15aecfb5281bd04af14810a2287a8bcf1a90f4dc0f1f6c594366fad4d054b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base directory GLUT OpenGL ];
       homepage = "http://www.geocities.jp/takascience/haskell/monadius_en.html";
       description = "2-D arcade scroller";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Monaris" = callPackage
    ({ mkDerivation, array, base, containers, directory, free
     , free-game, mtl
     }:
     mkDerivation {
       pname = "Monaris";
       version = "0.1.8";
       sha256 = "8bc5319d6490e7a7c89a4849cba77c2a5bb07dbc152b753f0b5688c00187cf57";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory free free-game mtl
       ];
       homepage = "https://github.com/fumieval/Monaris/";
       description = "A simple tetris clone";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Monatron" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Monatron";
       version = "0.3.1";
       sha256 = "06213877722f21ee5e8e2299b81766aa7bdbab5bd383e5d3ab883e5718eea008";
       libraryHaskellDepends = [ base ];
       description = "Monad transformer library with uniform liftings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Monatron-IO" = callPackage
    ({ mkDerivation, base, Monatron, transformers }:
     mkDerivation {
       pname = "Monatron-IO";
       version = "1.0";
       sha256 = "605bcdc40eaa189f9f4e447b0de931a62860149a91f36098959c76b2bff36d6b";
       libraryHaskellDepends = [ base Monatron transformers ];
       jailbreak = true;
       homepage = "https://github.com/kreuzschlitzschraubenzieher/Monatron-IO";
       description = "MonadIO instances for the Monatron transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Monocle" = callPackage
    ({ mkDerivation, base, containers, haskell98, mtl }:
     mkDerivation {
       pname = "Monocle";
       version = "0.0.4";
       sha256 = "be04e7f8dd8f9047b3534e67769de2138308f1f170354ff781a644ab9f121add";
       libraryHaskellDepends = [ base containers haskell98 mtl ];
       description = "Symbolic computations in strict monoidal categories with LaTeX output";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MorseCode" = callPackage
    ({ mkDerivation, base, containers, split }:
     mkDerivation {
       pname = "MorseCode";
       version = "0.0.5";
       sha256 = "1f8855fdf26b8f02f7dbd2b7b8450a9022f8052f4568d36cc267b513a6f2f4b5";
       libraryHaskellDepends = [ base containers split ];
       description = "Morse code";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "MuCheck" = callPackage
    ({ mkDerivation, base, directory, hashable, haskell-src-exts, hint
     , hspec, mtl, random, syb, temporary, time
     }:
     mkDerivation {
       pname = "MuCheck";
       version = "0.3.0.4";
       sha256 = "19c850758616259d2a232ff6d1cf654043ef1143fbfdcad13ba695ffab1b77a0";
       libraryHaskellDepends = [
         base directory hashable haskell-src-exts hint mtl random syb
         temporary time
       ];
       testHaskellDepends = [
         base directory hashable haskell-src-exts hint hspec mtl random syb
         temporary time
       ];
       homepage = "https://bitbucket.com/osu-testing/mucheck";
       description = "Automated Mutation Testing";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "MuCheck-HUnit" = callPackage
    ({ mkDerivation, base, HUnit, MuCheck }:
     mkDerivation {
       pname = "MuCheck-HUnit";
       version = "0.3.0.4";
       sha256 = "122ed915acb4347e2c962ef62a19d15bf851acbe7e247d75123afe4fb9d3a517";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base HUnit MuCheck ];
       executableHaskellDepends = [ base HUnit MuCheck ];
       homepage = "https://bitbucket.com/osu-testing/mucheck-hunit";
       description = "Automated Mutation Testing for HUnit tests";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "MuCheck-Hspec" = callPackage
    ({ mkDerivation, base, hspec, hspec-core, MuCheck }:
     mkDerivation {
       pname = "MuCheck-Hspec";
       version = "0.3.0.4";
       sha256 = "bc16ce3c7cecbec9ee9323e7fa4369f438e8713c1ec873ca61d042a4ad691a31";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base hspec hspec-core MuCheck ];
       executableHaskellDepends = [ base hspec hspec-core MuCheck ];
       homepage = "https://bitbucket.com/osu-testing/mucheck-hspec";
       description = "Automated Mutation Testing for Hspec tests";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "MuCheck-QuickCheck" = callPackage
    ({ mkDerivation, base, MuCheck, QuickCheck }:
     mkDerivation {
       pname = "MuCheck-QuickCheck";
       version = "0.3.0.4";
       sha256 = "131b470565afa63308c5c92b0a4c83ba92535de8dc589982748c4970f81644e0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base MuCheck QuickCheck ];
       executableHaskellDepends = [ base MuCheck QuickCheck ];
       homepage = "https://bitbucket.com/osu-testing/mucheck-quickcheck";
       description = "Automated Mutation Testing for QuickCheck tests";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "MuCheck-SmallCheck" = callPackage
    ({ mkDerivation, base, MuCheck, smallcheck }:
     mkDerivation {
       pname = "MuCheck-SmallCheck";
       version = "0.3.0.4";
       sha256 = "316e15b540ed194c534f62b063a71f85aa180b39edf1274f796be965297d79a5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base MuCheck smallcheck ];
       executableHaskellDepends = [ base MuCheck smallcheck ];
       homepage = "https://bitbucket.com/osu-testing/mucheck-smallcheck";
       description = "Automated Mutation Testing for SmallCheck tests";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "Munkres" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "Munkres";
       version = "0.1";
       sha256 = "29708d54b5a19d8015d9517fb6b6508f983722c92598bbac8bba014d3d7b3599";
       libraryHaskellDepends = [ array base ];
       description = "Munkres' assignment algorithm (hungarian method)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Munkres-simple" = callPackage
    ({ mkDerivation, array, base, bimap, containers, Munkres }:
     mkDerivation {
       pname = "Munkres-simple";
       version = "0.1.0.1";
       sha256 = "2b0b964aad3898d2053d411f93f8cf52f85ce57b73cbd41d2c112d98f119bb4c";
       libraryHaskellDepends = [ array base bimap containers Munkres ];
       jailbreak = true;
       description = "Simple and typesafe layer over the Munkres package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "MusicBrainz_0_2_2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra
     , HTTP, http-conduit, http-types, monad-control, old-locale
     , resourcet, text, time, transformers, vector, xml-conduit
     , xml-types
     }:
     mkDerivation {
       pname = "MusicBrainz";
       version = "0.2.2";
       sha256 = "831e69fafc05fe300066a716e52992f81c4d925270eb0fac300d4e6fba8fd4af";
       libraryHaskellDepends = [
         aeson base bytestring conduit conduit-extra HTTP http-conduit
         http-types monad-control old-locale resourcet text time
         transformers vector xml-conduit xml-types
       ];
       jailbreak = true;
       homepage = "http://floss.scru.org/hMusicBrainz";
       description = "interface to MusicBrainz XML2 web service";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MusicBrainz_0_2_3" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra
     , HTTP, http-conduit, http-types, monad-control, old-locale
     , resourcet, text, time, transformers, vector, xml-conduit
     , xml-types
     }:
     mkDerivation {
       pname = "MusicBrainz";
       version = "0.2.3";
       sha256 = "685ed55d2fc1361020db4a44304ffbe6c16545d67db97bbd8c683897bbcc9e77";
       libraryHaskellDepends = [
         aeson base bytestring conduit conduit-extra HTTP http-conduit
         http-types monad-control old-locale resourcet text time
         transformers vector xml-conduit xml-types
       ];
       homepage = "http://floss.scru.org/hMusicBrainz";
       description = "interface to MusicBrainz XML2 web service";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "MusicBrainz" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra
     , HTTP, http-conduit, http-types, monad-control, resourcet, text
     , time, time-locale-compat, transformers, vector, xml-conduit
     , xml-types
     }:
     mkDerivation {
       pname = "MusicBrainz";
       version = "0.2.4";
       sha256 = "d221f8752fe4c0abdb6e681b1b1811af067b2bc202fa3ef869c5cebe631c3db8";
       libraryHaskellDepends = [
         aeson base bytestring conduit conduit-extra HTTP http-conduit
         http-types monad-control resourcet text time time-locale-compat
         transformers vector xml-conduit xml-types
       ];
       homepage = "http://floss.scru.org/hMusicBrainz";
       description = "interface to MusicBrainz XML2 web service";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "MusicBrainz-libdiscid" = callPackage
    ({ mkDerivation, base, containers, vector }:
     mkDerivation {
       pname = "MusicBrainz-libdiscid";
       version = "0.5.0.0";
       sha256 = "455dc26fec79b05ad661f75cd7051e3017565ad9042739ce0c64778fe0badc95";
       libraryHaskellDepends = [ base containers vector ];
       homepage = "https://github.com/atwupack/MusicBrainz-libdiscid";
       description = "Binding to libdiscid by MusicBrainz";
       license = "LGPL";
     }) {};

  "MyPrimes" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "MyPrimes";
       version = "0.1.0.0";
       sha256 = "9e7ed5da25bbfe833bdd89673fd1d1491ae481756df5d4e51491f009b90398af";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [ base containers ];
       jailbreak = true;
       homepage = "http://afonso.xyz";
       description = "Generate all primes";
       license = stdenv.lib.licenses.mit;
     }) {};

  "NGrams" = callPackage
    ({ mkDerivation, base, HCL, HTTP, network, regex-compat }:
     mkDerivation {
       pname = "NGrams";
       version = "1.1";
       sha256 = "cc0a244b0f62ddd9ece292cbb6fce63a2d4b423ca2940e2f1aedfdd92c803cda";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base HCL HTTP network regex-compat ];
       description = "Simple application for calculating n-grams using Google";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "NTRU" = callPackage
    ({ mkDerivation, arithmoi, base, bytestring, containers, crypto-api
     , polynomial, random, SHA, split
     }:
     mkDerivation {
       pname = "NTRU";
       version = "1.0.0.1";
       sha256 = "4639599d4459e01a6876a2d51847d2d72161616d4dcda18d7e9e5d5e02b02cc1";
       libraryHaskellDepends = [
         arithmoi base bytestring containers crypto-api polynomial random
         SHA split
       ];
       jailbreak = true;
       description = "NTRU Cryptography";
       license = "GPL";
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "NXT" = callPackage
    ({ mkDerivation, base, bluetooth, bytestring, filepath, HUnit, mtl
     , QuickCheck, serialport, test-framework, test-framework-hunit
     , test-framework-quickcheck2, time, unix
     }:
     mkDerivation {
       pname = "NXT";
       version = "0.2.3";
       sha256 = "23429e3654c48d7b009f5a0fef46af6831919c59aa15c250ef9920ce5b9a41cd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring mtl serialport time unix
       ];
       librarySystemDepends = [ bluetooth ];
       executableHaskellDepends = [ base bytestring filepath mtl ];
       testHaskellDepends = [
         base bytestring filepath HUnit mtl QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 time
       ];
       homepage = "http://mitar.tnode.com";
       description = "A Haskell interface to Lego Mindstorms NXT";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {bluetooth = null;};

  "NXTDSL" = callPackage
    ({ mkDerivation, attoparsec, base, hashable, mtl, resourcet, stm
     , text, unordered-containers
     }:
     mkDerivation {
       pname = "NXTDSL";
       version = "0.4";
       sha256 = "05110380357a644ed73f5671705ee97887f0491eaa0509b3b7901559c27ff684";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base hashable mtl resourcet stm text
         unordered-containers
       ];
       homepage = "https://github.com/agrafix/legoDSL";
       description = "Generate NXC Code from DSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "NanoProlog" = callPackage
    ({ mkDerivation, base, containers, ListLike, uu-parsinglib }:
     mkDerivation {
       pname = "NanoProlog";
       version = "0.3";
       sha256 = "b63ae436a8acd35c212d8268db6b32805db079ec0f06acb43d52a3c3fee75272";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ListLike uu-parsinglib ];
       executableHaskellDepends = [ base uu-parsinglib ];
       jailbreak = true;
       description = "Very small interpreter for a Prolog-like language";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "NaturalLanguageAlphabets" = callPackage
    ({ mkDerivation, aeson, array, attoparsec, base, bimaps, binary
     , bytestring, cereal, cereal-text, deepseq, file-embed, hashable
     , intern, LinguisticsTypes, QuickCheck, stringable, system-filepath
     , test-framework, test-framework-quickcheck2, test-framework-th
     , text, text-binary, unordered-containers, vector, vector-th-unbox
     }:
     mkDerivation {
       pname = "NaturalLanguageAlphabets";
       version = "0.1.0.0";
       sha256 = "c233d60b74a4131705e36b5873fae2973f168b8c1c0717055c6d546d40ac6215";
       libraryHaskellDepends = [
         aeson array attoparsec base bimaps binary bytestring cereal
         cereal-text deepseq file-embed hashable intern LinguisticsTypes
         QuickCheck stringable system-filepath text text-binary
         unordered-containers vector vector-th-unbox
       ];
       testHaskellDepends = [
         aeson base binary cereal LinguisticsTypes QuickCheck stringable
         test-framework test-framework-quickcheck2 test-framework-th text
         unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/choener/NaturalLanguageAlphabets";
       description = "Simple scoring schemes for word alignments";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "NaturalSort" = callPackage
    ({ mkDerivation, base, bytestring, QuickCheck, strict }:
     mkDerivation {
       pname = "NaturalSort";
       version = "0.2.1";
       sha256 = "49fd310566c86d85714a1839f1bc845891771dbc023a0befee16f073bbac50f6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring strict ];
       executableHaskellDepends = [ base bytestring QuickCheck strict ];
       homepage = "http://github.com/joachifm/natsort";
       description = "Natural sorting for strings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "NearContextAlgebra" = callPackage
    ({ mkDerivation, base, containers, ContextAlgebra, lattices
     , multiset, QuickCheck
     }:
     mkDerivation {
       pname = "NearContextAlgebra";
       version = "0.1.0.2";
       sha256 = "77e6bd6cb609bc8730c72cca98d04f78292ebd8fe52c2a0c903cfe2950629b5b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers ContextAlgebra lattices multiset QuickCheck
       ];
       jailbreak = true;
       description = "Context Algebra of near";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Neks" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, directory
     , hashable, messagepack, network, stm, vector
     }:
     mkDerivation {
       pname = "Neks";
       version = "0.5.0.0";
       sha256 = "88d9af4e8e26ab61c29cb52b7118e08cd52b5b55e1f750a5bf82cc5c1f9b7020";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal containers directory hashable messagepack
         network stm vector
       ];
       executableHaskellDepends = [
         base bytestring cereal containers directory hashable messagepack
         network stm vector
       ];
       jailbreak = true;
       description = "Simple networked key/value store";
       license = stdenv.lib.licenses.mit;
     }) {};

  "NestedFunctor" = callPackage
    ({ mkDerivation, base, comonad, distributive }:
     mkDerivation {
       pname = "NestedFunctor";
       version = "0.2.0.2";
       sha256 = "651c4617b2bcb9cedff0a8e52c9ecda1177b65b5a9bce4390b16cfae2010bbce";
       libraryHaskellDepends = [ base comonad distributive ];
       jailbreak = true;
       homepage = "https://github.com/kwf/NestedFunctor";
       description = "Nested composition of functors with a type index tracking nesting";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "NestedSampling" = callPackage
    ({ mkDerivation, base, random, vector }:
     mkDerivation {
       pname = "NestedSampling";
       version = "0.1.4";
       sha256 = "9b86f50098712548a652a2da3ef7df91c1271e39e564e83f01abcc45adb4b4e9";
       libraryHaskellDepends = [ base random vector ];
       homepage = "https://github.com/ijt/haskell_nested_sampling";
       description = "A port of John Skilling's nested sampling C code to Haskell";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "NetSNMP" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, net_snmp, process
     , utf8-string
     }:
     mkDerivation {
       pname = "NetSNMP";
       version = "0.3.2.0";
       sha256 = "682dd18c07012ff2ec7fddede94ae2b66f039b6ecb918f4e9f70bccf2b266dfc";
       libraryHaskellDepends = [ base bytestring utf8-string ];
       librarySystemDepends = [ net_snmp ];
       testHaskellDepends = [ base bytestring HUnit process utf8-string ];
       homepage = "https://github.com/ptek/netsnmp";
       description = "Bindings for net-snmp's C API for clients";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) net_snmp;};

  "Network-NineP" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, convertible
     , exceptions, monad-loops, monad-peel, mstate, mtl, network, NineP
     , regex-posix, stateref, transformers
     }:
     mkDerivation {
       pname = "Network-NineP";
       version = "0.4.0";
       sha256 = "2d7e78e03feeb484d5812a3a8cef5f248d26e9daad8b7fe535516f6ec20dd7c0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers convertible exceptions
         monad-loops monad-peel mstate mtl network NineP regex-posix
         stateref transformers
       ];
       description = "High-level abstraction over 9P protocol";
       license = "unknown";
     }) {};

  "NewBinary" = callPackage
    ({ mkDerivation, array, base, integer }:
     mkDerivation {
       pname = "NewBinary";
       version = "0.2.1";
       sha256 = "f8d3db5b0c70c2641bb8725764b6298c51dffa0a1c17d7e5e98c31d4270ce732";
       libraryHaskellDepends = [ array base integer ];
       jailbreak = true;
       description = "A binary I/O library";
       license = "unknown";
       broken = true;
     }) {integer = null;};

  "NineP" = callPackage
    ({ mkDerivation, base, binary, bytestring }:
     mkDerivation {
       pname = "NineP";
       version = "0.0.2.1";
       sha256 = "4bb1516b9fb340118960043e0c72aa62316be8ff3f78cc8c1354e2fac96dd8cc";
       libraryHaskellDepends = [ base binary bytestring ];
       homepage = "http://9ph.googlecode.com";
       description = "9P2000 in pure Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Ninjas" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, filepath
     , gloss, network, networked-game, random
     }:
     mkDerivation {
       pname = "Ninjas";
       version = "0.1.0.0";
       sha256 = "154af665ed36c48b8c5c86fab42cf4f0a42504f107b46cbcc1a49e7a3603e873";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring containers filepath gloss network
         networked-game random
       ];
       jailbreak = true;
       homepage = "http://github.com/glguy/ninjas";
       description = "Ninja game";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "NoSlow" = callPackage
    ({ mkDerivation, array, base, containers, criterion, dph-base
     , dph-prim-seq, statistics, storablevector, template-haskell
     , uvector, vector
     }:
     mkDerivation {
       pname = "NoSlow";
       version = "0.2";
       sha256 = "9d80f0545ce4220e504bc9f6ba8a20737da7299f14620957f7a741db3bda21df";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers criterion dph-base dph-prim-seq statistics
         storablevector template-haskell uvector vector
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/NoSlow";
       description = "Microbenchmarks for various array libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "NoTrace" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "NoTrace";
       version = "0.3.0.0";
       sha256 = "6ffdd65376971c4fa4faea10dacaeaf1b6ada23870c8dc9cb278dc3250e40e81";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       homepage = "https://github.com/CindyLinz/Haskell-NoTrace";
       description = "Remove all the functions come from Debug.Trace after debugging";
       license = stdenv.lib.licenses.mit;
     }) {};

  "Noise" = callPackage
    ({ mkDerivation, array, base, data-default, vector }:
     mkDerivation {
       pname = "Noise";
       version = "1.0.6";
       sha256 = "d8efb502664cb4db7d1b12169e22fbd0bb03bfd035c4a716a415621a2dc25e6a";
       libraryHaskellDepends = [ array base data-default vector ];
       description = "A Haskell coherent noise generator based on libnoise";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Nomyx" = callPackage
    ({ mkDerivation, base, directory, exceptions, filepath, hint-server
     , mtl, network, Nomyx-Core, Nomyx-Language, Nomyx-Web, safe, stm
     , time
     }:
     mkDerivation {
       pname = "Nomyx";
       version = "0.7.6";
       sha256 = "23628112dc562a1e8a1e9971bba710359153228055555ace4fce3d466f8e79fd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory exceptions filepath hint-server mtl network
         Nomyx-Core Nomyx-Language Nomyx-Web safe stm time
       ];
       jailbreak = true;
       homepage = "http://www.nomyx.net";
       description = "A Nomic game in haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Nomyx-Core" = callPackage
    ({ mkDerivation, acid-state, aeson, base, blaze-html, blaze-markup
     , bytestring, data-lens, data-lens-fd, data-lens-template
     , DebugTraceHelpers, deepseq, directory, either-unwrap, exceptions
     , filepath, happstack-authenticate, hint, hint-server, hscolour
     , ixset, mime-mail, MissingH, mtl, network, Nomyx-Language
     , old-locale, random, safe, safecopy, stm, tar, template-haskell
     , temporary, text, time, unix
     }:
     mkDerivation {
       pname = "Nomyx-Core";
       version = "0.7.6";
       sha256 = "3837a6685371eff15c0da491fa7e5550a6e7fbbdadc9fe85d1728a71d503469b";
       libraryHaskellDepends = [
         acid-state aeson base blaze-html blaze-markup bytestring data-lens
         data-lens-fd data-lens-template DebugTraceHelpers deepseq directory
         either-unwrap exceptions filepath happstack-authenticate hint
         hint-server hscolour ixset mime-mail MissingH mtl network
         Nomyx-Language old-locale random safe safecopy stm tar
         template-haskell temporary text time unix
       ];
       jailbreak = true;
       homepage = "http://www.nomyx.net";
       description = "A Nomic game in haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Nomyx-Language" = callPackage
    ({ mkDerivation, base, Boolean, containers, data-lens, data-lens-fd
     , data-lens-template, DebugTraceHelpers, ghc, mtl, old-locale
     , random, safe, time, time-recurrence
     }:
     mkDerivation {
       pname = "Nomyx-Language";
       version = "0.7.6";
       sha256 = "898eae368fabce7fd66be2ca84f43fd7c7c0888ba3d9d1a9b8d12b8b4db54959";
       libraryHaskellDepends = [
         base Boolean containers data-lens data-lens-fd data-lens-template
         DebugTraceHelpers ghc mtl old-locale random safe time
         time-recurrence
       ];
       jailbreak = true;
       homepage = "http://www.nomyx.net";
       description = "Language to express rules for Nomic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Nomyx-Rules" = callPackage
    ({ mkDerivation, base, containers, ghc, hint-server, hslogger, mtl
     , old-locale, safe, stm, time, time-recurrence
     }:
     mkDerivation {
       pname = "Nomyx-Rules";
       version = "0.1.0";
       sha256 = "0583d0f857c4eb643ffbdb13227700d1db6b6a8f8f6b3ef1ad4d9f6277bb7f9a";
       libraryHaskellDepends = [
         base containers ghc hint-server hslogger mtl old-locale safe stm
         time time-recurrence
       ];
       description = "Language to express rules for Nomic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Nomyx-Web" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
     , data-lens, data-lens-fd, fb, filepath, happstack-authenticate
     , happstack-server, hscolour, mtl, Nomyx-Core, Nomyx-Language
     , old-locale, reform, reform-blaze, reform-happstack, safe, split
     , stm, text, time, web-routes, web-routes-happstack
     , web-routes-regular, web-routes-th
     }:
     mkDerivation {
       pname = "Nomyx-Web";
       version = "0.7.6";
       sha256 = "67c9f60b48e542fca25628dbdb96ae34371ef7e123c18d6da440c3bf8e497ba4";
       libraryHaskellDepends = [
         base blaze-html blaze-markup bytestring data-lens data-lens-fd fb
         filepath happstack-authenticate happstack-server hscolour mtl
         Nomyx-Core Nomyx-Language old-locale reform reform-blaze
         reform-happstack safe split stm text time web-routes
         web-routes-happstack web-routes-regular web-routes-th
       ];
       jailbreak = true;
       homepage = "http://www.nomyx.net";
       description = "Web gui for Nomyx";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "NonEmpty" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "NonEmpty";
       version = "0.1";
       sha256 = "b4bfaeac23a0c7d86e0e1a0f132e18e906dbf9a83cf9f2155b651916d2d9cc5b";
       libraryHaskellDepends = [ base ];
       description = "Library providing a non-empty list datatype, and total functions operating on it";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "NonEmptyList" = callPackage
    ({ mkDerivation, base, category-extras, QuickCheck, Semigroup
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "NonEmptyList";
       version = "0.0.9";
       sha256 = "a287105d312c0f9ee9b039899ede26b44e6b7b370b0914a46e7693ae8e2fa124";
       libraryHaskellDepends = [
         base category-extras QuickCheck Semigroup test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "http://code.google.com/p/nonempty/";
       description = "A list with a length of at least one";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "NumInstances" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "NumInstances";
       version = "1.4";
       sha256 = "cbdb2a49346f59ceb5ab38592d7bc52e5205580d431d0ac6d852fd9880e59679";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/conal/NumInstances";
       description = "Instances of numeric classes for functions and tuples";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "NumLazyByteString" = callPackage
    ({ mkDerivation, base, binary, bytestring }:
     mkDerivation {
       pname = "NumLazyByteString";
       version = "0.0.0.1";
       sha256 = "1acb8424c116f25df398a92011d48f2a8cc58f25e1fe39fd983d7dd521198a9d";
       libraryHaskellDepends = [ base binary bytestring ];
       description = "Num, Enum, Eq, Integral, Ord, Real, and Show instances for Lazy ByteStrings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "NumberSieves" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "NumberSieves";
       version = "0.1.2";
       sha256 = "825b71db4e602592b89b187084d4081538b3f108dce63621cd6744baa3211ef1";
       libraryHaskellDepends = [ array base ];
       homepage = "http://patch-tag.com/r/lpsmith/NumberSieves";
       description = "Number Theoretic Sieves: primes, factorization, and Euler's Totient";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "NumberTheory" = callPackage
    ({ mkDerivation, base, containers, HUnit, primes }:
     mkDerivation {
       pname = "NumberTheory";
       version = "0.1.0.1";
       sha256 = "e0cc1d5500b4d719b846c3e96ef4e4b04e620b40acc5e4b5c942495537ee1da9";
       libraryHaskellDepends = [ base containers primes ];
       testHaskellDepends = [ base containers HUnit primes ];
       description = "A library for number theoretic computations, written in Haskell";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "Numbers" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "Numbers";
       version = "0.2.1";
       sha256 = "e73d1706aaefd21ca1edf84854df6bf6043b8b7d650e1d3d05cb64454d1a3bfc";
       libraryHaskellDepends = [ base random ];
       homepage = "http://page.mi.fu-berlin.de/aneumann/numbers/index.html";
       description = "An assortment of number theoretic functions";
       license = "LGPL";
     }) {};

  "Nussinov78" = callPackage
    ({ mkDerivation, ADPfusion, base, ghc-prim, mtl, primitive
     , PrimitiveArray, vector
     }:
     mkDerivation {
       pname = "Nussinov78";
       version = "0.1.0.0";
       sha256 = "504bdbbe64289faa8050d6a806af21107265838e21f2e392f18e63776cac38c9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ADPfusion base ghc-prim mtl primitive PrimitiveArray vector
       ];
       jailbreak = true;
       homepage = "http://www.tbi.univie.ac.at/~choener/adpfusion";
       description = "Nussinov78 using the ADPfusion library";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Nutri" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Nutri";
       version = "0.1";
       sha256 = "b28cd8c652a0588c8db01547fd426ab3720ad9cf6796a2ccbcb2fce67fe9f8d4";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/frosch03/Nutri";
       description = "A little library to calculate nutrition values of food items";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "OGL" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "OGL";
       version = "0.0.3";
       sha256 = "15a357d6628414f3a2e67dc594e1fe22c9047026f191217c26ab849145bc14f1";
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://haskell.org/haskellwiki/OGL";
       description = "A context aware binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OSM" = callPackage
    ({ mkDerivation, base, comonad-transformers, containers, data-lens
     , hxt, newtype
     }:
     mkDerivation {
       pname = "OSM";
       version = "0.6.4";
       sha256 = "297b4db6b90a128b1e91522e4cb036fe48b82f1435cf6371b41a02464136c0d4";
       libraryHaskellDepends = [
         base comonad-transformers containers data-lens hxt newtype
       ];
       homepage = "https://github.com/tonymorris/geo-osm";
       description = "Parse OpenStreetMap files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OTP" = callPackage
    ({ mkDerivation, base, Crypto, time }:
     mkDerivation {
       pname = "OTP";
       version = "0.0.0.1";
       sha256 = "aba94f7d6afb16fe3c890b4e9fa3ee1a7432181d9b15fcac6360f41da6f39d6d";
       libraryHaskellDepends = [ base Crypto time ];
       testHaskellDepends = [ base Crypto time ];
       homepage = "https://github.com/matshch/OTP";
       description = "HMAC-Based and Time-Based One-Time Passwords";
       license = stdenv.lib.licenses.mit;
     }) {};

  "Object" = callPackage
    ({ mkDerivation, base, containers, ghc, template-haskell }:
     mkDerivation {
       pname = "Object";
       version = "1.0";
       sha256 = "c92dcbf7b82b24b38ae1c06e9c0998bff6dd5ef6b44fd4857676230008c69916";
       libraryHaskellDepends = [ base containers ghc template-haskell ];
       homepage = "https://github.com/yokto/object";
       description = "Object oriented programming for haskell using multiparameter typeclasses";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ObjectIO" = callPackage
    ({ mkDerivation, comctl32, comdlg32, gdi32, kernel32, ole32
     , shell32, user32, winmm, winspool
     }:
     mkDerivation {
       pname = "ObjectIO";
       version = "1.0.1.1";
       sha256 = "5e9a7b2b393d653755b447d258e6317b121332169e033e14ed46d330db610ab9";
       librarySystemDepends = [
         comctl32 comdlg32 gdi32 kernel32 ole32 shell32 user32 winmm
         winspool
       ];
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {comctl32 = null; comdlg32 = null; gdi32 = null; 
         kernel32 = null; ole32 = null; shell32 = null; user32 = null; 
         winmm = null; winspool = null;};

  "ObjectName_1_1_0_0" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "ObjectName";
       version = "1.1.0.0";
       sha256 = "afa91a31b325d2d70b27c367cf0447410f31f8e80bb851b5cbe6a9e9d372054e";
       libraryHaskellDepends = [ base transformers ];
       homepage = "https://github.com/svenpanne/ObjectName";
       description = "Explicitly handled object names";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ObjectName" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "ObjectName";
       version = "1.1.0.1";
       sha256 = "72dbef237580fd4e8567de2de752835bbadd3629f486d1586486d49a49aad210";
       libraryHaskellDepends = [ base transformers ];
       homepage = "https://github.com/svenpanne/ObjectName";
       description = "Explicitly handled object names";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Obsidian" = callPackage
    ({ mkDerivation, base, containers, cuda, language-c-quote
     , mainland-pretty, mtl, mwc-random, process, rdtsc, text
     , value-supply, vector
     }:
     mkDerivation {
       pname = "Obsidian";
       version = "0.1.0.0";
       sha256 = "0174c2d414abd166e9e6aea3efea49faeda46a0a142ec116249192488a54ab91";
       libraryHaskellDepends = [
         base containers cuda language-c-quote mainland-pretty mtl
         mwc-random process rdtsc text value-supply vector
       ];
       jailbreak = true;
       homepage = "https://github.com/svenssonjoel/Obsidian";
       description = "Embedded language for GPU Programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Octree_0_5_3" = callPackage
    ({ mkDerivation, AC-Vector, base, markdown-unlit, QuickCheck }:
     mkDerivation {
       pname = "Octree";
       version = "0.5.3";
       sha256 = "a6d7a8b0a8bc9ca8cf8ba2198f6f0719d0de74b2f96063862b1b54908bdfdf71";
       libraryHaskellDepends = [ AC-Vector base QuickCheck ];
       testHaskellDepends = [ AC-Vector base markdown-unlit QuickCheck ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/mgajda/octree";
       description = "Simple unbalanced Octree for storing data about 3D points";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Octree_0_5_4_1" = callPackage
    ({ mkDerivation, AC-Vector, base, markdown-unlit, QuickCheck }:
     mkDerivation {
       pname = "Octree";
       version = "0.5.4.1";
       sha256 = "00efa6232c695d2c1c537539171f684f5175ad6d78195df254e15a4293f8845f";
       revision = "1";
       editedCabalFile = "9ddb7579aab3157c69d4943c9e063ff946887e335a4dd6c59d1b855dafd991b4";
       libraryHaskellDepends = [ AC-Vector base QuickCheck ];
       testHaskellDepends = [ AC-Vector base markdown-unlit QuickCheck ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/mgajda/octree";
       description = "Simple unbalanced Octree for storing data about 3D points";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Octree" = callPackage
    ({ mkDerivation, AC-Vector, base, markdown-unlit, QuickCheck }:
     mkDerivation {
       pname = "Octree";
       version = "0.5.4.2";
       sha256 = "0207ac1cff400bf548f76dc4bf0eec7bb31ce61d660d28c6b5fbbdb2a9970760";
       libraryHaskellDepends = [ AC-Vector base QuickCheck ];
       testHaskellDepends = [ AC-Vector base markdown-unlit QuickCheck ];
       doCheck = false;
       homepage = "https://github.com/mgajda/octree";
       description = "Simple unbalanced Octree for storing data about 3D points";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "OddWord" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "OddWord";
       version = "1.0.1.0";
       sha256 = "a143467e9491fdf3b7149b381bb41d6720b946ebd33231ccb0adad1dc5bd4329";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base QuickCheck ];
       homepage = "http://www.gekkou.co.uk/";
       description = "Provides a wrapper for deriving word types with fewer bits";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "Omega" = callPackage
    ({ mkDerivation, base, containers, HUnit }:
     mkDerivation {
       pname = "Omega";
       version = "1.0.3";
       sha256 = "b2386093f0223326e8fe9d6984fb41f813e1581fc1f6affbd6abe57cb2e8aa15";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [ base containers HUnit ];
       description = "Integer sets and relations using Presburger arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OneTuple" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "OneTuple";
       version = "0.2.1";
       sha256 = "4b6f74b6d92df112b0f4eaf15ccdc5fbb763d59f07e9a2afa5690ef89159a2f4";
       libraryHaskellDepends = [ base ];
       description = "Singleton Tuple";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "OpenAFP" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, hashable, hashtables, mtl, process, regex-compat
     }:
     mkDerivation {
       pname = "OpenAFP";
       version = "1.4.2";
       sha256 = "80558f9ac3512a98e25ace02ceed4ad5ddcf8727335b54c2b9ef3fee7ccf1e75";
       libraryHaskellDepends = [
         array base binary bytestring containers directory hashable
         hashtables mtl process regex-compat
       ];
       homepage = "https://github.com/audreyt/openafp/";
       description = "IBM AFP document format parser and generator";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OpenAFP-Utils" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , filepath, hashable, line2pdf, OpenAFP, regex-base, regex-posix
     , text, text-locale-encoding, xhtml
     }:
     mkDerivation {
       pname = "OpenAFP-Utils";
       version = "1.4.1.3";
       sha256 = "c0ab6bd24d16ec864a2ab399c60f9d694dc4b512fb139728a6fa5d0025a31898";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring containers directory filepath hashable
         line2pdf OpenAFP regex-base regex-posix text text-locale-encoding
         xhtml
       ];
       description = "Assorted utilities to work with AFP data streams";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OpenAL" = callPackage
    ({ mkDerivation, base, ObjectName, openal, OpenGL, StateVar
     , transformers
     }:
     mkDerivation {
       pname = "OpenAL";
       version = "1.7.0.3";
       sha256 = "c8051477b773efe58d72cde32a1f24734a01e8a161cfee278420f0757eca2ac6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base ObjectName OpenGL StateVar transformers
       ];
       librarySystemDepends = [ openal ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/haskell-openal/ALUT";
       description = "A binding to the OpenAL cross-platform 3D audio API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) openal;};

  "OpenCL" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, mtl, OpenCL, QuickCheck }:
     mkDerivation {
       pname = "OpenCL";
       version = "1.0.3.4";
       sha256 = "fd8807fa5b78349d52218bde599d7b8e422f4c7e231a276406b52c62616b9811";
       libraryHaskellDepends = [ base bytestring mtl ];
       librarySystemDepends = [ OpenCL ];
       libraryToolDepends = [ c2hs ];
       testHaskellDepends = [ base QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/IFCA/opencl";
       description = "Haskell high-level wrapper for OpenCL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {OpenCL = null;};

  "OpenCLRaw" = callPackage
    ({ mkDerivation, base, bytestring, mtl }:
     mkDerivation {
       pname = "OpenCLRaw";
       version = "1.0.1001";
       sha256 = "07501b636c29dcec37992e008f09f0cb5dafcaa83d1db9e0605c8edb6ba636a9";
       libraryHaskellDepends = [ base bytestring mtl ];
       jailbreak = true;
       homepage = "http://vis.renci.org/jeff/opencl";
       description = "The OpenCL Standard for heterogenous data-parallel computing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OpenCLWrappers" = callPackage
    ({ mkDerivation, base, bytestring, mtl }:
     mkDerivation {
       pname = "OpenCLWrappers";
       version = "0.1.0.3";
       sha256 = "1a913126fdf547e8c895aef4c29aac65aa901138e4dd095b70925c3da5119576";
       libraryHaskellDepends = [ base bytestring mtl ];
       jailbreak = true;
       homepage = "https://github.com/jkarlson/OpenCLWrappers";
       description = "The OpenCL Standard for heterogenous data-parallel computing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "OpenGL_2_9_2_0" = callPackage
    ({ mkDerivation, base, bytestring, GLURaw, OpenGLRaw, text }:
     mkDerivation {
       pname = "OpenGL";
       version = "2.9.2.0";
       sha256 = "1758f6cacc9ea8f0d410fd0abc1a19f2a50dffdb62736d66d4e62b20619545e9";
       revision = "3";
       editedCabalFile = "afa0f940d3f946e52428d8580e65df8e150897b0eecd82e1d7d40934f3b16ba1";
       libraryHaskellDepends = [ base bytestring GLURaw OpenGLRaw text ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OpenGL_2_12_0_0" = callPackage
    ({ mkDerivation, base, bytestring, GLURaw, ObjectName, OpenGLRaw
     , StateVar, text, transformers
     }:
     mkDerivation {
       pname = "OpenGL";
       version = "2.12.0.0";
       sha256 = "1e47a3835d84acd21d2927e56a11630a59a8ba96606bab6c37158e5dc332ba38";
       libraryHaskellDepends = [
         base bytestring GLURaw ObjectName OpenGLRaw StateVar text
         transformers
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OpenGL_2_12_0_1" = callPackage
    ({ mkDerivation, base, bytestring, GLURaw, ObjectName, OpenGLRaw
     , StateVar, text, transformers
     }:
     mkDerivation {
       pname = "OpenGL";
       version = "2.12.0.1";
       sha256 = "8b7cfc07cb4cc4a6c45910eeb9fdfe114be1f64090fa0705c3e550794c588ed5";
       libraryHaskellDepends = [
         base bytestring GLURaw ObjectName OpenGLRaw StateVar text
         transformers
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OpenGL_3_0_0_0" = callPackage
    ({ mkDerivation, base, bytestring, containers, GLURaw, ObjectName
     , OpenGLRaw, StateVar, text, transformers
     }:
     mkDerivation {
       pname = "OpenGL";
       version = "3.0.0.0";
       sha256 = "f05a76b800fed837379f295aa69a142842610d22246f6a6764ec642bbbb05bf0";
       libraryHaskellDepends = [
         base bytestring containers GLURaw ObjectName OpenGLRaw StateVar
         text transformers
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OpenGL" = callPackage
    ({ mkDerivation, base, bytestring, containers, GLURaw, ObjectName
     , OpenGLRaw, StateVar, text, transformers
     }:
     mkDerivation {
       pname = "OpenGL";
       version = "3.0.0.1";
       sha256 = "6039244fa37f8ace40e3d778757ecca331b37fd846b8717363038b269b58e100";
       libraryHaskellDepends = [
         base bytestring containers GLURaw ObjectName OpenGLRaw StateVar
         text transformers
       ];
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "OpenGLCheck" = callPackage
    ({ mkDerivation, base, checkers, haskell98, OpenGL, QuickCheck }:
     mkDerivation {
       pname = "OpenGLCheck";
       version = "1.0";
       sha256 = "59391672b6cd5a1f62816c18a6a5624f49745022c05ad2cfddcc4a0353e34f7e";
       libraryHaskellDepends = [
         base checkers haskell98 OpenGL QuickCheck
       ];
       description = "Quickcheck instances for various data structures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OpenGLRaw_1_5_0_0" = callPackage
    ({ mkDerivation, base, ghc-prim, mesa }:
     mkDerivation {
       pname = "OpenGLRaw";
       version = "1.5.0.0";
       sha256 = "852aa5229722269d70daed3c04b95e9dc7b7013efd62ebc4f2873a81768b9a12";
       libraryHaskellDepends = [ base ghc-prim ];
       librarySystemDepends = [ mesa ];
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A raw binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mesa;};

  "OpenGLRaw_1_5_0_1" = callPackage
    ({ mkDerivation, base, mesa }:
     mkDerivation {
       pname = "OpenGLRaw";
       version = "1.5.0.1";
       sha256 = "a3a27cd887a928b677a4e16ad61ebf14d668e822933fd0046804f8fd64acda42";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ mesa ];
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A raw binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mesa;};

  "OpenGLRaw_2_4_1_0" = callPackage
    ({ mkDerivation, base, mesa, transformers }:
     mkDerivation {
       pname = "OpenGLRaw";
       version = "2.4.1.0";
       sha256 = "546eb00e2b25347e4ab8f3fe9124263020d20c5fca6e91492838c0bae5783376";
       libraryHaskellDepends = [ base transformers ];
       librarySystemDepends = [ mesa ];
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A raw binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mesa;};

  "OpenGLRaw_3_0_0_0" = callPackage
    ({ mkDerivation, base, bytestring, containers, fixed, half, mesa
     , text, transformers
     }:
     mkDerivation {
       pname = "OpenGLRaw";
       version = "3.0.0.0";
       sha256 = "81efc4c80bb9ddc5a977f95b59e3e322b14620b0e92a210cbe542a2d9f8eabf1";
       libraryHaskellDepends = [
         base bytestring containers fixed half text transformers
       ];
       librarySystemDepends = [ mesa ];
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A raw binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mesa;};

  "OpenGLRaw" = callPackage
    ({ mkDerivation, base, bytestring, containers, fixed, half, mesa
     , text, transformers
     }:
     mkDerivation {
       pname = "OpenGLRaw";
       version = "3.1.0.0";
       sha256 = "414364cacce1c7601c93b388dbb73c5bdc76e5b0f3754ee61d0a5b94ccf9f3ce";
       libraryHaskellDepends = [
         base bytestring containers fixed half text transformers
       ];
       librarySystemDepends = [ mesa ];
       homepage = "http://www.haskell.org/haskellwiki/Opengl";
       description = "A raw binding for the OpenGL graphics system";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) mesa;};

  "OpenGLRaw21" = callPackage
    ({ mkDerivation, OpenGLRaw }:
     mkDerivation {
       pname = "OpenGLRaw21";
       version = "2.0.0.2";
       sha256 = "e1af60d7b2b931310b8c04427993b8ea072230d1acdf851cffad506e25e7cfcd";
       libraryHaskellDepends = [ OpenGLRaw ];
       jailbreak = true;
       description = "The intersection of OpenGL 2.1 and OpenGL 3.1 Core";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OpenSCAD" = callPackage
    ({ mkDerivation, base, Cabal, colour, containers, deepseq, filepath
     , HUnit, semigroups, tasty, tasty-hunit, testpack
     }:
     mkDerivation {
       pname = "OpenSCAD";
       version = "0.3.0.2";
       sha256 = "1d55f995c05b7d5c85dffaf8e58b0fc731899e941a7ef415fa7be30292b16711";
       libraryHaskellDepends = [
         base colour containers filepath semigroups
       ];
       testHaskellDepends = [
         base Cabal colour containers deepseq filepath HUnit semigroups
         tasty tasty-hunit testpack
       ];
       homepage = "https://chiselapp.com/user/mwm/repository/OpenSCAD/";
       description = "ADT wrapper and renderer for OpenSCAD models";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OpenVG" = callPackage
    ({ mkDerivation, base, GLUT, OpenGL, OpenGLRaw, OpenVGRaw }:
     mkDerivation {
       pname = "OpenVG";
       version = "0.7.0";
       sha256 = "727fe87ac349d9424fd536352e03290c09c9c1aa35f45de6de8772c61735a929";
       libraryHaskellDepends = [ base GLUT OpenGL OpenGLRaw OpenVGRaw ];
       homepage = "http://code.google.com/p/copperbox/";
       description = "OpenVG (ShivaVG-0.2.1) binding";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OpenVGRaw" = callPackage
    ({ mkDerivation, base, OpenGLRaw }:
     mkDerivation {
       pname = "OpenVGRaw";
       version = "0.4.0";
       sha256 = "a2971a855bb8eae79b87e0e43f417bcace87619d5fcd569fe96674e1d02aafb9";
       libraryHaskellDepends = [ base OpenGLRaw ];
       jailbreak = true;
       homepage = "http://code.google.com/p/copperbox/";
       description = "Raw binding to OpenVG (ShivaVG-0.2.1 implementation).";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Operads" = callPackage
    ({ mkDerivation, array, base, containers, mtl }:
     mkDerivation {
       pname = "Operads";
       version = "1.0";
       sha256 = "130b8ce62168206b8feb0506a6804dc86a171391f6ea9f821c9cf7f6330508ad";
       libraryHaskellDepends = [ array base containers mtl ];
       jailbreak = true;
       homepage = "http://math.stanford.edu/~mik/operads";
       description = "Groebner basis computation for Operads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OptDir" = callPackage
    ({ mkDerivation, base, hashable, syb }:
     mkDerivation {
       pname = "OptDir";
       version = "0.0.3";
       sha256 = "1850d5012d5bcf7b9e1704fc755ba03afa82a6065496235a4ed9f3d14ed165ad";
       libraryHaskellDepends = [ base hashable syb ];
       description = "The OptDir type for representing optimization directions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "OrPatterns" = callPackage
    ({ mkDerivation, base, containers, haskell-src-exts
     , haskell-src-meta, mtl, split, syb, template-haskell
     }:
     mkDerivation {
       pname = "OrPatterns";
       version = "0.1";
       sha256 = "21849cfbf91abe7f7146887be47409f8ae858d746e8188dca708be33ed126f3a";
       libraryHaskellDepends = [
         base containers haskell-src-exts haskell-src-meta mtl split syb
         template-haskell
       ];
       jailbreak = true;
       description = "A quasiquoter for or-patterns";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "OrchestrateDB" = callPackage
    ({ mkDerivation, aeson, base, bytestring, HTTP, http-conduit
     , http-types, lifted-base, random
     }:
     mkDerivation {
       pname = "OrchestrateDB";
       version = "1.0.0.3";
       sha256 = "5f693e961bc4db8a8bad1cdeb942e40c8660ac594a36c44a577fbafbda922234";
       libraryHaskellDepends = [
         aeson base bytestring HTTP http-conduit http-types lifted-base
       ];
       testHaskellDepends = [
         aeson base bytestring HTTP http-conduit http-types lifted-base
         random
       ];
       homepage = "https://github.com/dwd31415/Haskell-OrchestrateDB";
       description = "Unofficial Haskell Client Library for the Orchestrate.io API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "OrderedBits" = callPackage
    ({ mkDerivation, base, bits, primitive, QuickCheck, test-framework
     , test-framework-quickcheck2, test-framework-th, vector
     , vector-algorithms
     }:
     mkDerivation {
       pname = "OrderedBits";
       version = "0.0.1.0";
       sha256 = "59fa6692c6a3960b3de86b1adaf4b2e12d71b23e7734302737aa8cfc7cfdd5af";
       libraryHaskellDepends = [
         base bits primitive vector vector-algorithms
       ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
         test-framework-th vector
       ];
       homepage = "https://github.com/choener/OrderedBits";
       description = "Efficient ordered (by popcount) enumeration of bits";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Ordinals" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Ordinals";
       version = "0.0.0.2";
       sha256 = "5153e441ca200a3aef7c733c2c2fde7c373ee7d2f0a46067b8db34413339b313";
       libraryHaskellDepends = [ base ];
       homepage = "http://patch-tag.com/r/kyagrd/Ordinals/";
       description = "Ordinal arithmetic";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "PArrows" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, mtl }:
     mkDerivation {
       pname = "PArrows";
       version = "0.1.1";
       sha256 = "17589865c3aa8c7415b9da80d67e09c9e06be83b53f22d00b8dca7fdc5c1b322";
       libraryHaskellDepends = [ base containers ghc-prim mtl ];
       homepage = "http://www.cs.helsinki.fi/u/ekarttun/PArrows/";
       description = "Arrow parser combinators similar to Parsec";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "PBKDF2" = callPackage
    ({ mkDerivation, base, binary, bytestring, Crypto, random }:
     mkDerivation {
       pname = "PBKDF2";
       version = "0.3.1.5";
       sha256 = "c2b425a4b758b6979d8578492b39b3c02c1dcc39e3123129999cd51b86644a52";
       revision = "1";
       editedCabalFile = "6e8829aa00d16484705a23417f548b237aa1bd152c864a7cfa6948996584db3e";
       libraryHaskellDepends = [ base binary bytestring Crypto random ];
       description = "Make password-based security schemes more secure";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "PCLT" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, utf8-string }:
     mkDerivation {
       pname = "PCLT";
       version = "0.1";
       sha256 = "38bdd54152d7a947b0a50c45225b4b472caa07682e0d39bfd6cd18f0db5daa4c";
       libraryHaskellDepends = [
         base bytestring containers mtl utf8-string
       ];
       homepage = "http://github.com/Andrey-Sisoyev/PCLT";
       description = "Extension to Show: templating, catalogizing, languages, parameters, etc";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "PCLT-DB" = callPackage
    ({ mkDerivation, base, bytestring, containers, convertible, HDBC
     , HDBC-postgresql, mtl, PCLT
     }:
     mkDerivation {
       pname = "PCLT-DB";
       version = "0.1.1";
       sha256 = "0ebb9ce053758ed31854c0740af3a625b5dc8850a3910192ce94ae7965ac6559";
       libraryHaskellDepends = [
         base bytestring containers convertible HDBC HDBC-postgresql mtl
         PCLT
       ];
       homepage = "http://github.com/Andrey-Sisoyev/PCLT-DB";
       description = "An addon to PCLT package: enchance PCLT catalog with PostgreSQL powers";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "PDBtools" = callPackage
    ({ mkDerivation, base, bytestring, containers }:
     mkDerivation {
       pname = "PDBtools";
       version = "0.0.3";
       sha256 = "d80810bd44765b86c0ebf247f32ddded301eddb587fe12a0bdc378ee6b8fb0c4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring containers ];
       homepage = "http://www.github.com/rotskoff";
       description = "A library for analysis of 3-D protein coordinates";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "PSQueue" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "PSQueue";
       version = "1.1";
       sha256 = "a8e0871ad10f916f55c3b9baec53eff23c4e97e09cf96d6c66771789e00a49cc";
       libraryHaskellDepends = [ base ];
       description = "Priority Search Queue";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "PTQ" = callPackage
    ({ mkDerivation, base, containers, mtl, network, network-uri, xml
     }:
     mkDerivation {
       pname = "PTQ";
       version = "0.0.7";
       sha256 = "15d6f4eb1a2ff9b94a94e1b3e2991bbcf36f24b640c635216b2c767a912fcd5d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers mtl network network-uri xml
       ];
       homepage = "http://msakai.jp/hiki/?hsPTQ";
       description = "An implementation of Montague's PTQ";
       license = "LGPL";
     }) {};

  "PUH-Project" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, mime-mail
     , network, old-locale, persistent, persistent-sqlite
     , persistent-template, pwstore-fast, random, smtp-mail, text, time
     , transformers
     }:
     mkDerivation {
       pname = "PUH-Project";
       version = "0.1.0.1";
       sha256 = "3ae48511d92c0d0794b1de80363ab718400e9a44f80cb0e4f03b225ed4c0c522";
       libraryHaskellDepends = [
         base bytestring containers directory mime-mail network old-locale
         persistent persistent-sqlite persistent-template pwstore-fast
         random smtp-mail text time transformers
       ];
       description = "This is a package which includes Assignments, Email, User and Reviews modules for Programming in Haskell course";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "PageIO" = callPackage
    ({ mkDerivation, array, attoparsec, base, base64-string, bytestring
     , containers, directory, iconv, network, old-time, regex-base
     , regex-compat, regex-tdfa, sqlite, stringtable-atom, utf8-string
     , uuid
     }:
     mkDerivation {
       pname = "PageIO";
       version = "0.0.3";
       sha256 = "53f224ffa8891f5f21a82140b6d8a63babe4e1d24a5c92de58774b482b87d65e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array attoparsec base base64-string bytestring containers directory
         iconv network old-time regex-base regex-compat regex-tdfa sqlite
         stringtable-atom utf8-string uuid
       ];
       executableHaskellDepends = [
         array attoparsec base base64-string bytestring containers directory
         iconv network old-time regex-base regex-compat regex-tdfa sqlite
         stringtable-atom utf8-string uuid
       ];
       description = "Page-oriented extraction and composition library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Paillier" = callPackage
    ({ mkDerivation, base, crypto-numbers, crypto-random, HUnit
     , QuickCheck, test-framework, test-framework-quickcheck2
     , test-framework-th
     }:
     mkDerivation {
       pname = "Paillier";
       version = "0.1.0.3";
       sha256 = "e2bfd82dcfe0e5d18af6fc0b6208e476cb4fe5291f8f6c2f05b7a808b5388b49";
       libraryHaskellDepends = [ base crypto-numbers crypto-random ];
       testHaskellDepends = [
         base crypto-numbers crypto-random HUnit QuickCheck test-framework
         test-framework-quickcheck2 test-framework-th
       ];
       jailbreak = true;
       description = "a simple Paillier cryptosystem";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "PandocAgda" = callPackage
    ({ mkDerivation, Agda, base, containers, directory, filepath, mtl
     , pandoc, pandoc-types, QuickCheck, text, time, xhtml
     }:
     mkDerivation {
       pname = "PandocAgda";
       version = "2.3.3.0.2";
       sha256 = "602e964e7227fa38e51f17f6a0497da967d1b36bfbacc500a91bc5e872af69bc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         Agda base containers directory filepath mtl pandoc pandoc-types
         QuickCheck text time xhtml
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       description = "Pandoc support for literate Agda";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Paraiso" = callPackage
    ({ mkDerivation, array, base, containers, directory, failure, fgl
     , filepath, HUnit, mtl, numeric-prelude, process, QuickCheck
     , random, repa, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, typelevel-tensor, vector
     }:
     mkDerivation {
       pname = "Paraiso";
       version = "0.3.1.5";
       sha256 = "4448a2a736f5fec503927d6dc9b5729ef67c818bd2ee14044bcf6c0614951525";
       libraryHaskellDepends = [
         array base containers directory failure fgl filepath mtl
         numeric-prelude random text typelevel-tensor vector
       ];
       testHaskellDepends = [
         array base containers directory fgl filepath HUnit mtl
         numeric-prelude process QuickCheck random repa test-framework
         test-framework-hunit test-framework-quickcheck2 text
         typelevel-tensor vector
       ];
       homepage = "http://www.paraiso-lang.org/wiki/index.php/Main_Page";
       description = "a code generator for partial differential equations solvers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Parry" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , ghc-prim, network, old-locale, process, random, RSA
     , SafeSemaphore, time, unix
     }:
     mkDerivation {
       pname = "Parry";
       version = "0.1.0.0";
       sha256 = "9a587206cc456cce1e36c50efbba247b167c280df1471ff8b7c0437594bfc04b";
       libraryHaskellDepends = [
         base binary bytestring containers directory ghc-prim network
         old-locale process random RSA SafeSemaphore time unix
       ];
       homepage = "http://parry.lif.univ-mrs.fr";
       description = "A proven synchronization server for high performance computing";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ParsecTools" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "ParsecTools";
       version = "0.0.2.0";
       sha256 = "ef4843353127aa3e6f6ab0aece9f4245225d375802921e151a1751d797857a87";
       libraryHaskellDepends = [ base parsec ];
       description = "Parsec combinators for more complex objects";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "ParserFunction" = callPackage
    ({ mkDerivation, base, containers, parsec }:
     mkDerivation {
       pname = "ParserFunction";
       version = "0.1.0";
       sha256 = "38f795f1317f8b1af702b6bd210a29d21799797c001e2a462b4b63e65b0d1250";
       libraryHaskellDepends = [ base containers parsec ];
       description = "Parse and evaluate mathematical expressions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "PartialTypeSignatures" = callPackage
    ({ mkDerivation, base, containers, syb, template-haskell }:
     mkDerivation {
       pname = "PartialTypeSignatures";
       version = "0.1.0.1";
       sha256 = "0382fdb6e7f3992acb7a8959f98ed58af96a15a73bae24c556e9acecd80a8011";
       libraryHaskellDepends = [ base containers syb template-haskell ];
       homepage = "http://code.haskell.org/~aavogt/PartialTypeSignatures";
       description = "emulate partial type signatures with template haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "PasswordGenerator" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "PasswordGenerator";
       version = "0.1.0.0";
       sha256 = "fc436e7823fb378cedea25e52715245ecd647995c7066e3c54c189782bf59d8a";
       libraryHaskellDepends = [ base QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/VictorDenisov/PasswordGenerator";
       description = "Simple library for generating passwords";
       license = stdenv.lib.licenses.mit;
     }) {};

  "PastePipe" = callPackage
    ({ mkDerivation, base, cmdargs, HTTP, network, network-uri }:
     mkDerivation {
       pname = "PastePipe";
       version = "1.8";
       sha256 = "9f6a2b7351ef710875195e6e1286ee0e468d39c352d114139a041ced674fee81";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base cmdargs HTTP network network-uri ];
       executableHaskellDepends = [ base cmdargs ];
       homepage = "http://github.com/Fuuzetsu/pastepipe";
       description = "CLI for pasting to lpaste.net";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "Pathfinder" = callPackage
    ({ mkDerivation, base, bytestring, libxml2, text }:
     mkDerivation {
       pname = "Pathfinder";
       version = "0.5.10";
       sha256 = "0ee705ceabee7bcc69bac8ef16a9ebfa2af3c4fb1747927eadcc4d2bc7b968cc";
       libraryHaskellDepends = [ base bytestring text ];
       librarySystemDepends = [ libxml2 ];
       description = "Relational optimiser and code generator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libxml2;};

  "Peano" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Peano";
       version = "0.0.4";
       sha256 = "bf62662a7279aadd5bc1e434dab355fa3e53b2f2c0c702db4a9ce1f900b9446b";
       libraryHaskellDepends = [ base ];
       description = "simple Peano numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "PeanoWitnesses" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "PeanoWitnesses";
       version = "0.1.0.0";
       sha256 = "ef55355140c40adccaa566c214e1d2fb60c3efb539216c1f4134bf21349703bd";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "GADT type witnesses for Peano-style natural numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "PerfectHash" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, cmph, containers
     , digest, time
     }:
     mkDerivation {
       pname = "PerfectHash";
       version = "0.1.4";
       sha256 = "76de68a4acda732bff57a13b6a7855469e9924569206b02eb401498f362d40c2";
       libraryHaskellDepends = [
         array base binary bytestring containers digest time
       ];
       librarySystemDepends = [ cmph ];
       jailbreak = true;
       description = "A perfect hashing library for mapping bytestrings to values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {cmph = null;};

  "PermuteEffects" = callPackage
    ({ mkDerivation, base, ReplicateEffects }:
     mkDerivation {
       pname = "PermuteEffects";
       version = "0.2";
       sha256 = "94f8e7b2b24e48acd8e90a145981af7eb7563fc5ae932282181370bbf0d6b552";
       libraryHaskellDepends = [ base ReplicateEffects ];
       jailbreak = true;
       homepage = "https://github.com/MedeaMelana/PermuteEffects";
       description = "Permutations of effectful computations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Phsu" = callPackage
    ({ mkDerivation, acid-state, aeson, base, blaze-html, blaze-markup
     , containers, curl, filepath, friendly-time, happstack-server
     , happstack-server-tls, lifted-base, MissingH, monad-control, mtl
     , network, network-uri, old-locale, process, regex-base, regex-pcre
     , safecopy, string-conversions, temporary, text, time
     }:
     mkDerivation {
       pname = "Phsu";
       version = "0.1.0.3";
       sha256 = "a913a073fd785e1b8b1adcf515fc4d9727834bb03982374ade7a38df1f86c689";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         acid-state aeson base blaze-html blaze-markup containers curl
         filepath friendly-time happstack-server happstack-server-tls
         lifted-base MissingH monad-control mtl network network-uri
         old-locale process regex-base regex-pcre safecopy
         string-conversions temporary text time
       ];
       jailbreak = true;
       homepage = "localhost:9119";
       description = "Personal Happstack Server Utils";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Pipe" = callPackage
    ({ mkDerivation, base, filepath, process, unix }:
     mkDerivation {
       pname = "Pipe";
       version = "2.1.2";
       sha256 = "19fa8409407d698e57a41b2ec5ef0dda23e5e43628221cb9df89425eaecca390";
       libraryHaskellDepends = [ base filepath process unix ];
       homepage = "http://iki.fi/matti.niemenmaa/pipe/";
       description = "Process piping library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Piso" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "Piso";
       version = "0.1";
       sha256 = "03455602293e88a9860129f0c2825db907257923dabf5fa9684de955b6e27088";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "https://github.com/MedeaMelana/Piso";
       description = "Partial isomorphisms";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "PlayHangmanGame" = callPackage
    ({ mkDerivation, base, containers, directory, mtl, random
     , regex-compat
     }:
     mkDerivation {
       pname = "PlayHangmanGame";
       version = "0.2";
       sha256 = "8ff24efea2b1b2f7125065f75e471337f9813fd86381ff66d900a966beb25b9d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory mtl random regex-compat
       ];
       homepage = "freizl.github.com";
       description = "Play Hangman Game";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "PlayingCards" = callPackage
    ({ mkDerivation, base, HUnit, MonadRandom, QuickCheck
     , random-shuffle
     }:
     mkDerivation {
       pname = "PlayingCards";
       version = "0.3.0.0";
       sha256 = "d35c58dcfb206e6b66bb421bbe1c3a980a16dae2adfcd5fd456c24eb9af104f3";
       libraryHaskellDepends = [
         base HUnit MonadRandom QuickCheck random-shuffle
       ];
       jailbreak = true;
       description = "Playing cards api";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Plot-ho-matic" = callPackage
    ({ mkDerivation, base, bytestring, cairo, cereal, Chart
     , Chart-cairo, containers, data-default-class, generic-accessors
     , glib, gtk3, lens, text, time, transformers, vector
     }:
     mkDerivation {
       pname = "Plot-ho-matic";
       version = "0.9.0.4";
       sha256 = "8f452a320c84cbb6f09670307b57af41c0ec30414440bd4f7155d13d0c28215a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cairo cereal Chart Chart-cairo containers
         data-default-class generic-accessors glib gtk3 lens text time
         transformers vector
       ];
       executableHaskellDepends = [ base containers generic-accessors ];
       description = "Real-time line plotter for generic data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "PlslTools" = callPackage
    ({ mkDerivation, array, base, directory, filepath, haskell98
     , old-locale, old-time, parsec, process, random
     }:
     mkDerivation {
       pname = "PlslTools";
       version = "0.0.2";
       sha256 = "2431e54883239aca764058e71345d20205247b92a90a381f74c992389d0c9ece";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base directory filepath haskell98 old-locale old-time parsec
         process random
       ];
       homepage = "LLayland.wordpress.com";
       description = "So far just a lint like program for PL/SQL. Diff and refactoring tools are planned";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Plural" = callPackage
    ({ mkDerivation, base, containers, regex-tdfa }:
     mkDerivation {
       pname = "Plural";
       version = "0.0.2";
       sha256 = "1c95f7ee047d09a142bc132cd74de22255805a9f39d605b5c5ba1f356fe0ea10";
       libraryHaskellDepends = [ base containers regex-tdfa ];
       description = "Pluralize English words";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "Pollutocracy" = callPackage
    ({ mkDerivation, array, base, clock, GLUT, random }:
     mkDerivation {
       pname = "Pollutocracy";
       version = "1.0";
       sha256 = "908b0a7f8c81ade7a69e3816a6437cad7aa1620e8bad3a07175a39e34808cb0c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base clock GLUT random ];
       description = "An imaginary world";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "PortFusion" = callPackage
    ({ mkDerivation, base, bytestring, network, splice }:
     mkDerivation {
       pname = "PortFusion";
       version = "1.2.1";
       sha256 = "7eef41029de0916d7bcb7eab021535e6c0b16c0e911ffb54ebfbcdf78e2a09d8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bytestring network splice ];
       homepage = "http://fusion.corsis.eu";
       description = "high-performance distributed reverse / forward proxy & tunneling for TCP";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "PortMidi" = callPackage
    ({ mkDerivation, alsaLib, base }:
     mkDerivation {
       pname = "PortMidi";
       version = "0.1.5.2";
       sha256 = "b855a9f3c0b9796e9e8fe00bbfad47fd233e648b31c3443881f4dfa544800276";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ alsaLib ];
       homepage = "http://haskell.org/haskellwiki/PortMidi";
       description = "A binding for PortMedia/PortMidi";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) alsaLib;};

  "PostgreSQL" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "PostgreSQL";
       version = "0.2";
       sha256 = "39f3553a9b1b4bb112890edfd5e4cbcc1ac4d3aa04026018fdff558f981fb85c";
       libraryHaskellDepends = [ base mtl ];
       description = "Thin wrapper over the C postgresql library";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "PrimitiveArray" = callPackage
    ({ mkDerivation, aeson, base, binary, bits, cereal, deepseq
     , hashable, OrderedBits, primitive, QuickCheck, test-framework
     , test-framework-quickcheck2, test-framework-th, vector
     , vector-binary-instances, vector-th-unbox
     }:
     mkDerivation {
       pname = "PrimitiveArray";
       version = "0.7.0.0";
       sha256 = "ecbf084d9167a0184e2e4504157f2e992c0bd9013a5e3c8ff98169492b7d8309";
       libraryHaskellDepends = [
         aeson base binary bits cereal deepseq hashable OrderedBits
         primitive QuickCheck vector vector-binary-instances vector-th-unbox
       ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
         test-framework-th
       ];
       jailbreak = true;
       homepage = "https://github.com/choener/PrimitiveArray";
       description = "Efficient multidimensional arrays";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Printf-TH" = callPackage
    ({ mkDerivation, base, haskell98, pretty, template-haskell }:
     mkDerivation {
       pname = "Printf-TH";
       version = "0.1.1";
       sha256 = "7ddb98d79c320b71c5ffd9f2a0eda2f1898f31ff53ee5f84dfc95c108ada2f58";
       libraryHaskellDepends = [ base haskell98 pretty template-haskell ];
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "PriorityChansConverger" = callPackage
    ({ mkDerivation, base, containers, stm }:
     mkDerivation {
       pname = "PriorityChansConverger";
       version = "0.1";
       sha256 = "410971d9e48f7d9ddd722d1a785e2d0fb62c384f9f12cf7b9f651a9b95f6a808";
       libraryHaskellDepends = [ base containers stm ];
       description = "Read single output from an array of inputs - channels with priorities";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ProbabilityMonads" = callPackage
    ({ mkDerivation, base, MaybeT, MonadRandom, mtl }:
     mkDerivation {
       pname = "ProbabilityMonads";
       version = "0.1.0";
       sha256 = "03fadcd3afd29529f36e5c1d058dec489e0361a0a4cbeb8308e012ec437ab26e";
       libraryHaskellDepends = [ base MaybeT MonadRandom mtl ];
       description = "Probability distribution monads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "PropLogic" = callPackage
    ({ mkDerivation, base, old-time, random }:
     mkDerivation {
       pname = "PropLogic";
       version = "0.9.0.4";
       sha256 = "1e53bd81f90f4068270a1cfc3518a76703b5b40826761177a6f8bd2279ec23bf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base old-time random ];
       executableHaskellDepends = [ base old-time random ];
       homepage = "http://www.bucephalus.org/PropLogic";
       description = "Propositional Logic";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Proper" = callPackage
    ({ mkDerivation, base, containers, HUnit, parsec, syb }:
     mkDerivation {
       pname = "Proper";
       version = "0.5.2.0";
       sha256 = "661e878b8b9372f197fefbda7159a5e45b0b52658843123fca76ac6de1ce1279";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers syb ];
       executableHaskellDepends = [ base containers HUnit parsec syb ];
       homepage = "https://github.com/dillonhuff/Proper";
       description = "An implementation of propositional logic in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ProxN" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "ProxN";
       version = "0.0.1";
       sha256 = "2d3ec242b45f43b7819166ccc38562298823ba4f6ba367aef8f7c2c5e69ba357";
       libraryHaskellDepends = [ base mtl ];
       homepage = "https://github.com/exFalso/ProxN";
       description = "Proximity sets in N dimensions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Pugs" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , control-timeout, directory, filepath, FindBin, hashable
     , hashtables, haskeline, HsParrot, HsSyck, MetaObject, mtl, network
     , parsec, pretty, process, pugs-compat, pugs-DrIFT, random, stm
     , stringtable-atom, text, time, utf8-string
     }:
     mkDerivation {
       pname = "Pugs";
       version = "6.2.13.20150815";
       sha256 = "4251b2e55a384c82c60303c0b703ef12c0916370572ad830649f03f0df27fd70";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base binary bytestring containers control-timeout directory
         filepath FindBin hashable hashtables haskeline HsParrot HsSyck
         MetaObject mtl network parsec pretty process pugs-compat pugs-DrIFT
         random stm stringtable-atom text time utf8-string
       ];
       homepage = "http://pugscode.org/";
       description = "A Perl 6 Implementation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Pup-Events" = callPackage
    ({ mkDerivation, base, Pup-Events-Client, Pup-Events-PQueue
     , Pup-Events-Server
     }:
     mkDerivation {
       pname = "Pup-Events";
       version = "1.0";
       sha256 = "d24bd5cf1a473ee9d8e2aad941b3d1d46957cd1ba79dc0963e0d078c7087f28f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Pup-Events-Client Pup-Events-PQueue Pup-Events-Server
       ];
       executableHaskellDepends = [ base ];
       doHaddock = false;
       description = "A networked event handling framework for hooking into other programs";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "Pup-Events-Client" = callPackage
    ({ mkDerivation, base, network, parsec, Pup-Events-PQueue, stm
     , transformers
     }:
     mkDerivation {
       pname = "Pup-Events-Client";
       version = "1.1.4";
       sha256 = "7577018493e23b02c53d062e0905c4ff49916a0d50da2084ca67fa30ad9cdbac";
       libraryHaskellDepends = [
         base network parsec Pup-Events-PQueue stm transformers
       ];
       description = "A networked event handling framework for hooking into other programs";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "Pup-Events-Demo" = callPackage
    ({ mkDerivation, base, GLUT, OpenGL, parsec, Pup-Events-Client
     , Pup-Events-PQueue, Pup-Events-Server, stm
     }:
     mkDerivation {
       pname = "Pup-Events-Demo";
       version = "1.3";
       sha256 = "ab77f85722035512e59a6a150c461851ac56fd09b23227eab45355c5180a8e19";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base GLUT OpenGL parsec Pup-Events-Client Pup-Events-PQueue
         Pup-Events-Server stm
       ];
       description = "A networked event handling framework for hooking into other programs";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Pup-Events-PQueue" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "Pup-Events-PQueue";
       version = "1.0";
       sha256 = "9dc77106f3eb2bccc96d29ecc24a40a7883d431f160a2d0a717116f93b8ecf6a";
       libraryHaskellDepends = [ base stm ];
       description = "A networked event handling framework for hooking into other programs";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "Pup-Events-Server" = callPackage
    ({ mkDerivation, base, network, parsec, Pup-Events-PQueue, stm
     , transformers
     }:
     mkDerivation {
       pname = "Pup-Events-Server";
       version = "1.2";
       sha256 = "b6011465718ff007796ca124331a84ffafae585cb72c4f763363f4cde15fc4a2";
       libraryHaskellDepends = [
         base network parsec Pup-Events-PQueue stm transformers
       ];
       description = "A networked event handling framework for hooking into other programs";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "QIO" = callPackage
    ({ mkDerivation, base, containers, mtl, old-time, random }:
     mkDerivation {
       pname = "QIO";
       version = "1.2";
       sha256 = "a6c35c08c698137e2923a1e5d5877d0349f75711d6119fcb68eb395b72b1a0f2";
       libraryHaskellDepends = [ base containers mtl old-time random ];
       homepage = "http://www.cs.nott.ac.uk/~asg/QIO/";
       description = "The Quantum IO Monad is a library for defining quantum computations in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "QuadEdge" = callPackage
    ({ mkDerivation, base, random, vector }:
     mkDerivation {
       pname = "QuadEdge";
       version = "0.2";
       sha256 = "67800f1b75c3f1c21bbf537e24caac20d0c78b96560bdc055013ad1b11eb7cb8";
       libraryHaskellDepends = [ base random vector ];
       description = "QuadEdge structure for representing triangulations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "QuadTree" = callPackage
    ({ mkDerivation, base, composition, lens, QuickCheck }:
     mkDerivation {
       pname = "QuadTree";
       version = "0.11.0";
       sha256 = "ce22be7f089d90babe9e46217cc99cb5da0c7771739423e7c6cec3b94da294e2";
       libraryHaskellDepends = [ base composition lens ];
       testHaskellDepends = [ base composition lens QuickCheck ];
       jailbreak = true;
       description = "QuadTree library for Haskell, with lens support";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "QuasiText" = callPackage
    ({ mkDerivation, attoparsec, base, haskell-src-meta
     , template-haskell, text
     }:
     mkDerivation {
       pname = "QuasiText";
       version = "0.1.2.5";
       sha256 = "9d2f0bd7dc6ea710475f8e1a0c67dd5d080623bd00777c484dd0f77c73a4c283";
       libraryHaskellDepends = [
         attoparsec base haskell-src-meta template-haskell text
       ];
       homepage = "https://github.com/mikeplus64/QuasiText";
       description = "A QuasiQuoter for Text";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Quelea" = callPackage
    ({ mkDerivation, base, bytestring, cassandra-cql, cereal
     , containers, derive, directory, lens, mtl, optparse-applicative
     , process, random, template-haskell, text, time, transformers
     , tuple, unix, uuid, z3, zeromq4-haskell
     }:
     mkDerivation {
       pname = "Quelea";
       version = "1.0.0";
       sha256 = "b30b6516160a7d3ab9db3c1341b69c35f0a9230ac23bb819a7b42be48a67d7e3";
       libraryHaskellDepends = [
         base bytestring cassandra-cql cereal containers derive directory
         lens mtl optparse-applicative process random template-haskell text
         time transformers tuple unix uuid z3 zeromq4-haskell
       ];
       homepage = "http://gowthamk.github.io/Quelea";
       description = "Programming with Eventual Consistency over Cassandra";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "QuickAnnotate" = callPackage
    ({ mkDerivation, base, haskell-src-exts }:
     mkDerivation {
       pname = "QuickAnnotate";
       version = "0.6";
       sha256 = "6bb7e18367dff603fa099ad53fc34efce3b892dba5acd0ead1ae3fa372a4f076";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base haskell-src-exts ];
       jailbreak = true;
       homepage = "http://code.haskell.org/QuickAnnotate/";
       description = "Annotation Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "QuickCheck_1_2_0_1" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "QuickCheck";
       version = "1.2.0.1";
       sha256 = "8daee0117004a5c8962092a1eadfafc31f86d1b37fb15f5619962c05d8dab7bf";
       revision = "2";
       editedCabalFile = "8f06f07cae74e90cd5bdde3eed23b0e3293ad494f42f0f0cb77074fa3b7950d9";
       libraryHaskellDepends = [ base random ];
       jailbreak = true;
       homepage = "http://www.math.chalmers.se/~rjmh/QuickCheck/";
       description = "Automatic testing of Haskell programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "QuickCheck_2_7_6" = callPackage
    ({ mkDerivation, base, random, template-haskell, test-framework
     , tf-random, transformers
     }:
     mkDerivation {
       pname = "QuickCheck";
       version = "2.7.6";
       sha256 = "80d8970a0c1dfcb714215cf11f2bf0f79339f70c01999dae2c31516100a0c527";
       revision = "1";
       editedCabalFile = "45ff46338dca0616041adade28d6b49d6a3ea810ba5dff619b2abdcbe7c93035";
       libraryHaskellDepends = [
         base random template-haskell tf-random transformers
       ];
       testHaskellDepends = [ base template-haskell test-framework ];
       jailbreak = true;
       homepage = "https://github.com/nick8325/quickcheck";
       description = "Automatic testing of Haskell programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "QuickCheck_2_8_1" = callPackage
    ({ mkDerivation, base, containers, random, template-haskell
     , test-framework, tf-random, transformers
     }:
     mkDerivation {
       pname = "QuickCheck";
       version = "2.8.1";
       sha256 = "7073aa3635660476aa31df7cf0476926a1ac0231235020122eb276070675763b";
       revision = "1";
       editedCabalFile = "f8c84fee9ea7efc5d033cde7e4cd2ade67a30bb832f08e62394353481e16b4b7";
       libraryHaskellDepends = [
         base containers random template-haskell tf-random transformers
       ];
       testHaskellDepends = [
         base containers template-haskell test-framework
       ];
       jailbreak = true;
       homepage = "https://github.com/nick8325/quickcheck";
       description = "Automatic testing of Haskell programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "QuickCheck" = callPackage
    ({ mkDerivation, base, containers, random, template-haskell
     , test-framework, tf-random, transformers
     }:
     mkDerivation {
       pname = "QuickCheck";
       version = "2.8.2";
       sha256 = "98c64de1e2dbf801c54dcdcb8ddc33b3569e0da38b39d711ee6ac505769926aa";
       libraryHaskellDepends = [
         base containers random template-haskell tf-random transformers
       ];
       testHaskellDepends = [
         base containers template-haskell test-framework
       ];
       homepage = "https://github.com/nick8325/quickcheck";
       description = "Automatic testing of Haskell programs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "QuickCheck-GenT" = callPackage
    ({ mkDerivation, base, mtl, QuickCheck, random }:
     mkDerivation {
       pname = "QuickCheck-GenT";
       version = "0.1.4";
       sha256 = "fdfc66a8d416b1c64c95b409552813f239c85bc829527759350f60956fb8fa1f";
       libraryHaskellDepends = [ base mtl QuickCheck random ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/QuickCheck-GenT";
       description = "A GenT monad transformer for QuickCheck library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "QuickCheck-safe" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "QuickCheck-safe";
       version = "0.1.0.1";
       sha256 = "874d16e6bcd6da551c3efcf8f91aeea97a935a7a2086f78dab6991806c68b867";
       revision = "3";
       editedCabalFile = "4e791ac9fa2f2e73029ab92d17e3ab93571ec5b1d5acda0ea1f340c5ee1346f6";
       libraryHaskellDepends = [ base QuickCheck ];
       description = "Safe reimplementation of QuickCheck's core";
       license = stdenv.lib.licenses.mit;
     }) {};

  "QuickPlot" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , haskell-src-meta, parsec, scientific, snap, snap-core
     , template-haskell, text, vector, websockets, websockets-snap
     }:
     mkDerivation {
       pname = "QuickPlot";
       version = "0.1.0.1";
       sha256 = "02864cb2f1abcea25b5956421cfdd596c3b4d3ceafcd54d3aad26f443ba53fb5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring haskell-src-meta parsec scientific
         snap snap-core template-haskell text vector websockets
         websockets-snap
       ];
       homepage = "http://github.com/tepf/QuickPlot#readme";
       description = "Quick and easy data visualization with Haskell";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "Quickson" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, either, text
     }:
     mkDerivation {
       pname = "Quickson";
       version = "0.2";
       sha256 = "6f517503074bce301373c260d0feb3c42d2c04e0869a49d7baac732a198d28d7";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either text
       ];
       homepage = "https://github.com/ssadler/quickson";
       description = "Quick JSON extractions with Aeson";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "R-pandoc" = callPackage
    ({ mkDerivation, base, directory, filepath, pandoc-types, process
     , split
     }:
     mkDerivation {
       pname = "R-pandoc";
       version = "0.2.1";
       sha256 = "57f08dfd05b50b9961ad4427fa6925d3a388618d73b41df7bee095b8349cbbd3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory filepath pandoc-types process split
       ];
       executableHaskellDepends = [ base pandoc-types ];
       jailbreak = true;
       description = "A pandoc filter to express R plots inside markdown";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "RANSAC" = callPackage
    ({ mkDerivation, base, HUnit, lens, linear, random, test-framework
     , test-framework-hunit, vector
     }:
     mkDerivation {
       pname = "RANSAC";
       version = "0.1.0.2";
       sha256 = "f8950593e10356339951a41d5331db83fcb41e8d2bb7b26a36d37140ae0367e7";
       libraryHaskellDepends = [ base random vector ];
       testHaskellDepends = [
         base HUnit lens linear test-framework test-framework-hunit vector
       ];
       description = "The RANSAC algorithm for parameter estimation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "RBTree" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "RBTree";
       version = "0.0.5";
       sha256 = "3873669ec394e570ebdb76682d60fb4713aa15719d5ff425eeab475a4058865c";
       libraryHaskellDepends = [ base ];
       homepage = "git://github.com/wuxb45/Haskell-RBTree.git";
       description = "Pure haskell Red-Black-Tree implemetation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "RESTng" = callPackage
    ({ mkDerivation, base, HDBC, HDBC-postgresql, mtl, old-time, parsec
     , redHandlers, xhtml, yuiGrid
     }:
     mkDerivation {
       pname = "RESTng";
       version = "0.1";
       sha256 = "52113fbc7974f3c25e6e8c1c447d5b88ea6001091cb5ce921d238e653fd056b9";
       libraryHaskellDepends = [
         base HDBC HDBC-postgresql mtl old-time parsec redHandlers xhtml
         yuiGrid
       ];
       jailbreak = true;
       description = "A framework for writing RESTful applications";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "RFC1751" = callPackage
    ({ mkDerivation, base, binary, bytestring, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , vector
     }:
     mkDerivation {
       pname = "RFC1751";
       version = "0.3.1.0";
       sha256 = "d19f8c3020e76c45343a746442efbeabc7e60a80d1fdf8a11e5c29723d4937c8";
       libraryHaskellDepends = [ base binary bytestring vector ];
       testHaskellDepends = [
         base binary bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 vector
       ];
       homepage = "https://github.com/xenog/RFC1751";
       description = "RFC-1751 library for Haskell";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "RJson" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, iconv, mtl
     , parsec, syb-with-class
     }:
     mkDerivation {
       pname = "RJson";
       version = "0.3.7";
       sha256 = "367489f04afa9704342939a23c30e1a54eaa89edc3c75e8c8f94b4193d837413";
       libraryHaskellDepends = [
         array base bytestring containers iconv mtl parsec syb-with-class
       ];
       description = "A reflective JSON serializer/parser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "RMP" = callPackage
    ({ mkDerivation, allocated-processor, base, canlib, cv-combinators
     , ftd2xx, HOpenCV, vector-space
     }:
     mkDerivation {
       pname = "RMP";
       version = "0.0.2";
       sha256 = "5ea196839f6e0d0cb6ec5fff637dbf841617d3ec3305295b349798f311a7912d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ allocated-processor base ];
       librarySystemDepends = [ canlib ftd2xx ];
       executableHaskellDepends = [
         allocated-processor base cv-combinators HOpenCV vector-space
       ];
       executableSystemDepends = [ canlib ftd2xx ];
       description = "Binding to code that controls a Segway RMP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {canlib = null; ftd2xx = null;};

  "RNAFold" = callPackage
    ({ mkDerivation, ADPfusion, base, BiobaseTurner, BiobaseVienna
     , BiobaseXNA, cmdargs, containers, deepseq, lens, primitive
     , PrimitiveArray, repa, strict, vector
     }:
     mkDerivation {
       pname = "RNAFold";
       version = "1.99.3.4";
       sha256 = "26d522483e5f7e17fe6798911a53c6237315ea53457b7b1def22b76c63269e64";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ADPfusion base BiobaseTurner BiobaseVienna BiobaseXNA cmdargs
         containers deepseq lens primitive PrimitiveArray repa strict vector
       ];
       executableHaskellDepends = [
         base BiobaseTurner BiobaseVienna BiobaseXNA cmdargs
       ];
       homepage = "http://www.tbi.univie.ac.at/~choener/adpfusion";
       description = "RNA secondary structure prediction";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "RNAFoldProgs" = callPackage
    ({ mkDerivation, base, Biobase, BiobaseTurner, BiobaseTypes
     , BiobaseVienna, cmdargs, containers, HsTools, primitive
     , PrimitiveArray, RNAFold, split, vector
     }:
     mkDerivation {
       pname = "RNAFoldProgs";
       version = "0.0.0.3";
       sha256 = "97539e46522664e6aa92fa5a3d06d5f82f1659cc5178fb25ee874307505dbeae";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Biobase BiobaseTurner BiobaseTypes BiobaseVienna cmdargs
         containers HsTools primitive PrimitiveArray RNAFold split vector
       ];
       jailbreak = true;
       description = "RNA secondary structure folding";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "RNAdesign" = callPackage
    ({ mkDerivation, array, base, BiobaseTurner, BiobaseVienna
     , BiobaseXNA, bytestring, cmdargs, containers, fgl
     , fgl-extras-decompositions, file-embed, lens, monad-primitive
     , mwc-random-monad, parallel, parsec, ParsecTools, primitive
     , PrimitiveArray, random, RNAFold, transformers, tuple, vector
     , ViennaRNA-bindings
     }:
     mkDerivation {
       pname = "RNAdesign";
       version = "0.1.2.2";
       sha256 = "4f955d9cbc1a12b90f60779a9626d27a2e0d3bd48ae453c94900cee6235faee1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base BiobaseTurner BiobaseVienna BiobaseXNA containers fgl
         fgl-extras-decompositions lens monad-primitive mwc-random-monad
         parallel parsec ParsecTools primitive PrimitiveArray random RNAFold
         transformers tuple vector ViennaRNA-bindings
       ];
       executableHaskellDepends = [ bytestring cmdargs file-embed ];
       description = "Multi-target RNA sequence design";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "RNAdraw" = callPackage
    ({ mkDerivation, array, base, BiobaseXNA, bytestring, cmdargs
     , containers, PrimitiveArray, QuasiText, repa, split, text, vector
     }:
     mkDerivation {
       pname = "RNAdraw";
       version = "0.2.0.1";
       sha256 = "bd0903068505a4252e92d49d89fd3a8e0a495183c5faef86b05a2c02f4a505b5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base BiobaseXNA bytestring containers PrimitiveArray
         QuasiText repa split text vector
       ];
       executableHaskellDepends = [ cmdargs ];
       homepage = "http://www.tbi.univie.ac.at/~choener/";
       description = "Draw RNA secondary structures";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "RNAlien_1_0_0" = callPackage
    ({ mkDerivation, base, biocore, biofasta, BlastHTTP, blastxml
     , bytestring, cassava, ClustalParser, cmdargs, containers
     , directory, edit-distance, either-unwrap, EntrezHTTP, filepath
     , hierarchical-clustering, HTTP, matrix, parsec, process, random
     , split, Taxonomy, time, vector, ViennaRNAParser
     }:
     mkDerivation {
       pname = "RNAlien";
       version = "1.0.0";
       sha256 = "5d621c19cf3a27cc29a2d80de97d9434b861799d87f743f25878771f907954c3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base biocore biofasta BlastHTTP blastxml bytestring cassava
         ClustalParser cmdargs containers directory edit-distance
         either-unwrap EntrezHTTP filepath hierarchical-clustering HTTP
         matrix parsec process random split Taxonomy vector ViennaRNAParser
       ];
       executableHaskellDepends = [
         base biocore biofasta bytestring cassava cmdargs containers
         directory either-unwrap filepath process random split time vector
         ViennaRNAParser
       ];
       description = "Unsupervized construction of RNA family models";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "RNAlien" = callPackage
    ({ mkDerivation, aeson, base, biocore, biofasta, BlastHTTP
     , blastxml, bytestring, cassava, ClustalParser, cmdargs, containers
     , directory, edit-distance, either-unwrap, EntrezHTTP, filepath
     , hierarchical-clustering, HTTP, http-conduit, hxt, matrix, network
     , parsec, process, pureMD5, random, split, Taxonomy, text, time
     , transformers, vector, ViennaRNAParser
     }:
     mkDerivation {
       pname = "RNAlien";
       version = "1.1.0";
       sha256 = "450d898235dadc7879eef1bb025713b7d55e8a271332760d8d744b4deb9636d8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base biocore biofasta BlastHTTP blastxml bytestring cassava
         ClustalParser cmdargs containers directory edit-distance
         either-unwrap EntrezHTTP filepath hierarchical-clustering HTTP
         http-conduit hxt matrix network parsec process pureMD5 random
         Taxonomy text transformers vector ViennaRNAParser
       ];
       executableHaskellDepends = [
         base biocore biofasta bytestring cassava cmdargs containers
         directory either-unwrap filepath process random split time vector
         ViennaRNAParser
       ];
       description = "Unsupervized construction of RNA family models";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "RNAwolf" = callPackage
    ({ mkDerivation, base, BiobaseTrainingData, BiobaseXNA, bytestring
     , cmdargs, containers, deepseq, directory, parallel, PrimitiveArray
     , random, split, StatisticalMethods, vector
     }:
     mkDerivation {
       pname = "RNAwolf";
       version = "0.4.0.0";
       sha256 = "7603e38d6938a086780d93f8509d80bfb9501649d31263c9a3ef9180d0a3f1e8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base BiobaseTrainingData BiobaseXNA bytestring containers deepseq
         directory parallel PrimitiveArray random StatisticalMethods vector
       ];
       executableHaskellDepends = [ cmdargs split ];
       jailbreak = true;
       homepage = "http://www.tbi.univie.ac.at/software/rnawolf/";
       description = "RNA folding with non-canonical basepairs and base-triplets";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "RSA_2_1_0_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, crypto-api
     , crypto-pubkey-types, DRBG, pureMD5, QuickCheck, SHA, tagged
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "RSA";
       version = "2.1.0.1";
       sha256 = "1b02096acd61e7fa477ca062773d47b7872e110cab594372699f8cba0632e454";
       libraryHaskellDepends = [
         base binary bytestring crypto-api crypto-pubkey-types pureMD5 SHA
       ];
       testHaskellDepends = [
         base binary bytestring crypto-api crypto-pubkey-types DRBG pureMD5
         QuickCheck SHA tagged test-framework test-framework-quickcheck2
       ];
       description = "Implementation of RSA, using the padding schemes of PKCS#1 v2.1.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "RSA_2_1_0_3" = callPackage
    ({ mkDerivation, base, binary, bytestring, crypto-api
     , crypto-pubkey-types, DRBG, pureMD5, QuickCheck, SHA, tagged
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "RSA";
       version = "2.1.0.3";
       sha256 = "3227c31d00ba0bb1713bdfa7ba2f8e186b6f5d3a0c518a9884ad168cb6d9364a";
       libraryHaskellDepends = [
         base binary bytestring crypto-api crypto-pubkey-types pureMD5 SHA
       ];
       testHaskellDepends = [
         base binary bytestring crypto-api crypto-pubkey-types DRBG pureMD5
         QuickCheck SHA tagged test-framework test-framework-quickcheck2
       ];
       description = "Implementation of RSA, using the padding schemes of PKCS#1 v2.1.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "RSA" = callPackage
    ({ mkDerivation, base, binary, bytestring, crypto-api
     , crypto-pubkey-types, DRBG, pureMD5, QuickCheck, SHA, tagged
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "RSA";
       version = "2.2.0";
       sha256 = "293056d43352716d7f9501aac7ac9871c338f00d40c97a54c927a798f8a4f2d7";
       libraryHaskellDepends = [
         base binary bytestring crypto-api crypto-pubkey-types pureMD5 SHA
       ];
       testHaskellDepends = [
         base binary bytestring crypto-api crypto-pubkey-types DRBG pureMD5
         QuickCheck SHA tagged test-framework test-framework-quickcheck2
       ];
       description = "Implementation of RSA, using the padding schemes of PKCS#1 v2.1.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Raincat" = callPackage
    ({ mkDerivation, base, containers, extensible-exceptions, GLUT, mtl
     , OpenGL, random, SDL, SDL-image, SDL-mixer, time
     }:
     mkDerivation {
       pname = "Raincat";
       version = "1.1.1.3";
       sha256 = "28abdf5df4d4654aee515f0629bab153163af5fd603cbfc9ae291d03918154a9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers extensible-exceptions GLUT mtl OpenGL random SDL
         SDL-image SDL-mixer time
       ];
       homepage = "http://raincat.bysusanlin.com/";
       description = "A puzzle game written in Haskell with a cat in lead role";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "Random123" = callPackage
    ({ mkDerivation, array, base, data-dword, HUnit, QuickCheck, random
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "Random123";
       version = "0.2.0";
       sha256 = "c4633bc61f2178931cf8f25cb16bb3f760d57060d7c50882bcfe2a3c8cb306a3";
       libraryHaskellDepends = [ array base data-dword random ];
       testHaskellDepends = [
         base HUnit QuickCheck random test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       homepage = "http://github.com/Manticore/haskell-random123";
       description = "Haskell port of Random123 library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "RandomDotOrg" = callPackage
    ({ mkDerivation, base, HTTP-Simple, network }:
     mkDerivation {
       pname = "RandomDotOrg";
       version = "0.2.1";
       sha256 = "8cf82860c1f3d5cd1a04cd654f2b76bd0dc3fefe38ac1337df5b732288cdca65";
       libraryHaskellDepends = [ base HTTP-Simple network ];
       description = "Interface to random.org";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Randometer" = callPackage
    ({ mkDerivation, base, random-fu }:
     mkDerivation {
       pname = "Randometer";
       version = "0.1.0.1";
       sha256 = "e6d9cf2b9d6db8ff279ff0813c5e9b4d19bc697fbe3979233480becb8449d2aa";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base random-fu ];
       homepage = "http://github.com/Soares/Randometer.hs";
       description = "Randomness intuition trainer";
       license = stdenv.lib.licenses.mit;
     }) {};

  "Range" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Range";
       version = "0.1.0.0";
       sha256 = "10e7ee42c0e9670e13fdc955ebbbe6afc5532fd6a664291352eb97a31128a91c";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Data structure for managing ranges";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Ranged-sets" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck }:
     mkDerivation {
       pname = "Ranged-sets";
       version = "0.3.0";
       sha256 = "14a0913c91f2c1e44aec0c042afb05f518d9fe718ecc34bd3ad6473f9aa6a0aa";
       libraryHaskellDepends = [ base HUnit QuickCheck ];
       homepage = "http://code.haskell.org/ranged-sets";
       description = "Ranged sets for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Ranka" = callPackage
    ({ mkDerivation, base, HTTP, json, network, utf8-string, XMPP }:
     mkDerivation {
       pname = "Ranka";
       version = "0.1";
       sha256 = "3960114faec46cc14faf80856b8fba9cd7e6a701e9bdc19e5ab2c9200208c0b5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base HTTP json network utf8-string XMPP
       ];
       homepage = "http://kagami.touhou.ru/projects/show/ranka";
       description = "HTTP to XMPP omegle chats gate";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Rasenschach" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, containers
     , convertible, directory, filepath, ghc, GLUT, monad-loops, OpenGL
     , OpenGLRaw, time, Yampa
     }:
     mkDerivation {
       pname = "Rasenschach";
       version = "0.1.3.1";
       sha256 = "a73c29528685248d266404daa4a92fcd3bd2f1e0442db39982989a213e652079";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring cereal containers convertible directory
         filepath ghc GLUT monad-loops OpenGL OpenGLRaw time Yampa
       ];
       homepage = "http://hub.darcs.net/martingw/Rasenschach";
       description = "Soccer simulation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Rasterific_0_4" = callPackage
    ({ mkDerivation, base, binary, criterion, deepseq, directory, dlist
     , filepath, FontyFruity, free, JuicyPixels, mtl, primitive
     , QuickCheck, statistics, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "Rasterific";
       version = "0.4";
       sha256 = "7f6c8804ef1f79496f4f09466f9b0ba74d00cbf58a6437071f9aa5dba9a288b3";
       libraryHaskellDepends = [
         base dlist FontyFruity free JuicyPixels mtl primitive vector
         vector-algorithms
       ];
       testHaskellDepends = [
         base binary criterion deepseq directory filepath FontyFruity
         JuicyPixels QuickCheck statistics vector
       ];
       jailbreak = true;
       doCheck = false;
       description = "A pure haskell drawing engine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Rasterific_0_4_1" = callPackage
    ({ mkDerivation, base, binary, criterion, deepseq, directory, dlist
     , filepath, FontyFruity, free, JuicyPixels, mtl, primitive
     , QuickCheck, statistics, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "Rasterific";
       version = "0.4.1";
       sha256 = "dcc32615911b8e2fe5331374ece145f1fc2ceaebf5f3726985b29c61b3f1fc68";
       libraryHaskellDepends = [
         base dlist FontyFruity free JuicyPixels mtl primitive vector
         vector-algorithms
       ];
       testHaskellDepends = [
         base binary criterion deepseq directory filepath FontyFruity
         JuicyPixels QuickCheck statistics vector
       ];
       jailbreak = true;
       doCheck = false;
       description = "A pure haskell drawing engine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Rasterific_0_4_2" = callPackage
    ({ mkDerivation, base, binary, criterion, deepseq, directory, dlist
     , filepath, FontyFruity, free, JuicyPixels, mtl, primitive
     , QuickCheck, statistics, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "Rasterific";
       version = "0.4.2";
       sha256 = "03536eca670dee35c7eb199f38fbe8338e2c6ca3a993685dcb3b6704a3e97451";
       libraryHaskellDepends = [
         base dlist FontyFruity free JuicyPixels mtl primitive vector
         vector-algorithms
       ];
       testHaskellDepends = [
         base binary criterion deepseq directory filepath FontyFruity
         JuicyPixels QuickCheck statistics vector
       ];
       jailbreak = true;
       doCheck = false;
       description = "A pure haskell drawing engine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Rasterific_0_5_1" = callPackage
    ({ mkDerivation, base, dlist, FontyFruity, free, JuicyPixels, mtl
     , primitive, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "Rasterific";
       version = "0.5.1";
       sha256 = "82be810dfca56ac7c95283cad9acccfcae2a4c292c67b034b102803cfb737ac0";
       libraryHaskellDepends = [
         base dlist FontyFruity free JuicyPixels mtl primitive vector
         vector-algorithms
       ];
       doCheck = false;
       description = "A pure haskell drawing engine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Rasterific_0_5_2_1" = callPackage
    ({ mkDerivation, base, dlist, FontyFruity, free, JuicyPixels, mtl
     , primitive, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "Rasterific";
       version = "0.5.2.1";
       sha256 = "42112877d158244a2a8eb61bcc5d54457bbab22f2b56e1a49663abbb0915a1f1";
       libraryHaskellDepends = [
         base dlist FontyFruity free JuicyPixels mtl primitive vector
         vector-algorithms
       ];
       doCheck = false;
       description = "A pure haskell drawing engine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Rasterific" = callPackage
    ({ mkDerivation, base, bytestring, containers, dlist, FontyFruity
     , free, JuicyPixels, mtl, primitive, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "Rasterific";
       version = "0.6.1";
       sha256 = "35136b8c7d8447b802fb3d9cbd5d2bc3ef939605ac43aa9cb00d54a5626432f9";
       libraryHaskellDepends = [
         base bytestring containers dlist FontyFruity free JuicyPixels mtl
         primitive vector vector-algorithms
       ];
       doCheck = false;
       description = "A pure haskell drawing engine";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ReadArgs" = callPackage
    ({ mkDerivation, base, hspec, system-filepath, text }:
     mkDerivation {
       pname = "ReadArgs";
       version = "1.2.2";
       sha256 = "47a1a21621a45a960f516393c1e7c5d33a7d840db0f7eff20d43e6fc7fc9deec";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base system-filepath text ];
       executableHaskellDepends = [ base system-filepath text ];
       testHaskellDepends = [ base hspec system-filepath text ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/rampion/ReadArgs";
       description = "Simple command line argument parsing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Redmine" = callPackage
    ({ mkDerivation, aeson, base, bytestring, connection, containers
     , HTTP, http-client-tls, http-conduit, http-types, HUnit, MissingH
     , network, old-locale, old-time, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "Redmine";
       version = "0.0.6";
       sha256 = "e81f23501fc58456db77b9797a196200f20a81013da3b8f89fdffbf1214d9882";
       libraryHaskellDepends = [
         aeson base bytestring connection containers HTTP http-client-tls
         http-conduit http-types MissingH network old-locale old-time
         resourcet text time transformers
       ];
       testHaskellDepends = [
         aeson base bytestring connection containers http-client-tls
         http-conduit HUnit MissingH network old-locale resourcet text time
         transformers
       ];
       homepage = "https://github.com/lookunder/RedmineHs";
       description = "Library to access Redmine's REST services";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Ref" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "Ref";
       version = "0.1.1.0";
       sha256 = "15920fe1123d96b8717710e170d4095fe9fca1de0a4e6d045b6a35bfe49a1197";
       libraryHaskellDepends = [ base ghc-prim ];
       jailbreak = true;
       homepage = "https://bitbucket.org/carter/ref";
       description = "Generic Mutable Ref Abstraction Layer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "RefSerialize_0_3_1_3" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, hashtables
     , stringsearch
     }:
     mkDerivation {
       pname = "RefSerialize";
       version = "0.3.1.3";
       sha256 = "354b0722db9ad9e94351873ccc2bc34f1c99254da177128f97fb561d25502c63";
       libraryHaskellDepends = [
         base binary bytestring containers hashtables stringsearch
       ];
       description = "Write to and read from ByteStrings maintaining internal memory references";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "RefSerialize" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, hashtables
     , stringsearch
     }:
     mkDerivation {
       pname = "RefSerialize";
       version = "0.3.1.4";
       sha256 = "dc38719d34a5e238dc7cda731f49a5367fc5a0bf7d4b1db44be5e2ac5a9781c2";
       libraryHaskellDepends = [
         base binary bytestring containers hashtables stringsearch
       ];
       description = "Write to and read from ByteStrings maintaining internal memory references";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Referees" = callPackage
    ({ mkDerivation, base, bytestring, cassava, cmdargs, cond
     , containers, directory, glpk-hs, matrix, MissingH, vector
     }:
     mkDerivation {
       pname = "Referees";
       version = "0.0.0";
       sha256 = "f9407b81a917b01d3d89d34ebbbd319c07a5f4742fe9d5c0224d96428a50d71c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cassava containers glpk-hs matrix MissingH vector
       ];
       executableHaskellDepends = [
         base cmdargs cond containers directory
       ];
       jailbreak = true;
       homepage = "https://github.com/pablocouto/Referees";
       description = "A utility for computing distributions of material to review among reviewers";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "RepLib" = callPackage
    ({ mkDerivation, base, containers, mtl, template-haskell
     , transformers
     }:
     mkDerivation {
       pname = "RepLib";
       version = "0.5.3.5";
       sha256 = "05c21fdaf2d09a44ffdb4d4f02a3b9a282dd5b5542ecc3e71222d31228644550";
       libraryHaskellDepends = [
         base containers mtl template-haskell transformers
       ];
       homepage = "https://github.com/sweirich/replib";
       description = "Generic programming library with representation types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ReplicateEffects" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ReplicateEffects";
       version = "0.3";
       sha256 = "4794e0eee76ea15e2090f2dd0dc6171144f8affae91bc8ae68e31597975d96a4";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/MedeaMelana/ReplicateEffects";
       description = "Composable replication schemes of applicative functors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ReviewBoard" = callPackage
    ({ mkDerivation, base, directory, HTTP, json, mtl, network, process
     , random
     }:
     mkDerivation {
       pname = "ReviewBoard";
       version = "0.2.2";
       sha256 = "e54852f764d3a2b13d5a19ab6bfe454dfc705cf8ec06fc5bbf4f781aebd12cbf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base HTTP json mtl network random ];
       executableHaskellDepends = [
         base directory HTTP json mtl network process random
       ];
       description = "Haskell bindings to ReviewBoard";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "RichConditional" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "RichConditional";
       version = "0.1.0.0";
       sha256 = "5caa6c1b74782a5ed2f1d43d389a6a56c92e343c3e1437a95226e4c227a3b718";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/avieth/RichConditional";
       description = "Tiny library to replace classic if/else";
       license = stdenv.lib.licenses.mit;
     }) {};

  "Rlang-QQ" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, Cabal, containers
     , data-binary-ieee754, directory, doctest, filepath
     , haskell-src-meta, HList, hspec, lens, mtl, process, repa, SHA
     , split, syb, template-haskell, temporary, text, transformers
     , trifecta, utf8-string, vector, zlib
     }:
     mkDerivation {
       pname = "Rlang-QQ";
       version = "0.3.1.0";
       sha256 = "121e05ebb444c85fc4ad2b1cdeac4f7b140a5604c48b11cedc88b97d72658366";
       libraryHaskellDepends = [
         array base binary bytestring Cabal containers data-binary-ieee754
         directory filepath haskell-src-meta HList lens mtl process repa SHA
         split syb template-haskell temporary text transformers trifecta
         utf8-string vector zlib
       ];
       testHaskellDepends = [ base directory doctest hspec lens vector ];
       doCheck = false;
       homepage = "http://code.haskell.org/~aavogt/Rlang-QQ";
       description = "quasiquoter for inline-R code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "RollingDirectory" = callPackage
    ({ mkDerivation, base, directory, filepath, hdaemonize-buildfix
     , hinotify, hsyslog, HUnit, monad-parallel, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , unix
     }:
     mkDerivation {
       pname = "RollingDirectory";
       version = "0.1";
       sha256 = "9bf4be9099226cb3445c6cde7a801ba9d152fd1e9b95f36c39f7a29d52838457";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath hdaemonize-buildfix hinotify hsyslog
         monad-parallel unix
       ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       description = "Limits the size of a directory's contents";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "RoyalMonad" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "RoyalMonad";
       version = "1000.9";
       sha256 = "99bf6ccf65077396f305d18993c23ab8acb85fc38e2bed82638bc4918ee13dbe";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/atzeus/RoyalMonad";
       description = "All hail the Royal Monad!";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "RxHaskell" = callPackage
    ({ mkDerivation, base, containers, stm, transformers }:
     mkDerivation {
       pname = "RxHaskell";
       version = "0.2";
       sha256 = "740f96baaf41bccfdb51f5a2cdded0d6dc584a9e55becb4cfe9be476e7d69d5f";
       libraryHaskellDepends = [ base containers stm transformers ];
       homepage = "https://github.com/jspahrsummers/RxHaskell";
       description = "Reactive Extensions for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SBench" = callPackage
    ({ mkDerivation, base, bytestring, cassava, criterion, deepseq
     , directory, filepath, gnuplot, hp2any-core, parsec, process
     , utf8-string, vector
     }:
     mkDerivation {
       pname = "SBench";
       version = "0.2.0";
       sha256 = "554568a9ed1cc6be2ff7d08996b18f6ee3f5653391ef078b190005cb79c3a97a";
       libraryHaskellDepends = [
         base bytestring cassava criterion deepseq directory filepath
         gnuplot hp2any-core parsec process utf8-string vector
       ];
       description = "A benchmark suite for runtime and heap measurements over a series of inputs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SConfig" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "SConfig";
       version = "0.2.0.0";
       sha256 = "df83eddc9ac14bbc5240901a42c7fe91b60bb390da1967db561f154abf365a0c";
       libraryHaskellDepends = [ base containers ];
       homepage = "https://github.com/fgaz/SConfig";
       description = "A simple config library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "SDL" = callPackage
    ({ mkDerivation, base, SDL }:
     mkDerivation {
       pname = "SDL";
       version = "0.6.5.1";
       sha256 = "864c336c8b7f9f9b0239ce2d62521c4e2fd101e67f8cde6d5c2fe8bc47ff43e9";
       revision = "1";
       editedCabalFile = "233e3fde4727ca7b597e0bf86619c6b862c32445191a37b7a536a3188634473e";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ SDL ];
       description = "Binding to libSDL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) SDL;};

  "SDL-gfx" = callPackage
    ({ mkDerivation, base, SDL, SDL_gfx }:
     mkDerivation {
       pname = "SDL-gfx";
       version = "0.6.0.2";
       sha256 = "ab0035335a2193d8fd3e468bc2e5ba74b086516b62bad35415153606a2770dc5";
       libraryHaskellDepends = [ base SDL ];
       librarySystemDepends = [ SDL_gfx ];
       description = "Binding to libSDL_gfx";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) SDL_gfx;};

  "SDL-image" = callPackage
    ({ mkDerivation, base, SDL, SDL_image }:
     mkDerivation {
       pname = "SDL-image";
       version = "0.6.1.2";
       sha256 = "01892919dc9576c9a7b7c6698f2308c9caca61afa5550197be1fdb1231e56df9";
       revision = "1";
       editedCabalFile = "7e837026adb1262504d8bc4799628961f66200ad1a5f25e2b6b5842f0618dd6b";
       libraryHaskellDepends = [ base SDL ];
       librarySystemDepends = [ SDL_image ];
       description = "Binding to libSDL_image";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) SDL_image;};

  "SDL-mixer" = callPackage
    ({ mkDerivation, base, SDL, SDL_mixer }:
     mkDerivation {
       pname = "SDL-mixer";
       version = "0.6.2.0";
       sha256 = "1969170ee9d20811697f1f3d3150d388d45a809ea3d72495980da0968e5719ba";
       revision = "1";
       editedCabalFile = "9f17a645f815b3a0f47507263f0d2a8f57ff9d6893c8c967a7241e16e68b7ca4";
       libraryHaskellDepends = [ base SDL ];
       librarySystemDepends = [ SDL_mixer ];
       description = "Binding to libSDL_mixer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) SDL_mixer;};

  "SDL-mpeg" = callPackage
    ({ mkDerivation, base, SDL, smpeg }:
     mkDerivation {
       pname = "SDL-mpeg";
       version = "0.0.1";
       sha256 = "92e7888962a00f053ad671b6a3c2e407605c785ccca7459ab790591fcf49a443";
       libraryHaskellDepends = [ base SDL ];
       librarySystemDepends = [ smpeg ];
       description = "Binding to the SMPEG library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) smpeg;};

  "SDL-ttf" = callPackage
    ({ mkDerivation, base, SDL, SDL_ttf }:
     mkDerivation {
       pname = "SDL-ttf";
       version = "0.6.2.2";
       sha256 = "1621e4f1262f0c63aef84e02a9f53515ddcc4fce92a50d6954d947598a527499";
       libraryHaskellDepends = [ base SDL ];
       librarySystemDepends = [ SDL_ttf ];
       description = "Binding to libSDL_ttf";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) SDL_ttf;};

  "SDL2-ttf" = callPackage
    ({ mkDerivation, base, SDL2, SDL2_ttf }:
     mkDerivation {
       pname = "SDL2-ttf";
       version = "0.1.0";
       sha256 = "06a20c0c8652c3c2ed53db5e638c44cb7b3f2199bc490324dfb72001e344cf0e";
       libraryHaskellDepends = [ base SDL2 ];
       librarySystemDepends = [ SDL2_ttf ];
       jailbreak = true;
       description = "Binding to libSDL-ttf";
       license = stdenv.lib.licenses.mit;
       broken = true;
     }) {SDL2 = null; inherit (pkgs) SDL2_ttf;};

  "SFML" = callPackage
    ({ mkDerivation, base, csfml-audio, csfml-graphics, csfml-network
     , csfml-system, csfml-window, sfml-audio, sfml-graphics
     , sfml-network, sfml-system, sfml-window
     }:
     mkDerivation {
       pname = "SFML";
       version = "2.3.2.2";
       sha256 = "b61578cc1bc95554aca715ed0ae15eadf89dbf3fe49866541903d384387fdf2d";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [
         csfml-audio csfml-graphics csfml-network csfml-system csfml-window
         sfml-audio sfml-graphics sfml-network sfml-system sfml-window
       ];
       homepage = "https://github.com/jeannekamikaze/SFML";
       description = "SFML bindings";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {csfml-audio = null; csfml-graphics = null; 
         csfml-network = null; csfml-system = null; csfml-window = null; 
         sfml-audio = null; sfml-graphics = null; sfml-network = null; 
         sfml-system = null; sfml-window = null;};

  "SFML-control" = callPackage
    ({ mkDerivation, base, mtl, SFML, template-haskell }:
     mkDerivation {
       pname = "SFML-control";
       version = "0.2.0.2";
       sha256 = "2fa99f0c2710ded653b8faffb9702cde5f62b746316854b233bf9634924f3000";
       libraryHaskellDepends = [ base mtl SFML template-haskell ];
       homepage = "https://github.com/SFML-haskell/SFML-control";
       description = "Higher level library on top of SFML";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SFont" = callPackage
    ({ mkDerivation, array, base, SDL, Sprig }:
     mkDerivation {
       pname = "SFont";
       version = "0.1.1";
       sha256 = "119070e8d6dc72c0195e68c05c5614d6a639abf5ab12b667a5e84e00b4dffe1c";
       libraryHaskellDepends = [ array base SDL Sprig ];
       homepage = "http://liamoc.net/static/SFont";
       description = "SFont SDL Bitmap Fonts";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SG" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "SG";
       version = "1.0";
       sha256 = "5b06339b45d73c79cef7c952afc39699cd83638876bb6693528d2e5e2e2d412a";
       libraryHaskellDepends = [ base mtl ];
       description = "Small geometry library for dealing with vectors and collision detection";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SGdemo" = callPackage
    ({ mkDerivation, base, GLUT, OpenGL, SG }:
     mkDerivation {
       pname = "SGdemo";
       version = "1.1";
       sha256 = "66f3c364997b8e420650c686116f312b4fac9d2b338a1ebd88e910cc8b47fa38";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base GLUT OpenGL SG ];
       jailbreak = true;
       description = "An example of using the SG and OpenGL libraries";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SHA_1_6_4_1" = callPackage
    ({ mkDerivation, array, base, binary, bytestring }:
     mkDerivation {
       pname = "SHA";
       version = "1.6.4.1";
       sha256 = "743bc6d7dd3e74a44bfca8920f0f0ba5855722a62f6cc44f0a38d10c11bddc0d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base binary bytestring ];
       description = "Implementations of the SHA suite of message digest functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SHA" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, directory
     , QuickCheck, test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "SHA";
       version = "1.6.4.2";
       sha256 = "c470176f63cbe49fd0502a1b32ef22bc01b1af42385583b8be94547750958a8c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base binary bytestring ];
       executableHaskellDepends = [ base bytestring directory ];
       testHaskellDepends = [
         array base binary bytestring QuickCheck test-framework
         test-framework-quickcheck2
       ];
       description = "Implementations of the SHA suite of message digest functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "SHA2" = callPackage
    ({ mkDerivation, AES, base, bytestring, monads-tf, transformers }:
     mkDerivation {
       pname = "SHA2";
       version = "0.2.5";
       sha256 = "804824c6df6520af89451f0b4aa7c58a7d5d29ca5bdc5195f3d5f423864a47ff";
       libraryHaskellDepends = [
         AES base bytestring monads-tf transformers
       ];
       description = "Fast, incremental SHA hashing for bytestrings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "SMTPClient" = callPackage
    ({ mkDerivation, base, containers, extensible-exceptions, hsemail
     , network, old-locale, old-time
     }:
     mkDerivation {
       pname = "SMTPClient";
       version = "1.1.0";
       sha256 = "d3e9be4675439b58f62dbd0abb2fa4234061a08ea50562d8183f0ec28890d21e";
       libraryHaskellDepends = [
         base containers extensible-exceptions hsemail network old-locale
         old-time
       ];
       description = "A simple SMTP client library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "SNet" = callPackage
    ({ mkDerivation, base, bindings-DSL, c2hsc, containers
     , data-default, lens, mtl, transformers
     }:
     mkDerivation {
       pname = "SNet";
       version = "0.1.0";
       sha256 = "2955c41e872833d4b631d0c6de58d5912ed39320ab589e9cfdd4edf258149aa6";
       libraryHaskellDepends = [
         base bindings-DSL containers data-default lens mtl transformers
       ];
       libraryToolDepends = [ c2hsc ];
       jailbreak = true;
       homepage = "http://www.snet-home.org/";
       description = "Declarative coördination language for streaming networks";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SQLDeps" = callPackage
    ({ mkDerivation, base, hashable, HDBC, HDBC-sqlite3, mtl
     , unordered-containers
     }:
     mkDerivation {
       pname = "SQLDeps";
       version = "0.1";
       sha256 = "f7ed82bfb390e30aa25709e80bd30e6b7659327f7601d4d7d055c2c372dfa4b7";
       libraryHaskellDepends = [
         base hashable HDBC HDBC-sqlite3 mtl unordered-containers
       ];
       description = "Calculate db-data dependencies of functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "STL" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, cereal, text }:
     mkDerivation {
       pname = "STL";
       version = "0.3.0.3";
       sha256 = "382247812f11b9f73cd9a02474fa68d402fac91471fac83dd0e15604a191548a";
       libraryHaskellDepends = [ attoparsec base bytestring cereal text ];
       homepage = "http://github.com/bergey/STL";
       description = "STL 3D geometry format parsing and pretty-printing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "STMonadTrans" = callPackage
    ({ mkDerivation, array, base, mtl }:
     mkDerivation {
       pname = "STMonadTrans";
       version = "0.3.3";
       sha256 = "d9911c7634c42b94f57ac7c2a6d523f6d7124870b35fc3030cb72109ba3aa315";
       libraryHaskellDepends = [ array base mtl ];
       description = "A monad transformer version of the ST monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "SVG2Q" = callPackage
    ({ mkDerivation, base, haskell98, language-c, pretty, svgutils, syb
     , xml
     }:
     mkDerivation {
       pname = "SVG2Q";
       version = "0.3";
       sha256 = "b8feb8f712856d02a9b5026eff2a240b93073fe54112241343b391df1810991d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base haskell98 language-c pretty svgutils syb xml
       ];
       jailbreak = true;
       homepage = "http://www.informatik.uni-kiel.de/~jgr/svg2q";
       description = "Code generation tool for Quartz code from a SVG";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SVGFonts_1_4_0_3" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-markup, blaze-svg
     , containers, data-default-class, diagrams-lib, directory, parsec
     , split, text, tuple, vector, vector-space, xml
     }:
     mkDerivation {
       pname = "SVGFonts";
       version = "1.4.0.3";
       sha256 = "367a9f256b934371b5e07f0f9c9fe546a8ca6640411e6f69da5fe27e8463724a";
       libraryHaskellDepends = [
         attoparsec base blaze-markup blaze-svg containers
         data-default-class diagrams-lib directory parsec split text tuple
         vector vector-space xml
       ];
       jailbreak = true;
       description = "Fonts from the SVG-Font format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SVGFonts" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-markup, blaze-svg
     , containers, data-default-class, diagrams-core, diagrams-lib
     , directory, parsec, split, text, tuple, vector, xml
     }:
     mkDerivation {
       pname = "SVGFonts";
       version = "1.5.0.0";
       sha256 = "e650a7837bb328d0097883a8f1953c5c9a4fa85d2a08027731fda1c659392670";
       libraryHaskellDepends = [
         attoparsec base blaze-markup blaze-svg containers
         data-default-class diagrams-core diagrams-lib directory parsec
         split text tuple vector xml
       ];
       description = "Fonts from the SVG-Font format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "SVGPath" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "SVGPath";
       version = "1.1.2";
       sha256 = "e452034117aa3d4e35a87795eb0c273b726f48880899a5a6455b1a9bc3ad99a8";
       libraryHaskellDepends = [ base parsec ];
       description = "Parsing the path command of SVG";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "SWMMoutGetMB" = callPackage
    ({ mkDerivation, base, binary, bytestring, data-binary-ieee754
     , pipes-binary, pipes-bytestring, pipes-parse, split
     }:
     mkDerivation {
       pname = "SWMMoutGetMB";
       version = "0.1.1.1";
       sha256 = "60b2a2188eaeb2b32bfae2b74a0b61daa25f3c5470cb2babf8082b8a52828f69";
       libraryHaskellDepends = [
         base binary bytestring data-binary-ieee754 pipes-binary
         pipes-bytestring pipes-parse split
       ];
       homepage = "https://github.com/siddhanathan/SWMMoutGetMB";
       description = "A parser for SWMM 5 binary .OUT files";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "SableCC2Hs" = callPackage
    ({ mkDerivation, array, base, containers, filepath, loch-th, pretty
     , text, transformers, wl-pprint-text, xml
     }:
     mkDerivation {
       pname = "SableCC2Hs";
       version = "0.0.1.0";
       sha256 = "d449d446e1917c746d036fc1a5dc72e09439b223874ef9f4889e970b4e98cfea";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base containers ];
       executableHaskellDepends = [
         array base containers filepath loch-th pretty text transformers
         wl-pprint-text xml
       ];
       jailbreak = true;
       description = "Generate a parser (in Haskell) with the SableCC parser generator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Safe" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Safe";
       version = "0.1";
       sha256 = "43980da212a6feda3177c8cec276ccbf2d6704a98b941703e9d29761482e7179";
       libraryHaskellDepends = [ base ];
       homepage = "http://www-users.cs.york.ac.uk/~ndm/projects/libraries.php";
       description = "Library for safe (pattern match free) functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "SafeSemaphore" = callPackage
    ({ mkDerivation, base, containers, HUnit, stm }:
     mkDerivation {
       pname = "SafeSemaphore";
       version = "0.10.1";
       sha256 = "21e5b737a378cae9e1faf85cab015316d4c84d4b37e6d9d202111cef8c4cef66";
       revision = "1";
       editedCabalFile = "1b168ec8de4b3958df15b33ba9ab60d8a651d9dd4ea36891d4c31ae81e7ec1cc";
       libraryHaskellDepends = [ base containers stm ];
       testHaskellDepends = [ base HUnit ];
       homepage = "https://github.com/ChrisKuklewicz/SafeSemaphore";
       description = "Much safer replacement for QSemN, QSem, and SampleVar";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Salsa" = callPackage
    ({ mkDerivation, base, bytestring, file-embed, glib, mono }:
     mkDerivation {
       pname = "Salsa";
       version = "0.2.0.2";
       sha256 = "edf10725602ec9e32b2b8fea0fe881d1ccbd302cf5ef016c2c48e91922af2524";
       libraryHaskellDepends = [ base bytestring file-embed ];
       librarySystemDepends = [ glib mono ];
       homepage = "http://haskell.org/haskellwiki/Salsa";
       description = "A .NET Bridge for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) glib; inherit (pkgs) mono;};

  "Saturnin" = callPackage
    ({ mkDerivation, base, bytestring, data-default, directory, either
     , exceptions, filepath, formatting, hlint, hspec, ini, mtl, network
     , old-locale, process, spawn, stm, temporary, text, time
     , unordered-containers, yaml
     }:
     mkDerivation {
       pname = "Saturnin";
       version = "0.1.0.2";
       sha256 = "59e34bfb8bc08ec95f24f09d3f9b3896ad76720237f228d59b1858e1f309df38";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring data-default directory either exceptions filepath
         formatting ini mtl network old-locale process spawn stm temporary
         text time unordered-containers yaml
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base data-default either hlint hspec mtl ];
       description = "Saturnin CI / Job System";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "SciFlow" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default-class
     , fgl, graphviz, lens, mtl, optparse-applicative, shelly, split
     , template-haskell, text, th-lift, yaml
     }:
     mkDerivation {
       pname = "SciFlow";
       version = "0.4.0";
       sha256 = "6ab39de90c8f4b31ee57ebab575db36d53ef1800895bc87cfa3b9d443807661b";
       libraryHaskellDepends = [
         base bytestring containers data-default-class fgl graphviz lens mtl
         optparse-applicative shelly split template-haskell text th-lift
         yaml
       ];
       description = "Scientific workflow management system";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ScratchFs" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, HFuse
     , hsyslog, process, regex-compat, sqlite-simple, unix
     }:
     mkDerivation {
       pname = "ScratchFs";
       version = "0.1.0.2";
       sha256 = "f0b35cfc2a5fe3e24cf76ac83ce8062155403b877ac8197ac3e51dbf2c048130";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory filepath HFuse hsyslog process
         regex-compat sqlite-simple unix
       ];
       jailbreak = true;
       homepage = "http://github.com/hirschenberger/ScratchFS";
       description = "Size limited temp filesystem based on fuse";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Scurry" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, network
     , network-bytestring, parsec, random, stm, time, unix
     }:
     mkDerivation {
       pname = "Scurry";
       version = "0.0.3";
       sha256 = "1261aefae7076bed3ae941e1794ed8c576f76a01c5e1b30745e05ffd51549447";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring containers network network-bytestring parsec
         random stm time unix
       ];
       homepage = "http://code.google.com/p/scurry/";
       description = "A cross platform P2P VPN application built using Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SegmentTree" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "SegmentTree";
       version = "0.3";
       sha256 = "6188c1b1276d7fa0391098a563df73dd522d20b57dc5321fe3418a9e3ca84fc1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       description = "Data structure for querying the set (or count) of intervals covering given point";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Semantique" = callPackage
    ({ mkDerivation, base, bytestring, classify, containers, mongoDB
     , mtl, network, process, split, tagsoup, text
     }:
     mkDerivation {
       pname = "Semantique";
       version = "0.3.0";
       sha256 = "2833c17d3b9cd6d872c999b940a7f601921f8fb4869611783eb99b52372563d0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring classify containers mongoDB mtl network process
         split tagsoup text
       ];
       jailbreak = true;
       description = "Command-line tool for maintaining the Semantique database";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Semigroup" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl }:
     mkDerivation {
       pname = "Semigroup";
       version = "0.0.7";
       sha256 = "a65f0934221cbec4a53205cc965d3fd3875512cd254ee6619102e407ca0fbcd5";
       libraryHaskellDepends = [ base bytestring containers mtl ];
       homepage = "https://bitbucket.org/dibblego/semigroup/";
       description = "A semigroup";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "SeqAlign" = callPackage
    ({ mkDerivation, base, bytestring, vector }:
     mkDerivation {
       pname = "SeqAlign";
       version = "0.1.0.0";
       sha256 = "c5d2b6ca6bad69d7891418cbca0a11b1035ff4b5620017918d7c2415a21d666e";
       libraryHaskellDepends = [ base bytestring vector ];
       description = "Sequence Alignment";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SessionLogger" = callPackage
    ({ mkDerivation, base, directory, filepath, hslogger, mtl
     , old-locale, random, time
     }:
     mkDerivation {
       pname = "SessionLogger";
       version = "0.3.0.0";
       sha256 = "83216a15e2bc48a9657d28b12852082c46e304968470cedb518a989b1cd5f2fd";
       libraryHaskellDepends = [
         base directory filepath hslogger mtl old-locale random time
       ];
       jailbreak = true;
       description = "Easy Loggingframework";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ShellCheck" = callPackage
    ({ mkDerivation, base, containers, directory, json, mtl, parsec
     , process, QuickCheck, regex-tdfa
     }:
     mkDerivation {
       pname = "ShellCheck";
       version = "0.4.3";
       sha256 = "df71c303c43ae79846c9f9198a4d4ba2c4c2ee4c06974491d7130fcea0b8efdf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory json mtl parsec process QuickCheck
         regex-tdfa
       ];
       executableHaskellDepends = [
         base containers directory json mtl parsec QuickCheck regex-tdfa
       ];
       testHaskellDepends = [
         base containers directory json mtl parsec QuickCheck regex-tdfa
       ];
       homepage = "http://www.shellcheck.net/";
       description = "Shell script analysis tool";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "Shellac" = callPackage
    ({ mkDerivation, base, directory, mtl, unix }:
     mkDerivation {
       pname = "Shellac";
       version = "0.9.5.2";
       sha256 = "91f6c2fe2b9cfe01052e5eec496a1f5c0bd598777f266ccaaa1ac70f81a249cb";
       libraryHaskellDepends = [ base directory mtl unix ];
       homepage = "http://rwd.rdockins.name/shellac/home/";
       description = "A framework for creating shell envinronments";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Shellac-compatline" = callPackage
    ({ mkDerivation, base, Shellac, Shellac-editline }:
     mkDerivation {
       pname = "Shellac-compatline";
       version = "0.9.5.2";
       sha256 = "1181de04bc49ebcf5eadb886a7e779c2a49e7c4f7bbbd625d7748fb6f204958c";
       libraryHaskellDepends = [ base Shellac Shellac-editline ];
       homepage = "http://rwd.rdockins.name/shellac/home/";
       description = "\"compatline\" backend module for Shellac";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Shellac-editline" = callPackage
    ({ mkDerivation, base, editline, Shellac }:
     mkDerivation {
       pname = "Shellac-editline";
       version = "0.9.5.2";
       sha256 = "50259ad0000221a32c01e57c8c4e9883748f568f086d0aff462c25a82be1a493";
       libraryHaskellDepends = [ base editline Shellac ];
       homepage = "http://rwd.rdockins.name/shellac/home/";
       description = "Editline backend module for Shellac";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Shellac-haskeline" = callPackage
    ({ mkDerivation, base, haskeline, mtl, Shellac }:
     mkDerivation {
       pname = "Shellac-haskeline";
       version = "0.2.0.2";
       sha256 = "0fdb0cbf8dd0fad1b8868c859b5113704912c703735cb39003cf079e5569e060";
       libraryHaskellDepends = [ base haskeline mtl Shellac ];
       jailbreak = true;
       description = "Haskeline backend module for Shellac";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Shellac-readline" = callPackage
    ({ mkDerivation, base, readline, Shellac }:
     mkDerivation {
       pname = "Shellac-readline";
       version = "0.9.5.2";
       sha256 = "16c44fe21d5e986c996d396a22d3ef00c34b98acade4d909634d3d40eeff8808";
       libraryHaskellDepends = [ base readline Shellac ];
       homepage = "http://rwd.rdockins.name/shellac/home/";
       description = "Readline backend module for Shellac";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ShowF" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ShowF";
       version = "0.1.1";
       sha256 = "d0f9ade81af6e341a5e6a99ba456a08d55a36f78963f6e9c41d0d941208904db";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/conal/ShowF/";
       description = "Show for * -> *";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Shrub" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Shrub";
       version = "0.1.0.0";
       sha256 = "a8a0081970dbffd0b09f5dc9d2509bddb50d3127bdaddedc7aeea98fb3b7b980";
       libraryHaskellDepends = [ base ];
       description = "4-way trie fuzzy search";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Shu-thing" = callPackage
    ({ mkDerivation, base, GLUT }:
     mkDerivation {
       pname = "Shu-thing";
       version = "1.1.3";
       sha256 = "3be209bad2521e6e1b5144483dd03e73db6f3a19469211c04c316e3c5a67bba0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base GLUT ];
       homepage = "http://www.geocities.jp/takascience/index_en.html";
       description = "A vector shooter game";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SimpleAES" = callPackage
    ({ mkDerivation, base, binary, bytestring, mwc-random }:
     mkDerivation {
       pname = "SimpleAES";
       version = "0.4.2";
       sha256 = "7213b531e9f9a49f6ec23f36d2c6bf552ae9c571c9b239b8c8be5198f9eb0569";
       libraryHaskellDepends = [ base binary bytestring mwc-random ];
       description = "Fast AES encryption/decryption for bytestrings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "SimpleEA" = callPackage
    ({ mkDerivation, base, mersenne-random-pure64, MonadRandom }:
     mkDerivation {
       pname = "SimpleEA";
       version = "0.2.1";
       sha256 = "7923b3d815b83de0b3e36c8a7b26547de694d059459b58fcb752a2117caa3562";
       libraryHaskellDepends = [
         base mersenne-random-pure64 MonadRandom
       ];
       homepage = "http://www.github.com/ehamberg/simpleea/";
       description = "Simple evolutionary algorithm framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "SimpleGL" = callPackage
    ({ mkDerivation, base, GLFW, JuicyPixels, OpenGL, SimpleH, vector
     }:
     mkDerivation {
       pname = "SimpleGL";
       version = "0.9.3";
       sha256 = "19968a2beff81a94fb5eaf044ad94d425149ebdce5833a0a637ae3280b26c730";
       libraryHaskellDepends = [
         base GLFW JuicyPixels OpenGL SimpleH vector
       ];
       jailbreak = true;
       description = "A Simple Graphics Library from the SimpleH framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SimpleH" = callPackage
    ({ mkDerivation, base, bytestring, clock, containers, cpu
     , directory, filepath, network, time, unix
     }:
     mkDerivation {
       pname = "SimpleH";
       version = "1.2";
       sha256 = "acfe142fdaecc57a316791fb6d92fc9561c466f198b5bc4eafbd98aae9f5053c";
       libraryHaskellDepends = [
         base bytestring clock containers cpu directory filepath network
         time unix
       ];
       jailbreak = true;
       description = "A light, clean and powerful Haskell utility library";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SimpleLog" = callPackage
    ({ mkDerivation, ansi-terminal, attoparsec, base, bytestring
     , containers, directory, ForkableT, monad-control, mtl, old-locale
     , resourcet, semigroups, stm, template-haskell, text, th-lift, time
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "SimpleLog";
       version = "0.1.0.3";
       sha256 = "7ce9dc8f7175ddcd93583e49401e5b5b7b57d6f245e890df08f75dd6556dd289";
       libraryHaskellDepends = [
         ansi-terminal attoparsec base bytestring containers directory
         ForkableT monad-control mtl old-locale resourcet semigroups stm
         template-haskell text th-lift time transformers transformers-base
       ];
       homepage = "https://github.com/exFalso/SimpleLog/";
       description = "Simple, configurable logging";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SimpleServer" = callPackage
    ({ mkDerivation, base, cmdargs, dyre, transformers, wai-routes
     , warp
     }:
     mkDerivation {
       pname = "SimpleServer";
       version = "0.1.1.1";
       sha256 = "e3f3d556ad866c442183788f64d97e4e55e50bedcab4bfef65803352146bdeb4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cmdargs dyre transformers wai-routes warp
       ];
       executableHaskellDepends = [
         base cmdargs dyre transformers wai-routes warp
       ];
       description = "A simple static file server, for when apache is overkill";
       license = stdenv.lib.licenses.mit;
     }) {};

  "SizeCompare" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "SizeCompare";
       version = "0.1";
       sha256 = "478504d5fdf1789ced9361c7234d038217129d9aa27d647388da0756dfdba338";
       libraryHaskellDepends = [ base containers ];
       description = "Fast size comparison for standard containers";
       license = "GPL";
     }) {};

  "Slides" = callPackage
    ({ mkDerivation, base, colour, diagrams-lib, diagrams-svg
     , file-embed, regex-applicative
     }:
     mkDerivation {
       pname = "Slides";
       version = "0.1.0.8";
       sha256 = "1058d7ccedef0081bec5a4f7ebbb70e7e564d70ee642d3fd49920b0be569c57c";
       libraryHaskellDepends = [
         base colour diagrams-lib diagrams-svg file-embed regex-applicative
       ];
       testHaskellDepends = [ base file-embed ];
       description = "Generate slides from Haskell code";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Smooth" = callPackage
    ({ mkDerivation, base, containers, DifferenceLogic
     , FirstOrderTheory, HUnit, Proper
     }:
     mkDerivation {
       pname = "Smooth";
       version = "0.1.0.1";
       sha256 = "8dfdc9f4c3fa9fec50f0c9afbbdf1b164174a72161ca7b34fcfadd1d782b9467";
       libraryHaskellDepends = [
         base containers DifferenceLogic FirstOrderTheory HUnit Proper
       ];
       jailbreak = true;
       description = "A tiny, lazy SMT solver";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SmtLib" = callPackage
    ({ mkDerivation, base, parsec, transformers }:
     mkDerivation {
       pname = "SmtLib";
       version = "0.1.0.0";
       sha256 = "6133bcb354742ffc6b46e221887a1c3935768a975cd02966c46e2dab06fdad72";
       libraryHaskellDepends = [ base parsec transformers ];
       jailbreak = true;
       homepage = "https://github.com/MfesGA/HsmtlibParser";
       description = "Library for parsing SMTLIB2";
       license = stdenv.lib.licenses.mit;
     }) {};

  "Snusmumrik" = callPackage
    ({ mkDerivation, base, bytestring, convertible, cpphs, directory
     , filepath, haskell98, HDBC, HDBC-sqlite3, HFuse, hslogger, iconv
     , LibZip, regex-tdfa, stm, unix, utf8-string, xml, zip
     }:
     mkDerivation {
       pname = "Snusmumrik";
       version = "0.0.1";
       sha256 = "534f22cd28443ca2cd27b3bd7a7e0167193641b5505cc1d253ee6c0b47228db8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring convertible directory filepath haskell98 HDBC
         HDBC-sqlite3 HFuse hslogger iconv LibZip regex-tdfa stm unix
         utf8-string xml
       ];
       executableSystemDepends = [ zip ];
       executableToolDepends = [ cpphs ];
       jailbreak = true;
       homepage = "http://bitbucket.org/jetxee/snusmumrik/";
       description = "E-library directory based on FUSE virtual file system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) zip;};

  "SoOSiM" = callPackage
    ({ mkDerivation, base, concurrent-supply, containers
     , monad-coroutine, mtl, stm, transformers
     }:
     mkDerivation {
       pname = "SoOSiM";
       version = "0.2.1.0";
       sha256 = "b7b2a9aafa91a97d4fb81504109e75bffa17b9f908aaad5b644f90e4e0a40b3e";
       libraryHaskellDepends = [
         base concurrent-supply containers monad-coroutine mtl stm
         transformers
       ];
       jailbreak = true;
       homepage = "http://www.soos-project.eu/";
       description = "Abstract full system simulator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SoccerFun" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, binary, derive
     , directory, mtl, process, random, zlib
     }:
     mkDerivation {
       pname = "SoccerFun";
       version = "0.5.3";
       sha256 = "1219c1cdf6f9cbfd6dfe27c22fc86c12e47625bddf1f973da50fdd4f51ddb789";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-unicode-symbols binary derive directory mtl process
         random zlib
       ];
       jailbreak = true;
       homepage = "http://www.cs.ru.nl/~peter88/SoccerFun/SoccerFun.html";
       description = "Football simulation framework for teaching functional programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SoccerFunGL" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, binary, GLUT, OpenGL
     , process, random, SoccerFun
     }:
     mkDerivation {
       pname = "SoccerFunGL";
       version = "0.5.3";
       sha256 = "4eabc997d8e247d127c5cfa07242cb87ba868bf9893f93773e6a155350b4450a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-unicode-symbols binary GLUT OpenGL process random
         SoccerFun
       ];
       jailbreak = true;
       homepage = "http://www.cs.ru.nl/~peter88/SoccerFun/SoccerFun.html";
       description = "OpenGL UI for the SoccerFun framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Sonnex" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "Sonnex";
       version = "0.1.0.3";
       sha256 = "aa7daf85955ef1db716594997e5cb3b7bc13b0c65be372e82c83d60339e10a3b";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/Zigazou/Sonnex";
       description = "Sonnex is an alternative to Soundex for french language";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "SourceGraph" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, fgl, filepath
     , Graphalyze, graphviz, haskell-src-exts, mtl, multiset, random
     }:
     mkDerivation {
       pname = "SourceGraph";
       version = "0.7.0.7";
       sha256 = "93734a272f17f6ff463c8ee7d016cd8a5f8fbace8eb5ceb99a4696fd729f99d4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers directory fgl filepath Graphalyze graphviz
         haskell-src-exts mtl multiset random
       ];
       jailbreak = true;
       description = "Static code analysis using graph-theoretic techniques";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Southpaw" = callPackage
    ({ mkDerivation, ALUT, base, bytestring, cairo, containers
     , filepath, GLFW-b, gtk3, JuicyPixels, OpenAL, OpenGL, vector
     , Win32
     }:
     mkDerivation {
       pname = "Southpaw";
       version = "0.1.0.2";
       sha256 = "f8da4e5ab633be375d39fef22c5cea2aa28fe3c92e443084c035fb6c565832fe";
       libraryHaskellDepends = [
         ALUT base bytestring cairo containers filepath GLFW-b gtk3
         JuicyPixels OpenAL OpenGL vector Win32
       ];
       jailbreak = true;
       description = "Assorted utility modules";
       license = stdenv.lib.licenses.mit;
     }) {};

  "SpaceInvaders" = callPackage
    ({ mkDerivation, array, base, HGL, random, Yampa }:
     mkDerivation {
       pname = "SpaceInvaders";
       version = "0.4.2";
       sha256 = "03993ad20fb5142605b7b94208825ee7b847934435efcd720acc8c517d49bec5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base HGL random Yampa ];
       homepage = "http://www.haskell.org/yampa/";
       description = "Video game";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SpacePrivateers" = callPackage
    ({ mkDerivation, base, containers, enummapset-th, filepath
     , LambdaHack, template-haskell, text
     }:
     mkDerivation {
       pname = "SpacePrivateers";
       version = "0.1.0.0";
       sha256 = "70e6061caa2b7eed8be2d120ba165365e008c37a510290c8f89b926d6702473e";
       revision = "1";
       editedCabalFile = "b59d607892ad860616cef196c83ff54388204102eae597acf88467a2f54764bf";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers enummapset-th filepath LambdaHack template-haskell
         text
       ];
       jailbreak = true;
       homepage = "https://github.com/tuturto/space-privateers";
       description = "Simple space pirate roguelike";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SpinCounter" = callPackage
    ({ mkDerivation, base, monad-loops, ref-mtl, stm }:
     mkDerivation {
       pname = "SpinCounter";
       version = "0.0.1";
       sha256 = "22060672e6d23e14116b1925b3357d92d91adb1b956f2b7c75784ca192c9c9e5";
       libraryHaskellDepends = [ base monad-loops ref-mtl stm ];
       jailbreak = true;
       homepage = "https://github.com/Julek";
       description = "Lock free Spin Counter";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Spintax" = callPackage
    ({ mkDerivation, attoparsec, base, extra, mwc-random, text }:
     mkDerivation {
       pname = "Spintax";
       version = "0.1.0.0";
       sha256 = "d9d115f107f3b9a8e44a605d4b44727ff385974f3fd2d1d5b5a40a380467feec";
       libraryHaskellDepends = [ attoparsec base extra mwc-random text ];
       homepage = "https://github.com/MichelBoucey/spintax";
       description = "Random text generation based on spintax";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Spock_0_7_5_1" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, blaze-html
     , bytestring, case-insensitive, containers, digestive-functors
     , directory, hashable, hspec, hspec-wai, http-types, monad-control
     , mtl, old-locale, path-pieces, random, reroute, resource-pool
     , resourcet, stm, text, time, transformers, transformers-base
     , unordered-containers, vault, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "Spock";
       version = "0.7.5.1";
       sha256 = "718aabacc152a32f031085914da7111cb7f1c72b0bedab3f8333b87f6d0b7c17";
       libraryHaskellDepends = [
         aeson base base64-bytestring blaze-html bytestring case-insensitive
         containers digestive-functors directory hashable http-types
         monad-control mtl old-locale path-pieces random reroute
         resource-pool resourcet stm text time transformers
         transformers-base unordered-containers vault wai wai-extra warp
       ];
       testHaskellDepends = [ base hspec hspec-wai http-types text wai ];
       homepage = "https://github.com/agrafix/Spock";
       description = "Another Haskell web framework for rapid development";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Spock_0_7_5_2" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, blaze-html
     , bytestring, case-insensitive, containers, digestive-functors
     , directory, hashable, hspec, hspec-wai, http-types, monad-control
     , mtl, old-locale, path-pieces, random, reroute, resource-pool
     , resourcet, stm, text, time, transformers, transformers-base
     , unordered-containers, vault, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "Spock";
       version = "0.7.5.2";
       sha256 = "8a26ddc030bebf479454fd2ccce5dabb1f0dfa9a4287aab62d4e4d4b68278652";
       revision = "1";
       editedCabalFile = "10eeb5badbfd9eedc11318b2410d9fdeef67a4c6e562e8a22548921d1f3be1d9";
       libraryHaskellDepends = [
         aeson base base64-bytestring blaze-html bytestring case-insensitive
         containers digestive-functors directory hashable http-types
         monad-control mtl old-locale path-pieces random reroute
         resource-pool resourcet stm text time transformers
         transformers-base unordered-containers vault wai wai-extra warp
       ];
       testHaskellDepends = [ base hspec hspec-wai http-types text wai ];
       jailbreak = true;
       homepage = "https://github.com/agrafix/Spock";
       description = "Another Haskell web framework for rapid development";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Spock_0_7_6_0" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , case-insensitive, containers, directory, hashable, hspec
     , hspec-wai, http-types, monad-control, mtl, old-locale
     , path-pieces, random, reroute, resource-pool, resourcet, stm, text
     , time, transformers, transformers-base, unordered-containers
     , vault, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "Spock";
       version = "0.7.6.0";
       sha256 = "f828b30a7f1ca06ea049d64b5f9b3bdff24327ae6049532ea84f4fa85d3aa017";
       revision = "1";
       editedCabalFile = "601a3e20c13fc76cf165b444b65de977b10bf64cb9d7fdee362de22f0bcaa684";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring case-insensitive containers
         directory hashable http-types monad-control mtl old-locale
         path-pieces random reroute resource-pool resourcet stm text time
         transformers transformers-base unordered-containers vault wai
         wai-extra warp
       ];
       testHaskellDepends = [ base hspec hspec-wai http-types text wai ];
       jailbreak = true;
       homepage = "https://github.com/agrafix/Spock";
       description = "Another Haskell web framework for rapid development";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Spock_0_7_7_0" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , case-insensitive, containers, directory, hashable, hspec
     , hspec-wai, http-types, monad-control, mtl, old-locale
     , path-pieces, random, reroute, resource-pool, resourcet, stm, text
     , time, transformers, transformers-base, unordered-containers
     , vault, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "Spock";
       version = "0.7.7.0";
       sha256 = "0cf988412beaf09725a292e93dc759b69c71732a740003635cf63b3c17ce5c4b";
       revision = "1";
       editedCabalFile = "5af4c51a10923dce6677d1c328e29bb882c79b9ccc82bc24686023e9516bac7e";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring case-insensitive containers
         directory hashable http-types monad-control mtl old-locale
         path-pieces random reroute resource-pool resourcet stm text time
         transformers transformers-base unordered-containers vault wai
         wai-extra warp
       ];
       testHaskellDepends = [ base hspec hspec-wai http-types text wai ];
       jailbreak = true;
       homepage = "https://github.com/agrafix/Spock";
       description = "Another Haskell web framework for rapid development";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Spock_0_7_9_0" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , case-insensitive, containers, directory, hashable, hspec
     , hspec-wai, http-types, monad-control, mtl, old-locale
     , path-pieces, random, reroute, resource-pool, resourcet, stm, text
     , time, transformers, transformers-base, unordered-containers
     , vault, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "Spock";
       version = "0.7.9.0";
       sha256 = "3d6da99b2378e36678a0cb156465bed18f767cf6a8eeee928411c7b7638e97b6";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring case-insensitive containers
         directory hashable http-types monad-control mtl old-locale
         path-pieces random reroute resource-pool resourcet stm text time
         transformers transformers-base unordered-containers vault wai
         wai-extra warp
       ];
       testHaskellDepends = [
         base hspec hspec-wai http-types reroute text wai
       ];
       homepage = "http://www.spock.li";
       description = "Another Haskell web framework for rapid development";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Spock_0_7_10_0" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , case-insensitive, containers, directory, hashable, hspec
     , hspec-wai, http-types, list-t, monad-control, mtl, old-locale
     , path-pieces, random, reroute, resource-pool, resourcet, stm
     , stm-containers, text, time, transformers, transformers-base
     , unordered-containers, vault, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "Spock";
       version = "0.7.10.0";
       sha256 = "d2226d0940469d666820523288c1f726ac8640e38279fefeb25e46e3d9d0f129";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring case-insensitive containers
         directory hashable http-types list-t monad-control mtl old-locale
         path-pieces random reroute resource-pool resourcet stm
         stm-containers text time transformers transformers-base
         unordered-containers vault wai wai-extra warp
       ];
       testHaskellDepends = [
         base hspec hspec-wai http-types reroute stm text wai
       ];
       homepage = "http://www.spock.li";
       description = "Another Haskell web framework for rapid development";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Spock_0_8_0_0" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , case-insensitive, containers, directory, hashable, hspec
     , hspec-wai, http-types, hvect, list-t, monad-control, mtl
     , old-locale, path-pieces, random, reroute, resource-pool
     , resourcet, stm, stm-containers, text, time, transformers
     , transformers-base, unordered-containers, vault, wai, wai-extra
     , warp
     }:
     mkDerivation {
       pname = "Spock";
       version = "0.8.0.0";
       sha256 = "04a0a66eb9cb6cc1528e3989e5b54378079ee9919412bc54015a3919603b7e3a";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring case-insensitive containers
         directory hashable http-types hvect list-t monad-control mtl
         old-locale path-pieces random reroute resource-pool resourcet stm
         stm-containers text time transformers transformers-base
         unordered-containers vault wai wai-extra warp
       ];
       testHaskellDepends = [
         base bytestring hspec hspec-wai http-types reroute stm text wai
       ];
       homepage = "http://www.spock.li";
       description = "Another Haskell web framework for rapid development";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Spock_0_8_1_0" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , case-insensitive, containers, directory, focus, hashable, hspec
     , hspec-wai, http-types, hvect, list-t, monad-control, mtl
     , old-locale, path-pieces, random, reroute, resource-pool
     , resourcet, stm, stm-containers, text, time, transformers
     , transformers-base, unordered-containers, vault, wai, wai-extra
     , warp
     }:
     mkDerivation {
       pname = "Spock";
       version = "0.8.1.0";
       sha256 = "d9e62dba8c757b9877010c4ecbc2e79de519cf14a54c919fc99eda3a1c2e70d6";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring case-insensitive containers
         directory focus hashable http-types hvect list-t monad-control mtl
         old-locale path-pieces random reroute resource-pool resourcet stm
         stm-containers text time transformers transformers-base
         unordered-containers vault wai wai-extra warp
       ];
       testHaskellDepends = [
         base bytestring hspec hspec-wai http-types reroute stm text wai
       ];
       homepage = "http://www.spock.li";
       description = "Another Haskell web framework for rapid development";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Spock" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , case-insensitive, containers, crypto-random, directory, focus
     , hashable, hspec, hspec-wai, http-types, hvect, list-t
     , monad-control, mtl, old-locale, path-pieces, random, reroute
     , resource-pool, resourcet, stm, stm-containers, text, time
     , transformers, transformers-base, unordered-containers, vault, wai
     , wai-extra, warp
     }:
     mkDerivation {
       pname = "Spock";
       version = "0.10.0.1";
       sha256 = "ef80deb37728e89369f34c3a8cc9c4190d8aa50911a08a9e1e0c1993466595d2";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring case-insensitive containers
         crypto-random directory focus hashable http-types hvect list-t
         monad-control mtl old-locale path-pieces random reroute
         resource-pool resourcet stm stm-containers text time transformers
         transformers-base unordered-containers vault wai wai-extra warp
       ];
       testHaskellDepends = [
         base base64-bytestring bytestring hspec hspec-wai http-types
         reroute stm text time unordered-containers wai wai-extra
       ];
       homepage = "http://www.spock.li";
       description = "Another Haskell web framework for rapid development";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Spock-auth" = callPackage
    ({ mkDerivation, base, http-types, Spock, text, time }:
     mkDerivation {
       pname = "Spock-auth";
       version = "0.2.0.1";
       sha256 = "a05fdae300281affe0ca45c2f2338f62afdd01da5ea8bf7c8a1958895ba199ed";
       libraryHaskellDepends = [ base http-types Spock text time ];
       jailbreak = true;
       homepage = "https://github.com/agrafix/Spock-auth";
       description = "Provides authentification helpers for Spock";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Spock-digestive_0_1_0_0" = callPackage
    ({ mkDerivation, base, digestive-functors, http-types, mtl, Spock
     , text, unordered-containers, wai
     }:
     mkDerivation {
       pname = "Spock-digestive";
       version = "0.1.0.0";
       sha256 = "c768f30f6fadc71b8498d847349b8250c9569d56c5afbae40c42f1e7a0e08c10";
       libraryHaskellDepends = [
         base digestive-functors http-types mtl Spock text
         unordered-containers wai
       ];
       homepage = "https://github.com/agrafix/Spock-digestive";
       description = "Digestive functors support for Spock";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Spock-digestive_0_1_0_1" = callPackage
    ({ mkDerivation, base, digestive-functors, http-types, mtl, Spock
     , text, unordered-containers, wai
     }:
     mkDerivation {
       pname = "Spock-digestive";
       version = "0.1.0.1";
       sha256 = "d453585fb08777a67e80ae25f1c6e390097e2f4827e0510f6c550ee2cb36e68c";
       libraryHaskellDepends = [
         base digestive-functors http-types mtl Spock text
         unordered-containers wai
       ];
       homepage = "https://github.com/agrafix/Spock-digestive";
       description = "Digestive functors support for Spock";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Spock-digestive" = callPackage
    ({ mkDerivation, base, digestive-functors, http-types, mtl, Spock
     , text, unordered-containers, wai
     }:
     mkDerivation {
       pname = "Spock-digestive";
       version = "0.2.0.0";
       sha256 = "e5571d88d7b9dcafc7f5c364c8499a1d8d698d1698f2615b5f26698c85080260";
       libraryHaskellDepends = [
         base digestive-functors http-types mtl Spock text
         unordered-containers wai
       ];
       homepage = "https://github.com/agrafix/Spock-digestive";
       description = "Digestive functors support for Spock";
       license = stdenv.lib.licenses.mit;
     }) {};

  "Spock-worker" = callPackage
    ({ mkDerivation, base, containers, HTF, lifted-base, mtl, Spock
     , stm, text, time, transformers, vector
     }:
     mkDerivation {
       pname = "Spock-worker";
       version = "0.2.1.3";
       sha256 = "4105ebdfa39aa0465ca82a3b4294538b4c5acc727a1f80c052b79b85193bb05f";
       libraryHaskellDepends = [
         base containers lifted-base mtl Spock stm text time transformers
         vector
       ];
       testHaskellDepends = [ base containers HTF stm vector ];
       homepage = "http://github.com/agrafix/Spock-worker";
       description = "Background workers for Spock";
       license = stdenv.lib.licenses.mit;
     }) {};

  "SpreadsheetML" = callPackage
    ({ mkDerivation, base, xml }:
     mkDerivation {
       pname = "SpreadsheetML";
       version = "0.1";
       sha256 = "28ac9a7eaee61471aae34a0530c1dafc7987c85c0b2ecac4da1a50c5c074a391";
       libraryHaskellDepends = [ base xml ];
       description = "Write support for Excel's SpreadsheetML format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Sprig" = callPackage
    ({ mkDerivation, base, SDL }:
     mkDerivation {
       pname = "Sprig";
       version = "0.1.1";
       sha256 = "76d1c04b622f998bda5b6a90329314b60f4923b2d0a96dd1d87127c360d05d1a";
       libraryHaskellDepends = [ base SDL ];
       homepage = "http://liamoc.net/static/Sprig";
       description = "Binding to Sprig";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Stasis" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "Stasis";
       version = "0.0.1";
       sha256 = "0833e8942085e4ef8c74e40736deafea42725a9b80b6a686fbfb3c0806abccdf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/zcourts/Stasis";
       description = "A simple MVCC like library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "StateVar_1_1_0_0" = callPackage
    ({ mkDerivation, base, stm, transformers }:
     mkDerivation {
       pname = "StateVar";
       version = "1.1.0.0";
       sha256 = "a19963f014d45163035a3c54e5266b31dfe53a640e53d869ee946efcf9793d7e";
       libraryHaskellDepends = [ base stm transformers ];
       homepage = "https://github.com/haskell-opengl/StateVar";
       description = "State variables";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "StateVar_1_1_0_1" = callPackage
    ({ mkDerivation, base, stm, transformers }:
     mkDerivation {
       pname = "StateVar";
       version = "1.1.0.1";
       sha256 = "0eae79ccc58509f2302cb90f2306d6bb2f1805a2847058fa643d18cc370be5aa";
       libraryHaskellDepends = [ base stm transformers ];
       homepage = "https://github.com/haskell-opengl/StateVar";
       description = "State variables";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "StateVar_1_1_0_2" = callPackage
    ({ mkDerivation, base, stm, transformers }:
     mkDerivation {
       pname = "StateVar";
       version = "1.1.0.2";
       sha256 = "051c4b98bc4456afe4eb26f775ab0aa370e9e12b1588d5865abd5b0aea83c3f9";
       libraryHaskellDepends = [ base stm transformers ];
       homepage = "https://github.com/haskell-opengl/StateVar";
       description = "State variables";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "StateVar" = callPackage
    ({ mkDerivation, base, stm, transformers }:
     mkDerivation {
       pname = "StateVar";
       version = "1.1.0.3";
       sha256 = "b494e6895185826cef9c67be54bb73beb2b76ad69a963c5d7e83da59dc0eac2f";
       libraryHaskellDepends = [ base stm transformers ];
       homepage = "https://github.com/haskell-opengl/StateVar";
       description = "State variables";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "StateVar-transformer" = callPackage
    ({ mkDerivation, base, mtl, transformers }:
     mkDerivation {
       pname = "StateVar-transformer";
       version = "1.0.0.0";
       sha256 = "a00d8eb64012b7563d48ad42d5b49c768208da7eb6540ec455c479f325ef77b5";
       libraryHaskellDepends = [ base mtl transformers ];
       homepage = "http://github.com/seagull-kamome/StateVar-transformer";
       description = "State variables";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "StatisticalMethods" = callPackage
    ({ mkDerivation, base, statistics, tuple, vector }:
     mkDerivation {
       pname = "StatisticalMethods";
       version = "0.0.0.1";
       sha256 = "2647a85aa5d29898230cea576176f3e115f3beab27629fff10bbdb99998920c1";
       libraryHaskellDepends = [ base statistics tuple vector ];
       homepage = "http://www.tbi.univie.ac.at/~choener/Haskell/";
       description = "Collection of useful statistical methods";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "Stomp" = callPackage
    ({ mkDerivation, base, binary, bytestring, network, time
     , utf8-string
     }:
     mkDerivation {
       pname = "Stomp";
       version = "0.1.1";
       sha256 = "968fb85a6b94b60c16ad96e8169202082a33f54dcf5d705c1b4096a5a05db139";
       libraryHaskellDepends = [
         base binary bytestring network time utf8-string
       ];
       homepage = "http://github.com/rukav/Stomp";
       description = "Client library for Stomp brokers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Strafunski-ATermLib" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "Strafunski-ATermLib";
       version = "1.6.0.3";
       sha256 = "fc378082e94514decc28de2820c498986d53a61b359d3b3c9189fa591af92cb2";
       libraryHaskellDepends = [ base containers ];
       jailbreak = true;
       description = "An abstract data type designed for the exchange of tree-like data structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Strafunski-Sdf2Haskell" = callPackage
    ({ mkDerivation, base, directory, haskell-src, mtl, pretty, process
     , Strafunski-ATermLib, Strafunski-StrategyLib, template-haskell
     }:
     mkDerivation {
       pname = "Strafunski-Sdf2Haskell";
       version = "1.0.0.2";
       sha256 = "602c6ee481b3b6a9eb7ca8f0eb2682fb9af165e01057b5cf1d13d04b8ef4e340";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory haskell-src mtl pretty process Strafunski-ATermLib
         Strafunski-StrategyLib template-haskell
       ];
       jailbreak = true;
       description = "Converts SDF to Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Strafunski-StrategyLib" = callPackage
    ({ mkDerivation, base, directory, mtl, syb, transformers }:
     mkDerivation {
       pname = "Strafunski-StrategyLib";
       version = "5.0.0.8";
       sha256 = "4c552011c167dc361bb9665c3bc889a9937702af863dc5fdb946fe9633a36926";
       libraryHaskellDepends = [ base directory mtl syb transformers ];
       description = "Library for strategic programming";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "StrappedTemplates" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers
     , filemanip, filepath, hspec, mtl, parsec, text, transformers
     }:
     mkDerivation {
       pname = "StrappedTemplates";
       version = "0.2.0.2";
       sha256 = "d078997983ace38c0f908e325d213f81474466e45dcf51c6e53765b17ed61674";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers filemanip filepath mtl
         parsec text transformers
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec text ];
       jailbreak = true;
       homepage = "https://github.com/hansonkd/StrappedTemplates";
       description = "General purpose templates in haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "StrategyLib" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "StrategyLib";
       version = "4.0.0.0";
       sha256 = "b31b841c5af0020c31fb923ca6a98d894c390e542f44a217892fd4cb7db353eb";
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://naesten.dyndns.org:8080/repos/StrategyLib";
       license = stdenv.lib.licenses.unfree;
     }) {};

  "Stream" = callPackage
    ({ mkDerivation, base, lazysmallcheck, QuickCheck }:
     mkDerivation {
       pname = "Stream";
       version = "0.4.7.2";
       sha256 = "990be249b3ef1b0075563026d4d2c803b86e3cbf168965ba6f9f2b4227a007d1";
       libraryHaskellDepends = [ base lazysmallcheck QuickCheck ];
       description = "A library for manipulating infinite lists";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "StrictBench" = callPackage
    ({ mkDerivation, base, benchpress, parallel }:
     mkDerivation {
       pname = "StrictBench";
       version = "0.1.1";
       sha256 = "751caae386b89d7031288d8233e61aa4eeb5b3cecacb991048af5028f33994d0";
       libraryHaskellDepends = [ base benchpress parallel ];
       homepage = "http://bonsaicode.wordpress.com/2009/06/07/strictbench-0-1/";
       description = "Benchmarking code through strict evaluation";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "SuffixStructures" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, cereal, cmdargs
     , containers, data-default-class, ListLike, primitive, vector
     , vector-algorithms, vector-binary-instances
     }:
     mkDerivation {
       pname = "SuffixStructures";
       version = "0.0.1.0";
       sha256 = "8b0e6349f1a3e19e81380d87bc7745a91fd6e6d39d058bb08925c96b80264968";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base binary bytestring cereal containers data-default-class
         ListLike primitive vector vector-algorithms vector-binary-instances
       ];
       executableHaskellDepends = [
         aeson base binary bytestring cereal cmdargs containers vector
       ];
       jailbreak = true;
       homepage = "http://www.bioinf.uni-leipzig.de/~choener/";
       description = "Suffix array construction";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "SybWidget" = callPackage
    ({ mkDerivation, base, containers, mtl, syb-with-class
     , template-haskell, TypeCompose
     }:
     mkDerivation {
       pname = "SybWidget";
       version = "0.5.6";
       sha256 = "c82cb1593932bed3858b4b10ca44198980593d0356ea8e69fd433b90e8557754";
       libraryHaskellDepends = [
         base containers mtl syb-with-class template-haskell TypeCompose
       ];
       jailbreak = true;
       description = "Library which aids constructing generic (SYB3-based) widgets";
       license = "LGPL";
     }) {};

  "SyntaxMacros" = callPackage
    ({ mkDerivation, AspectAG, base, containers, HList, ListLike
     , template-haskell, TTTAS, uu-parsinglib, uulib
     }:
     mkDerivation {
       pname = "SyntaxMacros";
       version = "1.0.3";
       sha256 = "ccef54664f442a1871531a541c08af28b91694f58dfbcc04fb468037cf9ebb94";
       libraryHaskellDepends = [
         AspectAG base containers HList ListLike template-haskell TTTAS
         uu-parsinglib uulib
       ];
       homepage = "http://www.cs.uu.nl/wiki/Center/SyntaxMacrosForFree";
       description = "Syntax Macros in the form of an EDSL";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Sysmon" = callPackage
    ({ mkDerivation, base, ConfigFile, filepath, fingertree, Glob
     , MissingH, mtl, old-locale, pretty, statistics, template-haskell
     , time, vector
     }:
     mkDerivation {
       pname = "Sysmon";
       version = "0.1.2";
       sha256 = "e3aa721caa64934bdf9823638305f588a4edbe15058b1b2bcb4ab2b8c718d7ff";
       libraryHaskellDepends = [
         base ConfigFile filepath fingertree Glob MissingH mtl old-locale
         pretty statistics template-haskell time vector
       ];
       homepage = "http://github.com/rukav/Sysmon";
       description = "Sybase 15 sysmon reports processor";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "TBC" = callPackage
    ({ mkDerivation, base, Cabal, deepseq, directory, filepath, process
     , unix
     }:
     mkDerivation {
       pname = "TBC";
       version = "0.0.3";
       sha256 = "c3b6ef59bba3e6f6eb4e2293e9a79d16067fd0c817f91e8836ab9201f664c380";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal deepseq directory filepath process
       ];
       executableHaskellDepends = [
         base Cabal directory filepath process unix
       ];
       description = "Testing By Convention";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "TBit" = callPackage
    ({ mkDerivation, base, containers, deepseq, fgl, free, hmatrix
     , integration, list-extras, mtl, numeric-tools, parallel
     }:
     mkDerivation {
       pname = "TBit";
       version = "0.4.2.3";
       sha256 = "3a73b3904666d571790c1b5127cb6e028fc26608a99e0b6f78d3aac185e7c1af";
       libraryHaskellDepends = [
         base containers deepseq fgl free hmatrix integration list-extras
         mtl numeric-tools parallel
       ];
       jailbreak = true;
       description = "Utilities for condensed matter physics tight binding calculations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "TCache" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory
     , hashtables, mtl, old-time, RefSerialize, stm, text
     }:
     mkDerivation {
       pname = "TCache";
       version = "0.12.0";
       sha256 = "fab4e5fb6751a06324994577d6d4e5feae106496d28326e2c8c63c593ed55955";
       libraryHaskellDepends = [
         base bytestring containers directory hashtables mtl old-time
         RefSerialize stm text
       ];
       description = "A Transactional cache with user-defined persistence";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "THEff" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "THEff";
       version = "0.1.1.0";
       sha256 = "545725746fa7ea7d77cdb1447a1f2564ddfe36624c8a3118a7e8d0b009ef2462";
       libraryHaskellDepends = [ base template-haskell ];
       description = "TH implementation of effects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "TTTAS" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "TTTAS";
       version = "0.6.0";
       sha256 = "978746bb5372a1dddb322a7364366a8f3ca8091d054b4870f193903760cfe3a2";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.cs.uu.nl/wiki/bin/view/Center/TTTAS";
       description = "Typed Transformations of Typed Abstract Syntax";
       license = "LGPL";
     }) {};

  "TV" = callPackage
    ({ mkDerivation, base, DeepArrow, TypeCompose }:
     mkDerivation {
       pname = "TV";
       version = "0.5.0";
       sha256 = "6bf7dba5fef81d4bb428a0f4419c8e8d14e93e9bc6a1d0e85fd35e2f7791e96f";
       libraryHaskellDepends = [ base DeepArrow TypeCompose ];
       homepage = "http://haskell.org/haskellwiki/TV";
       description = "Tangible Values -- composable interfaces";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "TYB" = callPackage
    ({ mkDerivation, array, base, containers, mtl, template-haskell
     , transformers
     }:
     mkDerivation {
       pname = "TYB";
       version = "0.2.3";
       sha256 = "b6fc2644d012c727faabd74c2c6520ea7b204118b9237d2230d194f09a91bce5";
       libraryHaskellDepends = [
         array base containers mtl template-haskell transformers
       ];
       description = "Template Your Boilerplate - a Template Haskell version of SYB";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "TableAlgebra" = callPackage
    ({ mkDerivation, base, containers, HaXml, mtl, pretty
     , template-haskell
     }:
     mkDerivation {
       pname = "TableAlgebra";
       version = "0.7.1";
       sha256 = "7f11ed02510cd2a86a6356ea0a4356fc18d1e34b8c54a8858f9e4efbbd9513cb";
       libraryHaskellDepends = [
         base containers HaXml mtl pretty template-haskell
       ];
       description = "Ferry Table Algebra";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Tables" = callPackage
    ({ mkDerivation, base, cookbook }:
     mkDerivation {
       pname = "Tables";
       version = "0.1.0.2";
       sha256 = "793a4754d85b109d8904cdb973f9ab61583c7d19773d4a0e3bbb428e17574609";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base cookbook ];
       jailbreak = true;
       description = "A client for Quill databases";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Tablify" = callPackage
    ({ mkDerivation, base, parsec, xhtml }:
     mkDerivation {
       pname = "Tablify";
       version = "0.8.2";
       sha256 = "e3ebf5677e991f12667935176e4f31cf092d1617ab66bae4ccb3be0c658b8383";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base parsec xhtml ];
       homepage = "http://www.storytotell.org/code/tablify";
       description = "Tool to render CSV into tables of various formats";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Tainted" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "Tainted";
       version = "0.1.0.2";
       sha256 = "8b56335f2a61f3a9ab420f698bd052f1aef52fd59a6e2aad511c62417e4059d6";
       libraryHaskellDepends = [ base mtl ];
       homepage = "https://github.com/RossMeikleham/Tainted";
       description = "Tainted type, and associated operations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Takusen" = callPackage
    ({ mkDerivation, base, mtl, old-time, time }:
     mkDerivation {
       pname = "Takusen";
       version = "0.8.7";
       sha256 = "9e9fe740a9030e27ee84343a7e308853b0e5d50371a841d9a3979a9f8d99ac57";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl old-time time ];
       executableHaskellDepends = [ base mtl old-time ];
       description = "Database library with left-fold interface, for PostgreSQL, Oracle, SQLite, ODBC";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Tape" = callPackage
    ({ mkDerivation, base, comonad, distributive, Stream }:
     mkDerivation {
       pname = "Tape";
       version = "0.4.0.0";
       sha256 = "77199900d9deff059a92de2e10f13e55b2c4e074ddd16714c1c3b2c88ea1c6b4";
       libraryHaskellDepends = [ base comonad distributive Stream ];
       jailbreak = true;
       homepage = "https://github.com/kwf/Tape";
       description = "Bidirectionally infinite streams, akin to the tape of a Turing machine";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Taxonomy" = callPackage
    ({ mkDerivation, aeson, base, bytestring, either-unwrap, fgl
     , graphviz, parsec, text, vector
     }:
     mkDerivation {
       pname = "Taxonomy";
       version = "1.0.1";
       sha256 = "22d434dc827c75c0ab2075f81e689de22ed7a79d955625fdee18f047570ca289";
       revision = "1";
       editedCabalFile = "b8a2e83455df8cc4f08354e0f28625d0a16c94a5d54fda667d7e3a8bfeb369f3";
       libraryHaskellDepends = [
         aeson base bytestring either-unwrap fgl graphviz parsec text vector
       ];
       description = "Libary for parsing, processing and vizualization of taxonomy data";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "TaxonomyTools" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cassava, cmdargs
     , directory, either-unwrap, EntrezHTTP, fgl, hxt, parsec, process
     , Taxonomy, vector
     }:
     mkDerivation {
       pname = "TaxonomyTools";
       version = "1.0.0";
       sha256 = "6019493009c6b720fdabae83c939460780dca06ec67251160814f1dca842f26a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring cassava cmdargs directory either-unwrap
         EntrezHTTP fgl hxt parsec process Taxonomy vector
       ];
       description = "Tool for parsing, processing, comparing and visualizing taxonomy data";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "TeaHS" = callPackage
    ({ mkDerivation, array, base, containers, mtl, SDL, SDL-image
     , SDL-mixer, SFont, Sprig
     }:
     mkDerivation {
       pname = "TeaHS";
       version = "0.3.1";
       sha256 = "96d5fa830ecd90a31baf261713e741dd3211bf7f68f49bfcb1fe093e6fa6468c";
       libraryHaskellDepends = [
         array base containers mtl SDL SDL-image SDL-mixer SFont Sprig
       ];
       homepage = "http://liamoc.net/tea";
       description = "TeaHS Game Creation Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Tensor" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Tensor";
       version = "1.1.0.1";
       sha256 = "55840a4fe93deaddb568492e2be4f6908de1dd18db85b73c766b7dcda4b311e1";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/svenpanne/Tensor";
       description = "Tensor data types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "TernaryTrees" = callPackage
    ({ mkDerivation, base, binary }:
     mkDerivation {
       pname = "TernaryTrees";
       version = "0.2.0.2";
       sha256 = "9937a648eeb4c1a1530158361540710f6e31e0056b459eac77da04ca52aca41a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base binary ];
       executableHaskellDepends = [ base ];
       description = "Efficient pure ternary tree Sets and Maps";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "TestExplode" = callPackage
    ({ mkDerivation, base, containers, directory, fgl, graphviz
     , interpolatedstring-perl6, mtl, process, text
     }:
     mkDerivation {
       pname = "TestExplode";
       version = "0.1.0.0";
       sha256 = "4133d9f69e7df366ac374ccb42bd9801ae66c0cd29f9f20ab849d1d8f8e79664";
       revision = "3";
       editedCabalFile = "8c288eba01903e9c55bb60350b9a607f88b6a8537c2156bdbed5aa9be071a804";
       libraryHaskellDepends = [
         base containers directory fgl graphviz interpolatedstring-perl6 mtl
         process text
       ];
       homepage = "https://github.com/testexplode/testexplode";
       description = "Generates testcases from program-snippets";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "Theora" = callPackage
    ({ mkDerivation, base, ogg, theora }:
     mkDerivation {
       pname = "Theora";
       version = "1.0";
       sha256 = "2f02b05f75561bbf59275d52309e79a402eab3fef23db73161dc9bc57b3d89bf";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ ogg theora ];
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {ogg = null; theora = null;};

  "Thingie" = callPackage
    ({ mkDerivation, base, cairo, gtk, mtl }:
     mkDerivation {
       pname = "Thingie";
       version = "0.80";
       sha256 = "8ae35e5711cf126fff0477b987c02ed0ae47c16bd229c2be7fc59cbbc5bc863a";
       libraryHaskellDepends = [ base cairo gtk mtl ];
       description = "Purely functional 2D drawing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ThreadObjects" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ThreadObjects";
       version = "0.0";
       sha256 = "bf62a5e4183bbc8768e79a3d4631f564c2fc3c6e782067869c3e94c1a7d9ec66";
       libraryHaskellDepends = [ base ];
       description = "Mutable objects that reside in their own threads";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "Thrift" = callPackage
    ({ mkDerivation, base, binary, bytestring, ghc-prim, HTTP, network
     }:
     mkDerivation {
       pname = "Thrift";
       version = "0.6.0.1";
       sha256 = "db972c282932a51a069a2301cb6f71d4eb019873bf2d3f90f457028abf49647a";
       revision = "1";
       editedCabalFile = "56a8ab041685777391702f1475e5c2a3462b36765bd53de2e21e1f55aa5999d9";
       libraryHaskellDepends = [
         base binary bytestring ghc-prim HTTP network
       ];
       jailbreak = true;
       homepage = "http://thrift.apache.org";
       description = "Haskell bindings for the Apache Thrift RPC system";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Tic-Tac-Toe" = callPackage
    ({ mkDerivation, base, safe }:
     mkDerivation {
       pname = "Tic-Tac-Toe";
       version = "0.1.0.2";
       sha256 = "bfe5dd9b3bc2b7396282fe3036b096a3dfcac19d73ad10fc8609fb4e59c8c799";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base safe ];
       homepage = "https://github.com/2016rshah/Tic-Tac-Toe";
       description = "Tic Tac Toe in your command line!";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "TicTacToe" = callPackage
    ({ mkDerivation, base, containers, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "TicTacToe";
       version = "0.0.1";
       sha256 = "843b472d9e878994cf41b863cba9323d2c01ffefa94d6877e3d4167b63868214";
       libraryHaskellDepends = [
         base containers HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       description = "A sub-project (exercise) for a functional programming course";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "TigerHash" = callPackage
    ({ mkDerivation, base, binary, bytestring, dataenc }:
     mkDerivation {
       pname = "TigerHash";
       version = "0.2";
       sha256 = "333631a1620819fd3500125f631d84ded06945b73aeb42af1c77577a7cf8f40a";
       libraryHaskellDepends = [ base binary bytestring dataenc ];
       description = "TigerHash with C implementation";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "TimePiece" = callPackage
    ({ mkDerivation, base, containers, old-locale, old-time, random
     , SDL, SDL-gfx, SDL-image, SDL-ttf
     }:
     mkDerivation {
       pname = "TimePiece";
       version = "0.0.5";
       sha256 = "72fdcc586dfdfb9c1968e7f86d4ff2d5c6f5fc9e3b8215dfd78724e7ff248efa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers old-locale old-time random SDL SDL-gfx SDL-image
         SDL-ttf
       ];
       executableHaskellDepends = [
         base containers old-locale old-time random SDL SDL-gfx SDL-image
         SDL-ttf
       ];
       description = "A simple tile-based digital clock screen saver";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "TinyLaunchbury" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "TinyLaunchbury";
       version = "1.0.1";
       sha256 = "6991d5a0e9a09c04a7ac32c7a386173431d04d75c8e2bcd107f42d7c516baaf7";
       libraryHaskellDepends = [ base mtl ];
       description = "Simple implementation of call-by-need using Launchbury's semantics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "TinyURL" = callPackage
    ({ mkDerivation, base, HTTP, network }:
     mkDerivation {
       pname = "TinyURL";
       version = "0.1.0";
       sha256 = "507340820d644cc84d5e92673858f302640d4e7c5f71102a945ff438b8a10b79";
       libraryHaskellDepends = [ base HTTP network ];
       description = "Use TinyURL to compress URLs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Titim" = callPackage
    ({ mkDerivation, base, containers, matrix, random }:
     mkDerivation {
       pname = "Titim";
       version = "0.2.3";
       sha256 = "5bed63fd43f6f02c9b06c748902dd6ddb07c65a40688d24a81fda68cc6da1fe9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers matrix random ];
       jailbreak = true;
       description = "Game for Lounge Marmelade";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Top" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec }:
     mkDerivation {
       pname = "Top";
       version = "1.7";
       sha256 = "3d8da13be43fa6393d660bc0ec17c4336a93d8f0ac5808c6274149af3866717a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers mtl ];
       executableHaskellDepends = [ base containers mtl parsec ];
       homepage = "http://www.cs.uu.nl/wiki/bin/view/Helium/WebHome";
       description = "Constraint solving framework employed by the Helium Compiler";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Tournament" = callPackage
    ({ mkDerivation, base, containers, mtl, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "Tournament";
       version = "0.0.1";
       sha256 = "53161b646dde077f6bef2bb796a65da9965f94cdd105bc55f74e9737ae66effb";
       libraryHaskellDepends = [ base containers mtl ];
       testHaskellDepends = [
         base containers mtl QuickCheck test-framework
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/clux/tournament.hs";
       description = "Tournament related algorithms";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "TraceUtils" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "TraceUtils";
       version = "0.1.0.2";
       sha256 = "267cfc9366ad5ad50f12c09b8bac6d8eb044377050049022d7779d66bd4f4151";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/Peaker/TraceUtils";
       description = "Functions that should have been in Debug.Trace";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "TransformersStepByStep" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "TransformersStepByStep";
       version = "0.1.1.0";
       sha256 = "3784e2398da4c09b7b3179f826e1f5da59c57cea81ff094edbf5a7f80cd4a8b1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers mtl ];
       homepage = "https://github.com/mgrabmueller/TransformersStepByStep";
       description = "Tutorial on monad transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Transhare" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "Transhare";
       version = "0.9";
       sha256 = "668030dae27efa11ba8f3937c051eac2b79d8cfc4b79be2d8ee1e0014da3c112";
       libraryHaskellDepends = [ base containers ];
       description = "A library to apply transformation to containers so as to maximize sharing of unchanged subcomponents";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "TreeCounter" = callPackage
    ({ mkDerivation, base, ref-mtl, stm }:
     mkDerivation {
       pname = "TreeCounter";
       version = "0.0.2";
       sha256 = "54fd5c837a9193e97d490ec3169f5cb3d5c1cf821bdfccc7894f53f7d0269119";
       libraryHaskellDepends = [ base ref-mtl stm ];
       jailbreak = true;
       homepage = "https://github.com/Julek";
       description = "Wait-free Tree Counter";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "TreeStructures" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "TreeStructures";
       version = "0.0.2";
       sha256 = "5dfb5bacaddc363e88706bd8fead6f977f635bc7fd6c891d28e838148d0992d1";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://www.github.com/bhickey/TreeStructures";
       description = "A collection of heaps and search trees";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "TreeT" = callPackage
    ({ mkDerivation, base, containers, transformers }:
     mkDerivation {
       pname = "TreeT";
       version = "0.0";
       sha256 = "0df7ef29c8737ccf8daf10fb8a2b33768ad64526619365a4807a5a4697253334";
       libraryHaskellDepends = [ base containers transformers ];
       description = "Transformer for Data.Tree";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "Treiber" = callPackage
    ({ mkDerivation, base, ghc-prim, monad-loops, ref-mtl, stm }:
     mkDerivation {
       pname = "Treiber";
       version = "0.0.4";
       sha256 = "4d8eef82810106d23463bfcd43dbb63becb7a96d6f873ba17213ffe1c34d4d27";
       libraryHaskellDepends = [ base ghc-prim monad-loops ref-mtl stm ];
       jailbreak = true;
       homepage = "https://github.com/Julek";
       description = "Lock free Treiber stack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "TrendGraph" = callPackage
    ({ mkDerivation, base, containers, diagrams-cairo, diagrams-lib
     , mtl, optparse-applicative, time
     }:
     mkDerivation {
       pname = "TrendGraph";
       version = "0.1.0.1";
       sha256 = "77fe6851ae96cf929a14290f4e2a790a3f8b587f1f5b68674240ddb6688db4e5";
       libraryHaskellDepends = [
         base containers diagrams-cairo diagrams-lib mtl
         optparse-applicative time
       ];
       jailbreak = true;
       description = "A simple trend Graph script";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "TrieMap" = callPackage
    ({ mkDerivation, base, bytestring, containers, primitive
     , template-haskell, th-expand-syns, transformers, unpack-funcs
     , vector
     }:
     mkDerivation {
       pname = "TrieMap";
       version = "4.1.0";
       sha256 = "845dca9ad94e7411a4ef341f5f508abaae91394e501d6f8c92ac0ca5038d9993";
       libraryHaskellDepends = [
         base bytestring containers primitive template-haskell
         th-expand-syns transformers unpack-funcs vector
       ];
       description = "Automatic type inference of generalized tries with Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Twofish" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, cereal
     , crypto-api, HUnit, largeword, mtl, tagged
     }:
     mkDerivation {
       pname = "Twofish";
       version = "0.3.2";
       sha256 = "aaf8c0bd1bcf04fdbd447d6fbadba2f5ac1cd1345a43578a988f7727504967af";
       libraryHaskellDepends = [
         array base binary bytestring cereal crypto-api largeword mtl tagged
       ];
       testHaskellDepends = [
         array base binary bytestring cereal crypto-api HUnit largeword
         tagged
       ];
       homepage = "http://github.com/rleisti/twofish";
       description = "An implementation of the Twofish Symmetric-key cipher";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "TypeClass" = callPackage
    ({ mkDerivation, base, containers, filepath, random
     , reactive-banana, reactive-banana-sdl, SDL, SDL-ttf, transformers
     }:
     mkDerivation {
       pname = "TypeClass";
       version = "0.2.1";
       sha256 = "1bcae261f6b74a0a4aea65cf1258721f8b98464788fcbae882a0f790f8ab3e33";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers filepath random reactive-banana reactive-banana-sdl
         SDL SDL-ttf transformers
       ];
       jailbreak = true;
       description = "Typing speed game";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "TypeCompose" = callPackage
    ({ mkDerivation, base, base-orphans }:
     mkDerivation {
       pname = "TypeCompose";
       version = "0.9.11";
       sha256 = "124c2f9971aa8e45c8cc4f706407f9c28805e63b387400a0b2b9e115aa22044a";
       libraryHaskellDepends = [ base base-orphans ];
       homepage = "https://github.com/conal/TypeCompose";
       description = "Type composition classes & instances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "TypeIlluminator" = callPackage
    ({ mkDerivation, base, haskell98 }:
     mkDerivation {
       pname = "TypeIlluminator";
       version = "0.0";
       sha256 = "0c3e7734e5c6852ac2c2fae80f1a68d45dda440d56ad34134a70f332a33e9309";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskell98 ];
       homepage = "http://www.cs.kent.ac.uk/people/staff/oc/TypeIlluminator/";
       description = "TypeIlluminator is a prototype tool exploring debugging of type errors/";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "TypeNat" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "TypeNat";
       version = "0.4.0.1";
       sha256 = "e62ef42bad43ca0487d59fe7840313e31fe47a05f210cf37786dd6f5897504f3";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/avieth/TypeNat";
       description = "Some Nat-indexed types for GHC";
       license = stdenv.lib.licenses.mit;
     }) {};

  "TypingTester" = callPackage
    ({ mkDerivation, base, containers, directory, time }:
     mkDerivation {
       pname = "TypingTester";
       version = "0.2.0.0";
       sha256 = "d650609a7e073ec772940572b059236b536b4c75644e2c4ad9c484025bdd1c1f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers directory time ];
       homepage = "https://github.com/xpika/typingtester";
       description = "Command Line Typing speed tester";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "UISF" = callPackage
    ({ mkDerivation, array, arrows, base, containers, deepseq, GLUT
     , OpenGL, stm, transformers
     }:
     mkDerivation {
       pname = "UISF";
       version = "0.4.0.0";
       sha256 = "1d2084f1c81364b830fab4937901b83bee08addf6ea4e8123573b084cd80f3e7";
       libraryHaskellDepends = [
         array arrows base containers deepseq GLUT OpenGL stm transformers
       ];
       homepage = "http://haskell.cs.yale.edu/";
       description = "Library for Arrowized Graphical User Interfaces";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "UMM" = callPackage
    ({ mkDerivation, base, haskell98, old-time, parsec, process
     , utf8-string
     }:
     mkDerivation {
       pname = "UMM";
       version = "0.3.1";
       sha256 = "b0e0697180aaa359a733dd6eba62a1f313491480ff57cf5cf366dacf26dd334d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base haskell98 old-time parsec process utf8-string
       ];
       homepage = "http://www.korgwal.com/umm/";
       description = "A small command-line accounting tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "URLT" = callPackage
    ({ mkDerivation, applicative-extras, base, Consumer
     , happstack-server, hsp, hsx, mtl, QuickCheck, regular
     , template-haskell
     }:
     mkDerivation {
       pname = "URLT";
       version = "0.14";
       sha256 = "7a3cf19bb5d070a27d4fafe88789b4660f192af41431d120a743db3858f61493";
       libraryHaskellDepends = [
         applicative-extras base Consumer happstack-server hsp hsx mtl
         QuickCheck regular template-haskell
       ];
       description = "Library for maintaining correctness of URLs within an application";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "URLb" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers }:
     mkDerivation {
       pname = "URLb";
       version = "0.0.1";
       sha256 = "b9dba10748c51f3f47d3f58a45dd80eaa327006251989f97237e2d94cef9c2d0";
       libraryHaskellDepends = [ attoparsec base bytestring containers ];
       homepage = "http://github.com/solidsnack/URLb";
       description = "DEPRECATED A simple, liberal URL parser";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "UTFTConverter" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, hspec
     , JuicyPixels, time
     }:
     mkDerivation {
       pname = "UTFTConverter";
       version = "0.1.0.0";
       sha256 = "5679130800bbb11e3a67ab638e97e733b4824edff8b8a6b2e88b7daaf56b934e";
       revision = "10";
       editedCabalFile = "abbfdf9c3e4816c0f010740a21d3360ceb55d2591329c92d6b163015fd581e01";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring directory filepath JuicyPixels time
       ];
       executableHaskellDepends = [
         base bytestring directory filepath JuicyPixels time
       ];
       testHaskellDepends = [
         base bytestring directory filepath hspec JuicyPixels time
       ];
       jailbreak = true;
       homepage = "http://github.com/cirquit/UTFTConverter";
       description = "Processing popular picture formats into .c or .raw format in RGB565";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Unique" = callPackage
    ({ mkDerivation, base, containers, extra, hashable
     , unordered-containers
     }:
     mkDerivation {
       pname = "Unique";
       version = "0.4.2";
       sha256 = "82b5410ba4b432389b0897be3726c9eed9a08cdadc530cabf89d9bb890b13e66";
       libraryHaskellDepends = [
         base containers extra hashable unordered-containers
       ];
       jailbreak = true;
       description = "It provides the functionality like unix \"uniq\" utility";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Unixutils" = callPackage
    ({ mkDerivation, base, bytestring, directory, exceptions, filepath
     , mtl, process, process-extras, pureMD5, regex-tdfa, unix, zlib
     }:
     mkDerivation {
       pname = "Unixutils";
       version = "1.54.1";
       sha256 = "f9295529744cb2658364956f376ff506dc1876eb2b0148e5b09c1a4bc4732644";
       libraryHaskellDepends = [
         base bytestring directory exceptions filepath mtl process
         process-extras pureMD5 regex-tdfa unix zlib
       ];
       homepage = "https://github.com/seereason/haskell-unixutils.git";
       description = "A crude interface between Haskell and Unix-like operating systems";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Unixutils-shadow" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "Unixutils-shadow";
       version = "1.0.0";
       sha256 = "277bfb031b827570f155e67ee06531da92495c8f589fa8913c70cb2cf0a3a886";
       libraryHaskellDepends = [ base unix ];
       homepage = "http://src.seereason.com/haskell-unixutils-shadow";
       description = "A simple interface to shadow passwords (aka, shadow.h)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "Updater" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Updater";
       version = "0.3";
       sha256 = "e0cfe9572c1561741dc35c73f40335c98cb96801993a232b033e92e66f2a3e47";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/yokto/Updater";
       description = "Monadic FRP library based on stm";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "UrlDisp" = callPackage
    ({ mkDerivation, base, cgi, MaybeT, mtl }:
     mkDerivation {
       pname = "UrlDisp";
       version = "0.1.7";
       sha256 = "f7ef9c0b2e92b7ac90a03de4dfb1df1f900e502cf7b391cb4752277d66d941f8";
       libraryHaskellDepends = [ base cgi MaybeT mtl ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/UrlDisp";
       description = "Url dispatcher. Helps to retain friendly URLs in web applications.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Useful" = callPackage
    ({ mkDerivation, base, containers, random }:
     mkDerivation {
       pname = "Useful";
       version = "0.0.6";
       sha256 = "a4a48b812de89807a9c4e13749c22c05dd800fc74dedde2e580627013132ab07";
       libraryHaskellDepends = [ base containers random ];
       description = "Some useful functions and shorthands";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "UtilityTM" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "UtilityTM";
       version = "0.0.4";
       sha256 = "05a9cbb51bf34ff04d88734b54eed82149ed5abc15fa116a5d590cae091f5ed6";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/tonymorris/utility-tm";
       description = "Utility functions that are missing from the standard library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "VKHS" = callPackage
    ({ mkDerivation, aeson, base, bimap, bytestring, containers, curl
     , curlhs, directory, failure, filepath, mtl, optparse-applicative
     , parsec, pretty-show, regexpr, safe, split, tagsoup
     , template-haskell, text, time, transformers, utf8-string, vector
     }:
     mkDerivation {
       pname = "VKHS";
       version = "0.5.7";
       sha256 = "89cb9291667358d2df2fb86e1cb87fef42ebfbd410e31222d8b3d90199df72cd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bimap bytestring containers curlhs directory failure
         filepath mtl optparse-applicative parsec pretty-show regexpr safe
         split tagsoup template-haskell text time transformers utf8-string
         vector
       ];
       executableSystemDepends = [ curl ];
       homepage = "http://github.com/grwlf/vkhs";
       description = "Provides access to Vkontakte social network via public API";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) curl;};

  "Validation" = callPackage
    ({ mkDerivation, base, bifunctors, semigroupoids, semigroups }:
     mkDerivation {
       pname = "Validation";
       version = "0.2.0";
       sha256 = "e383aa5d20ae03716bb50e57036915234a3ec3089a8fa7b28af2ade2918b5583";
       libraryHaskellDepends = [
         base bifunctors semigroupoids semigroups
       ];
       jailbreak = true;
       homepage = "https://github.com/tonymorris/validation";
       description = "A data-type like Either but with an accumulating Applicative";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Vec" = callPackage
    ({ mkDerivation, array, base, ghc-prim }:
     mkDerivation {
       pname = "Vec";
       version = "1.0.5";
       sha256 = "f523945104cf8d8c11f0299dc8a3fb9579d4eaf8d20a1403fbe2d8764729d343";
       libraryHaskellDepends = [ array base ghc-prim ];
       homepage = "http://github.net/sedillard/Vec";
       description = "Fixed-length lists and low-dimensional linear algebra";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Vec-Boolean" = callPackage
    ({ mkDerivation, base, Boolean, Vec }:
     mkDerivation {
       pname = "Vec-Boolean";
       version = "1.0.6";
       sha256 = "13ea1c747329764c0415a989e930994a20411bb10fa490cfceb4b60699bfbd7f";
       libraryHaskellDepends = [ base Boolean Vec ];
       jailbreak = true;
       description = "Provides Boolean instances for the Vec package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Vec-OpenGLRaw" = callPackage
    ({ mkDerivation, base, OpenGLRaw, Vec }:
     mkDerivation {
       pname = "Vec-OpenGLRaw";
       version = "0.2.0.1";
       sha256 = "95ae058417ea29e0b82727ccbae5f5bd541a54f0a70a4855c9d38d8b910e5163";
       libraryHaskellDepends = [ base OpenGLRaw Vec ];
       homepage = "http://www.downstairspeople.org/darcs/Vec-opengl";
       description = "Instances and functions to interoperate Vec and OpenGL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Vec-Transform" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "Vec-Transform";
       version = "1.1";
       sha256 = "cccd1b5402249cb392d0083719cd772459c69d7b7a4e9b0201ad2319df4c914b";
       doHaddock = false;
       homepage = "https://github.com/tobbebex/Vec-Transform";
       description = "This package is obsolete";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "VecN" = callPackage
    ({ mkDerivation, base, Peano }:
     mkDerivation {
       pname = "VecN";
       version = "0.0.2";
       sha256 = "42ebc6f44794140c66d7557656404e3e17c6d62a071fa325e7d1beb47b8b68c3";
       libraryHaskellDepends = [ base Peano ];
       description = "a simple peano-indexed vector type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Verba" = callPackage
    ({ mkDerivation, base, containers, matrix }:
     mkDerivation {
       pname = "Verba";
       version = "0.1.2.0";
       sha256 = "f5c68bcb9ea60f75f853fecb0b399cf1794caebe4ab3bfcb0ea5e9d8fb4f2fba";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers matrix ];
       description = "A solver for the WordBrain game";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ViennaRNA-bindings" = callPackage
    ({ mkDerivation, array, base, c2hs }:
     mkDerivation {
       pname = "ViennaRNA-bindings";
       version = "0.1.2.2";
       sha256 = "83169ef8f28901644c36446b12322ab5e63b5d5c5a007de4fad878ddb61eff1b";
       libraryHaskellDepends = [ array base ];
       libraryToolDepends = [ c2hs ];
       homepage = "http://www.tbi.univie.ac.at/~choener/";
       description = "ViennaRNA v2 bindings";
       license = "unknown";
     }) {};

  "ViennaRNAParser_1_2_7" = callPackage
    ({ mkDerivation, base, hspec, parsec, process, transformers }:
     mkDerivation {
       pname = "ViennaRNAParser";
       version = "1.2.7";
       sha256 = "94a6eabf894ce77c16854393ebfcbb14b8f440634c480d4d2a84a2f2c76c1ebf";
       libraryHaskellDepends = [ base parsec process transformers ];
       testHaskellDepends = [ base hspec parsec ];
       description = "Libary for parsing ViennaRNA package output";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ViennaRNAParser" = callPackage
    ({ mkDerivation, base, hspec, parsec, process, transformers }:
     mkDerivation {
       pname = "ViennaRNAParser";
       version = "1.2.8";
       sha256 = "5d298b026f0c40d04cc3da3d148671602bd602c1583c1812153a21f90b40f25e";
       libraryHaskellDepends = [ base parsec process transformers ];
       testHaskellDepends = [ base hspec parsec ];
       description = "Libary for parsing ViennaRNA package output";
       license = "GPL";
     }) {};

  "Vulkan" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Vulkan";
       version = "0.1.0.0";
       sha256 = "e1cb8411cf76d254fa1c708f498442a27fe1c2783d7aa04f887ca9608b21fcca";
       libraryHaskellDepends = [ base ];
       description = "A binding for the Vulkan API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "WAVE" = callPackage
    ({ mkDerivation, base, bytestring, containers, parseargs }:
     mkDerivation {
       pname = "WAVE";
       version = "0.1.3";
       sha256 = "277a96f392efc43d0580ffb960126f531b7d5af557375c9a6a9a711a7c52f4b1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring ];
       executableHaskellDepends = [
         base bytestring containers parseargs
       ];
       homepage = "http://github.com/BartMassey/WAVE";
       description = "WAVE audio file IO library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "WL500gPControl" = callPackage
    ({ mkDerivation, base, directory, filepath, mtl, unix, WL500gPLib
     }:
     mkDerivation {
       pname = "WL500gPControl";
       version = "0.3.4";
       sha256 = "fb415178a8e0dd808c4b76ff050634fd0c60e5242baf7247db1c95230659723d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath mtl unix WL500gPLib
       ];
       jailbreak = true;
       description = "A simple command line tools to control the Asus WL500gP router";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "WL500gPLib" = callPackage
    ({ mkDerivation, base, curl, mtl, tagsoup }:
     mkDerivation {
       pname = "WL500gPLib";
       version = "0.3.1";
       sha256 = "faf199f7d1ca246971cab7625db56f072ee8b37508f56a9fa45042f47c318097";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base curl mtl tagsoup ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       description = "A simple library to access to the WL 500gP router from the Haskell code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "WMSigner" = callPackage
    ({ mkDerivation, base, base64-bytestring, binary, bytestring
     , cryptohash, directory, hspec, lens, mtl, random, split, vector
     }:
     mkDerivation {
       pname = "WMSigner";
       version = "0.1.0.0";
       sha256 = "d834165aaaee428d254ad357b8d57d17698cedeea44a5608d10243ebbccba846";
       libraryHaskellDepends = [
         base base64-bytestring binary bytestring cryptohash directory lens
         mtl random split vector
       ];
       testHaskellDepends = [
         base bytestring cryptohash hspec lens random split vector
       ];
       jailbreak = true;
       description = "WebMoney authentication module";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "WURFL" = callPackage
    ({ mkDerivation, base, haskell98, parsec }:
     mkDerivation {
       pname = "WURFL";
       version = "0.1";
       sha256 = "73c77a329f21de85110e23f57232e52f3425417391c68fe2279f77effcd76e8f";
       libraryHaskellDepends = [ base haskell98 parsec ];
       description = "Convert the WURFL file into a Parsec parser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "WXDiffCtrl" = callPackage
    ({ mkDerivation, base, containers, wx, wxcore }:
     mkDerivation {
       pname = "WXDiffCtrl";
       version = "0.0.1";
       sha256 = "13fc9556ff5e4a608d8cd314d8938ffd1705e467928d81a6efb38d3710d1686f";
       libraryHaskellDepends = [ base containers wx wxcore ];
       homepage = "http://wewantarock.wordpress.com";
       description = "WXDiffCtrl";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "WashNGo" = callPackage
    ({ mkDerivation, base, containers, directory, ghc-paths, haskell98
     , parsec, process, regex-compat
     }:
     mkDerivation {
       pname = "WashNGo";
       version = "2.12.0.1";
       sha256 = "d2d945bd20dea9613a6ceb11f7fed7b93db2ca1e6a4457544ac9edeb3067a985";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers haskell98 parsec regex-compat
       ];
       executableHaskellDepends = [ directory ghc-paths process ];
       jailbreak = true;
       homepage = "http://www.informatik.uni-freiburg.de/~thiemann/haskell/WASH/";
       description = "WASH is a family of EDSLs for programming Web applications in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "WaveFront" = callPackage
    ({ mkDerivation, base, Cartesian, containers, filepath, GLUtil
     , lens, linear, OpenGL
     }:
     mkDerivation {
       pname = "WaveFront";
       version = "0.1.2.0";
       sha256 = "7a169c00d1c008904ca827ddcf99db1026e3af9b3b4f48cf62486b269339bb80";
       libraryHaskellDepends = [
         base Cartesian containers filepath GLUtil lens linear OpenGL
       ];
       description = "Parsers and utilities for the OBJ WaveFront 3D model format";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Weather" = callPackage
    ({ mkDerivation, aeson, base, bytestring, HTTP, text
     , unordered-containers
     }:
     mkDerivation {
       pname = "Weather";
       version = "0.1.0.4";
       sha256 = "dbf64ceb70be6869a2965c0e7d05e09e888e22e3f63079dfa11039fbccbfb93c";
       libraryHaskellDepends = [
         aeson base bytestring HTTP text unordered-containers
       ];
       homepage = "https://github.com/bstamour/weather";
       description = "Library for interacting with the Weather Underground JSON API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "WebBits" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec, pretty, syb }:
     mkDerivation {
       pname = "WebBits";
       version = "2.2";
       sha256 = "5fec0e64d9913a0b9b46d236b2fb1d0ceb689633e6901bf46fe6d47797b435bb";
       libraryHaskellDepends = [ base containers mtl parsec pretty syb ];
       homepage = "http://github.com/brownplt/webbits";
       description = "JavaScript analysis tools";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "WebBits-Html" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec, pretty, syb
     , WebBits
     }:
     mkDerivation {
       pname = "WebBits-Html";
       version = "1.0.2";
       sha256 = "543da5bb6a8284817337c7114e1a5e2d57d1f3de0951a2f23ca231709228ada1";
       libraryHaskellDepends = [
         base containers mtl parsec pretty syb WebBits
       ];
       jailbreak = true;
       homepage = "http://www.cs.brown.edu/research/plt/";
       description = "JavaScript analysis tools";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "WebBits-multiplate" = callPackage
    ({ mkDerivation, base, multiplate, multiplate-simplified
     , transformers, WebBits
     }:
     mkDerivation {
       pname = "WebBits-multiplate";
       version = "0.0.0.1";
       sha256 = "632f8d613f16df243a0591fa2a848d332a84364b1c6f6dd75b860737a28b6dc8";
       libraryHaskellDepends = [
         base multiplate multiplate-simplified transformers WebBits
       ];
       jailbreak = true;
       description = "A Multiplate instance for JavaScript";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "WebCont" = callPackage
    ({ mkDerivation, applicative-extras, base, concatenative
     , containers, formlets, happstack-server, happstack-state
     , happstack-util, mtl, utf8-string, xhtml
     }:
     mkDerivation {
       pname = "WebCont";
       version = "0.0.1";
       sha256 = "267a3f3d016145646c414047e9fea28305aefda2150d7018e028433cc18f25d3";
       libraryHaskellDepends = [
         applicative-extras base concatenative containers formlets
         happstack-server happstack-state happstack-util mtl utf8-string
         xhtml
       ];
       homepage = "http://patch-tag.com/r/salazar/webconts/snapshot/current/content/pretty";
       description = "Continuation based web programming for Happstack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "WeberLogic" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "WeberLogic";
       version = "0.1.2";
       sha256 = "5f9862063a98a6fb431755cf37d6cbdc4193606a48f67ba7ed2062e1074e875a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base parsec ];
       executableHaskellDepends = [ base parsec ];
       jailbreak = true;
       homepage = "https://github.com/cameronbwhite/WeberLogic";
       description = "Logic interpreter";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Webrexp" = callPackage
    ({ mkDerivation, aeson, array, base, bytestring, containers
     , directory, filepath, HaXml, HTTP, hxt, mtl, network, parsec
     , process, regex-pcre-builtin, template-haskell, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "Webrexp";
       version = "1.1.2";
       sha256 = "4b167df8b1326e1bb44d1e384fe2a7fd13831ae1d599480e7faa76d25e3269c7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array base bytestring containers directory filepath HaXml
         HTTP hxt mtl network parsec process regex-pcre-builtin
         template-haskell text transformers unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson array base bytestring containers directory filepath HaXml
         HTTP hxt mtl network parsec process regex-pcre-builtin
         template-haskell text transformers unordered-containers vector
       ];
       jailbreak = true;
       description = "Regexp-like engine to scrap web data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Wheb" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , containers, cookie, http-types, HUnit, mtl, pwstore-fast
     , QuickCheck, stm, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time, transformers, unix, uuid
     , wai, wai-extra, wai-websockets, warp, web-routes, websockets
     }:
     mkDerivation {
       pname = "Wheb";
       version = "0.3.1.0";
       sha256 = "1affec4db10dba9767960ad2f2744f0f34116d0ee970347cceee2bf12901a28f";
       libraryHaskellDepends = [
         base blaze-builder bytestring case-insensitive containers cookie
         http-types mtl pwstore-fast stm text time transformers unix uuid
         wai wai-extra wai-websockets warp web-routes websockets
       ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "https://github.com/hansonkd/Wheb-Framework";
       description = "The frictionless WAI Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "WikimediaParser" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "WikimediaParser";
       version = "0.1";
       sha256 = "32f41ed23148dc10b65a0dd850576f6bdba8bbfef19ba0e79a1b93403e72f767";
       libraryHaskellDepends = [ base parsec ];
       description = "A parser for wikimedia style article markup";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Win32" = callPackage
    ({ mkDerivation, advapi32, base, bytestring, gdi32, shell32
     , shfolder, user32, winmm
     }:
     mkDerivation {
       pname = "Win32";
       version = "2.3.1.0";
       sha256 = "685a695e9ec86efb06d3a2effb3e18f916c8696e71ca4811cb53befa04323ff9";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [
         advapi32 gdi32 shell32 shfolder user32 winmm
       ];
       homepage = "https://github.com/haskell/win32";
       description = "A binding to part of the Win32 library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {advapi32 = null; gdi32 = null; shell32 = null; 
         shfolder = null; user32 = null; winmm = null;};

  "Win32-dhcp-server" = callPackage
    ({ mkDerivation, base, text, Win32, Win32-errors }:
     mkDerivation {
       pname = "Win32-dhcp-server";
       version = "0.3.2";
       sha256 = "3f6fd5dcd65f0883f40a5e3ee9467df0039abf7fc4f5cf0a119c56696d120664";
       libraryHaskellDepends = [ base text Win32 Win32-errors ];
       homepage = "http://github.com/mikesteele81/win32-dhcp-server";
       description = "Win32 DHCP Server Management API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Win32-errors" = callPackage
    ({ mkDerivation, base, template-haskell, text, Win32 }:
     mkDerivation {
       pname = "Win32-errors";
       version = "0.2.2.1";
       sha256 = "61803f36a418726540f230df294b8a86331a8ffa1b79d04e3398064af7a9efec";
       libraryHaskellDepends = [ base template-haskell text Win32 ];
       homepage = "http://github.com/mikesteele81/win32-errors";
       description = "Alternative error handling for Win32 foreign calls";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Win32-extras" = callPackage
    ({ mkDerivation, base, imm32, msimg32, Win32 }:
     mkDerivation {
       pname = "Win32-extras";
       version = "0.2.0.1";
       sha256 = "f0dc0e62d87114953e111bb3c8a09f90d5dba490007c4f26d8b892a3f4c69902";
       libraryHaskellDepends = [ base Win32 ];
       librarySystemDepends = [ imm32 msimg32 ];
       homepage = "http://hub.darcs.net/shelarcy/Win32-extras/";
       description = "Provides missing Win32 API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {imm32 = null; msimg32 = null;};

  "Win32-junction-point" = callPackage
    ({ mkDerivation, base, text, Win32, Win32-errors }:
     mkDerivation {
       pname = "Win32-junction-point";
       version = "0.2.1.1";
       sha256 = "81a4c662c07ca698434775c9fdfdaf6d80eff3ccb0515bec449f71721bdc74df";
       libraryHaskellDepends = [ base text Win32 Win32-errors ];
       homepage = "http://github.com/mikesteele81/Win32-junction-point";
       description = "Support for manipulating NTFS junction points";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Win32-notify" = callPackage
    ({ mkDerivation, base, containers, directory, Win32 }:
     mkDerivation {
       pname = "Win32-notify";
       version = "0.3.0.1";
       sha256 = "c49159d8154f9ff7d30207901125ceadc2aa94baa3b2996ff0884e9f0158eb7f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers directory Win32 ];
       executableHaskellDepends = [ base directory ];
       description = "A binding to part of the Win32 library for file notification";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Win32-security" = callPackage
    ({ mkDerivation, base, text, Win32, Win32-errors }:
     mkDerivation {
       pname = "Win32-security";
       version = "0.1.1";
       sha256 = "9eca6c3efea64d83ee3aaf2ec0706695087e98e47c77163ac497f70ad4f90436";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base text Win32 Win32-errors ];
       homepage = "https://github.com/anton-dessiatov/Win32-security";
       description = "Haskell bindings to a security-related functions of the Windows API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Win32-services" = callPackage
    ({ mkDerivation, Advapi32, base, Win32, Win32-errors }:
     mkDerivation {
       pname = "Win32-services";
       version = "0.3";
       sha256 = "5aa626c00d3c255a0d20fad34f2c96661d31825f12e19f8a7848144d4ef16b1f";
       libraryHaskellDepends = [ base Win32 Win32-errors ];
       librarySystemDepends = [ Advapi32 ];
       homepage = "http://github.com/mikesteele81/win32-services";
       description = "Windows service applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {Advapi32 = null;};

  "Win32-services-wrapper" = callPackage
    ({ mkDerivation, base, directory, filepath, Win32, Win32-errors
     , Win32-services
     }:
     mkDerivation {
       pname = "Win32-services-wrapper";
       version = "0.1.3.0";
       sha256 = "cd4ba155ec34e9d4cafe90d2033b1e2791e266f0b65d2044d1503db6447030da";
       libraryHaskellDepends = [
         base directory filepath Win32 Win32-errors Win32-services
       ];
       description = "Wrapper code for making a Win32 service";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Wired" = callPackage
    ({ mkDerivation, base, chalmers-lava2000, containers, mtl
     , QuickCheck
     }:
     mkDerivation {
       pname = "Wired";
       version = "0.3";
       sha256 = "d20022114fd9b284df7390704ed0d7260827ae7453e512cbac63929c0872fd93";
       libraryHaskellDepends = [
         base chalmers-lava2000 containers mtl QuickCheck
       ];
       homepage = "http://www.cse.chalmers.se/~emax/wired/";
       description = "Wire-aware hardware description";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "WordAlignment" = callPackage
    ({ mkDerivation, ADPfusion, AlignmentAlgorithms, ascii-progress
     , attoparsec, base, bytestring, cmdargs, containers
     , control-monad-omega, deepseq, file-embed, fmlist, FormalGrammars
     , ghc-prim, GrammarProducts, hashable, intern, lens
     , LinguisticsTypes, NaturalLanguageAlphabets, parallel, primitive
     , PrimitiveArray, QuickCheck, strict, stringable, template-haskell
     , test-framework, test-framework-quickcheck2, test-framework-th
     , text, text-format, transformers, tuple-th, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "WordAlignment";
       version = "0.1.0.0";
       sha256 = "0182ffbf3dfddcabd73dce16eef232fce5c680125391ce881ddf2b81c97593d0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ADPfusion AlignmentAlgorithms attoparsec base bytestring containers
         control-monad-omega deepseq file-embed fmlist FormalGrammars
         ghc-prim GrammarProducts hashable intern lens LinguisticsTypes
         NaturalLanguageAlphabets primitive PrimitiveArray strict stringable
         template-haskell text text-format transformers tuple-th
         unordered-containers vector
       ];
       executableHaskellDepends = [
         ascii-progress base bytestring cmdargs containers file-embed intern
         LinguisticsTypes NaturalLanguageAlphabets parallel strict text
         unordered-containers vector
       ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
         test-framework-th
       ];
       jailbreak = true;
       homepage = "https://github.com/choener/WordAlignment";
       description = "Bigram word pair alignments";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "WordNet" = callPackage
    ({ mkDerivation, array, base, containers, filepath }:
     mkDerivation {
       pname = "WordNet";
       version = "1.1.0";
       sha256 = "5380d6e5b9c36d2b34437d01b9f0fff49fc07b2788f45e04d7df291867ef842c";
       libraryHaskellDepends = [ array base containers filepath ];
       description = "Haskell interface to the WordNet database";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "WordNet-ghc74" = callPackage
    ({ mkDerivation, array, base, containers, filepath }:
     mkDerivation {
       pname = "WordNet-ghc74";
       version = "0.1.3";
       sha256 = "2867dc9c3a3c47f349137ee251d91aa0610ddb1f0fd89610766d28ae96e765a9";
       libraryHaskellDepends = [ array base containers filepath ];
       description = "Haskell interface to the WordNet database";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Wordlint" = callPackage
    ({ mkDerivation, base, boxes, cmdargs }:
     mkDerivation {
       pname = "Wordlint";
       version = "0.2.0.4";
       sha256 = "a5f978de7e4c837993496bf9b88678f9f8245b7510cd8f7bc79d4feb0914a021";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base boxes cmdargs ];
       executableHaskellDepends = [ base boxes cmdargs ];
       jailbreak = true;
       homepage = "https://github.com/gbgar/Wordlint";
       description = "Plaintext prose redundancy linter";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Workflow_0_8_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , exceptions, extensible-exceptions, mtl, old-time, RefSerialize
     , stm, TCache, vector
     }:
     mkDerivation {
       pname = "Workflow";
       version = "0.8.1";
       sha256 = "1400773a04761c778a465dd46cc2277568997424143374e220762df69079437c";
       libraryHaskellDepends = [
         base binary bytestring containers directory exceptions
         extensible-exceptions mtl old-time RefSerialize stm TCache vector
       ];
       description = "Workflow patterns over a monad for thread state logging & recovery";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Workflow" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , exceptions, extensible-exceptions, mtl, old-time, RefSerialize
     , stm, TCache, vector
     }:
     mkDerivation {
       pname = "Workflow";
       version = "0.8.3";
       sha256 = "c89b4b3a4a29fe576f8972ffa1e698eff8ac0ceb433642fc0b3f9c0308d22123";
       revision = "1";
       editedCabalFile = "1be542eaf091e04c561a2a589f37330b0a65d6d3d5a44609c197a74e8385c64b";
       libraryHaskellDepends = [
         base binary bytestring containers directory exceptions
         extensible-exceptions mtl old-time RefSerialize stm TCache vector
       ];
       description = "Workflow patterns over a monad for thread state logging & recovery";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "WxGeneric" = callPackage
    ({ mkDerivation, base, containers, mtl, SybWidget, wx, wxcore, xtc
     }:
     mkDerivation {
       pname = "WxGeneric";
       version = "0.8.1";
       sha256 = "c0b43c5b236b4e258ab7617a4dea640eeabbdeb7259c0ffe425f731c566d6b53";
       libraryHaskellDepends = [
         base containers mtl SybWidget wx wxcore xtc
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/WxGeneric";
       description = "Generic (SYB3) construction of wxHaskell widgets";
       license = "LGPL";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "X11" = callPackage
    ({ mkDerivation, base, data-default, libX11, libXext, libXinerama
     , libXrandr, libXrender
     }:
     mkDerivation {
       pname = "X11";
       version = "1.6.1.2";
       sha256 = "5216d485f807bd53bf34fba170896a8930290a6ac28b8e611c28e751ad67f2cf";
       libraryHaskellDepends = [ base data-default ];
       librarySystemDepends = [
         libX11 libXext libXinerama libXrandr libXrender
       ];
       homepage = "https://github.com/haskell-pkg-janitors/X11";
       description = "A binding to the X11 graphics library";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXext; 
         inherit (pkgs.xorg) libXinerama; inherit (pkgs.xorg) libXrandr; 
         inherit (pkgs.xorg) libXrender;};

  "X11-extras" = callPackage
    ({ mkDerivation, base, libX11, X11 }:
     mkDerivation {
       pname = "X11-extras";
       version = "0.4";
       sha256 = "ea08c3f71e2f14374c56bbb9050df3eec81ff6b44a6d8e396892b5f612c8f2b2";
       revision = "1";
       editedCabalFile = "f7b315acd1fb4d44ee6312b2e8d397b7cda103cf5e9e8ca6867389ef6cadff3c";
       libraryHaskellDepends = [ base X11 ];
       librarySystemDepends = [ libX11 ];
       jailbreak = true;
       description = "Missing bindings to the X11 graphics library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.xorg) libX11;};

  "X11-rm" = callPackage
    ({ mkDerivation, base, X11 }:
     mkDerivation {
       pname = "X11-rm";
       version = "0.2";
       sha256 = "23934dece742f54d7505ce5cda525d59aadcb2f0cfa35d5a6bf2c9d494a25d86";
       libraryHaskellDepends = [ base X11 ];
       description = "A binding to the resource management functions missing from X11";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "X11-xdamage" = callPackage
    ({ mkDerivation, base, X11, Xdamage }:
     mkDerivation {
       pname = "X11-xdamage";
       version = "0.1.2";
       sha256 = "5bae74d1ab40ca375331ac0c7f92a9655340839c7b1d2f4c00206cd07bc2cd64";
       libraryHaskellDepends = [ base X11 ];
       librarySystemDepends = [ Xdamage ];
       homepage = "http://darcs.haskell.org/X11-xdamage";
       description = "A binding to the Xdamage X11 extension library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {Xdamage = null;};

  "X11-xfixes" = callPackage
    ({ mkDerivation, base, X11, Xfixes }:
     mkDerivation {
       pname = "X11-xfixes";
       version = "0.1.1";
       sha256 = "d38f206149128b071b4df92132701fc94f957912a4b4122bf25be6e531f69073";
       libraryHaskellDepends = [ base X11 ];
       librarySystemDepends = [ Xfixes ];
       homepage = "https://github.com/reacocard/x11-xfixes";
       description = "A binding to the Xfixes X11 extension library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {Xfixes = null;};

  "X11-xft" = callPackage
    ({ mkDerivation, base, libXft, utf8-string, X11 }:
     mkDerivation {
       pname = "X11-xft";
       version = "0.3.1";
       sha256 = "4eba3fee62570e06447654030a62fb55f19587884bc2cef77a9c3b2c3458f8d1";
       libraryHaskellDepends = [ base utf8-string X11 ];
       libraryPkgconfigDepends = [ libXft ];
       description = "Bindings to the Xft, X Free Type interface library, and some Xrender parts";
       license = "LGPL";
     }) {inherit (pkgs.xorg) libXft;};

  "X11-xshape" = callPackage
    ({ mkDerivation, base, X11 }:
     mkDerivation {
       pname = "X11-xshape";
       version = "0.1.1";
       sha256 = "5098376a0e6c79a0b66a47f2aba9f2c97dd066003209fa3bb00e4608180de7a6";
       libraryHaskellDepends = [ base X11 ];
       homepage = "http://darcs.haskell.org/X11-xshape";
       description = "A binding to the Xshape X11 extension library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "XAttr" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "XAttr";
       version = "0.1.1";
       sha256 = "c7681961f3530523c5ab61cf09f349331a414fd7ae5dcc5c7fd408c033b86a9b";
       libraryHaskellDepends = [ base unix ];
       description = "Read, set, and list extended attributes";
       license = "GPL";
     }) {};

  "XInput" = callPackage
    ({ mkDerivation, base, Win32, xinput }:
     mkDerivation {
       pname = "XInput";
       version = "0.1";
       sha256 = "094a387fcb4fcf954914c8f99d26ac5bb5426f3e2c893e0c41bc0eb4197b60ce";
       libraryHaskellDepends = [ base Win32 ];
       librarySystemDepends = [ xinput ];
       homepage = "http://code.fac9.com/xinput/";
       description = "Bindings for the DirectX XInput library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.xorg) xinput;};

  "XMMS" = callPackage
    ({ mkDerivation, base, containers, xmmsclient, xmmsclient-glib }:
     mkDerivation {
       pname = "XMMS";
       version = "0.1.1";
       sha256 = "1d27c0429d615c34e9a78449d522b68b18487750ae8f629de4699bcbc11a8522";
       libraryHaskellDepends = [ base containers ];
       librarySystemDepends = [ xmmsclient xmmsclient-glib ];
       homepage = "http://kawais.org.ua/XMMS/";
       description = "XMMS2 client library";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {xmmsclient = null; xmmsclient-glib = null;};

  "XMPP" = callPackage
    ({ mkDerivation, base, haskell98, hsdns, mtl, network, parsec
     , random, utf8-string
     }:
     mkDerivation {
       pname = "XMPP";
       version = "0.1.2";
       sha256 = "ebd8ade16b5655ee41f0fa5e0824478f98d1c524f6ebeef11f5b583a93bafe0d";
       libraryHaskellDepends = [
         base haskell98 hsdns mtl network parsec random utf8-string
       ];
       jailbreak = true;
       homepage = "http://kagami.touhou.ru/projects/show/matsuri";
       description = "XMPP library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "XSaiga" = callPackage
    ({ mkDerivation, base, cgi, containers, hsparql, pretty, rdf4h
     , text
     }:
     mkDerivation {
       pname = "XSaiga";
       version = "1.1.0.0";
       sha256 = "580f29b238c9195613f836eea693a937ba1ad00ea4591bbb7cb1a6a2032f02fd";
       revision = "4";
       editedCabalFile = "0cd366fd1401a0c35d4b127ef70b7c26447b6ab2c6c5cb4b0c8b4b4b654e27b2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers hsparql pretty rdf4h text
       ];
       executableHaskellDepends = [
         base cgi containers hsparql pretty rdf4h text
       ];
       jailbreak = true;
       homepage = "http://hafiz.myweb.cs.uwindsor.ca/proHome.html";
       description = "An implementation of a polynomial-time top-down parser suitable for NLP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Xauth" = callPackage
    ({ mkDerivation, base, libXau }:
     mkDerivation {
       pname = "Xauth";
       version = "0.1";
       sha256 = "ba332dea9ec152b3f676d22461eee81a657e16987c3dfb8249e9dbe0cda56ed7";
       libraryHaskellDepends = [ base ];
       libraryPkgconfigDepends = [ libXau ];
       description = "A binding to the X11 authentication library";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs.xorg) libXau;};

  "Xec" = callPackage
    ({ mkDerivation, base, binary, bytestring, cairo, containers
     , directory, filepath, gtk, mtl, old-time, SHA, unix
     }:
     mkDerivation {
       pname = "Xec";
       version = "0.1.6";
       sha256 = "88bb3aed99daed6962650a98680b615627f0ca31fc8b09f5fab2c4b4c5107ed8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring cairo containers directory filepath gtk mtl
         old-time SHA unix
       ];
       description = "Gtk command launcher with identicon";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "XmlHtmlWriter" = callPackage
    ({ mkDerivation, base, mtl, transformers }:
     mkDerivation {
       pname = "XmlHtmlWriter";
       version = "0.0.0.1";
       sha256 = "61d2b890f166239a0997622f123bea14067e25e48b2ce565b3801b8ff7b66537";
       libraryHaskellDepends = [ base mtl transformers ];
       homepage = "http://github.com/mmirman/haskogeneous/tree/XmlHtmlWriter";
       description = "A library for writing XML and HTML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Xorshift128Plus" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Xorshift128Plus";
       version = "0.1.0.1";
       sha256 = "bd09b98dfbb9125a21684e9495d4a624f34ae4912337fb658101edc46e7ce185";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/kanaihiroki/Xorshift128Plus";
       description = "Pure haskell implementation of xorshift128plus random number generator";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "YACPong" = callPackage
    ({ mkDerivation, base, data-accessor-transformers, fclabels
     , monads-fd, random, SDL, SDL-image, SDL-mixer, SDL-ttf
     , transformers
     }:
     mkDerivation {
       pname = "YACPong";
       version = "0.1";
       sha256 = "85c3315de599e67253cca2f4270b13d8491faa33aeacef90b9a51cfcd70e56e4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base data-accessor-transformers fclabels monads-fd random SDL
         SDL-image SDL-mixer SDL-ttf transformers
       ];
       homepage = "http://github.com/snkkid/YACPong";
       description = "Yet Another Pong Clone using SDL";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "YFrob" = callPackage
    ({ mkDerivation, array, base, HGL, Yampa }:
     mkDerivation {
       pname = "YFrob";
       version = "0.4";
       sha256 = "2e5aba7ff70395f62225f4a83c2e220af2824f9f25d35d5087d549947d3af79e";
       libraryHaskellDepends = [ array base HGL Yampa ];
       homepage = "http://www.haskell.org/yampa/";
       description = "Yampa-based library for programming robots";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Yablog" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, bytestring
     , case-insensitive, clientsession, conduit, containers
     , data-default, directory, filepath, hamlet, hjsmin, http-conduit
     , http-types, mime-mail, monad-control, mtl, network, old-locale
     , pandoc, pandoc-types, persistent, persistent-mongoDB, resourcet
     , shakespeare-css, shakespeare-js, shakespeare-text
     , template-haskell, temporary, text, time, wai, wai-extra
     , xml-conduit, xml-hamlet, yaml, yesod, yesod-auth, yesod-core
     , yesod-default, yesod-form, yesod-newsfeed, yesod-platform
     , yesod-recaptcha, yesod-static
     }:
     mkDerivation {
       pname = "Yablog";
       version = "0.2.0";
       sha256 = "737b4a1ab300cc2d5b8689640b51092b5a54d8ad4cb4bb451699b2367caa4761";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-builder blaze-html bytestring case-insensitive
         clientsession conduit containers data-default directory filepath
         hamlet hjsmin http-conduit http-types mime-mail monad-control mtl
         network old-locale pandoc pandoc-types persistent
         persistent-mongoDB resourcet shakespeare-css shakespeare-js
         shakespeare-text template-haskell temporary text time wai wai-extra
         xml-conduit xml-hamlet yaml yesod yesod-auth yesod-core
         yesod-default yesod-form yesod-newsfeed yesod-platform
         yesod-recaptcha yesod-static
       ];
       jailbreak = true;
       homepage = "http://gitweb.konn-san.com/repo/Yablog/tree/master";
       description = "A simple blog engine powered by Yesod";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "YamlReference" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, dlist
     , HUnit, regex-compat
     }:
     mkDerivation {
       pname = "YamlReference";
       version = "0.9.3";
       sha256 = "cfee41cb2e8f860ceadd6847fddecb5e384ca40151039d3f4c85ec1907ff675a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers dlist HUnit regex-compat
       ];
       executableHaskellDepends = [ directory ];
       homepage = "http://www.ben-kiki.org/oren/YamlReference";
       description = "YAML reference implementation";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Yampa_0_9_6" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "Yampa";
       version = "0.9.6";
       sha256 = "e0f9a9c70d67e79f15012f6f4515a97a0ec4a369f86e10eeea738e0896063528";
       revision = "1";
       editedCabalFile = "acf73dc58b9dbdb285957308a5453c3b507873f517753340c1df83a9c2625b8e";
       libraryHaskellDepends = [ base random ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Yampa";
       description = "Library for programming hybrid systems";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Yampa_0_9_6_1" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "Yampa";
       version = "0.9.6.1";
       sha256 = "c1b500560da363c0b6de0c360ab3c0371bda3be961f56ca86c39de8725d5da92";
       libraryHaskellDepends = [ base random ];
       homepage = "http://www.haskell.org/haskellwiki/Yampa";
       description = "Library for programming hybrid systems";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Yampa_0_9_7" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "Yampa";
       version = "0.9.7";
       sha256 = "3a134ba166ff7eb2790537dddb7f1cf4572339e35364d414da3350dc4da28730";
       libraryHaskellDepends = [ base random ];
       homepage = "http://www.haskell.org/haskellwiki/Yampa";
       description = "Library for programming hybrid systems";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Yampa_0_10_2" = callPackage
    ({ mkDerivation, base, deepseq, random }:
     mkDerivation {
       pname = "Yampa";
       version = "0.10.2";
       sha256 = "98914f770aaa81e5fa36f657f4bdab422d8723aaaa49502769b1bbe056febade";
       libraryHaskellDepends = [ base deepseq random ];
       homepage = "http://www.haskell.org/haskellwiki/Yampa";
       description = "Library for programming hybrid systems";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Yampa_0_10_3" = callPackage
    ({ mkDerivation, base, deepseq, random }:
     mkDerivation {
       pname = "Yampa";
       version = "0.10.3";
       sha256 = "d72259ee589a1c838d5349c08b585c5b77c939c42e22c99e4d5c91f25ea607ad";
       libraryHaskellDepends = [ base deepseq random ];
       homepage = "http://www.haskell.org/haskellwiki/Yampa";
       description = "Library for programming hybrid systems";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Yampa" = callPackage
    ({ mkDerivation, base, deepseq, random }:
     mkDerivation {
       pname = "Yampa";
       version = "0.10.4";
       sha256 = "6e126b668858e9bedaff8fb2ffe07a4c43341052779f351e05b7ff997a30d790";
       libraryHaskellDepends = [ base deepseq random ];
       testHaskellDepends = [ base ];
       homepage = "http://www.haskell.org/haskellwiki/Yampa";
       description = "Library for programming hybrid systems";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Yampa-core" = callPackage
    ({ mkDerivation, base, deepseq, random, vector-space }:
     mkDerivation {
       pname = "Yampa-core";
       version = "0.2.0";
       sha256 = "b78b1367c404e50021a7f17748d894e0c74a8b22dc8e48c7fbceea8fa4adaf1a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base deepseq random vector-space ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       homepage = "https://github.com/ony/Yampa-core";
       description = "Library for programming hybrid systems";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "YampaSynth" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, HCodecs
     , Yampa
     }:
     mkDerivation {
       pname = "YampaSynth";
       version = "0.2";
       sha256 = "a1c6a0ea57aee855ca3f558f1b6d7ec167abb57333052d8a9f7b46ef323d0a09";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring containers HCodecs Yampa
       ];
       homepage = "http://www-db.informatik.uni-tuebingen.de/team/giorgidze";
       description = "Software synthesizer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Yocto" = callPackage
    ({ mkDerivation, base, containers, parsec }:
     mkDerivation {
       pname = "Yocto";
       version = "0.1.0";
       sha256 = "d73cb870d3a2016fd2b79f63c9dc9d69f4f9dd6d71b80c90506715c1f30937cf";
       libraryHaskellDepends = [ base containers parsec ];
       homepage = "https://github.com/ajg/yocto";
       description = "A Minimal JSON Parser & Printer for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "Yogurt" = callPackage
    ({ mkDerivation, base, containers, mtl, network, old-locale
     , process, readline, regex-posix, syb, time
     }:
     mkDerivation {
       pname = "Yogurt";
       version = "0.4.1";
       sha256 = "d8b96bcbd0b5b77efb66d9b652b5534ec6d66f9ca28cdb44ff0a58fd648fdf11";
       libraryHaskellDepends = [
         base containers mtl network old-locale process readline regex-posix
         syb time
       ];
       homepage = "http://code.google.com/p/yogurt-mud/";
       description = "A MUD client library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "Yogurt-Standalone" = callPackage
    ({ mkDerivation, base, containers, hint, mtl, network, old-locale
     , process, readline, regex-posix, syb, time, Yogurt
     }:
     mkDerivation {
       pname = "Yogurt-Standalone";
       version = "0.4";
       sha256 = "148a42ca193e142449c5867f1893cb767b9f274bb8fdaab78dd0f2c671553394";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers hint mtl network old-locale process regex-posix syb
         time Yogurt
       ];
       executableSystemDepends = [ readline ];
       homepage = "http://code.google.com/p/yogurt-mud/";
       description = "A functional MUD client";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) readline;};

  "ZEBEDDE" = callPackage
    ({ mkDerivation, base, vect }:
     mkDerivation {
       pname = "ZEBEDDE";
       version = "0.1.0.0";
       sha256 = "27b4f25adda6a500627a9311fe4c74c92dae0a18789cc7ea8e828c74a0ba05c5";
       revision = "3";
       editedCabalFile = "bd302015dbeab652042fed7c86f942d1cdf28d365de82e742290d5aac13d97c2";
       libraryHaskellDepends = [ base vect ];
       description = "Polymer growth simulation method";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ZFS" = callPackage
    ({ mkDerivation, base, CC-delcont, containers, mtl, network, unix
     }:
     mkDerivation {
       pname = "ZFS";
       version = "0.0.2";
       sha256 = "f9fbe01ab8ffe70ac2bd8a5bb55cd56f4ecf030274a305f31391b1c0e76397d7";
       libraryHaskellDepends = [
         base CC-delcont containers mtl network unix
       ];
       homepage = "https://github.com/jkarni/ZipperFS";
       description = "Oleg's Zipper FS";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ZMachine" = callPackage
    ({ mkDerivation, array, base, gtk, mtl, random }:
     mkDerivation {
       pname = "ZMachine";
       version = "0.0";
       sha256 = "63651245799f1948622f80c42d8e074aa17a7993404a916b28267d91d02c00e8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base gtk mtl random ];
       description = "A Z-machine interpreter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ZipFold" = callPackage
    ({ mkDerivation, base, TypeCompose }:
     mkDerivation {
       pname = "ZipFold";
       version = "0.1.4";
       sha256 = "c06a41ed6bb1901a5ebab046a81e19dbe727c558834892b1441244c312bd9615";
       libraryHaskellDepends = [ base TypeCompose ];
       homepage = "http://haskell.org/haskellwiki/ZipFold";
       description = "Zipping folds";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ZipperAG" = callPackage
    ({ mkDerivation, base, syz }:
     mkDerivation {
       pname = "ZipperAG";
       version = "0.9";
       sha256 = "29774627c34cede63f6de1638f96e626284669742991a764c9b0e4a14f46805a";
       libraryHaskellDepends = [ base syz ];
       homepage = "www.di.uminho.pt/~prmartins";
       description = "An implementationg of Attribute Grammars using Functional Zippers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Zora" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, fgl
     , graphviz, random, shelly, tasty, tasty-hunit, text
     }:
     mkDerivation {
       pname = "Zora";
       version = "1.2.0";
       sha256 = "71d4df73f9f4377c2cf09d6bc0e8f26cd75da102dd2ff52d94095b8fb017d1fa";
       libraryHaskellDepends = [
         base bytestring containers directory fgl graphviz random shelly
         text
       ];
       testHaskellDepends = [ base containers random tasty tasty-hunit ];
       homepage = "http://github.com/bgwines/zora";
       description = "Graphing library wrapper + assorted useful functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "Zwaluw" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "Zwaluw";
       version = "0.1";
       sha256 = "419fadba4077db63d2104ca196e64b343cfbc0c55859665860f7bf12ed663bb3";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/MedeaMelana/Zwaluw";
       description = "Combinators for bidirectional URL routing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "a50" = callPackage
    ({ mkDerivation, base, biofasta, biopsl, cmdargs, containers
     , directory, process
     }:
     mkDerivation {
       pname = "a50";
       version = "0.5";
       sha256 = "407f49e1a7f851e9abb09f3494f34749475f55548bcb6f5260d1e5813370d649";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base biofasta biopsl cmdargs containers directory process
       ];
       homepage = "http://blog.malde.org/index.php/a50-a-graphical-comparison-of-genome-assemblies";
       description = "Compare genome assemblies";
       license = "GPL";
     }) {};

  "abacate" = callPackage
    ({ mkDerivation, base, HUnit, parsec, text }:
     mkDerivation {
       pname = "abacate";
       version = "0.0.0.0";
       sha256 = "af0d3d6e860826a12029fa048f8616713ffb8374ce9a13119567ba73ecb0bad3";
       libraryHaskellDepends = [ base parsec text ];
       testHaskellDepends = [ base HUnit text ];
       jailbreak = true;
       homepage = "http://github.com/marcotmarcot/abacate";
       description = "Parser for a language similar to Cucumber's Gherkin";
       license = "unknown";
     }) {};

  "abc-puzzle" = callPackage
    ({ mkDerivation, array, base, minisat, random, random-shuffle, Safe
     }:
     mkDerivation {
       pname = "abc-puzzle";
       version = "0.2.1";
       sha256 = "8deb8fb78bd903be9909947095d5d94967989eda98cee43ed6915dca93142644";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base minisat random random-shuffle Safe
       ];
       homepage = "https://github.com/pa-ba/abc-puzzle";
       description = "Generate instances of the ABC Logic Puzzle";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "abcBridge" = callPackage
    ({ mkDerivation, abc, aig, base, base-compat, c2hs, containers
     , directory, QuickCheck, tasty, tasty-ant-xml, tasty-hunit
     , tasty-quickcheck, vector
     }:
     mkDerivation {
       pname = "abcBridge";
       version = "0.15";
       sha256 = "45fef882d6e9c3f7ad48621fc835417df5c161c6743ebc4e4d3cabe9445b113c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aig base base-compat containers directory vector
       ];
       librarySystemDepends = [ abc ];
       libraryToolDepends = [ c2hs ];
       executableHaskellDepends = [ base base-compat ];
       testHaskellDepends = [
         aig base base-compat directory QuickCheck tasty tasty-ant-xml
         tasty-hunit tasty-quickcheck vector
       ];
       description = "Bindings for ABC, A System for Sequential Synthesis and Verification";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) abc;};

  "abcnotation" = callPackage
    ({ mkDerivation, base, parsec, prettify, process, semigroups }:
     mkDerivation {
       pname = "abcnotation";
       version = "1.9.0";
       sha256 = "804c9df346b08ed489f4e2f6b82ccd7f9a5bfb8c87f2b29603125aad707bb76e";
       libraryHaskellDepends = [
         base parsec prettify process semigroups
       ];
       description = "Haskell representation and parser for ABC notation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "abeson" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bson, bytestring
     , data-default-class, scientific, text, time, unordered-containers
     , uuid, vector
     }:
     mkDerivation {
       pname = "abeson";
       version = "0.1.0.1";
       sha256 = "2c781d0a5f17d546dbd6dc2bb337bc3c27233780aa474b9a8668ea33dd4345bc";
       revision = "1";
       editedCabalFile = "fc1839c19327f8fb9b36d2aa6dd133e3d391696183b3292894f9f7e1ca188727";
       libraryHaskellDepends = [
         aeson base base64-bytestring bson bytestring data-default-class
         scientific text time unordered-containers uuid vector
       ];
       jailbreak = true;
       homepage = "https://github.com/philopon/abeson";
       description = "interconversion between aeson and bson";
       license = stdenv.lib.licenses.mit;
     }) {};

  "abstract-deque" = callPackage
    ({ mkDerivation, array, base, containers, random, time }:
     mkDerivation {
       pname = "abstract-deque";
       version = "0.3";
       sha256 = "09aa10f38193a8275a7791b92a4f3a7192a304874637e2a35c897dde25d75ca2";
       libraryHaskellDepends = [ array base containers random time ];
       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, 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
       ];
       testHaskellDepends = [
         abstract-deque array base containers HUnit random test-framework
         test-framework-hunit time
       ];
       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 }:
     mkDerivation {
       pname = "abstract-par";
       version = "0.3.3";
       sha256 = "248a8739bd902462cb16755b690b55660e196e58cc7e6ef8157a72c2a3d5d860";
       libraryHaskellDepends = [ base deepseq ];
       homepage = "https://github.com/simonmar/monad-par";
       description = "Type classes generalizing the functionality of the 'monad-par' library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "abstract-par-accelerate" = callPackage
    ({ mkDerivation, abstract-par, accelerate, array, base, vector }:
     mkDerivation {
       pname = "abstract-par-accelerate";
       version = "0.3.3";
       sha256 = "e4dbe142b15b5cfade9a8da12397752e448d6a2a84b9335010ce6ff12a18274c";
       libraryHaskellDepends = [
         abstract-par accelerate array base vector
       ];
       homepage = "https://github.com/simonmar/monad-par";
       description = "Provides the class ParAccelerate, nothing more";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "abt" = callPackage
    ({ mkDerivation, base, profunctors, transformers
     , transformers-compat, vinyl
     }:
     mkDerivation {
       pname = "abt";
       version = "0.1.1.0";
       sha256 = "c90bc229e962799ab80b4ba8fc9fe962e2570cf818222dffd0ec19dbefffebc1";
       libraryHaskellDepends = [
         base profunctors transformers transformers-compat vinyl
       ];
       jailbreak = true;
       description = "Abstract binding trees for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ac-machine" = callPackage
    ({ mkDerivation, base, hashable, unordered-containers, vector }:
     mkDerivation {
       pname = "ac-machine";
       version = "0.2.0.5";
       sha256 = "2482425924af29da76abc529bb6b57d507753dc1eac642e89d00d082dab64203";
       libraryHaskellDepends = [
         base hashable unordered-containers vector
       ];
       jailbreak = true;
       description = "Aho-Corasick string matching algorithm in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ac-machine-conduit" = callPackage
    ({ mkDerivation, ac-machine, base, conduit, text }:
     mkDerivation {
       pname = "ac-machine-conduit";
       version = "0.1.0.0";
       sha256 = "837eae5d369b4c53293b66c4c5a6c3156ffcdc4ec08dc199c7cb7e4ee95e56db";
       libraryHaskellDepends = [ ac-machine base conduit text ];
       jailbreak = true;
       description = "Drive Aho-Corasick machines in Conduit pipelines";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "accelerate_0_15_0_0" = callPackage
    ({ mkDerivation, array, base, containers, fclabels, ghc-prim
     , hashable, hashtables, pretty, template-haskell
     , unordered-containers
     }:
     mkDerivation {
       pname = "accelerate";
       version = "0.15.0.0";
       sha256 = "fa5ae43a58be2f0d4e5a340a29b8e18c3dc66f0200259ea6552e55ae43fd23c2";
       revision = "2";
       editedCabalFile = "98cea47c7fdb595a54cb06751fe54eb800059e5a2b1f9699a65d4e845b55cd4c";
       libraryHaskellDepends = [
         array base containers fclabels ghc-prim hashable hashtables pretty
         template-haskell unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/AccelerateHS/accelerate/";
       description = "An embedded language for accelerated array processing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "accelerate" = callPackage
    ({ mkDerivation, array, base, containers, fclabels, ghc-prim
     , hashable, hashtables, pretty, template-haskell
     , unordered-containers
     }:
     mkDerivation {
       pname = "accelerate";
       version = "0.15.1.0";
       sha256 = "db0f9a5bd8ba6e264561bb62b213384e70baae6fe90208ea2ee101f553556b1d";
       libraryHaskellDepends = [
         array base containers fclabels ghc-prim hashable hashtables pretty
         template-haskell unordered-containers
       ];
       homepage = "https://github.com/AccelerateHS/accelerate/";
       description = "An embedded language for accelerated array processing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "accelerate-arithmetic" = callPackage
    ({ mkDerivation, accelerate, accelerate-utility, base, QuickCheck
     , utility-ht
     }:
     mkDerivation {
       pname = "accelerate-arithmetic";
       version = "0.0.1";
       sha256 = "819c4d6b24bf5858bf9ef77a002724d1685f80ac8c2c074b329ac3a51a0f7224";
       libraryHaskellDepends = [
         accelerate accelerate-utility base QuickCheck utility-ht
       ];
       testHaskellDepends = [ accelerate base QuickCheck ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/accelerate-arithmetic/";
       description = "Linear algebra and interpolation using the Accelerate framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "accelerate-cublas" = callPackage
    ({ mkDerivation, accelerate, accelerate-arithmetic, accelerate-cuda
     , accelerate-io, accelerate-utility, base, cublas, cuda, random
     , utility-ht, vector
     }:
     mkDerivation {
       pname = "accelerate-cublas";
       version = "0.0";
       sha256 = "4c27f8f6dca4c6e822cc731fe89ab90712f29acb341ad856791aa97db15199b5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         accelerate accelerate-arithmetic accelerate-cuda accelerate-io
         accelerate-utility base cublas cuda utility-ht vector
       ];
       executableHaskellDepends = [
         accelerate accelerate-arithmetic accelerate-cuda accelerate-utility
         base cublas random
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/accelerate-cublas/";
       description = "Basic Linear Algebra using native CUBLAS library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "accelerate-cuda" = callPackage
    ({ mkDerivation, accelerate, array, base, binary, bytestring
     , cryptohash, cuda, directory, fclabels, filepath, hashable
     , hashtables, language-c-quote, mainland-pretty, mtl, old-time
     , pretty, process, SafeSemaphore, srcloc, template-haskell, text
     , transformers, unix, unordered-containers
     }:
     mkDerivation {
       pname = "accelerate-cuda";
       version = "0.15.1.1";
       sha256 = "6140c60df329f78d77d258ae3029522cb7a3fb038c531e23792dd8b307ff379d";
       libraryHaskellDepends = [
         accelerate array base binary bytestring cryptohash cuda directory
         fclabels filepath hashable hashtables language-c-quote
         mainland-pretty mtl old-time pretty process SafeSemaphore srcloc
         template-haskell text transformers unix unordered-containers
       ];
       homepage = "https://github.com/AccelerateHS/accelerate-cuda/";
       description = "Accelerate backend for NVIDIA GPUs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "accelerate-cufft" = callPackage
    ({ mkDerivation, accelerate, accelerate-cuda, accelerate-fourier
     , accelerate-utility, base, cuda, cufft
     }:
     mkDerivation {
       pname = "accelerate-cufft";
       version = "0.0";
       sha256 = "a7f5f2ee43acebd1a5caf6fd268b05def2d279485bf1e7021a0299097ef9ca89";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         accelerate accelerate-cuda accelerate-fourier accelerate-utility
         base cuda cufft
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/accelerate-cufft/";
       description = "Accelerate frontend to the CUFFT library (Fourier transform)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "accelerate-examples" = callPackage
    ({ mkDerivation, accelerate, accelerate-cuda, accelerate-fft
     , accelerate-io, ansi-wl-pprint, array, attoparsec, base, binary
     , bmp, bytestring, bytestring-lexing, cereal, containers, criterion
     , directory, ekg, fclabels, filepath, gloss, gloss-accelerate
     , gloss-raster-accelerate, gloss-rendering, HUnit, mwc-random
     , normaldistribution, primitive, QuickCheck, random, repa, repa-io
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , vector, vector-algorithms
     }:
     mkDerivation {
       pname = "accelerate-examples";
       version = "0.15.1.0";
       sha256 = "2191601709da693aedb29f570e44b899b5132d2bc05fe618bc93608a43fec4a2";
       configureFlags = [ "-f-opencl" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         accelerate accelerate-cuda ansi-wl-pprint base containers criterion
         directory ekg fclabels HUnit mwc-random QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       executableHaskellDepends = [
         accelerate accelerate-cuda accelerate-fft accelerate-io array
         attoparsec base binary bmp bytestring bytestring-lexing cereal
         containers criterion directory fclabels filepath gloss
         gloss-accelerate gloss-raster-accelerate gloss-rendering HUnit
         mwc-random normaldistribution primitive QuickCheck random repa
         repa-io test-framework test-framework-hunit
         test-framework-quickcheck2 vector vector-algorithms
       ];
       homepage = "https://github.com/AccelerateHS/accelerate-examples";
       description = "Examples using the Accelerate library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "accelerate-fft" = callPackage
    ({ mkDerivation, accelerate, accelerate-cuda, base, cuda, cufft }:
     mkDerivation {
       pname = "accelerate-fft";
       version = "0.15.1.0";
       sha256 = "fd2648931ce4607aba4ad527691a4bba0f043ea4182a160aa8f024152101a702";
       libraryHaskellDepends = [
         accelerate accelerate-cuda base cuda cufft
       ];
       homepage = "https://github.com/AccelerateHS/accelerate-fft";
       description = "FFT using the Accelerate library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "accelerate-fftw" = callPackage
    ({ mkDerivation, accelerate, accelerate-io, base, carray, fft
     , storable-complex
     }:
     mkDerivation {
       pname = "accelerate-fftw";
       version = "0.0";
       sha256 = "7a8678f28b621d2e0f4414f3e6e7b4a21bf290088de64714ea1942dd8dd2ce0d";
       libraryHaskellDepends = [
         accelerate accelerate-io base carray fft storable-complex
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/accelerate-fftw/";
       description = "Accelerate frontend to the FFTW library (Fourier transform)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "accelerate-fourier" = callPackage
    ({ mkDerivation, accelerate, accelerate-arithmetic
     , accelerate-utility, base, containers, QuickCheck, transformers
     , utility-ht
     }:
     mkDerivation {
       pname = "accelerate-fourier";
       version = "0.0";
       sha256 = "58acf3266fb8007706c97c69024b5fdf2be08b5e1a1975944c7fd40848a9ec2c";
       libraryHaskellDepends = [
         accelerate accelerate-arithmetic accelerate-utility base containers
         QuickCheck transformers utility-ht
       ];
       testHaskellDepends = [
         accelerate accelerate-arithmetic accelerate-utility base QuickCheck
         utility-ht
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/accelerate-fourier/";
       description = "Fast Fourier transform and convolution using the Accelerate framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "accelerate-fourier-benchmark" = callPackage
    ({ mkDerivation, accelerate, accelerate-cuda, accelerate-cufft
     , accelerate-fftw, accelerate-fourier, base, criterion
     }:
     mkDerivation {
       pname = "accelerate-fourier-benchmark";
       version = "0.0";
       sha256 = "ea65bce4c026c4ac47a34ed80d5901f2b14d06c94dbe7693acce58a992d5e998";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         accelerate accelerate-cuda accelerate-cufft accelerate-fftw
         accelerate-fourier base criterion
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/accelerate-fourier-benchmark/";
       description = "Compare different implementations of the Fast Fourier Transform";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "accelerate-io" = callPackage
    ({ mkDerivation, accelerate, array, base, bmp, bytestring, repa
     , vector
     }:
     mkDerivation {
       pname = "accelerate-io";
       version = "0.15.1.0";
       sha256 = "d531fc6c950a6fcf0bdd72c65438c27fbffe2f3043444128979490d53fc7677c";
       libraryHaskellDepends = [
         accelerate array base bmp bytestring repa vector
       ];
       homepage = "https://github.com/AccelerateHS/accelerate-io";
       description = "Read and write Accelerate arrays in various formats";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "accelerate-random" = callPackage
    ({ mkDerivation, accelerate, base, mwc-random }:
     mkDerivation {
       pname = "accelerate-random";
       version = "0.15.0.0";
       sha256 = "6d2600b2b4eac2246658e926a088447b1aa8add76994071a3cf8a5c455081ef3";
       libraryHaskellDepends = [ accelerate base mwc-random ];
       description = "Generate Accelerate arrays filled with high quality pseudorandom numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "accelerate-utility" = callPackage
    ({ mkDerivation, accelerate, base, utility-ht }:
     mkDerivation {
       pname = "accelerate-utility";
       version = "0.1";
       sha256 = "fbbe0d70a474d82bdfe7d4b6ded152145df23dc0f1fcc256e9a20b1ae9f4b0d8";
       libraryHaskellDepends = [ accelerate base utility-ht ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/accelerate-utility/";
       description = "Utility functions for the Accelerate framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "accentuateus" = callPackage
    ({ mkDerivation, base, bytestring, HTTP, json, network, text }:
     mkDerivation {
       pname = "accentuateus";
       version = "0.9.4";
       sha256 = "1e82b7b3c5f6e6d980242d3819f379a8c0d5fdfe34c17cf55eef0fcd02d20f9a";
       libraryHaskellDepends = [ base bytestring HTTP json network text ];
       jailbreak = true;
       homepage = "http://accentuate.us/";
       description = "A Haskell implementation of the Accentuate.us API.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "access-time" = callPackage
    ({ mkDerivation, base, filepath, old-time, time, unix }:
     mkDerivation {
       pname = "access-time";
       version = "0.1.0.4";
       sha256 = "fa598105be558f8d079bda919eb14ab5fdba490f04acc34146c8459b65456f8e";
       libraryHaskellDepends = [ base filepath old-time time unix ];
       jailbreak = true;
       homepage = "http://www.github.com/batterseapower/access-time";
       description = "Cross-platform support for retrieving file access times";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ace" = callPackage
    ({ mkDerivation, attoparsec, base, bifunctors, blaze-html
     , blaze-markup, data-default, hspec, HUnit, mtl, parsec, text
     }:
     mkDerivation {
       pname = "ace";
       version = "0.6";
       sha256 = "d3472b659d26cf7ea9afa207ec24ac0314598de997722e636e9bfa24b3900738";
       libraryHaskellDepends = [
         attoparsec base blaze-html blaze-markup data-default parsec text
       ];
       testHaskellDepends = [
         base bifunctors hspec HUnit mtl parsec text
       ];
       description = "Attempto Controlled English parser and printer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acid-state_0_12_4" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, containers
     , directory, extensible-exceptions, filepath, mtl, network
     , safecopy, stm, template-haskell, unix
     }:
     mkDerivation {
       pname = "acid-state";
       version = "0.12.4";
       sha256 = "4d2db186740e8d33fab5c6fd7ef2364e0f6bc39bdf58be845fb0a57893b86255";
       revision = "1";
       editedCabalFile = "a2b63490651e784a60fe3a8c73f877c5f51e08e6df8ff17e7a4c4bd112f1670d";
       libraryHaskellDepends = [
         array base bytestring cereal containers directory
         extensible-exceptions filepath mtl network safecopy stm
         template-haskell unix
       ];
       jailbreak = true;
       homepage = "http://acid-state.seize.it/";
       description = "Add ACID guarantees to any serializable Haskell data structure";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "acid-state" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, containers
     , directory, extensible-exceptions, filepath, mtl, network
     , safecopy, stm, template-haskell, unix
     }:
     mkDerivation {
       pname = "acid-state";
       version = "0.14.0";
       sha256 = "db7cc0fdfe0af9757f448a4184c88d5a8f2ac5e014bea1623a6272821a510621";
       revision = "2";
       editedCabalFile = "8aa8c1e14d8dcfec861e9ef4198a9084b54c64719b77e9b505c53024a6ad7f51";
       libraryHaskellDepends = [
         array base bytestring cereal containers directory
         extensible-exceptions filepath mtl network safecopy stm
         template-haskell unix
       ];
       homepage = "http://acid-state.seize.it/";
       description = "Add ACID guarantees to any serializable Haskell data structure";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "acid-state-dist" = callPackage
    ({ mkDerivation, acid-state, base, bytestring, cereal
     , concurrent-extra, containers, directory, filepath, mtl, random
     , safe, safecopy, semigroups, stm, transformers, zeromq4-haskell
     }:
     mkDerivation {
       pname = "acid-state-dist";
       version = "0.1.0.1";
       sha256 = "868d3c28720d6757609ee8247634a04d49884cf0a049b1fca8fe542ddcc69eab";
       libraryHaskellDepends = [
         acid-state base bytestring cereal concurrent-extra containers
         filepath mtl safe safecopy semigroups stm transformers
         zeromq4-haskell
       ];
       testHaskellDepends = [
         acid-state base directory mtl random safecopy
       ];
       jailbreak = true;
       description = "A replication backend for acid-state";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "acid-state-tls" = callPackage
    ({ mkDerivation, acid-state, base, directory, HsOpenSSL, network
     , safecopy
     }:
     mkDerivation {
       pname = "acid-state-tls";
       version = "0.9.2";
       sha256 = "f1fe502f2dff0374a401f15db4fe4afe82493c4dc945da6a8f7aeb3a7ac88313";
       libraryHaskellDepends = [
         acid-state base directory HsOpenSSL network safecopy
       ];
       jailbreak = true;
       homepage = "http://acid-state.seize.it/";
       description = "Add TLS support for Data.Acid.Remote";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "acl2" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "acl2";
       version = "0.0.1";
       sha256 = "8f11af048dd74ef814dfcf20052ac359713650eb272bd841ca71d1317bd3942f";
       libraryHaskellDepends = [ base process ];
       description = "Writing and calling ACL2 from Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-all-monad" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "acme-all-monad";
       version = "0.1.0.0";
       sha256 = "fb2dcbc36232d9a93dcff35ecdcb3c26a32dd653d3c665157a524b6f423d5ee1";
       libraryHaskellDepends = [ base transformers ];
       jailbreak = true;
       description = "A monad which is powerful enough to interpret any action";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "acme-box" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-box";
       version = "0.0.0.0";
       sha256 = "1b51150b9cddf25c036f297658e17e7f9e68e15298774f2441dae0992457d558";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/drwebb/acme-box";
       description = "A full featured empty project";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-cadre" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-cadre";
       version = "0.1";
       sha256 = "718954cdc4c7eba1c6f24935726909ed888f12711040d2eacb87948c086694d9";
       libraryHaskellDepends = [ base ];
       description = "car, cdr and more";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "acme-cofunctor" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-cofunctor";
       version = "0.1.0.0";
       sha256 = "d5ecbe477dd579fec0c6f6ad5d8f05d884de65af6570d519703896ecfe08311a";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/jaspervdj/acme-cofunctor";
       description = "A Cofunctor is a structure from category theory dual to Functor";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-colosson" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "acme-colosson";
       version = "0.1";
       sha256 = "6c27d923310196d1196bba42fb151e572b6b5854f0cd618b197a82c5c156d655";
       libraryHaskellDepends = [ base random ];
       description = "Determines whether it is numberwang";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-comonad" = callPackage
    ({ mkDerivation, base, comonad }:
     mkDerivation {
       pname = "acme-comonad";
       version = "0.1.0.0";
       sha256 = "1a75f1f516870cfe2de7cd6c9fda7f8e54fcd7c4c0134c3c0a9abad7385580e9";
       libraryHaskellDepends = [ base comonad ];
       jailbreak = true;
       description = "A more efficient dualization";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-cutegirl" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-cutegirl";
       version = "0.2.0.0";
       sha256 = "7f2c87f308c5fdcd3f0e715393561280858dad55b310fcf25f97e06c997570ef";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       homepage = "http://github.com/Fuuzetsu/acme-cutegirl";
       description = "Maybe gives you a cute girl";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "acme-dont" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-dont";
       version = "1.1";
       sha256 = "c32231ff8548bccd4f3bafcc9b1eb84947a2e5e0897c50c048e0e7609fc443ce";
       libraryHaskellDepends = [ base ];
       description = "A don't construct";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-flipping-tables" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-flipping-tables";
       version = "0";
       sha256 = "a71c3bd27e878d2501bc2eeee2a426cceebda53e36bfd9dc218fa963187f85f6";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/jystic/acme-flipping-tables";
       description = "Stop execution with rage";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-grawlix" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-grawlix";
       version = "0.1.0.2";
       sha256 = "56f3f73854e790aab0f41a209033f4b6893dc418cc8fef6a448b8fb046dc0c9c";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/kadoban/acme-grawlix";
       description = "More readable names for commonly used symbols";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-hq9plus" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-hq9plus";
       version = "0.1";
       sha256 = "07856883a46fa23f98e51ba489420107e57b1237cbf5bed762b03a72a4f64435";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/joeyadams/haskell-acme-hq9plus";
       description = "An embedded DSL for the HQ9+ programming language";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "acme-http" = callPackage
    ({ mkDerivation, base, bytestring, extensible-exceptions, mtl
     , network, pretty
     }:
     mkDerivation {
       pname = "acme-http";
       version = "0.2.2";
       sha256 = "f1915876a243d5ad8ff61a7235068a5d0cb0974760d05ecdcd72a0036944bbda";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring extensible-exceptions mtl network pretty
       ];
       jailbreak = true;
       homepage = "http://www.happstack.com";
       description = "fastest Haskell PONG server in the world";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-inator" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-inator";
       version = "0.1.0.0";
       sha256 = "d37f74ce98de9e3a8fd42492bf53ec99a8e80c0445186fa846abe6acf06f3bc0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       description = "Evil inventions in the Tri-State area";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "acme-io" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-io";
       version = "0.1.0.1";
       sha256 = "8b0d441cdc3389bbd3672b43ca3685d1a8ce2c43da0aae9a2d8735bf58fb2c24";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "N/A";
       description = "The only true way to do IO in Haskell!";
       license = "unknown";
     }) {};

  "acme-lolcat" = callPackage
    ({ mkDerivation, base, parsec, random, random-shuffle, text }:
     mkDerivation {
       pname = "acme-lolcat";
       version = "0.1.1";
       sha256 = "6228b1679885fef0c29e3e9a27cb8b273e1d68d700e9b7b1d2823d9af2d23a22";
       libraryHaskellDepends = [ base parsec random random-shuffle text ];
       homepage = "https://github.com/llelf/acme-lolcat";
       description = "LOLSPEAK translator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-lookofdisapproval" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-lookofdisapproval";
       version = "0.1";
       sha256 = "3a423e4d0045d75951b9b1b2a4ba53c0a8363eb9ddab6cc71a7a91b014db9da4";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/llelf/acme-lookofdisapproval";
       description = "Express your disapproval";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-memorandom" = callPackage
    ({ mkDerivation, base, MemoTrie, random }:
     mkDerivation {
       pname = "acme-memorandom";
       version = "0.0.3";
       sha256 = "115a0f491fb5f3ae4ddfb54305f837fcdb46a0a10bb3eb1a3d24bab35aedd3d0";
       libraryHaskellDepends = [ base MemoTrie random ];
       homepage = "https://github.com/ion1/acme-memorandom";
       description = "Memoized random number generation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "acme-microwave" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-microwave";
       version = "0.1.0.2";
       sha256 = "6948517284fa20e90169073c6d04fa3de1303b8ba7039ab00d44c81a59e7d48c";
       libraryHaskellDepends = [ base ];
       description = "The eighth wonder of the world, kitchen math!";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-miscorder" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "acme-miscorder";
       version = "0.1.0.0";
       sha256 = "44826a0f6d37ccd99a3173cda9ecbc754e81feff10610cc011ab2fba89d10ea0";
       libraryHaskellDepends = [ base random ];
       jailbreak = true;
       description = "Miscellaneous newtypes for orderings of discutable use";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "acme-missiles" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "acme-missiles";
       version = "0.3";
       sha256 = "e563d8b524017a06b32768c4db8eff1f822f3fb22a90320b7e414402647b735b";
       libraryHaskellDepends = [ base stm ];
       description = "Cause serious international side effects";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "acme-now" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "acme-now";
       version = "1.0.0.1";
       sha256 = "55f34fa960eecf16317414f4bfc4baa4966164b95526f8f65900e4d39bd5d952";
       libraryHaskellDepends = [ base time ];
       jailbreak = true;
       description = "An interface to the philosophical and metaphysical \"now\"";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "acme-numbersystem" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "acme-numbersystem";
       version = "0.3.0.0";
       sha256 = "07ed4a91c5cfc38c4d44120c927082000558068274fbb11ff646b7dab46eb9dc";
       libraryHaskellDepends = [ base template-haskell ];
       jailbreak = true;
       description = "Define the less than and add and subtract for nats";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "acme-omitted" = callPackage
    ({ mkDerivation, base, hspec }:
     mkDerivation {
       pname = "acme-omitted";
       version = "2.0.0.0";
       sha256 = "4d75086cd1957562a65e4284a4dc33dfc1e93a68c634a4bd05b580482a95465e";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec ];
       homepage = "https://github.com/joachifm/acme-omitted#readme";
       description = "A name for omitted definitions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-one" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "acme-one";
       version = "0.0.2";
       sha256 = "6bed9ce93f0c6efabc63addcafbaf732187d7a111975541127a9948788e94f87";
       doHaddock = false;
       homepage = "https://github.com/ion1/acme-zero-one";
       description = "The identity element of package dependencies";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "acme-operators" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-operators";
       version = "0.2.0.0";
       sha256 = "3c80f60d4add0170b1a0a94d53abfc6d14a2a4efc7c3dd9ecf5a840d6f14c1f1";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/phadej/acme-operators#readme";
       description = "Operators of base, all in one place!";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-php" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-php";
       version = "0.0.3";
       sha256 = "df37993a472d9f867ce7cdb16ab2f8db1e4aa7fa92a0f617344c0542c66b2d24";
       libraryHaskellDepends = [ base ];
       description = "The flexibility of Haskell and the safety of PHP";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-pointful-numbers" = callPackage
    ({ mkDerivation, base, split }:
     mkDerivation {
       pname = "acme-pointful-numbers";
       version = "0.1.2.4";
       sha256 = "c9d733ac1df9b8294c6f6f99d0c9610d2b77a7fc98a6d4279f2feeb29aa0f509";
       libraryHaskellDepends = [ base split ];
       description = "Make more than one point in numeric literals";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-realworld" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-realworld";
       version = "0.1.1";
       sha256 = "19b90d7c8603ed633ce0faf9f223be0d6056bf68f57ac94a3b2c4228218bd039";
       libraryHaskellDepends = [ base ];
       description = "Primitives for manipulating the state of the universe";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-safe" = callPackage
    ({ mkDerivation, acme-dont, base }:
     mkDerivation {
       pname = "acme-safe";
       version = "0.1.0.0";
       sha256 = "c87ce02c7188303b2a109e0c81e8c5a074c35d3fc3ebddde31a9903d5621bb2e";
       libraryHaskellDepends = [ acme-dont base ];
       homepage = "http://github.com/fgaz/acme-safe";
       description = "Safe versions of some infamous haskell functions such as fromJust";
       license = "unknown";
     }) {};

  "acme-schoenfinkel" = callPackage
    ({ mkDerivation, base, QuickCheck, test-framework
     , test-framework-quickcheck2, test-framework-th
     }:
     mkDerivation {
       pname = "acme-schoenfinkel";
       version = "0.1.1";
       sha256 = "4da179d999d1b430d48fe4e61bf764a08d277abf439a0f735912e1db77cc6b4b";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
         test-framework-th
       ];
       description = "Proper names for curry and uncurry";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "acme-strfry" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "acme-strfry";
       version = "0.1";
       sha256 = "8b2208e73aaab38d3a948a8be016a7d0ac651d980b2d0a0dfe700ad1fdb4dde4";
       libraryHaskellDepends = [ base bytestring ];
       jailbreak = true;
       homepage = "https://github.com/ehird/acme-strfry";
       description = "A binding to the glibc strfry function";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-stringly-typed" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "acme-stringly-typed";
       version = "1.0.0.0";
       sha256 = "ce045ee38baade76be3e83f59f709b28bd4dec4d8ef8c8156b09f255dbd69ba3";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Stringly Typed Programming";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-strtok" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "acme-strtok";
       version = "0.1.0.3";
       sha256 = "c828c77a49e89e25fabb077f8f28c304a98635af7971cc2da113b3ffbc47d2aa";
       libraryHaskellDepends = [ base mtl ];
       description = "A Haskell port of the C/PHP strtok function";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "acme-timemachine" = callPackage
    ({ mkDerivation, base, ghc-prim, mtl, transformers }:
     mkDerivation {
       pname = "acme-timemachine";
       version = "0.0.1.0";
       sha256 = "6be7e0cef59212ac8431073f1934645bf3ab859d5f9a3f23d1df3c482cb0dcb5";
       libraryHaskellDepends = [ base ghc-prim mtl transformers ];
       description = "An easy way to perform and unperform IO and other stateful actions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "acme-year" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "acme-year";
       version = "2015";
       sha256 = "3b8b506b4d38b3e781aa3296f10643e76214a3a80e023c653951c41d8aefbafa";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base time ];
       homepage = "http://github.com/joeyadams/hs-acme-year";
       description = "Get the current year";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "acme-zero" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "acme-zero";
       version = "0.0.2";
       sha256 = "c68d82cbf3bda44ce0b63055a751ab81a681e375a6bff979c29c63a4da85a419";
       doHaddock = false;
       jailbreak = true;
       homepage = "https://github.com/ion1/acme-zero-one";
       description = "The absorbing element of package dependencies";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "action-permutations" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "action-permutations";
       version = "0.0.0.1";
       sha256 = "a419ee59f996e5305afd96336a561a9fcf26844362eaa32ab6b747a8f9fd1466";
       libraryHaskellDepends = [ base ];
       description = "Execute a set of actions (e.g. parsers) in each possible order";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "active_0_1_0_17" = callPackage
    ({ mkDerivation, array, base, newtype, QuickCheck, semigroupoids
     , semigroups, vector-space
     }:
     mkDerivation {
       pname = "active";
       version = "0.1.0.17";
       sha256 = "0b1f5837407bd89a2da9802db111d7927c02908c5a3d91a6db671c61150457ab";
       libraryHaskellDepends = [
         array base newtype semigroupoids semigroups vector-space
       ];
       testHaskellDepends = [
         array base newtype QuickCheck semigroupoids semigroups vector-space
       ];
       jailbreak = true;
       description = "Abstractions for animation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "active_0_1_0_18" = callPackage
    ({ mkDerivation, array, base, newtype, QuickCheck, semigroupoids
     , semigroups, vector-space
     }:
     mkDerivation {
       pname = "active";
       version = "0.1.0.18";
       sha256 = "73652715e912e166bc8e151e3f9425962f639ac8d9c704d0d2bc0e857a3d52e0";
       libraryHaskellDepends = [
         array base newtype semigroupoids semigroups vector-space
       ];
       testHaskellDepends = [
         array base newtype QuickCheck semigroupoids semigroups vector-space
       ];
       jailbreak = true;
       description = "Abstractions for animation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "active_0_1_0_19" = callPackage
    ({ mkDerivation, array, base, newtype, QuickCheck, semigroupoids
     , semigroups, vector-space
     }:
     mkDerivation {
       pname = "active";
       version = "0.1.0.19";
       sha256 = "9c65f1e862af486f74e07b42fabacb5bb613b1bb966df4d707ee77eeaeccffff";
       libraryHaskellDepends = [
         array base newtype semigroupoids semigroups vector-space
       ];
       testHaskellDepends = [
         array base newtype QuickCheck semigroupoids semigroups vector-space
       ];
       jailbreak = true;
       description = "Abstractions for animation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "active_0_2_0_4" = callPackage
    ({ mkDerivation, base, lens, linear, QuickCheck, semigroupoids
     , semigroups, vector
     }:
     mkDerivation {
       pname = "active";
       version = "0.2.0.4";
       sha256 = "e029fada3b6e12e3121583f2533a241bb23dc480248540d840a8416c27f2a2f6";
       libraryHaskellDepends = [
         base lens linear semigroupoids semigroups vector
       ];
       testHaskellDepends = [
         base lens linear QuickCheck semigroupoids semigroups vector
       ];
       jailbreak = true;
       description = "Abstractions for animation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "active_0_2_0_6" = callPackage
    ({ mkDerivation, base, lens, linear, QuickCheck, semigroupoids
     , semigroups, vector
     }:
     mkDerivation {
       pname = "active";
       version = "0.2.0.6";
       sha256 = "786060f5470fbbbad90064e03cdf8b97434ed956932406464c37595efc0d6bdc";
       libraryHaskellDepends = [
         base lens linear semigroupoids semigroups vector
       ];
       testHaskellDepends = [
         base lens linear QuickCheck semigroupoids semigroups vector
       ];
       jailbreak = true;
       description = "Abstractions for animation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "active" = callPackage
    ({ mkDerivation, base, lens, linear, QuickCheck, semigroupoids
     , semigroups, vector
     }:
     mkDerivation {
       pname = "active";
       version = "0.2.0.8";
       sha256 = "a8335dd10b4bab3a2a73a2f8fa49cb20ab2f9ec1400fa7a49de3d92f9e887fdf";
       libraryHaskellDepends = [
         base lens linear semigroupoids semigroups vector
       ];
       testHaskellDepends = [
         base lens linear QuickCheck semigroupoids semigroups vector
       ];
       description = "Abstractions for animation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "activehs" = callPackage
    ({ mkDerivation, activehs-base, array, base, blaze-html, bytestring
     , cmdargs, containers, data-pprint, deepseq, dia-base
     , dia-functions, directory, filepath, haskell-src-exts
     , highlighting-kate, hint, hoogle, mtl, old-locale, old-time
     , pandoc, process, pureMD5, QuickCheck, simple-reflect, snap-core
     , snap-server, split, syb, text, time, utf8-string, xhtml
     }:
     mkDerivation {
       pname = "activehs";
       version = "0.3.1";
       sha256 = "0c0ab3ef3338d713d0bde0ce288199ce28c6401e27545691f04e08450403ea0f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         activehs-base array base blaze-html bytestring cmdargs containers
         data-pprint deepseq dia-base dia-functions directory filepath
         haskell-src-exts highlighting-kate hint hoogle mtl old-locale
         old-time pandoc process pureMD5 QuickCheck simple-reflect snap-core
         snap-server split syb text time utf8-string xhtml
       ];
       jailbreak = true;
       description = "Haskell code presentation tool";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "activehs-base" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "activehs-base";
       version = "0.3.0.3";
       sha256 = "6258c61cd325735f033e5bf388c96502fa4fd283e67c2465ce473f9ffc1a83e0";
       libraryHaskellDepends = [ base QuickCheck ];
       jailbreak = true;
       description = "Basic definitions for activehs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "activitystreams-aeson" = callPackage
    ({ mkDerivation, aeson, base, text, time, unordered-containers }:
     mkDerivation {
       pname = "activitystreams-aeson";
       version = "0.2.0.1";
       sha256 = "4fe91f1355c2572661baa932988159123dd8a61e6c9c09a40af98b520291f9ae";
       libraryHaskellDepends = [
         aeson base text time unordered-containers
       ];
       jailbreak = true;
       description = "An interface to the ActivityStreams specification";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "actor" = callPackage
    ({ mkDerivation, base, haskell98, stm, time }:
     mkDerivation {
       pname = "actor";
       version = "0.1.1";
       sha256 = "6589dd602fb3fdbedd6553c2500b6bc36da6bc714ec07d8238131aefb22787c5";
       libraryHaskellDepends = [ base haskell98 stm time ];
       homepage = "http://sulzmann.blogspot.com/2008/10/actors-with-multi-headed-receive.html";
       description = "Actors with multi-headed receive clauses";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ad_4_2_1_1" = callPackage
    ({ mkDerivation, array, base, comonad, containers, data-reify
     , directory, doctest, erf, filepath, free, nats, reflection
     , transformers
     }:
     mkDerivation {
       pname = "ad";
       version = "4.2.1.1";
       sha256 = "6acacab870ca12a0e2e31a6b310756db136b140d9c9e1a52cdcf8f340974b7fd";
       libraryHaskellDepends = [
         array base comonad containers data-reify erf free nats reflection
         transformers
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/ad";
       description = "Automatic Differentiation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ad_4_2_2" = callPackage
    ({ mkDerivation, array, base, comonad, containers, data-reify
     , directory, doctest, erf, filepath, free, nats, reflection
     , transformers
     }:
     mkDerivation {
       pname = "ad";
       version = "4.2.2";
       sha256 = "ae4bfd52671e94fc98490457274f27df205df371c1911679741fa1279f814c0c";
       libraryHaskellDepends = [
         array base comonad containers data-reify erf free nats reflection
         transformers
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/ad";
       description = "Automatic Differentiation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ad_4_2_3" = callPackage
    ({ mkDerivation, array, base, comonad, containers, data-reify
     , directory, doctest, erf, filepath, free, nats, reflection
     , transformers
     }:
     mkDerivation {
       pname = "ad";
       version = "4.2.3";
       sha256 = "25a72665dc5c366f2a5482237b65e86bab2b1029b08e167a484bb24f296a3671";
       libraryHaskellDepends = [
         array base comonad containers data-reify erf free nats reflection
         transformers
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/ekmett/ad";
       description = "Automatic Differentiation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ad_4_2_4" = callPackage
    ({ mkDerivation, array, base, comonad, containers, data-reify
     , directory, doctest, erf, filepath, free, nats, reflection
     , transformers
     }:
     mkDerivation {
       pname = "ad";
       version = "4.2.4";
       sha256 = "d6850ebd71f39a1ba269f2b1e91b57d13cf2e0a1c73e4394798c3e704ea5fe5c";
       libraryHaskellDepends = [
         array base comonad containers data-reify erf free nats reflection
         transformers
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       doCheck = false;
       homepage = "http://github.com/ekmett/ad";
       description = "Automatic Differentiation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ad_4_3_1" = callPackage
    ({ mkDerivation, array, base, comonad, containers, data-reify
     , directory, doctest, erf, filepath, free, nats, reflection
     , transformers
     }:
     mkDerivation {
       pname = "ad";
       version = "4.3.1";
       sha256 = "da9baee8042acd8a266863604dd4c02b5903f366dc8b5208584745c54e027392";
       libraryHaskellDepends = [
         array base comonad containers data-reify erf free nats reflection
         transformers
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/ekmett/ad";
       description = "Automatic Differentiation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ad" = callPackage
    ({ mkDerivation, array, base, comonad, containers, data-reify
     , directory, doctest, erf, filepath, free, nats, reflection
     , transformers
     }:
     mkDerivation {
       pname = "ad";
       version = "4.3.2";
       sha256 = "04ed3648d14b2af0a385abfe7819f3704c499b43a1dd48ce5858f020b873d5ed";
       libraryHaskellDepends = [
         array base comonad containers data-reify erf free nats reflection
         transformers
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/ekmett/ad";
       description = "Automatic Differentiation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "adaptive-containers" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "adaptive-containers";
       version = "0.3";
       sha256 = "1387d8f5e89f452da04d59c0e97154345571fa7c952d1dfb012f39584afc009a";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.haskell.org/~dons/code/adaptive-containers";
       description = "Self optimizing container types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "adaptive-tuple" = callPackage
    ({ mkDerivation, base, template-haskell, type-level }:
     mkDerivation {
       pname = "adaptive-tuple";
       version = "0.2.0";
       sha256 = "218f0271298f9a42aad50c10cc042388c62d1619624b750f0b665be4f068c4cd";
       libraryHaskellDepends = [ base template-haskell type-level ];
       homepage = "http://inmachina.net/~jwlato/haskell/";
       description = "Self-optimizing tuple types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "adb" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, mtl, network
     }:
     mkDerivation {
       pname = "adb";
       version = "0.1.0.0";
       sha256 = "a00146b86834664784452d1e210f6e808354a19740aeb71eb0288e577fdbbd9d";
       libraryHaskellDepends = [
         base bytestring cereal containers mtl network
       ];
       jailbreak = true;
       description = "Android Debug Bridge (ADB) protocol";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "adblock2privoxy" = callPackage
    ({ mkDerivation, base, case-insensitive, containers, directory
     , filepath, http-conduit, MissingH, mtl, network, network-uri
     , old-locale, parsec, parsec-permutation, strict, text, time
     }:
     mkDerivation {
       pname = "adblock2privoxy";
       version = "1.4.2";
       sha256 = "2c42c4a75720d8a988898440d06df15b10a2ff1de88fe793de7b7cfe415a339e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base case-insensitive containers directory filepath http-conduit
         MissingH mtl network network-uri old-locale parsec
         parsec-permutation strict text time
       ];
       homepage = "https://projects.zubr.me/wiki/adblock2privoxy";
       description = "Convert adblock config files to privoxy format";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "addLicenseInfo" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "addLicenseInfo";
       version = "0.1";
       sha256 = "3c4b5d38fcd60c73a77e276e1f3e34c5d2cebb1fdc8cc8fc6c38c01541659314";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base process ];
       description = "Adds license info to the top of a file";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "adhoc-network" = callPackage
    ({ mkDerivation, base, bytestring, containers, Crypto, dataenc
     , HaXml, hsgnutls, network, old-locale, parsec, pkcs1, random, time
     , utf8-string, xml-parsec
     }:
     mkDerivation {
       pname = "adhoc-network";
       version = "1.0.3";
       sha256 = "e70ca6886bd4a2b17cf92b94a848e7ac3e3ac75718e692d63ad98ec07bcd0df2";
       libraryHaskellDepends = [
         base bytestring containers Crypto dataenc HaXml hsgnutls network
         old-locale parsec pkcs1 random time utf8-string xml-parsec
       ];
       homepage = "http://sep07.mroot.net/";
       description = "Ad-hoc P2P network protocol";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "adict" = callPackage
    ({ mkDerivation, array, base, binary, containers, dawg, PSQueue
     , QuickCheck, test-framework, test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "adict";
       version = "0.4.1";
       sha256 = "f8edd2ae3ceadb7a4bf4005f6218caa3a51e9e2e3171021edf2c52ce4a2a831f";
       libraryHaskellDepends = [
         array base binary containers dawg PSQueue vector
       ];
       testHaskellDepends = [
         base containers dawg QuickCheck test-framework
         test-framework-quickcheck2 vector
       ];
       homepage = "https://github.com/kawu/adict";
       description = "Approximate dictionary searching";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "adjunctions_4_2" = callPackage
    ({ mkDerivation, array, base, comonad, containers, contravariant
     , distributive, free, mtl, profunctors, semigroupoids, semigroups
     , tagged, transformers, void
     }:
     mkDerivation {
       pname = "adjunctions";
       version = "4.2";
       sha256 = "31c9988b9e76fa342bff9314af5fd088f99bcaf6d66adb3ba3dc343f4d36251f";
       libraryHaskellDepends = [
         array base comonad containers contravariant distributive free mtl
         profunctors semigroupoids semigroups tagged transformers void
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/adjunctions/";
       description = "Adjunctions and representable functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "adjunctions_4_2_1" = callPackage
    ({ mkDerivation, array, base, comonad, containers, contravariant
     , distributive, free, mtl, profunctors, semigroupoids, semigroups
     , tagged, transformers, void
     }:
     mkDerivation {
       pname = "adjunctions";
       version = "4.2.1";
       sha256 = "65a64cd42dcf356c2b44fffc4360f8cbf494702f7574b5a1e57e1864b0f8f46f";
       libraryHaskellDepends = [
         array base comonad containers contravariant distributive free mtl
         profunctors semigroupoids semigroups tagged transformers void
       ];
       homepage = "http://github.com/ekmett/adjunctions/";
       description = "Adjunctions and representable functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "adjunctions_4_2_2" = callPackage
    ({ mkDerivation, array, base, comonad, containers, contravariant
     , distributive, free, mtl, profunctors, semigroupoids, semigroups
     , tagged, transformers, void
     }:
     mkDerivation {
       pname = "adjunctions";
       version = "4.2.2";
       sha256 = "58f2d5e66bc61cb8d2fe2148c9b3df3c95e87a353dfc7ed18af2cbeb2318e002";
       libraryHaskellDepends = [
         array base comonad containers contravariant distributive free mtl
         profunctors semigroupoids semigroups tagged transformers void
       ];
       homepage = "http://github.com/ekmett/adjunctions/";
       description = "Adjunctions and representable functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "adjunctions" = callPackage
    ({ mkDerivation, array, base, comonad, containers, contravariant
     , distributive, free, mtl, profunctors, semigroupoids, semigroups
     , tagged, transformers, transformers-compat, void
     }:
     mkDerivation {
       pname = "adjunctions";
       version = "4.3";
       sha256 = "b948a14fafe8857f451ae3e474f5264c907b5a2d841d52bf78249ae4749c3ecc";
       revision = "1";
       editedCabalFile = "f88c4f5440736d64ad6a478e9feccc116727b5dc616fc6535cfe64ff75a2e980";
       libraryHaskellDepends = [
         array base comonad containers contravariant distributive free mtl
         profunctors semigroupoids semigroups tagged transformers
         transformers-compat void
       ];
       homepage = "http://github.com/ekmett/adjunctions/";
       description = "Adjunctions and representable functors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "adler32" = callPackage
    ({ mkDerivation, base, bytestring, hspec, zlib }:
     mkDerivation {
       pname = "adler32";
       version = "0.1.1.0";
       sha256 = "578cb9ea7451dc905a22de15e46f8d6fc27f76e4c6f75352a70ebfe53a6928ec";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ zlib ];
       testHaskellDepends = [ base bytestring hspec ];
       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;};

  "adobe-swatch-exchange" = callPackage
    ({ mkDerivation, base, binary, bytestring, data-binary-ieee754
     , language-css, mtl, pretty
     }:
     mkDerivation {
       pname = "adobe-swatch-exchange";
       version = "0.2.0";
       sha256 = "fb52d7cf35da9d8e512279660ea627779673c61047444d99bb158a1a20ef8649";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring data-binary-ieee754 language-css mtl pretty
       ];
       executableHaskellDepends = [
         base binary bytestring data-binary-ieee754 language-css mtl pretty
       ];
       jailbreak = true;
       homepage = "https://github.com/stepcut/ase2css";
       description = "parse Adobe Swatch Exchange files and (optionally) output .css files with the colors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "adp-multi" = callPackage
    ({ mkDerivation, array, base, containers, htrace, HUnit, mtl
     , QuickCheck, random-shuffle, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "adp-multi";
       version = "0.2.3";
       sha256 = "4728f3d87728adead1d6ebb33e032dd05673cc43573dc00d52a9522154f7b5d2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base containers htrace ];
       testHaskellDepends = [
         array base containers htrace HUnit mtl QuickCheck random-shuffle
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://adp-multi.ruhoh.com";
       description = "ADP for multiple context-free languages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "adp-multi-monadiccp" = callPackage
    ({ mkDerivation, adp-multi, base, containers, monadiccp, mtl
     , QuickCheck, test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "adp-multi-monadiccp";
       version = "0.2.1";
       sha256 = "dae838558f728af3cf1e58aaccfcc66fe66a0d3d33332eb365d710e71facf48f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ adp-multi base containers monadiccp ];
       testHaskellDepends = [
         adp-multi base containers monadiccp mtl QuickCheck test-framework
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://adp-multi.ruhoh.com";
       description = "Subword construction in adp-multi using monadiccp";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson_0_7_0_6" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, deepseq
     , dlist, ghc-prim, hashable, HUnit, mtl, old-locale, QuickCheck
     , scientific, syb, template-haskell, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson";
       version = "0.7.0.6";
       sha256 = "645531759ba18105cadf024415e1be60353ad704ac686ff5ee67c7f4754d4e6f";
       revision = "1";
       editedCabalFile = "8b87a1343dd8d93d98e48e530f2ec14f5949fcdc96c8ecc81458a1d20defd001";
       libraryHaskellDepends = [
         attoparsec base bytestring containers deepseq dlist ghc-prim
         hashable mtl old-locale scientific syb template-haskell text time
         unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring containers ghc-prim HUnit QuickCheck
         template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2 text time unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/bos/aeson";
       description = "Fast JSON parsing and encoding";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson_0_8_0_2" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, deepseq
     , dlist, ghc-prim, hashable, HUnit, mtl, QuickCheck, scientific
     , syb, template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "aeson";
       version = "0.8.0.2";
       sha256 = "0707588dfb5fdfe787eba5b3d5a9950acb224a8dae9dcdcfc9c974ae2b6788d5";
       revision = "1";
       editedCabalFile = "8062e672ca956e133718772983f98be0fda9990c431299afab8b4e22703c943c";
       libraryHaskellDepends = [
         attoparsec base bytestring containers deepseq dlist ghc-prim
         hashable mtl scientific syb template-haskell text time
         unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring containers ghc-prim HUnit QuickCheck
         template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2 text time unordered-containers vector
       ];
       homepage = "https://github.com/bos/aeson";
       description = "Fast JSON parsing and encoding";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, deepseq
     , dlist, ghc-prim, hashable, HUnit, mtl, QuickCheck, scientific
     , syb, template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson";
       version = "0.9.0.1";
       sha256 = "92b97dbc4968a2af6bc13b499629118f85b22efe113a4d60e578fbfb0f6ef8bc";
       revision = "2";
       editedCabalFile = "5796e32c015d96fcbce31eaf22eba93580d47a8df798bd2260732ef5eac3cb02";
       libraryHaskellDepends = [
         attoparsec base bytestring containers deepseq dlist ghc-prim
         hashable mtl scientific syb template-haskell text time transformers
         unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring containers ghc-prim HUnit QuickCheck
         template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2 text time unordered-containers vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/bos/aeson";
       description = "Fast JSON parsing and encoding";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aeson_0_10_0_0" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, deepseq
     , dlist, ghc-prim, hashable, HUnit, mtl, QuickCheck, scientific
     , syb, template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson";
       version = "0.10.0.0";
       sha256 = "3fefae24f68fcb47371e8b13664b47f7343e00b21d65efeb6824efe8f21877a6";
       revision = "1";
       editedCabalFile = "e0c6473d5afc602a085c78ec97731f29d4c85581f2d4d7df8df251cfae78bd45";
       libraryHaskellDepends = [
         attoparsec base bytestring containers deepseq dlist ghc-prim
         hashable mtl scientific syb template-haskell text time transformers
         unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring containers ghc-prim HUnit QuickCheck
         template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2 text time unordered-containers vector
       ];
       doCheck = false;
       homepage = "https://github.com/bos/aeson";
       description = "Fast JSON parsing and encoding";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson_0_11_0_0" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, deepseq
     , dlist, fail, ghc-prim, hashable, HUnit, mtl, QuickCheck
     , quickcheck-instances, scientific, semigroups, syb
     , template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson";
       version = "0.11.0.0";
       sha256 = "ad3849d5d73824edea0fa3aa552d4c4630e67a8cf1295250e92d34b5e824add5";
       libraryHaskellDepends = [
         attoparsec base bytestring containers deepseq dlist fail ghc-prim
         hashable mtl scientific semigroups syb template-haskell text time
         transformers unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring containers ghc-prim HUnit QuickCheck
         quickcheck-instances template-haskell test-framework
         test-framework-hunit test-framework-quickcheck2 text time
         unordered-containers vector
       ];
       homepage = "https://github.com/bos/aeson";
       description = "Fast JSON parsing and encoding";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-applicative" = callPackage
    ({ mkDerivation, aeson, base, text, unordered-containers }:
     mkDerivation {
       pname = "aeson-applicative";
       version = "0.1.0.0";
       sha256 = "1f8f9bd254cfc56f44a9c1994815a3c8ebd36978ca12378a42aed2172cbd8b5e";
       libraryHaskellDepends = [ aeson base text unordered-containers ];
       jailbreak = true;
       homepage = "https://github.com/gregwebs/aeson-applicative-dsl";
       description = "make To/From JSOn instances from an applicative description";
       license = stdenv.lib.licenses.mit;
     }) {};

  "aeson-better-errors" = callPackage
    ({ mkDerivation, aeson, base, bytestring, dlist, mtl, scientific
     , text, transformers, transformers-compat, unordered-containers
     , vector, void
     }:
     mkDerivation {
       pname = "aeson-better-errors";
       version = "0.9.0";
       sha256 = "e658a5306611e40a14a47fed5b7a0a3ddeb9b0413e9804ca7bee9a619cac6901";
       libraryHaskellDepends = [
         aeson base bytestring dlist mtl scientific text transformers
         transformers-compat unordered-containers vector void
       ];
       homepage = "https://github.com/hdgarrood/aeson-better-errors";
       description = "Better error messages when decoding JSON values";
       license = stdenv.lib.licenses.mit;
     }) {};

  "aeson-bson" = callPackage
    ({ mkDerivation, aeson, array, attoparsec, base, bson, bytestring
     , containers, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson-bson";
       version = "0.3.0";
       sha256 = "c94a02a032c7ada488bc2dc50c751e7fdf7773d5d425e784db6e066c4acf9028";
       libraryHaskellDepends = [
         aeson array attoparsec base bson bytestring containers text
         unordered-containers vector
       ];
       jailbreak = true;
       description = "Mapping between Aeson's JSON and Bson objects";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-casing" = callPackage
    ({ mkDerivation, aeson, base, tasty, tasty-hunit, tasty-quickcheck
     , tasty-th
     }:
     mkDerivation {
       pname = "aeson-casing";
       version = "0.1.0.5";
       sha256 = "cfec563dc6822f035858a7190153d8818c200be565806b43b70f198bf5410577";
       libraryHaskellDepends = [ aeson base ];
       testHaskellDepends = [
         aeson base tasty tasty-hunit tasty-quickcheck tasty-th
       ];
       description = "Tools to change the formatting of field names in Aeson instances";
       license = stdenv.lib.licenses.mit;
     }) {};

  "aeson-compat_0_3_0_0" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , exceptions, hashable, quickcheck-instances, scientific, tasty
     , tasty-hunit, tasty-quickcheck, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "aeson-compat";
       version = "0.3.0.0";
       sha256 = "697b2f86628bd6665db153b84ef40c699d372b4b429a7c4ef28719313b9c97ef";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers exceptions hashable
         scientific text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring containers exceptions hashable
         quickcheck-instances scientific tasty tasty-hunit tasty-quickcheck
         text time unordered-containers vector
       ];
       homepage = "https://github.com/phadej/aeson-compat#readme";
       description = "Compatibility layer for aeson";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-compat" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , exceptions, hashable, nats, QuickCheck, quickcheck-instances
     , scientific, tasty, tasty-hunit, tasty-quickcheck, text, time
     , time-locale-compat, unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson-compat";
       version = "0.3.1.0";
       sha256 = "9275040d031433eb0006bce8228a0828e058d547c7d07d61ab0b22154286d736";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers exceptions hashable
         nats scientific text time time-locale-compat unordered-containers
         vector
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring containers exceptions hashable
         nats QuickCheck quickcheck-instances scientific tasty tasty-hunit
         tasty-quickcheck text time time-locale-compat unordered-containers
         vector
       ];
       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, QuickCheck
     , quickcheck-instances, scientific, text, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "aeson-diff";
       version = "0.1.1.3";
       sha256 = "c178500a64e09d14f39af26ec5930a23de3c64dfa7b68a1f047e847834f6a895";
       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
       ];
       testHaskellDepends = [
         aeson base QuickCheck quickcheck-instances text
         unordered-containers vector
       ];
       homepage = "https://github.com/thsutton/aeson-diff";
       description = "Extract and apply patches to JSON documents";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aeson-extra_0_2_1_0" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , exceptions, hashable, quickcheck-instances, scientific, tagged
     , tasty, tasty-hunit, tasty-quickcheck, text, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "aeson-extra";
       version = "0.2.1.0";
       sha256 = "d46ac20994321ee480ec9ec4b4714943af9121b55d5ef45f25a51932eec63f91";
       revision = "2";
       editedCabalFile = "e4bc838bebc2442c95e2d5987b1f71d38323686ab15a87d15f79431dfcd9ac7f";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers exceptions hashable
         scientific tagged text unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring containers exceptions hashable
         quickcheck-instances scientific tagged tasty tasty-hunit
         tasty-quickcheck text unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/phadej/aeson-extra#readme";
       description = "Extra goodies for aeson";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-extra_0_2_2_0" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , exceptions, hashable, quickcheck-instances, scientific, tasty
     , tasty-hunit, tasty-quickcheck, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "aeson-extra";
       version = "0.2.2.0";
       sha256 = "368aa018e650f323a1d52cfd38596fe419667e1ef3f83faf0f7255518b18dc45";
       revision = "1";
       editedCabalFile = "dd886d138f237630ab72659d26ede725526dc02edce98b0371265ad1854cac74";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers exceptions hashable
         scientific text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring containers exceptions hashable
         quickcheck-instances scientific tasty tasty-hunit tasty-quickcheck
         text time unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/phadej/aeson-extra#readme";
       description = "Extra goodies for aeson";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-extra_0_2_3_0" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , exceptions, hashable, quickcheck-instances, scientific, tasty
     , tasty-hunit, tasty-quickcheck, template-haskell, text, time
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson-extra";
       version = "0.2.3.0";
       sha256 = "43ace09b9c03c5c55216b2062228bda94e5fd23333a0cc1eca0e5478546f9e77";
       revision = "1";
       editedCabalFile = "bb41b2e6c386698b33d2d8d67571542392afd8984821897a4fbf318f3bb2e844";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers exceptions hashable
         scientific template-haskell text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring containers exceptions hashable
         quickcheck-instances scientific tasty tasty-hunit tasty-quickcheck
         template-haskell text time unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/phadej/aeson-extra#readme";
       description = "Extra goodies for aeson";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-extra_0_3_0_0" = callPackage
    ({ mkDerivation, aeson, aeson-compat, base, base-compat, bytestring
     , containers, exceptions, hashable, parsec, quickcheck-instances
     , scientific, tasty, tasty-hunit, tasty-quickcheck
     , template-haskell, text, time, time-parsers, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "aeson-extra";
       version = "0.3.0.0";
       sha256 = "b9e54cf293c25bbd5646a777cf71a23c4158b708dd358fe3e705add326d5870f";
       revision = "2";
       editedCabalFile = "7b0de3823d241afec75697e2f8e387f85e0bd6f4bcb50937658bb3ba7d115558";
       libraryHaskellDepends = [
         aeson aeson-compat base base-compat bytestring containers
         exceptions hashable parsec scientific template-haskell text time
         time-parsers unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-compat base base-compat bytestring containers
         exceptions hashable parsec quickcheck-instances scientific tasty
         tasty-hunit tasty-quickcheck template-haskell text time
         time-parsers unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/phadej/aeson-extra#readme";
       description = "Extra goodies for aeson";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-extra_0_3_1_0" = callPackage
    ({ mkDerivation, aeson, aeson-compat, base, base-compat, bytestring
     , containers, exceptions, hashable, parsec, quickcheck-instances
     , recursion-schemes, scientific, tasty, tasty-hunit
     , tasty-quickcheck, template-haskell, text, these, time
     , time-parsers, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson-extra";
       version = "0.3.1.0";
       sha256 = "d82c92ea155ee103d8feaaf772c813b4d73182a3e10f8f0739ab845cdfbb8831";
       libraryHaskellDepends = [
         aeson aeson-compat base base-compat bytestring containers
         exceptions hashable parsec recursion-schemes scientific
         template-haskell text time time-parsers transformers
         unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-compat base base-compat bytestring containers
         exceptions hashable parsec quickcheck-instances scientific tasty
         tasty-hunit tasty-quickcheck template-haskell text these time
         time-parsers unordered-containers vector
       ];
       homepage = "https://github.com/phadej/aeson-extra#readme";
       description = "Extra goodies for aeson";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-extra" = callPackage
    ({ mkDerivation, aeson, aeson-compat, base, base-compat, bytestring
     , containers, exceptions, hashable, parsec, quickcheck-instances
     , recursion-schemes, scientific, tasty, tasty-hunit
     , tasty-quickcheck, template-haskell, text, these, time
     , time-parsers, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson-extra";
       version = "0.3.1.1";
       sha256 = "0fe646bdb96820ddef55a26b730f4b65a213b748229e3ba9758335a72d258fec";
       libraryHaskellDepends = [
         aeson aeson-compat base base-compat bytestring containers
         exceptions hashable parsec recursion-schemes scientific
         template-haskell text time time-parsers transformers
         unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-compat base base-compat bytestring containers
         exceptions hashable parsec quickcheck-instances scientific tasty
         tasty-hunit tasty-quickcheck template-haskell text these time
         time-parsers unordered-containers vector
       ];
       homepage = "https://github.com/phadej/aeson-extra#readme";
       description = "Extra goodies for aeson";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-filthy" = callPackage
    ({ mkDerivation, aeson, base, bytestring, doctest, text
     , unordered-containers
     }:
     mkDerivation {
       pname = "aeson-filthy";
       version = "0.1";
       sha256 = "d4dc207915fca4e65a2de331898ea870c9e09247a93dd0bc0abe159b932ee0b4";
       libraryHaskellDepends = [
         aeson base bytestring text unordered-containers
       ];
       testHaskellDepends = [ base doctest ];
       homepage = "https://github.com/deviant-logic/aeson-filthy";
       description = "Several newtypes and combinators for dealing with less-than-cleanly JSON input";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aeson-iproute" = callPackage
    ({ mkDerivation, aeson, base, iproute, text }:
     mkDerivation {
       pname = "aeson-iproute";
       version = "0.1.1";
       sha256 = "9fc733cbe7d47e69b33a0003a73e82f337846006de672f87ce1eafbe6bc159af";
       libraryHaskellDepends = [ aeson base iproute text ];
       homepage = "https://github.com/greydot/aeson-iproute";
       description = "Aeson instances for iproute types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aeson-lens" = callPackage
    ({ mkDerivation, aeson, base, bytestring, doctest, lens, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson-lens";
       version = "0.5.0.0";
       sha256 = "7ace668031da8119439e21b6ccbe329d37c533be2f5c5612389107d2676728df";
       libraryHaskellDepends = [
         aeson base bytestring lens text unordered-containers vector
       ];
       testHaskellDepends = [ base doctest ];
       doCheck = false;
       description = "Lens of Aeson";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aeson-native" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder
     , blaze-textual-native, bytestring, containers, deepseq, hashable
     , mtl, old-locale, syb, text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson-native";
       version = "0.3.3.2";
       sha256 = "d0b95fff53727f3840595c6b305f04d9cc71040ace7079b357a7358d3242b1e8";
       revision = "1";
       editedCabalFile = "c9519a30bce75564cfbe84aade5ffb99fad12ecea1c7d2c362cca2234b8ae497";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-textual-native bytestring
         containers deepseq hashable mtl old-locale syb text time
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "http://github.com/mailrank/aeson";
       description = "Fast JSON parsing and encoding (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-parsec-picky" = callPackage
    ({ mkDerivation, aeson, base, parsec, scientific, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson-parsec-picky";
       version = "0.1.0.1";
       sha256 = "f617704188453e639d60ea9ac24d6c161affb517581cfff6dfbd2b580ccaea62";
       libraryHaskellDepends = [
         aeson base parsec scientific text unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/FPBrno/aeson-parsec-picky";
       description = "Alternative JSON parser based on Parsec and Aeson";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aeson-pretty" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, cmdargs, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson-pretty";
       version = "0.7.2";
       sha256 = "6408b8b2bcd12cf591e4b93b4d9f5143449b33a59fbd3653f328e2515040570d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring text unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson attoparsec base bytestring cmdargs
       ];
       homepage = "http://github.com/informatikr/aeson-pretty";
       description = "JSON pretty-printing library and command-line tool";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aeson-qq_0_7_4" = callPackage
    ({ mkDerivation, aeson, base, ghc-prim, haskell-src-meta, hspec
     , parsec, template-haskell, text, vector
     }:
     mkDerivation {
       pname = "aeson-qq";
       version = "0.7.4";
       sha256 = "9b4c5583e21007aade87ac75d5c5ee95ef910641c0fddea67b25b42ddb4dcc72";
       libraryHaskellDepends = [
         aeson base haskell-src-meta parsec template-haskell text vector
       ];
       testHaskellDepends = [
         aeson base ghc-prim haskell-src-meta hspec parsec template-haskell
         text vector
       ];
       homepage = "http://github.com/zalora/aeson-qq";
       description = "JSON quasiquoter for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-qq_0_8_0" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, ghc-prim
     , haskell-src-meta, hspec, parsec, scientific, template-haskell
     , text, vector
     }:
     mkDerivation {
       pname = "aeson-qq";
       version = "0.8.0";
       sha256 = "eec4bc1cac531c784be01bd2db5b1113c464d6bf2b84dcc9c9421a15601d7a8b";
       libraryHaskellDepends = [
         aeson attoparsec base haskell-src-meta parsec scientific
         template-haskell text vector
       ];
       testHaskellDepends = [
         aeson attoparsec base ghc-prim haskell-src-meta hspec parsec
         scientific template-haskell text vector
       ];
       homepage = "http://github.com/zalora/aeson-qq";
       description = "JSON quasiquoter for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-qq" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base-compat, ghc-prim
     , haskell-src-meta, hspec, parsec, scientific, template-haskell
     , text, vector
     }:
     mkDerivation {
       pname = "aeson-qq";
       version = "0.8.1";
       sha256 = "2dcd2392902baac446e317621df509b09db9dca9b8c9187e53701226f18013fd";
       libraryHaskellDepends = [
         aeson attoparsec base base-compat haskell-src-meta parsec
         scientific template-haskell text vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base-compat ghc-prim haskell-src-meta hspec
         parsec scientific template-haskell text vector
       ];
       homepage = "http://github.com/zalora/aeson-qq";
       description = "JSON quasiquoter for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "aeson-schema_0_3_0_7" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , directory, filepath, ghc-prim, hashable, hint, HUnit, mtl
     , QuickCheck, regex-base, regex-compat, regex-pcre, scientific, syb
     , template-haskell, temporary, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, th-lift, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson-schema";
       version = "0.3.0.7";
       sha256 = "af50aa3ff6974d021aeeb90e7f43d0b4082a3a81972843e1a0ee5bb8068c04e5";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers ghc-prim mtl QuickCheck
         regex-base regex-compat regex-pcre scientific syb template-haskell
         text th-lift transformers unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring containers directory filepath
         hashable hint HUnit mtl QuickCheck regex-compat scientific
         template-haskell temporary test-framework test-framework-hunit
         test-framework-quickcheck2 text unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/timjb/aeson-schema";
       description = "Haskell JSON schema validator and parser generator";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-schema" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , directory, filepath, ghc-prim, hashable, hint, HUnit, mtl
     , QuickCheck, regex-base, regex-compat, regex-pcre, scientific, syb
     , template-haskell, temporary, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, th-lift, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson-schema";
       version = "0.4.0.0";
       sha256 = "2b8f58f3539644527c4ab3ff5c07742c9aa2250281b7b3cba8e2c39b88f148a8";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers ghc-prim mtl QuickCheck
         regex-base regex-compat regex-pcre scientific syb template-haskell
         text th-lift transformers unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring containers directory filepath
         hashable hint HUnit mtl QuickCheck regex-compat scientific
         template-haskell temporary test-framework test-framework-hunit
         test-framework-quickcheck2 text unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/Fuuzetsu/aeson-schema";
       description = "Haskell JSON schema validator and parser generator";
       license = stdenv.lib.licenses.mit;
     }) {};

  "aeson-serialize" = callPackage
    ({ mkDerivation, aeson, base, cereal, hspec, HUnit }:
     mkDerivation {
       pname = "aeson-serialize";
       version = "0.0.0";
       sha256 = "a1e0ee1a8db3f00c990e20b1015644dfaec76772966a54716c4fcc58ea5f1404";
       libraryHaskellDepends = [ aeson base cereal ];
       testHaskellDepends = [ aeson base cereal hspec HUnit ];
       description = "Simple serialization functions for aeson types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aeson-smart" = callPackage
    ({ mkDerivation, aeson, base, data-default, template-haskell, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson-smart";
       version = "0.2.0.0";
       sha256 = "6538a6f8226c5899a19914fdaa0e1904c58377e1b95465ed9ada9e66a63062e4";
       libraryHaskellDepends = [
         aeson base data-default template-haskell text unordered-containers
         vector
       ];
       jailbreak = true;
       homepage = "https://github.com/lassoinc/aeson-smart";
       description = "Smart derivation of Aeson instances";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-streams" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, HsOpenSSL
     , http-streams, io-streams
     }:
     mkDerivation {
       pname = "aeson-streams";
       version = "0.1.0";
       sha256 = "45a057c36b0783fcf39e1916bcda71e22c1309bb9308d08e5bdfb92c378db3d6";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring HsOpenSSL http-streams io-streams
       ];
       jailbreak = true;
       homepage = "https://github.com/noteed/aeson-streams";
       description = "An HTTP client library for JSON-based APIs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aeson-t" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, bytestring, hspec, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson-t";
       version = "0.0.5";
       sha256 = "6d4e1764a676d7958219a82341682888db39ca4b437b24e7aa7791a7bb9cf8d6";
       libraryHaskellDepends = [
         aeson base bytestring text unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-qq base bytestring hspec text unordered-containers
         vector
       ];
       jailbreak = true;
       homepage = "https://github.com/begriffs/aeson-t";
       description = "Transform JSON";
       license = stdenv.lib.licenses.mit;
     }) {};

  "aeson-toolkit" = callPackage
    ({ mkDerivation, aeson, base, bytestring, failure, hspec, text }:
     mkDerivation {
       pname = "aeson-toolkit";
       version = "0.0.1";
       sha256 = "83323407652dab284537d49269f9c2460344a7d66f985f30e8c454fe89238b1d";
       libraryHaskellDepends = [ aeson base bytestring failure text ];
       testHaskellDepends = [ base hspec ];
       description = "A generalization of Aeson over Failure";
       license = stdenv.lib.licenses.mit;
     }) {};

  "aeson-utils_0_2_2_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, scientific
     , text
     }:
     mkDerivation {
       pname = "aeson-utils";
       version = "0.2.2.1";
       sha256 = "4d1b5e5cfb139bcbe44a41e338a139e9c3f710ee3e81a087b35c48d6599b446a";
       revision = "2";
       editedCabalFile = "f306a03acf8d68a087cdcf5fd1ddcf7672820cd303a494c892aa176f56d1332d";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring scientific text
       ];
       jailbreak = true;
       description = "Utilities for working with Aeson";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-utils_0_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, scientific
     , text
     }:
     mkDerivation {
       pname = "aeson-utils";
       version = "0.3";
       sha256 = "7bdc5ca1dadecf50cae4917918f5bf5d9b40982aac5b122654b964065d2b2b8b";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring scientific text
       ];
       jailbreak = true;
       description = "Utilities for working with Aeson";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-utils_0_3_0_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, scientific
     , text
     }:
     mkDerivation {
       pname = "aeson-utils";
       version = "0.3.0.1";
       sha256 = "d4ff8648a61601194bc00d0ac9ddbef1b80be09998c31ee7697b0d1f08aad6f8";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring scientific text
       ];
       jailbreak = true;
       description = "Utilities for working with Aeson";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aeson-utils" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, scientific
     , text
     }:
     mkDerivation {
       pname = "aeson-utils";
       version = "0.3.0.2";
       sha256 = "71814b1be8849f945395eb81217a2ad464f2943134c50c09afd8a3126add4b1f";
       revision = "2";
       editedCabalFile = "32116e177571bd140c1d68b2c0502ba2ab58cc327cf83ca15b40521ceab61682";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring scientific text
       ];
       description = "Utilities for working with Aeson";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aeson-value-parser" = callPackage
    ({ mkDerivation, aeson, base-prelude, mtl-prelude, scientific
     , success, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "aeson-value-parser";
       version = "0.11.2";
       sha256 = "a0e64e5c4eb8e75e4ba27c6ea26276f508da407883fb1527102e07a20ed0d454";
       libraryHaskellDepends = [
         aeson base-prelude mtl-prelude scientific success text
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/sannsyn/aeson-value-parser";
       description = "An API for parsing \"aeson\" JSON tree into Haskell types";
       license = stdenv.lib.licenses.mit;
     }) {};

  "aeson-yak" = callPackage
    ({ mkDerivation, aeson, base }:
     mkDerivation {
       pname = "aeson-yak";
       version = "0.1.1";
       sha256 = "b71317e0a87bbd84d6ec407a307299201070a10e3b2cf9d28c4afb5cf8b0dad2";
       libraryHaskellDepends = [ aeson base ];
       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;
     }) {};

  "affine-invariant-ensemble-mcmc" = callPackage
    ({ mkDerivation, base, containers, mwc-random, primitive, split
     , vector
     }:
     mkDerivation {
       pname = "affine-invariant-ensemble-mcmc";
       version = "0.2.0.0";
       sha256 = "65ee8788c39b1c054bf345fb914e3543b7f3209f63796f4bf21d58e27eb2d484";
       libraryHaskellDepends = [
         base containers mwc-random primitive split vector
       ];
       jailbreak = true;
       homepage = "http://github.com/jtobin/affine-invariant-ensemble-mcmc";
       description = "General-purpose sampling";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "afis" = callPackage
    ({ mkDerivation, base, byteable, bytestring, crypto-random
     , cryptohash, HUnit, mtl, packer, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "afis";
       version = "0.1.2";
       sha256 = "c9b1e505b0451b3050ee05af15c26462d38b2544f37df03ee3e37fcd571ef85e";
       libraryHaskellDepends = [
         base byteable bytestring crypto-random cryptohash packer
       ];
       testHaskellDepends = [
         base byteable bytestring crypto-random cryptohash HUnit mtl
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       homepage = "http://github.com/vincenthz/hs-afis";
       description = "Anti-forensic Information Splitter";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "afv" = callPackage
    ({ mkDerivation, base, bytestring, directory, language-c, mtl
     , process, yices
     }:
     mkDerivation {
       pname = "afv";
       version = "0.1.1";
       sha256 = "7307e0613e15bc8c6c5fc2354931a181cd524ee69f4c85bf87f2465fcbede21a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory language-c mtl process yices
       ];
       jailbreak = true;
       homepage = "http://tomahawkins.org";
       description = "Infinite state model checking of iterative C programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ag-pictgen" = callPackage
    ({ mkDerivation, base, containers, uuagc, uulib }:
     mkDerivation {
       pname = "ag-pictgen";
       version = "1.0.0.0";
       sha256 = "3afe523fe3beae494e274e21258f8d69abb1d228f207fd1e286b8d23180bb97c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers uuagc uulib ];
       homepage = "https://github.com/UU-ComputerScience/ag-pictgen";
       description = "Attribute Grammar picture generation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "agda-server" = callPackage
    ({ mkDerivation, Agda, base, cmdargs, containers, directory
     , filepath, HJavaScript, mtl, pandoc, snap-core, snap-server
     , transformers, utf8-string, xhtml
     }:
     mkDerivation {
       pname = "agda-server";
       version = "0.1.1";
       sha256 = "ea5d9712aaff8c4d1779e8eb8b1aa4c4c41073c0026a1aae8ef3ab3cfdd71d1c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         Agda base cmdargs containers directory filepath HJavaScript mtl
         pandoc snap-core snap-server transformers utf8-string xhtml
       ];
       description = "Http server for Agda (prototype)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "agda-snippets" = callPackage
    ({ mkDerivation, Agda, base, containers, mtl, network-uri
     , transformers, xhtml
     }:
     mkDerivation {
       pname = "agda-snippets";
       version = "2.4.2.5";
       sha256 = "f1e42f920bb4c4f43836d9844f13ac3942b1048c032b05b043716cd47d11ed22";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         Agda base containers mtl network-uri xhtml
       ];
       executableHaskellDepends = [ Agda base network-uri transformers ];
       homepage = "http://github.com/liamoc/agda-snippets#readme";
       description = "Render just the Agda snippets of a literate Agda file to HTML";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "agda-snippets-hakyll" = callPackage
    ({ mkDerivation, agda-snippets, base, directory, filepath, hakyll
     , network-uri, pandoc, pandoc-types
     }:
     mkDerivation {
       pname = "agda-snippets-hakyll";
       version = "0.1.1.1";
       sha256 = "d779e0b6b70eeba21efed698a6842873fb5ddc1de4fe5e91c40d761dceec514c";
       libraryHaskellDepends = [
         agda-snippets base directory filepath hakyll network-uri pandoc
         pandoc-types
       ];
       jailbreak = true;
       homepage = "https://github.com/liamoc/agda-snippets#readme";
       description = "Literate Agda support using agda-snippets, for Hakyll pages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "agentx" = callPackage
    ({ mkDerivation, base, binary, bitwise, bytestring, containers
     , data-default, Diff, fclabels, mtl, network, pipes
     , pipes-concurrency, pipes-network, safe, snmp, time, transformers
     , unix
     }:
     mkDerivation {
       pname = "agentx";
       version = "0.2.0.0";
       sha256 = "e61dc3994aaf70cf8823064d56e839ee1af18ae6be30e294214f759064ccb65e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bitwise bytestring containers data-default Diff
         fclabels mtl network pipes pipes-concurrency pipes-network safe
         snmp time transformers unix
       ];
       executableHaskellDepends = [
         base binary bitwise bytestring containers data-default Diff
         fclabels mtl network pipes pipes-concurrency pipes-network safe
         snmp time transformers unix
       ];
       description = "AgentX protocol for write SNMP subagents";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "agum" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "agum";
       version = "2.6";
       sha256 = "35ce62ef518591fb1f81f9a17b420b7bc629f9b0c58fe950973d9fb72da758c8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [ base containers ];
       description = "Unification and Matching in an Abelian Group";
       license = "GPL";
     }) {};

  "aig" = callPackage
    ({ mkDerivation, base, base-compat, mtl, QuickCheck, vector }:
     mkDerivation {
       pname = "aig";
       version = "0.2.4";
       sha256 = "ac0e06a707b7488de7e1f9d7b123703e2df14763f9e6448d67c4dd20ffdc88eb";
       libraryHaskellDepends = [ base base-compat mtl QuickCheck vector ];
       description = "And-inverter graphs in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "air" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , filepath, mtl, text, time
     }:
     mkDerivation {
       pname = "air";
       version = "2015.5.4";
       sha256 = "5271aa9bed499454943c1d645feb2bb715bc07dc5b5f556bbb38ce0abbfe3fbd";
       libraryHaskellDepends = [
         array base bytestring containers directory filepath mtl text time
       ];
       homepage = "https://github.com/nfjinjing/air";
       description = "air";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "air-extra" = callPackage
    ({ mkDerivation, air, array, base, bytestring, containers
     , directory, filepath, parallel, parsec, regexpr, text, time
     }:
     mkDerivation {
       pname = "air-extra";
       version = "2015.5.4";
       sha256 = "2735bb2762eede3bb36ef4f1dccb694d0fe1aa4c3c1c941bc045ce94a50f601e";
       libraryHaskellDepends = [
         air array base bytestring containers directory filepath parallel
         parsec regexpr text time
       ];
       homepage = "https://github.com/nfjinjing/air-extra";
       description = "air-extra";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "air-spec" = callPackage
    ({ mkDerivation, base, hspec, text }:
     mkDerivation {
       pname = "air-spec";
       version = "2013.7.1";
       sha256 = "dd71db18db9240ff30fefb4ed16b82d9acf97d859696fcfa6fde555b00129e68";
       libraryHaskellDepends = [ base hspec text ];
       homepage = "https://github.com/nfjinjing/air-spec";
       description = "air spec helper";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "air-th" = callPackage
    ({ mkDerivation, air, base, template-haskell }:
     mkDerivation {
       pname = "air-th";
       version = "2014.11.17";
       sha256 = "f892a115f7af4326aeba6629e928b59d5cba97a77add7d8fce9447beb1291766";
       libraryHaskellDepends = [ air base template-haskell ];
       homepage = "https://github.com/nfjinjing/air-th";
       description = "air";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "airbrake" = callPackage
    ({ mkDerivation, base, blaze-markup, bytestring, directory
     , exceptions, filepath, http-conduit, monad-control, network
     , semigroups, template-haskell, text, transformers, utf8-string
     , wai
     }:
     mkDerivation {
       pname = "airbrake";
       version = "0.2.0.0";
       sha256 = "18ea70dab5f581154e659b4d6959893505561dc437c21da496136ddeb284e50f";
       libraryHaskellDepends = [
         base blaze-markup bytestring directory exceptions filepath
         http-conduit monad-control network semigroups template-haskell text
         transformers utf8-string wai
       ];
       homepage = "https://github.com/joelteon/airbrake";
       description = "An Airbrake notifier for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "airship_0_4_1_0" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, bytestring-trie, case-insensitive, cryptohash
     , directory, either, filepath, http-date, http-media, http-types
     , lifted-base, microlens, mime-types, mmorph, monad-control, mtl
     , network, old-locale, random, tasty, tasty-hunit, tasty-quickcheck
     , text, time, transformers, transformers-base, unix
     , unordered-containers, wai, wai-extra
     }:
     mkDerivation {
       pname = "airship";
       version = "0.4.1.0";
       sha256 = "6706b25bde3a243ed54020dc6967ee247a2136a59a7665c6a142116ab36e9a51";
       libraryHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring
         bytestring-trie case-insensitive cryptohash directory either
         filepath http-date http-media http-types lifted-base microlens
         mime-types mmorph monad-control mtl network old-locale random text
         time transformers transformers-base unix unordered-containers wai
         wai-extra
       ];
       testHaskellDepends = [
         base bytestring tasty tasty-hunit tasty-quickcheck text
         transformers wai
       ];
       jailbreak = true;
       homepage = "https://github.com/helium/airship/";
       description = "A Webmachine-inspired HTTP library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "airship_0_4_2_0" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, bytestring-trie, case-insensitive, cryptohash
     , directory, either, filepath, http-date, http-media, http-types
     , lifted-base, microlens, mime-types, mmorph, monad-control, mtl
     , network, old-locale, random, tasty, tasty-hunit, tasty-quickcheck
     , text, time, transformers, transformers-base, unix
     , unordered-containers, wai, wai-extra
     }:
     mkDerivation {
       pname = "airship";
       version = "0.4.2.0";
       sha256 = "d8638e31ee1087c33e6592488d8dc33642ba3d3a14f78f3a077a4dc27bbd1597";
       libraryHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring
         bytestring-trie case-insensitive cryptohash directory either
         filepath http-date http-media http-types lifted-base microlens
         mime-types mmorph monad-control mtl network old-locale random text
         time transformers transformers-base unix unordered-containers wai
         wai-extra
       ];
       testHaskellDepends = [
         base bytestring tasty tasty-hunit tasty-quickcheck text
         transformers wai
       ];
       jailbreak = true;
       homepage = "https://github.com/helium/airship/";
       description = "A Webmachine-inspired HTTP library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "airship" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, bytestring-trie, case-insensitive, cryptohash
     , directory, either, filepath, http-date, http-media, http-types
     , lifted-base, microlens, mime-types, mmorph, monad-control, mtl
     , network, old-locale, random, tasty, tasty-hunit, tasty-quickcheck
     , text, time, transformers, transformers-base, unix
     , unordered-containers, wai, wai-extra
     }:
     mkDerivation {
       pname = "airship";
       version = "0.4.3.0";
       sha256 = "1b7b3e5b66c853b7d84bce08c7cb92e7b40d69e02dbd28cd95bcb39dba9a6544";
       libraryHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring
         bytestring-trie case-insensitive cryptohash directory either
         filepath http-date http-media http-types lifted-base microlens
         mime-types mmorph monad-control mtl network old-locale random text
         time transformers transformers-base unix unordered-containers wai
         wai-extra
       ];
       testHaskellDepends = [
         base bytestring tasty tasty-hunit tasty-quickcheck text
         transformers wai
       ];
       homepage = "https://github.com/helium/airship/";
       description = "A Webmachine-inspired HTTP library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "aivika" = callPackage
    ({ mkDerivation, array, base, containers, mtl, random, vector }:
     mkDerivation {
       pname = "aivika";
       version = "4.3.2";
       sha256 = "a4209fea2b6d66bfd5d5d9a6477f95ce04c2c5fac06bfbde3c51941d84fba063";
       libraryHaskellDepends = [
         array base containers mtl random vector
       ];
       homepage = "http://www.aivikasoft.com/en/products/aivika.html";
       description = "A multi-paradigm simulation library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aivika-branches" = callPackage
    ({ mkDerivation, aivika, aivika-transformers, base, containers, mtl
     , random
     }:
     mkDerivation {
       pname = "aivika-branches";
       version = "0.1.2";
       sha256 = "6c8a2cd2b840f839881e847af3402f13cb2dc33e6fed19954477c4ae3417a417";
       libraryHaskellDepends = [
         aivika aivika-transformers base containers mtl random
       ];
       homepage = "http://www.aivikasoft.com/en/products/aivika.html";
       description = "Branching discrete event simulation library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aivika-experiment" = callPackage
    ({ mkDerivation, aivika, base, containers, directory, filepath, mtl
     , network-uri, parallel-io, split
     }:
     mkDerivation {
       pname = "aivika-experiment";
       version = "4.0.3";
       sha256 = "fb9fabcb770b87bbd4bcf1da33172c8e3e548ce12be6ddeb58076d55e7191dec";
       libraryHaskellDepends = [
         aivika base containers directory filepath mtl network-uri
         parallel-io split
       ];
       homepage = "http://github.com/dsorokin/aivika-experiment";
       description = "Simulation experiments for the Aivika library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aivika-experiment-cairo" = callPackage
    ({ mkDerivation, aivika-experiment, aivika-experiment-chart, base
     , Chart, Chart-cairo
     }:
     mkDerivation {
       pname = "aivika-experiment-cairo";
       version = "4.3.1";
       sha256 = "ab5df1225bb9a35c14fe06e32a04249b945448172649ca5f2893294097d6a45c";
       libraryHaskellDepends = [
         aivika-experiment aivika-experiment-chart base Chart Chart-cairo
       ];
       homepage = "http://github.com/dsorokin/aivika-experiment-cairo";
       description = "Cairo backend for the Aivika simulation library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aivika-experiment-chart" = callPackage
    ({ mkDerivation, aivika, aivika-experiment, array, base, Chart
     , colour, containers, data-default-class, filepath, lens, mtl
     , split
     }:
     mkDerivation {
       pname = "aivika-experiment-chart";
       version = "4.3.1";
       sha256 = "16a94b1d7fb03a6184755ad10b3c6691d9a7b5f2a02006b2891fefd6087ecaa1";
       libraryHaskellDepends = [
         aivika aivika-experiment array base Chart colour containers
         data-default-class filepath lens mtl split
       ];
       homepage = "http://github.com/dsorokin/aivika-experiment-chart";
       description = "Simulation experiments with charting for the Aivika library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aivika-experiment-diagrams" = callPackage
    ({ mkDerivation, aivika-experiment, aivika-experiment-chart, base
     , Chart, Chart-diagrams, containers, filepath
     }:
     mkDerivation {
       pname = "aivika-experiment-diagrams";
       version = "4.3.1";
       sha256 = "f664ee412a4ba768532953372a00fad17ffe3dad99a5a5dd785c59c916218bde";
       libraryHaskellDepends = [
         aivika-experiment aivika-experiment-chart base Chart Chart-diagrams
         containers filepath
       ];
       homepage = "http://github.com/dsorokin/aivika-experiment-diagrams";
       description = "Diagrams backend for the Aivika simulation library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aivika-transformers" = callPackage
    ({ mkDerivation, aivika, array, base, containers, mtl, random
     , vector
     }:
     mkDerivation {
       pname = "aivika-transformers";
       version = "4.3.2";
       sha256 = "34a0f93a75918a9a4c9db2062522bc6e042b33705797ad7a50215f244fa72355";
       libraryHaskellDepends = [
         aivika array base containers mtl random vector
       ];
       homepage = "http://www.aivikasoft.com/en/products/aivika.html";
       description = "Transformers for the Aivika simulation library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ajhc" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers, cpphs
     , directory, fgl, filepath, haskeline, HsSyck, HTTP, mtl, network
     , old-time, pretty, process, random, regex-compat, syb, temporary
     , unix, utf8-string, zlib
     }:
     mkDerivation {
       pname = "ajhc";
       version = "0.8.0.10";
       sha256 = "1a5ee944f7717d8fbbfb2cb33a4531aac0b2e776c44478006bf13cef1f6059f4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers cpphs directory fgl
         filepath haskeline HsSyck mtl old-time pretty process random
         regex-compat syb temporary unix utf8-string zlib
       ];
       executableHaskellDepends = [
         array base binary bytestring containers directory fgl filepath
         haskeline HsSyck HTTP mtl network old-time pretty process random
         regex-compat syb temporary unix utf8-string zlib
       ];
       homepage = "http://ajhc.metasepi.org/";
       description = "Haskell compiler that produce binary through C language";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "al" = callPackage
    ({ mkDerivation, base, c2hs, mtl, openal }:
     mkDerivation {
       pname = "al";
       version = "0.1.4.1";
       sha256 = "30e58c4459630e669c1029afe845f5fa9e33b140fc4983f5d086cec41850b3d6";
       libraryHaskellDepends = [ base mtl ];
       libraryPkgconfigDepends = [ openal ];
       libraryToolDepends = [ c2hs ];
       homepage = "http://github.com/phaazon/al";
       description = "OpenAL 1.1 raw API.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openal;};

  "alarmclock_0_2_0_5" = callPackage
    ({ mkDerivation, base, stm, time, unbounded-delays }:
     mkDerivation {
       pname = "alarmclock";
       version = "0.2.0.5";
       sha256 = "cd8566867c9f654b5d3d26b558106dbaaca69be9b517524be7c944e35c270fc8";
       libraryHaskellDepends = [ base stm time unbounded-delays ];
       testHaskellDepends = [ base time ];
       jailbreak = true;
       homepage = "https://bitbucket.org/davecturner/alarmclock";
       description = "Wake up and perform an action at a certain time";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "alarmclock_0_2_0_6" = callPackage
    ({ mkDerivation, base, stm, time, unbounded-delays }:
     mkDerivation {
       pname = "alarmclock";
       version = "0.2.0.6";
       sha256 = "01b361e8fb982ce1c809ae92f0427e40da37b05aefcd69590bf899ff72bf24cb";
       libraryHaskellDepends = [ base stm time unbounded-delays ];
       testHaskellDepends = [ base time ];
       homepage = "https://bitbucket.org/davecturner/alarmclock";
       description = "Wake up and perform an action at a certain time";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "alarmclock" = callPackage
    ({ mkDerivation, base, stm, time, unbounded-delays }:
     mkDerivation {
       pname = "alarmclock";
       version = "0.2.0.8";
       sha256 = "cee02d5065e4407ca5716ef0cfaf0eac9f49271208aef7cf67cd7870975d06bc";
       libraryHaskellDepends = [ base stm time unbounded-delays ];
       testHaskellDepends = [ base time ];
       homepage = "https://bitbucket.org/davecturner/alarmclock";
       description = "Wake up and perform an action at a certain time";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "alea" = callPackage
    ({ mkDerivation, argparser, base, containers, threefish }:
     mkDerivation {
       pname = "alea";
       version = "0.4.0.0";
       sha256 = "258d629383851804321a54d320df892b1513216b3336a2e8b3d07b973d8628c8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ argparser base containers threefish ];
       homepage = "https://github.com/Rnhmjoj/alea";
       description = "a diceware passphrase generator";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "alex_3_1_3" = callPackage
    ({ mkDerivation, array, base, containers, directory, happy, perl
     , process, QuickCheck
     }:
     mkDerivation {
       pname = "alex";
       version = "3.1.3";
       sha256 = "8d41a6e72a016155f00c846f7146ab4b27fe9640668a4b592d6a9b856f970a92";
       revision = "1";
       editedCabalFile = "cd88d8be642aa3de367ccc2bcfa54c68ed2156260b982d613f4d22b50959a099";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory QuickCheck
       ];
       executableToolDepends = [ happy ];
       testHaskellDepends = [ base process ];
       testToolDepends = [ perl ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.haskell.org/alex/";
       description = "Alex is a tool for generating lexical analysers in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) perl;};

  "alex_3_1_4" = callPackage
    ({ mkDerivation, array, base, containers, directory, happy, perl
     , process, QuickCheck
     }:
     mkDerivation {
       pname = "alex";
       version = "3.1.4";
       sha256 = "d64e4eccd953c62795ed566a6de5f3d150b653e05872ff697b3d9dbc961da19f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory QuickCheck
       ];
       executableToolDepends = [ happy ];
       testHaskellDepends = [ base process ];
       testToolDepends = [ perl ];
       doCheck = false;
       homepage = "http://www.haskell.org/alex/";
       description = "Alex is a tool for generating lexical analysers in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) perl;};

  "alex_3_1_5" = callPackage
    ({ mkDerivation, array, base, containers, directory, happy, process
     , QuickCheck
     }:
     mkDerivation {
       pname = "alex";
       version = "3.1.5";
       sha256 = "ddadb06546c2d5677482a943ceefad6990936367712bf6e6ceae251163092210";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory QuickCheck
       ];
       executableToolDepends = [ happy ];
       testHaskellDepends = [ base process ];
       doCheck = false;
       homepage = "http://www.haskell.org/alex/";
       description = "Alex is a tool for generating lexical analysers in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "alex_3_1_6" = callPackage
    ({ mkDerivation, array, base, containers, directory, happy, process
     , QuickCheck
     }:
     mkDerivation {
       pname = "alex";
       version = "3.1.6";
       sha256 = "2858e6784b60b4cd3e5d7b514ca15663a363c4ca2e44e019b73064168afdfe2f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory QuickCheck
       ];
       executableToolDepends = [ happy ];
       testHaskellDepends = [ base process ];
       doCheck = false;
       homepage = "http://www.haskell.org/alex/";
       description = "Alex is a tool for generating lexical analysers in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "alex" = callPackage
    ({ mkDerivation, array, base, containers, directory, happy, process
     , QuickCheck
     }:
     mkDerivation {
       pname = "alex";
       version = "3.1.7";
       sha256 = "89a1a13da6ccbeb006488d9574382e891cf7c0567752b330cc8616d748bf28d1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory QuickCheck
       ];
       executableToolDepends = [ happy ];
       testHaskellDepends = [ base process ];
       homepage = "http://www.haskell.org/alex/";
       description = "Alex is a tool for generating lexical analysers in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "alex-meta" = callPackage
    ({ mkDerivation, alex, array, base, containers, happy
     , haskell-src-meta, QuickCheck, template-haskell
     }:
     mkDerivation {
       pname = "alex-meta";
       version = "0.3.0.8";
       sha256 = "2ed9c0e13ad7f73d732d7bf87d187628009fe1ef19b6848f3490d0e89bf045c9";
       libraryHaskellDepends = [
         array base containers haskell-src-meta QuickCheck template-haskell
       ];
       libraryToolDepends = [ alex happy ];
       description = "Quasi-quoter for Alex lexers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "alfred" = callPackage
    ({ mkDerivation, aeson, base, bytestring, hexpat, http-conduit
     , http-types, network-uri, text, xmlgen
     }:
     mkDerivation {
       pname = "alfred";
       version = "0.5";
       sha256 = "76bbd427610242c87a94f65cbaabb8350d307f78d09f6e8c569327f14c99cab0";
       revision = "1";
       editedCabalFile = "06e4b9ba672fc3d29452df70d2e9f9018ada5e8b62aa5890b9a70d9d937d6581";
       libraryHaskellDepends = [
         aeson base bytestring hexpat http-conduit http-types network-uri
         text xmlgen
       ];
       description = "utility library for Alfred version 2";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "alga" = callPackage
    ({ mkDerivation, base, containers, directory, exceptions, filepath
     , formatting, haskeline, hxt, megaparsec, mtl, optparse-applicative
     , path, QuickCheck, random, temporary, test-framework
     , test-framework-quickcheck2, text, tf-random, transformers
     }:
     mkDerivation {
       pname = "alga";
       version = "0.1.0";
       sha256 = "e5a0bccf2817a5fa4446a6ee348de0f43f60e75884b61f12229cde948617f813";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers exceptions haskeline hxt megaparsec mtl path random
         text tf-random transformers
       ];
       executableHaskellDepends = [
         base containers directory exceptions filepath formatting haskeline
         hxt megaparsec mtl optparse-applicative path random temporary text
         tf-random transformers
       ];
       testHaskellDepends = [
         base containers hxt megaparsec mtl QuickCheck random test-framework
         test-framework-quickcheck2 text tf-random transformers
       ];
       homepage = "https://github.com/mrkkrp/alga";
       description = "Algorithmic automation for various DAWs";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "algebra" = callPackage
    ({ mkDerivation, adjunctions, array, base, containers, distributive
     , mtl, nats, semigroupoids, semigroups, tagged, transformers, void
     }:
     mkDerivation {
       pname = "algebra";
       version = "4.2";
       sha256 = "1ada84a9a816ad86f8bb11627df31f9707230fc21efa8ffdb51a1b314a61e4ac";
       revision = "1";
       editedCabalFile = "621c4b71305b0a6a926f055608b5ca76c4c2360a523bcdf88d80fd10d20f4210";
       libraryHaskellDepends = [
         adjunctions array base containers distributive mtl nats
         semigroupoids semigroups tagged transformers void
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/algebra/";
       description = "Constructive abstract algebra";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "algebra-dag" = callPackage
    ({ mkDerivation, aeson, base, containers, fgl, mtl, parsec
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "algebra-dag";
       version = "0.1.1.1";
       sha256 = "c92be90690f1ae2b0ae2a49c054007721db98afd025120025f23d863e45a26df";
       libraryHaskellDepends = [
         aeson base containers fgl mtl parsec template-haskell transformers
       ];
       description = "Infrastructure for DAG-shaped relational algebra plans";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "algebra-sql" = callPackage
    ({ mkDerivation, aeson, algebra-dag, ansi-wl-pprint, base
     , bytestring, containers, Decimal, dlist, errors, fgl, filepath
     , ghc-prim, mtl, multiset, parsec, pretty, process
     , template-haskell, text, time, transformers
     }:
     mkDerivation {
       pname = "algebra-sql";
       version = "0.3.0.0";
       sha256 = "f23f5dee89beaef9211eb245fe9310c71fbfaa86fa7ad324e7cad71e274e75f3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson algebra-dag ansi-wl-pprint base bytestring containers Decimal
         dlist errors fgl filepath ghc-prim mtl multiset parsec pretty
         process template-haskell text time transformers
       ];
       executableHaskellDepends = [
         aeson algebra-dag ansi-wl-pprint base bytestring containers Decimal
         dlist errors fgl filepath ghc-prim mtl multiset parsec pretty
         process template-haskell text time transformers
       ];
       description = "Relational Algebra and SQL Code Generation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "algebraic" = callPackage
    ({ mkDerivation, accelerate, base }:
     mkDerivation {
       pname = "algebraic";
       version = "0.1.0.2";
       sha256 = "905b4727b737349d9754059cd7dd3d729ab8d34913b46532304980bf1337fb95";
       libraryHaskellDepends = [ accelerate base ];
       jailbreak = true;
       homepage = "https://github.com/wdanilo/algebraic";
       description = "General linear algebra structures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "algebraic-classes" = callPackage
    ({ mkDerivation, base, syb, template-haskell }:
     mkDerivation {
       pname = "algebraic-classes";
       version = "0.6";
       sha256 = "c1548c369dc3695b655a1c3211fc4415556a6df3b16eac6cee22705b69b06444";
       libraryHaskellDepends = [ base syb template-haskell ];
       jailbreak = true;
       homepage = "https://github.com/sjoerdvisscher/algebraic-classes";
       description = "Conversions between algebraic classes and F-algebras";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "align" = callPackage
    ({ mkDerivation, base, containers, transformers, vector }:
     mkDerivation {
       pname = "align";
       version = "0.1.1.2";
       sha256 = "093b9727c3f485035efb0467a5e612034b7a75ae7a086adb1ca6a87790e967af";
       libraryHaskellDepends = [ base containers transformers vector ];
       description = "Sequence alignment algorithms";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "align-text" = callPackage
    ({ mkDerivation, base, optparse-applicative, text }:
     mkDerivation {
       pname = "align-text";
       version = "0.1.0.1";
       sha256 = "02ca5c06d069f641427cc3a8885f60845c147b27125137e5425cc0d869a2c8ee";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base optparse-applicative text ];
       jailbreak = true;
       homepage = "https://github.com/danchoi/align-text";
       description = "A simple unix filter to align text on specified substrings";
       license = stdenv.lib.licenses.mit;
     }) {};

  "aligned-foreignptr" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "aligned-foreignptr";
       version = "0.1";
       sha256 = "00b0e740cc0e79f4c8cc33b5bc4f898f64529e54ba5cefd25380113011b8b642";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "An aligned ForeignPtr type";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "allocated-processor" = callPackage
    ({ mkDerivation, base, vector-space }:
     mkDerivation {
       pname = "allocated-processor";
       version = "0.0.2";
       sha256 = "b504c33e889f4888ba3ad22ac31fa794cfd6c848991e96dacb568b93001e1f4a";
       libraryHaskellDepends = [ base vector-space ];
       description = "Functional combinators for monadic actions that require allocation and de-allocation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "alloy" = callPackage
    ({ mkDerivation, base, containers, mtl, syb, vector }:
     mkDerivation {
       pname = "alloy";
       version = "1.2.1";
       sha256 = "db73b7f02b642aec6a007c1542874d1bb674e482bc0d19f916a9410f466c7601";
       libraryHaskellDepends = [ base containers mtl syb vector ];
       description = "Generic programming library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "alloy-proxy-fd" = callPackage
    ({ mkDerivation, alloy, base, mtl }:
     mkDerivation {
       pname = "alloy-proxy-fd";
       version = "1.0.0";
       sha256 = "5ce651ee340400ceee7c1f6bfc56473f31269ea3e5e1974eb18002679b2f13ba";
       libraryHaskellDepends = [ alloy base mtl ];
       description = "Some add-on instances for the Alloy library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "almost-fix" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "almost-fix";
       version = "0.0.2";
       sha256 = "20597d015fe9b6bb6bfcb0eaee3eb58b28e38a1f4f43049ad0aeebcc6409a70f";
       libraryHaskellDepends = [ base ];
       description = "Recurse while a predicate is satisfied";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "alms" = callPackage
    ({ mkDerivation, array, base, containers, directory, editline, fgl
     , filepath, HUnit, incremental-sat-solver, mtl, network, parsec
     , pretty, QuickCheck, random, stm, syb, template-haskell
     , transformers, tuple
     }:
     mkDerivation {
       pname = "alms";
       version = "0.6.7";
       sha256 = "b7aa2734042296ad0d3bf1fb0b49b1b81a59aad372b15fd415b6892e6f9e2cf6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory editline fgl filepath HUnit
         incremental-sat-solver mtl network parsec pretty QuickCheck random
         stm syb template-haskell transformers tuple
       ];
       homepage = "http://www.ccs.neu.edu/~tov/pubs/alms/";
       description = "a practical affine language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "alpha" = callPackage
    ({ mkDerivation, array, AvlTree, base, bimap, bindings-posix
     , bytestring, cereal, containers, COrdering, cpphs, directory
     , filepath, ghc-prim, mtl, parsec, transformers, unix
     }:
     mkDerivation {
       pname = "alpha";
       version = "1.0.15";
       sha256 = "09d8dcaeb8fa8d25a7c10215773039963d824f92897051fc7b9d9533bd9c82bd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array AvlTree base bimap bindings-posix bytestring cereal
         containers COrdering cpphs directory filepath ghc-prim mtl parsec
         transformers unix
       ];
       jailbreak = true;
       homepage = "http://www.alpha-lang.net/";
       description = "A compiler for the Alpha language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "alpino-tools" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-lexing, conduit
     , containers, hexpat-pickle, MonadRandom, mtl, random-shuffle
     , resourcet, rosezipper, utf8-string
     }:
     mkDerivation {
       pname = "alpino-tools";
       version = "0.2.0";
       sha256 = "39986d30c2afa423bb9f024001506ca44678611ce257cc8188652a7769ae00ea";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring bytestring-lexing conduit containers hexpat-pickle
         MonadRandom mtl random-shuffle resourcet rosezipper utf8-string
       ];
       executableHaskellDepends = [
         base conduit containers MonadRandom mtl resourcet utf8-string
       ];
       jailbreak = true;
       homepage = "http://github.com/danieldk/alpino-tools";
       description = "Alpino data manipulation tools";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "alsa" = callPackage
    ({ mkDerivation, alsaLib, array, base, extensible-exceptions
     , sample-frame
     }:
     mkDerivation {
       pname = "alsa";
       version = "0.4";
       sha256 = "af2623551cf94a07ad53a263bdf63c6f14d24da88c5533050a869fca4584b67d";
       libraryHaskellDepends = [
         array base extensible-exceptions sample-frame
       ];
       librarySystemDepends = [ alsaLib ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/ALSA";
       description = "Binding to the ALSA Library API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) alsaLib;};

  "alsa-core" = callPackage
    ({ mkDerivation, alsaLib, base, extensible-exceptions }:
     mkDerivation {
       pname = "alsa-core";
       version = "0.5.0.1";
       sha256 = "eb50495ef05ecc7c06a0147da7f0d3efde832a44d23caaf5172dc114882270ab";
       libraryHaskellDepends = [ base extensible-exceptions ];
       libraryPkgconfigDepends = [ alsaLib ];
       homepage = "http://www.haskell.org/haskellwiki/ALSA";
       description = "Binding to the ALSA Library API (Exceptions)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) alsaLib;};

  "alsa-gui" = callPackage
    ({ mkDerivation, alsa-core, alsa-seq, base, midi, midi-alsa, wx
     , wxcore
     }:
     mkDerivation {
       pname = "alsa-gui";
       version = "0.1";
       sha256 = "dafec5f40b61a4a903260e3b7908921d5dd792fc6dac1849305243d926939e7d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         alsa-core alsa-seq base midi midi-alsa wx wxcore
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/ALSA";
       description = "Some simple interactive programs for sending MIDI control messages via ALSA";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "alsa-midi" = callPackage
    ({ mkDerivation, alsaLib, array, base, event-list, midi
     , non-negative
     }:
     mkDerivation {
       pname = "alsa-midi";
       version = "0.4.0.1";
       sha256 = "c3cb39ff34f83b54a7c3273b76471ca8d9376c525f38e36de386c31ccd18acb6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base event-list midi non-negative
       ];
       librarySystemDepends = [ alsaLib ];
       executableSystemDepends = [ alsaLib ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/ALSA";
       description = "Bindings for the ALSA sequencer API (MIDI stuff)";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) alsaLib;};

  "alsa-mixer" = callPackage
    ({ mkDerivation, alsa-core, alsaLib, base, c2hs, unix }:
     mkDerivation {
       pname = "alsa-mixer";
       version = "0.2.0.3";
       sha256 = "f76deb4081a2ce4a765e78a017b2e13c073d2aaa5a2d2652fd5e635dd169cf8d";
       libraryHaskellDepends = [ alsa-core base unix ];
       librarySystemDepends = [ alsaLib ];
       libraryToolDepends = [ c2hs ];
       homepage = "https://github.com/ttuegel/alsa-mixer";
       description = "Bindings to the ALSA simple mixer API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) alsaLib;};

  "alsa-pcm" = callPackage
    ({ mkDerivation, alsa-core, alsaLib, array, base
     , extensible-exceptions, sample-frame, storable-record
     }:
     mkDerivation {
       pname = "alsa-pcm";
       version = "0.6.0.4";
       sha256 = "9aae1379903b8445073f8a2b6ccf86b904b4045247747516530a165a3f76ca2a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         alsa-core array base extensible-exceptions sample-frame
         storable-record
       ];
       libraryPkgconfigDepends = [ alsaLib ];
       homepage = "http://www.haskell.org/haskellwiki/ALSA";
       description = "Binding to the ALSA Library API (PCM audio)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) alsaLib;};

  "alsa-pcm-tests" = callPackage
    ({ mkDerivation, alsa, base }:
     mkDerivation {
       pname = "alsa-pcm-tests";
       version = "0.1";
       sha256 = "330806eac691a87340d3ba43d1b1b402b65acd2a2db27f92281acb308e9319ae";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ alsa base ];
       description = "Tests for the ALSA audio signal library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "alsa-seq" = callPackage
    ({ mkDerivation, alsa-core, alsaLib, array, base, bytestring
     , data-accessor, enumset, extensible-exceptions, poll, transformers
     , utility-ht
     }:
     mkDerivation {
       pname = "alsa-seq";
       version = "0.6.0.6";
       sha256 = "f5e58660f07943f0cc33eb2e1ada5e111c43d4114eeb4e0ac0251d72c43b7144";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         alsa-core array base bytestring data-accessor enumset
         extensible-exceptions poll transformers utility-ht
       ];
       libraryPkgconfigDepends = [ alsaLib ];
       homepage = "http://www.haskell.org/haskellwiki/ALSA";
       description = "Binding to the ALSA Library API (MIDI sequencer)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) alsaLib;};

  "alsa-seq-tests" = callPackage
    ({ mkDerivation, alsa, base }:
     mkDerivation {
       pname = "alsa-seq-tests";
       version = "0.1";
       sha256 = "fa00a082bc210dff36d7eb33a06a9f6a701ba43805d2487fa93fabea1b0f4147";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ alsa base ];
       jailbreak = true;
       description = "Tests for the ALSA sequencer library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "altcomposition" = callPackage
    ({ mkDerivation, base, composition }:
     mkDerivation {
       pname = "altcomposition";
       version = "0.2.2.0";
       sha256 = "a9051c75339d16d6d3b875145f98c704127a5caba615280be5be36be04402321";
       libraryHaskellDepends = [ base composition ];
       homepage = "https://github.com/jcristovao/altcomposition";
       description = "Alternative combinators for unorthodox function composition";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "alternative-io" = callPackage
    ({ mkDerivation, base, lifted-base, monad-control, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "alternative-io";
       version = "0.0.1";
       sha256 = "90e98870a6117db09f1ce54c025944a174e643d1149d5ee76782c311d9ba1e06";
       revision = "2";
       editedCabalFile = "08531a3a2f2c8e6c4d44a1b201feb1ec354332f75e39d635318d8f6e31e5f15a";
       libraryHaskellDepends = [
         base lifted-base monad-control transformers transformers-base
       ];
       description = "IO as Alternative instance (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "altfloat" = callPackage
    ({ mkDerivation, base, ghc-prim, integer-gmp }:
     mkDerivation {
       pname = "altfloat";
       version = "0.3.1";
       sha256 = "88aa9ab42a196bcb405a86fc3512910ad2920aa00571fa3439577d19e8eb15d8";
       libraryHaskellDepends = [ base ghc-prim integer-gmp ];
       homepage = "http://repo.or.cz/w/altfloat.git";
       description = "Alternative floating point support for GHC";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "alure" = callPackage
    ({ mkDerivation, alure, base, OpenAL }:
     mkDerivation {
       pname = "alure";
       version = "0.1";
       sha256 = "16ed602e80594f59851fc50df8dc31477a3b7f1914335a53a263bfd530e234db";
       libraryHaskellDepends = [ base OpenAL ];
       librarySystemDepends = [ alure ];
       description = "A Haskell binding for ALURE";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {alure = null;};

  "amazon-emailer" = callPackage
    ({ mkDerivation, base, bytestring, configurator, http-conduit
     , lifted-base, mime-mail, mime-mail-ses, postgresql-simple
     , resourcet, text, time
     }:
     mkDerivation {
       pname = "amazon-emailer";
       version = "0.4.0.0";
       sha256 = "bdff0ca31dc36a29dc59a8de81c7deeb04211ed7a1eb817a7fd27cb6b0091569";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring configurator http-conduit lifted-base mime-mail
         mime-mail-ses postgresql-simple resourcet text time
       ];
       jailbreak = true;
       homepage = "https://github.com/dbp/amazon-emailer";
       description = "A queue daemon for Amazon's SES with a PostgreSQL table as a queue";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazon-emailer-client-snap" = callPackage
    ({ mkDerivation, base, mtl, snap, snaplet-postgresql-simple, text
     }:
     mkDerivation {
       pname = "amazon-emailer-client-snap";
       version = "0.1.1.1";
       sha256 = "6b6a15b0116dea99f3af40a7e607d40e3e8179e5d619e2646a5c60a6be2d550d";
       libraryHaskellDepends = [
         base mtl snap snaplet-postgresql-simple text
       ];
       jailbreak = true;
       homepage = "https://github.com/dbp/amazon-emailer-client-snap";
       description = "Client library for amazon-emailer daemon";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "amazon-products" = callPackage
    ({ mkDerivation, base, base64-bytestring, byteable, bytestring
     , conduit, containers, cryptohash, http-conduit, http-types, mtl
     , old-locale, resourcet, text, time, transformers
     , transformers-base, xml-conduit, xml-picklers, xml-types
     }:
     mkDerivation {
       pname = "amazon-products";
       version = "0.1.0.1";
       sha256 = "541f661a0c501beb045320734e3180735a02e1803d5e740898def4bfc632c883";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring byteable bytestring conduit containers
         cryptohash http-conduit http-types mtl old-locale resourcet text
         time transformers transformers-base xml-conduit xml-picklers
         xml-types
       ];
       executableHaskellDepends = [
         base bytestring http-conduit text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/AndrewRademacher/hs-amazon-products";
       description = "Connector for Amazon Products API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka_0_3_3_1" = callPackage
    ({ mkDerivation, amazonka-core, base, bytestring, conduit
     , conduit-extra, cryptohash, cryptohash-conduit, exceptions
     , http-conduit, lens, mmorph, monad-control, mtl, resourcet, retry
     , text, time, transformers, transformers-base, transformers-compat
     }:
     mkDerivation {
       pname = "amazonka";
       version = "0.3.3.1";
       sha256 = "9c28874d3990addb816b08be84ed424b30e071ec6173d30cb3ca347b71a58b8e";
       libraryHaskellDepends = [
         amazonka-core base bytestring conduit conduit-extra cryptohash
         cryptohash-conduit exceptions http-conduit lens mmorph
         monad-control mtl resourcet retry text time transformers
         transformers-base transformers-compat
       ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Comprehensive Amazon Web Services SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base, bytestring, conduit
     , conduit-extra, cryptohash, cryptohash-conduit, exceptions
     , http-conduit, lens, mmorph, monad-control, mtl, resourcet, retry
     , text, time, transformers, transformers-base, transformers-compat
     }:
     mkDerivation {
       pname = "amazonka";
       version = "0.3.4";
       sha256 = "13421e76039f2918a4b12d248f26700eed9541e688b6ca9e6536634db386dfa5";
       libraryHaskellDepends = [
         amazonka-core base bytestring conduit conduit-extra cryptohash
         cryptohash-conduit exceptions http-conduit lens mmorph
         monad-control mtl resourcet retry text time transformers
         transformers-base transformers-compat
       ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Comprehensive Amazon Web Services SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base, bytestring, conduit
     , conduit-extra, cryptohash, cryptohash-conduit, exceptions
     , http-conduit, lens, mmorph, monad-control, mtl, resourcet, retry
     , text, time, transformers, transformers-base, transformers-compat
     }:
     mkDerivation {
       pname = "amazonka";
       version = "0.3.6";
       sha256 = "4b3f0229f988d4ca2d2cdef47ff9e77e6b1fbdca99be14f47ce508fd29cbdfea";
       libraryHaskellDepends = [
         amazonka-core base bytestring conduit conduit-extra cryptohash
         cryptohash-conduit exceptions http-conduit lens mmorph
         monad-control mtl resourcet retry text time transformers
         transformers-base transformers-compat
       ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Comprehensive Amazon Web Services SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka" = callPackage
    ({ mkDerivation, amazonka-core, base, bytestring, conduit
     , conduit-extra, directory, exceptions, http-conduit, ini, mmorph
     , monad-control, mtl, resourcet, retry, tasty, tasty-hunit, text
     , time, transformers, transformers-base, transformers-compat
     }:
     mkDerivation {
       pname = "amazonka";
       version = "1.3.7";
       sha256 = "4eb5be39c07f4638cc050e97905c31409aa0555650c2d3c055d0c9e117685797";
       libraryHaskellDepends = [
         amazonka-core base bytestring conduit conduit-extra directory
         exceptions http-conduit ini mmorph monad-control mtl resourcet
         retry text time transformers transformers-base transformers-compat
       ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Comprehensive Amazon Web Services SDK";
       license = "unknown";
     }) {};

  "amazonka-apigateway" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-apigateway";
       version = "1.3.7";
       sha256 = "69dc8132895383cee52625053c5a26d00522592441b86382425e2ad717113953";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon API Gateway SDK";
       license = "unknown";
     }) {};

  "amazonka-autoscaling_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-autoscaling";
       version = "0.3.3";
       sha256 = "72131c3a2797daf67646ede03884ee6d513e28f0e87e9def0f7176203ebcc5ca";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Auto Scaling SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-autoscaling_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-autoscaling";
       version = "0.3.4";
       sha256 = "c4932d36daf685f8e8e790f6aec6a8551dfcc56482a891f5edb5f2d3899ccd4e";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Auto Scaling SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-autoscaling_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-autoscaling";
       version = "0.3.6";
       sha256 = "692d0d3ec89257bc599715ae4e32a43369180202c9d8d87edb35caac8063b385";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Auto Scaling SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-autoscaling" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-autoscaling";
       version = "1.3.7";
       sha256 = "cb9c27d105c147cf6d2bc2bf7207f4a6f9b4a13b4231a05487a6bf0cfe36d824";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Auto Scaling SDK";
       license = "unknown";
     }) {};

  "amazonka-cloudformation_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudformation";
       version = "0.3.3";
       sha256 = "8d2ec91ebb60d0f820b4ab7e95d926aae18354798d5e6e977545ebbe94326eb5";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudFormation SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudformation_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudformation";
       version = "0.3.4";
       sha256 = "09a083f9579599679eb3dfeb40017b405b2e39d4ad055b50ae162e852c0e1e5a";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudFormation SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudformation_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudformation";
       version = "0.3.6";
       sha256 = "037f4b56b9ca397fac6a56236590c24795c75967a5cdf9fd2e7b6afe3abac454";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudFormation SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudformation" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-cloudformation";
       version = "1.3.7";
       sha256 = "320c72348c550a03ed080922f70865ea1fc9e48307932157d6872cb5c882be0d";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudFormation SDK";
       license = "unknown";
     }) {};

  "amazonka-cloudfront_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudfront";
       version = "0.3.3";
       sha256 = "e1ac500661b03c05704b84edb79ef3f80b3066965fb60acb22bc6770e4b9219a";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudFront SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudfront_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudfront";
       version = "0.3.4";
       sha256 = "73528926e36ae8f84316168621a4efe92d306e088311ae6ed3725bdb1b4ce5fa";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudFront SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudfront_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudfront";
       version = "0.3.6";
       sha256 = "371f56870da95340dea000551b4a2fc9d1ecd521c0891b43260257fb54007426";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudFront SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudfront" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-cloudfront";
       version = "1.3.7";
       sha256 = "4bdfe01425a6508a224975a9137d816bf76455b1e8d2908cff75c896c86b3c5a";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudFront SDK";
       license = "unknown";
     }) {};

  "amazonka-cloudhsm_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudhsm";
       version = "0.3.3";
       sha256 = "6a82c1288323466074f5faacbf81c49b7f2e77dfc97b84a9b232552e03f8e36a";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudHSM SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudhsm_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudhsm";
       version = "0.3.4";
       sha256 = "be92ae1400458c1bca2d18ca99de7e0728ff215cb00b12a90f754edcdddd46b8";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudHSM SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudhsm_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudhsm";
       version = "0.3.6";
       sha256 = "cef59c1a93c60803e44a64a5b93ceb14a6aaf11a7ad5d25085a79147a3f42754";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudHSM SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudhsm" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-cloudhsm";
       version = "1.3.7";
       sha256 = "1ddff0ccf07e8961ddf0c8e186f2ff420ab0a03e20c0450bf71ca5c16e8791fa";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudHSM SDK";
       license = "unknown";
     }) {};

  "amazonka-cloudsearch_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudsearch";
       version = "0.3.3";
       sha256 = "48db9a1dec03056d88d92e5565bb3a836d3acc330398b621e543b779c6dc3f7c";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudSearch SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudsearch_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudsearch";
       version = "0.3.4";
       sha256 = "2248cbd2b02aa4bd50cbbabdcb6c876d517983351377d60f45ef8802474ce052";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudSearch SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudsearch_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudsearch";
       version = "0.3.6";
       sha256 = "454f86d0c622f20993e94a8ad60e98494107a6f02ffada31d2e295cd28bdcac3";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudSearch SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudsearch" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-cloudsearch";
       version = "1.3.7";
       sha256 = "8d25ff01dc964a28250004ac1d94c3352f08d187893f53d9718399dcac0eb4f6";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudSearch SDK";
       license = "unknown";
     }) {};

  "amazonka-cloudsearch-domains_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudsearch-domains";
       version = "0.3.3";
       sha256 = "f2dcbf43a0c6ff5e98388f7002a669398cac5cd58a4018728f48cdc158919880";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudSearch Domain SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudsearch-domains_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudsearch-domains";
       version = "0.3.4";
       sha256 = "3a92edbe1729eb503fe4d35afe34bae80c8237eaeda51e9b857ae9fdea0f4b1b";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudSearch Domain SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudsearch-domains_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudsearch-domains";
       version = "0.3.6";
       sha256 = "d5f70ae58af1148a90cfb7b01b1a16b071de21c8cb3bddbe5cf29fb3a803d135";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudSearch Domain SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudsearch-domains" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-cloudsearch-domains";
       version = "1.3.7";
       sha256 = "36a6b4c1320b8b796e013f2ed9007dd411649f4f5f328ae74fd2b32b34bd385d";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudSearch Domain SDK";
       license = "unknown";
     }) {};

  "amazonka-cloudtrail_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudtrail";
       version = "0.3.3";
       sha256 = "256899e14a24cba16f4f61d3fdc2c8402863b8c51f8ed272874bca203f578a01";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudTrail SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudtrail_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudtrail";
       version = "0.3.4";
       sha256 = "004555ba250434c8400f9ee68b37adb3379c615677b092490e66563277b2bb88";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudTrail SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudtrail_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudtrail";
       version = "0.3.6";
       sha256 = "3d31db40aa3174443cf23f91c914c50427d543ffe11bfc0b6dc7859c7c3b641d";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudTrail SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudtrail" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-cloudtrail";
       version = "1.3.7";
       sha256 = "f1a2c200001d876154cb526066d7dd41928000391b46bf2071e685f2e2f47ab1";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudTrail SDK";
       license = "unknown";
     }) {};

  "amazonka-cloudwatch_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudwatch";
       version = "0.3.3";
       sha256 = "206f20b3d2918947583139cea04d501e3042ac2d5103cc91d331c8569d250480";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudWatch SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudwatch_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudwatch";
       version = "0.3.4";
       sha256 = "a96946bb309465ebc2e398821a54a4b1815070053946a5ff85998fc78af14dd3";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudWatch SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudwatch_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudwatch";
       version = "0.3.6";
       sha256 = "d3a6b96ac214633f70cf3cb30650839600c97fd5689f619039bbb318d32e7d93";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudWatch SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudwatch" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-cloudwatch";
       version = "1.3.7";
       sha256 = "7ca782f158f95e2cd68f60de45aeeac9404ff55743a02b490f6be2ac5a3c35e0";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudWatch SDK";
       license = "unknown";
     }) {};

  "amazonka-cloudwatch-logs_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudwatch-logs";
       version = "0.3.3";
       sha256 = "b6f8a74571d3b46023eaaef2127a8cd24ea7959545a788afed0f72af1bffa83a";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudWatch Logs SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudwatch-logs_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudwatch-logs";
       version = "0.3.4";
       sha256 = "b6da2bf7252fcb6a1991b0f06eef5dce08895b041d4e068d5ab9217aa6eab9f3";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudWatch Logs SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudwatch-logs_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cloudwatch-logs";
       version = "0.3.6";
       sha256 = "6b63a9aeb3e731755bd2c9d0ab567a051afb34f0612aed892ecc54eca2f3b797";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudWatch Logs SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cloudwatch-logs" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-cloudwatch-logs";
       version = "1.3.7";
       sha256 = "479dab55226364dc4f109e5189906ee782d7d8d114ab2754278b22b15bf28025";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CloudWatch Logs SDK";
       license = "unknown";
     }) {};

  "amazonka-codecommit" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-codecommit";
       version = "1.3.7";
       sha256 = "71d52bd60f5d5b7a04e33b9c41aedef5d34cfd0587af16cbce5c8b7346519bb7";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CodeCommit SDK";
       license = "unknown";
     }) {};

  "amazonka-codedeploy_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-codedeploy";
       version = "0.3.3";
       sha256 = "c6328fda8b1e3b24be59e1aa3e7b333a1cd68a60a04478fee8b1fc78dd540bb2";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CodeDeploy SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-codedeploy_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-codedeploy";
       version = "0.3.4";
       sha256 = "20d6f895935aa8f2ccbb4736ff55c9c0092bde99c4f9261ae72707a144339aeb";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CodeDeploy SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-codedeploy_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-codedeploy";
       version = "0.3.6";
       sha256 = "b559711e0862a6bfe97e4565e6ef28b612df00c079111696041c5439034de9b2";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CodeDeploy SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-codedeploy" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-codedeploy";
       version = "1.3.7";
       sha256 = "114b48813df24301ac27bcd3f6f2933c925616d5f155b55459dec3c8f836c842";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CodeDeploy SDK";
       license = "unknown";
     }) {};

  "amazonka-codepipeline" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-codepipeline";
       version = "1.3.7";
       sha256 = "9b113de6a18eac005182c85e37a21c59cf077d78debcf229e0c175b93b6686cb";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon CodePipeline SDK";
       license = "unknown";
     }) {};

  "amazonka-cognito-identity_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cognito-identity";
       version = "0.3.3";
       sha256 = "b23c1e08647a9369c9fc8180c46c539206b6e724ca0ae4caab3ae9d20b9cd6cd";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Cognito Identity SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cognito-identity_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cognito-identity";
       version = "0.3.4";
       sha256 = "7537767e70de5e5e47facef7bf7e4d41f8f79692cdd662519f50f91a4ec8e16e";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Cognito Identity SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cognito-identity_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cognito-identity";
       version = "0.3.6";
       sha256 = "7f4a090ab59effe06ed61c5f96dd2d782651f6820a061ce179c817f40707e5c5";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Cognito Identity SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cognito-identity" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-cognito-identity";
       version = "1.3.7";
       sha256 = "78b0cf4e3d7aed0c82fd11016baf1e7bf2a33207a012a3229cbec2fdd7853641";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Cognito Identity SDK";
       license = "unknown";
     }) {};

  "amazonka-cognito-sync_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cognito-sync";
       version = "0.3.3";
       sha256 = "1bf054816fde0fe59a7a518c23b4fd270d431548782dda9e4a52a03eca22118d";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Cognito Sync SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cognito-sync_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cognito-sync";
       version = "0.3.4";
       sha256 = "1b56e1d91b2c1a0eabdd8144464f6ebde9ffcef26b6d08e2ccb7c1602543ac12";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Cognito Sync SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cognito-sync_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-cognito-sync";
       version = "0.3.6";
       sha256 = "63040d0a5dded76f15c1a3726276c48e0785f8eec29b115929341f4d01e2d6d4";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Cognito Sync SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-cognito-sync" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-cognito-sync";
       version = "1.3.7";
       sha256 = "5f0a9a438bad4739e364804e5326ad18ca2a4792f799098b098a9192836f5577";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Cognito Sync SDK";
       license = "unknown";
     }) {};

  "amazonka-config_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-config";
       version = "0.3.3";
       sha256 = "b3e2f4e267921aeaeefa4b0f01218ea377e07c8b6bff23f3535dff7c4179fb11";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Config SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-config_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-config";
       version = "0.3.4";
       sha256 = "d5c64ef1ac15b7447f73ecc41a2f2f42394a9187ff08c2183c4fb4e836feb3e3";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Config SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-config_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-config";
       version = "0.3.6";
       sha256 = "efbbfa8feffd5b920dd0c3b6a1ad8646a1bcca6f7df56dfcf6aa79452b1b4729";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Config SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-config" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-config";
       version = "1.3.7";
       sha256 = "58da74215ae3291341197e4bbb235f07818accf50364fb9ce5c392c8af5312fa";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Config SDK";
       license = "unknown";
     }) {};

  "amazonka-core_0_3_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, bifunctors, bytestring, case-insensitive
     , conduit, conduit-extra, cryptohash, data-default-class, hashable
     , http-client, http-types, lens, mmorph, mtl, resourcet, scientific
     , semigroups, tagged, tasty, tasty-hunit, template-haskell, text
     , time, transformers, transformers-compat, unordered-containers
     , vector, xml-conduit
     }:
     mkDerivation {
       pname = "amazonka-core";
       version = "0.3.3";
       sha256 = "2382e3ba4576a544ee54037b346dea2cb99326d8d417fedfde70d50bb8a9f4d5";
       revision = "1";
       editedCabalFile = "5f5396e3f969b8f5c0eb6c956c85dade9a751388bd40e8d1c0b007ee3a59dde8";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         bifunctors bytestring case-insensitive conduit conduit-extra
         cryptohash data-default-class hashable http-client http-types lens
         mmorph mtl resourcet scientific semigroups tagged text time
         transformers transformers-compat unordered-containers vector
         xml-conduit
       ];
       testHaskellDepends = [
         aeson base tasty tasty-hunit template-haskell text
       ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Core functionality and data types for Amazonka libraries";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-core_0_3_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, bifunctors, bytestring, case-insensitive
     , conduit, conduit-extra, cryptohash, data-default-class, hashable
     , http-client, http-types, lens, mmorph, mtl, resourcet, scientific
     , semigroups, tagged, tasty, tasty-hunit, template-haskell, text
     , time, transformers, transformers-compat, unordered-containers
     , vector, xml-conduit
     }:
     mkDerivation {
       pname = "amazonka-core";
       version = "0.3.4";
       sha256 = "5f268010d0dff030398b272f7c505f25acc33a9c8c0ccb3ad9e667663707306a";
       revision = "2";
       editedCabalFile = "ce25f51af29b48e824a325c3c6cdb72826ff9e76b7912b13f1d12660830e880e";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         bifunctors bytestring case-insensitive conduit conduit-extra
         cryptohash data-default-class hashable http-client http-types lens
         mmorph mtl resourcet scientific semigroups tagged text time
         transformers transformers-compat unordered-containers vector
         xml-conduit
       ];
       testHaskellDepends = [
         aeson base tasty tasty-hunit template-haskell text
       ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Core functionality and data types for Amazonka libraries";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-core_0_3_6" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, bifunctors, bytestring, case-insensitive
     , conduit, conduit-extra, cryptohash, data-default-class, hashable
     , http-client, http-types, lens, mmorph, mtl, resourcet, scientific
     , semigroups, tagged, tasty, tasty-hunit, template-haskell, text
     , time, transformers, transformers-compat, unordered-containers
     , vector, xml-conduit
     }:
     mkDerivation {
       pname = "amazonka-core";
       version = "0.3.6";
       sha256 = "821e635dc21ea7a06c6ba6711dec228c6fb18c12de51924f84d92fc71cf8c0d0";
       revision = "2";
       editedCabalFile = "3f6c94016391ab596deae1721db67629a85d8a0a9d7651bea5c962e5c0b5d39d";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         bifunctors bytestring case-insensitive conduit conduit-extra
         cryptohash data-default-class hashable http-client http-types lens
         mmorph mtl resourcet scientific semigroups tagged text time
         transformers transformers-compat unordered-containers vector
         xml-conduit
       ];
       testHaskellDepends = [
         aeson base tasty tasty-hunit template-haskell text
       ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Core functionality and data types for Amazonka libraries";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-core" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bifunctors, bytestring
     , case-insensitive, conduit, conduit-extra, cryptonite, exceptions
     , hashable, http-conduit, http-types, lens, memory, mtl, QuickCheck
     , quickcheck-unicode, resourcet, scientific, semigroups, tagged
     , tasty, tasty-hunit, tasty-quickcheck, template-haskell, text
     , time, transformers, transformers-compat, unordered-containers
     , xml-conduit, xml-types
     }:
     mkDerivation {
       pname = "amazonka-core";
       version = "1.3.7";
       sha256 = "29c8aebe23cd6f48fa5f49c2ba02e2f12b8aa8fc0f820489b49dc95b28f8e05c";
       libraryHaskellDepends = [
         aeson attoparsec base bifunctors bytestring case-insensitive
         conduit conduit-extra cryptonite exceptions hashable http-conduit
         http-types lens memory mtl resourcet scientific semigroups tagged
         text time transformers transformers-compat unordered-containers
         xml-conduit xml-types
       ];
       testHaskellDepends = [
         aeson base bytestring case-insensitive http-types QuickCheck
         quickcheck-unicode tasty tasty-hunit tasty-quickcheck
         template-haskell text time
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Core data types and functionality for Amazonka libraries";
       license = "unknown";
     }) {};

  "amazonka-datapipeline_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-datapipeline";
       version = "0.3.3";
       sha256 = "13fed4bb7c90e40f480bfe711b96c0142f695edc9dd2a49534f11fef131993e4";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Data Pipeline SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-datapipeline_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-datapipeline";
       version = "0.3.4";
       sha256 = "51e8ad756699826e99b084e10e00801fcaccdb1f66abbfba84a8c998161ffe38";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Data Pipeline SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-datapipeline_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-datapipeline";
       version = "0.3.6";
       sha256 = "b07af711215a233c972696f68111aed5c9acc1359c87da2769b6b818a139135c";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Data Pipeline SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-datapipeline" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-datapipeline";
       version = "1.3.7";
       sha256 = "7df5cd02fd2d14ca7dd37408ec59374a338d862162ef6c6094703f24f39ab5bd";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Data Pipeline SDK";
       license = "unknown";
     }) {};

  "amazonka-devicefarm" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-devicefarm";
       version = "1.3.7";
       sha256 = "f370f855bcdb2b5a504f399add12856884f3faa3ca465dc18fd1e0877eb74e7b";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Device Farm SDK";
       license = "unknown";
     }) {};

  "amazonka-directconnect_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-directconnect";
       version = "0.3.3";
       sha256 = "9118813548a2d1212f9ba123646dade5d3a68d253fa030dd5745cd772e300b19";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Direct Connect SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-directconnect_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-directconnect";
       version = "0.3.4";
       sha256 = "56a632209716491eaa4570282ab2b767e3c940bc7eb1312d2ffe8a8a9cf4d6f8";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Direct Connect SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-directconnect_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-directconnect";
       version = "0.3.6";
       sha256 = "66b57a47db626db18ffe5d008512995e513f709ba3aafc3defa5d2c9bb434560";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Direct Connect SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-directconnect" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-directconnect";
       version = "1.3.7";
       sha256 = "b1119213b84a509ebe5cd7ea1032ee94d7b0aa45fd159f71aa0e2f4d19e59dcb";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Direct Connect SDK";
       license = "unknown";
     }) {};

  "amazonka-ds" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-ds";
       version = "1.3.7";
       sha256 = "fd75ba2790bf61db6db791afb2eb52e7867f2294275b9fdf8c5e2040bd8e7628";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Directory Service SDK";
       license = "unknown";
     }) {};

  "amazonka-dynamodb_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-dynamodb";
       version = "0.3.3";
       sha256 = "9a7236c6c32bec873bda208df14e9e1c1e90b3d1559c3a573b80f9130ad53342";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon DynamoDB SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-dynamodb_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-dynamodb";
       version = "0.3.4";
       sha256 = "a92bf1efd9a465346afce9a17433056be9ef8207ec3e3290b34d8b10ca991698";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon DynamoDB SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-dynamodb_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-dynamodb";
       version = "0.3.6";
       sha256 = "58b6b50f085f198b9e85443b02cccceb4a0c9aecc01e1f389b4aea646efcd3cc";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon DynamoDB SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-dynamodb" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-dynamodb";
       version = "1.3.7";
       sha256 = "8000caed96de1a7ffc9dd97668606f3c64a54619b549b4b7c29b73780091176e";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon DynamoDB SDK";
       license = "unknown";
     }) {};

  "amazonka-dynamodb-streams" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-dynamodb-streams";
       version = "1.3.7";
       sha256 = "a3b5304cde5c828135a813c2f005d5bdc9d0316ab09c966f3caffae084971072";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon DynamoDB Streams SDK";
       license = "unknown";
     }) {};

  "amazonka-ec2_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-ec2";
       version = "0.3.3";
       sha256 = "7eab1f34b32651e3ae24d138faf408453222cd42bc67805e88710fc5a170faa1";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Compute Cloud SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-ec2_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-ec2";
       version = "0.3.4";
       sha256 = "d52031e157bb9f1200287c74026a734551ce37574180814e681b4defb3f70e32";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Compute Cloud SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-ec2_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-ec2";
       version = "0.3.6";
       sha256 = "71c3608f6d62404cb017f72f39143386e8e1bdeff59dc6953190417afbd50f14";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Compute Cloud SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-ec2_0_3_6_1" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-ec2";
       version = "0.3.6.1";
       sha256 = "9eab4d5a9220c745d073a65d734f19287cb7e39c7efa6ba296a05c1cd4c3fea5";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Compute Cloud SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-ec2" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-ec2";
       version = "1.3.7";
       sha256 = "d76e66ca880a7dc8299186ea0334c12a4a38bf4efa79df59dc26016371e59e65";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       doCheck = false;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Compute Cloud SDK";
       license = "unknown";
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "amazonka-ecs_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-ecs";
       version = "0.3.3";
       sha256 = "c321370cb321aaf98521d9d3a01b7fa51b9ddc958064a0dcef5d7ba91b834d6b";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon EC2 Container Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-ecs_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-ecs";
       version = "0.3.4";
       sha256 = "44bd46ca02314f762cb0b71732a9c8d634223c99522e9590bbf81583c04a67df";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon EC2 Container Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-ecs_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-ecs";
       version = "0.3.6";
       sha256 = "d9bd1974ff69af39d4ed54d4af1bc02f31f3d0698f56ca1dcdb7e488db4da5d5";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon EC2 Container Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-ecs" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-ecs";
       version = "1.3.7";
       sha256 = "4124f46fa02ef085e989261b2617975dbbd7d2549fd1901279b311952c01d51e";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon EC2 Container Service SDK";
       license = "unknown";
     }) {};

  "amazonka-efs" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-efs";
       version = "1.3.7";
       sha256 = "ae1a69233552debb037c3d87062fe79562af74b735758e8c6cfcf59e8fc4269f";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic File System SDK";
       license = "unknown";
     }) {};

  "amazonka-elasticache_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-elasticache";
       version = "0.3.3";
       sha256 = "75650d6e006c75fe9c802a1259576d8f4776e1dbf128d01d15708dab63ededa7";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon ElastiCache SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-elasticache_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-elasticache";
       version = "0.3.4";
       sha256 = "912e979abf5a56ef74aee627a644d138f73a9fde9f3ba0f5f94475ac4d08af06";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon ElastiCache SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-elasticache_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-elasticache";
       version = "0.3.6";
       sha256 = "4a847479c6686eb26b2bb4ed1a7c384caff4a8906ebe4f46a22f212911905741";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon ElastiCache SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-elasticache" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-elasticache";
       version = "1.3.7";
       sha256 = "22d53cb522c73f1fd95dfd8678295055aebd34b3f999506042f00d49266ed0d9";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon ElastiCache SDK";
       license = "unknown";
     }) {};

  "amazonka-elasticbeanstalk_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-elasticbeanstalk";
       version = "0.3.3";
       sha256 = "1a83de35658d6feb889f48c65bbcee10909d0efa5bf9c26f56c12b1f2e955c25";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Beanstalk SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-elasticbeanstalk_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-elasticbeanstalk";
       version = "0.3.4";
       sha256 = "94a260aeaf62adfae56b9ce07bcf795b094f5ede60852226cc52f4f4b86d9f8e";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Beanstalk SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-elasticbeanstalk_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-elasticbeanstalk";
       version = "0.3.6";
       sha256 = "e31c1385d408158e36ff4a3a356ef913fcd5819fed0a77c01ebd652277eff1ae";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Beanstalk SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-elasticbeanstalk" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-elasticbeanstalk";
       version = "1.3.7";
       sha256 = "c4e6bfa1d599602c9f25a1b8a0c2a6d7518d959dde78b1fb64ad787d3e356dd4";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Beanstalk SDK";
       license = "unknown";
     }) {};

  "amazonka-elasticsearch" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-elasticsearch";
       version = "1.3.7";
       sha256 = "7179150c600ed9a2889700a1433f4bc12eec1406e74c25341993d3a8c27575b4";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elasticsearch Service SDK";
       license = "unknown";
     }) {};

  "amazonka-elastictranscoder_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-elastictranscoder";
       version = "0.3.3";
       sha256 = "22c71f05b5d0d22fc9bc11c04e24ab8ea745a3038ba58afad33c302ffe17d81a";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Transcoder SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-elastictranscoder_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-elastictranscoder";
       version = "0.3.4";
       sha256 = "944d279f547ea44771c565768ccf5d601623be931bd364ad2fc4a27b0f8021f2";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Transcoder SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-elastictranscoder_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-elastictranscoder";
       version = "0.3.6";
       sha256 = "e8868624347be2dbad1471ca3c96e50cc728ac329d2d5b2c15d5836f28ffd6e5";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Transcoder SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-elastictranscoder" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-elastictranscoder";
       version = "1.3.7";
       sha256 = "55d813660c91eee260111a252afddc295edf7a26a7f3b5c5e9c7ab4814ce338c";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Transcoder SDK";
       license = "unknown";
     }) {};

  "amazonka-elb_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-elb";
       version = "0.3.3";
       sha256 = "c7356f11109a56bc17389dea202c6a9cd5ecc2f6b849836bbef832666467bfe5";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Load Balancing SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-elb_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-elb";
       version = "0.3.4";
       sha256 = "394da22f6cf546eea4dcb623d00783c615350f024919d624a3a6d9c7d0037e86";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Load Balancing SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-elb_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-elb";
       version = "0.3.6";
       sha256 = "a92c4972a4b47fabd4a70c8ab7c63308c0dd3bc7b1c513b49589f7cc0bd9317b";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Load Balancing SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-elb" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-elb";
       version = "1.3.7";
       sha256 = "5d72d70f7ffa2ea1e0a244c60e87ccb19874bff27f547bf1b1c740e75c8872ec";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic Load Balancing SDK";
       license = "unknown";
     }) {};

  "amazonka-emr_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-emr";
       version = "0.3.3";
       sha256 = "bdc94e755feb1459a39b4c628ba46060cf2ee7c98ac1c53e5baa2df274bdf7ba";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic MapReduce SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-emr_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-emr";
       version = "0.3.4";
       sha256 = "9bc69ae4df39589dedd8df7c990cddaaa412a610992dc1c653acd7a88fee01b7";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic MapReduce SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-emr_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-emr";
       version = "0.3.6";
       sha256 = "2920743bbb3e4f507ef9662d27c224b3590162ead2059ee8cb540d814ea4605f";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic MapReduce SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-emr" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-emr";
       version = "1.3.7";
       sha256 = "cfd8c9416c1ba32001aeae5f60d5050276e9f6ac1870d13f5a995803711d35fc";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Elastic MapReduce SDK";
       license = "unknown";
     }) {};

  "amazonka-glacier_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-glacier";
       version = "0.3.3";
       sha256 = "81cbd1ff9a1d8ca811589f0b9edc8538b3ed0d800eb1ef8ff2fe14c98789b485";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Glacier SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-glacier_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-glacier";
       version = "0.3.4";
       sha256 = "260a14a33c442cda239e2c983f52311c2bd1b3db38a7d7849135a6087419a6b5";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Glacier SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-glacier_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-glacier";
       version = "0.3.6";
       sha256 = "b41519fc6e001406f0ad4a2e98c03ec38c9bc410a41a8b6b3c52c2a0a00f7244";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Glacier SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-glacier" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-glacier";
       version = "1.3.7";
       sha256 = "18ee97fef9915b433a716e40f6a83c332080fd9fa428ce60c56444161f67db04";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Glacier SDK";
       license = "unknown";
     }) {};

  "amazonka-iam_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-iam";
       version = "0.3.3";
       sha256 = "5080a0b65ceaf4d2277bf3acb013ad98dec386dbd9a68c132acb4d9ada91ea42";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Identity and Access Management SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-iam_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-iam";
       version = "0.3.4";
       sha256 = "24715253580d2f5ef6f86afa606321abb658fc38b21361e9c8b20a27743fd0ea";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Identity and Access Management SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-iam_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-iam";
       version = "0.3.6";
       sha256 = "12519b4244c0bd8158e73c03fcd810d9f20a66e3f9dad687054a38706c4ffa5b";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Identity and Access Management SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-iam" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-iam";
       version = "1.3.7";
       sha256 = "301463c7e704f82055307f0cbb9d092abdd3bc6672a78439ed748fbd061b3945";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Identity and Access Management SDK";
       license = "unknown";
     }) {};

  "amazonka-importexport_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-importexport";
       version = "0.3.3";
       sha256 = "cef04421bc019ad5f8762d817956fc4824c03e87aba99daf9f75cf3678fa6fba";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Import/Export SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-importexport_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-importexport";
       version = "0.3.4";
       sha256 = "1a005b37b6d91edaaed589524e6dcce06ae4bdd72e0355a88dc842996977af97";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Import/Export SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-importexport_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-importexport";
       version = "0.3.6";
       sha256 = "3de5b0833361758e806ac7c32ab6bf2daf72ffb121d1b166710a779d1efe98e1";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Import/Export SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-importexport" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-importexport";
       version = "1.3.7";
       sha256 = "ec40b77cc0f365d01c6614cf0daa1dbbdbcf97cd4cb1ac1b258cd8382ff3ae6d";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Import/Export SDK";
       license = "unknown";
     }) {};

  "amazonka-inspector" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-inspector";
       version = "1.3.7";
       sha256 = "eaf9eec94b9de0bfc2b1c204be38bbb9b808d69a0286686960ea4f551793a7d2";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Inspector SDK";
       license = "unknown";
     }) {};

  "amazonka-iot" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-iot";
       version = "1.3.7";
       sha256 = "7e515bf2ec1ac7f9ef84c31fd5b436d13df2e5ab9c21cc2b5fc54d92d0b2cee3";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon IoT SDK";
       license = "unknown";
     }) {};

  "amazonka-iot-dataplane" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-iot-dataplane";
       version = "1.3.7";
       sha256 = "de6f860acc5ca4d623ec66dad54cedc972516c6d04f0babfe0aa142fd86f1538";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon IoT Data Plane SDK";
       license = "unknown";
     }) {};

  "amazonka-kinesis_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-kinesis";
       version = "0.3.3";
       sha256 = "ea082f19763bb25cd9b6d1da213ea1d69d8e86f99a35f2f2dc2b4ee3b0e7a123";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Kinesis SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-kinesis_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-kinesis";
       version = "0.3.4";
       sha256 = "8a1ba473c62987cc12915c2688481fc5eaf570c5712608d100f1099e721f4f39";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Kinesis SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-kinesis_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-kinesis";
       version = "0.3.6";
       sha256 = "5e41b7c94eda13465b6c9c7c7bd9f8975c35ae5f2fcda79f7857e5781d2e9a64";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Kinesis SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-kinesis" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-kinesis";
       version = "1.3.7";
       sha256 = "321884fc3baa02e07f613dd23ec77ec79ce40c875a88772e9586a99745114b43";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Kinesis SDK";
       license = "unknown";
     }) {};

  "amazonka-kinesis-firehose" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-kinesis-firehose";
       version = "1.3.7";
       sha256 = "6a557b9b3fb21b1035aad13a6ddcbd249ce97bc2aeb77b48eee74b6d6a634d1a";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Kinesis Firehose SDK";
       license = "unknown";
     }) {};

  "amazonka-kms_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-kms";
       version = "0.3.3";
       sha256 = "f39ac5c5be55b3aff846df42d98309f243ba73d8ac378021b65609bb19a4148e";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Key Management Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-kms_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-kms";
       version = "0.3.4";
       sha256 = "c2fc28d719365eddc3bf9f718ae05fc4c557b48cbbd294421285b958263d4937";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Key Management Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-kms_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-kms";
       version = "0.3.6";
       sha256 = "c9feae3597f745414e560ae4613219bb71285ced6959b336bf2aa753cb93c8f4";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Key Management Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-kms" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-kms";
       version = "1.3.7";
       sha256 = "2daffffd16da332b52523802ee35173aaafed8d24a4e860045bc9933725c9de4";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Key Management Service SDK";
       license = "unknown";
     }) {};

  "amazonka-lambda_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-lambda";
       version = "0.3.3";
       sha256 = "d5bb30647867ef26c57f794c4373b32178c076afd3927b8000bd1b9d7dcc2128";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Lambda SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-lambda_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-lambda";
       version = "0.3.4";
       sha256 = "c136d09f50f7f94af026f19a7c26a16847b10f77feb121468317dd6a68e54dda";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Lambda SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-lambda_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-lambda";
       version = "0.3.6";
       sha256 = "9742cd0eff0e80552a5fb18dcddbefdb6cdb3f7a3a1f7476b5ea03338971cfbc";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Lambda SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-lambda" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-lambda";
       version = "1.3.7";
       sha256 = "cba44973510233399b0d5fa4c9d291691e30caef63035158f40b5b10e2dd5f90";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Lambda SDK";
       license = "unknown";
     }) {};

  "amazonka-marketplace-analytics" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-marketplace-analytics";
       version = "1.3.7";
       sha256 = "eaf080d9f19638c4d7d98fb19e4f0ce752622c04db675e91c9bcc23476ca4d8e";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Marketplace Commerce Analytics SDK";
       license = "unknown";
     }) {};

  "amazonka-ml_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-ml";
       version = "0.3.6";
       sha256 = "04b06c1f60461bfc807b5bf3c432a75999d4e96f283d9f521aba93605b054655";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Machine Learning SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-ml" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-ml";
       version = "1.3.7";
       sha256 = "05ced76e5eaad97bd2b5ead71df84f3f304d0c6fa16fb5af6a3df8e24e9af31e";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Machine Learning SDK";
       license = "unknown";
     }) {};

  "amazonka-opsworks_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-opsworks";
       version = "0.3.3";
       sha256 = "8844c16244c47d87eb5b870026c641630b5b45596d15ff5cd4738f449306130e";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon OpsWorks SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-opsworks_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-opsworks";
       version = "0.3.4";
       sha256 = "80d6a17db34cec13dc31145e15086b344c186ad86f213290dc000d7d3651871e";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon OpsWorks SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-opsworks_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-opsworks";
       version = "0.3.6";
       sha256 = "142bb8a969bc39ce8706d5fc8a83063733506a06eb3d1d09a3666272bf7a38b5";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon OpsWorks SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-opsworks" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-opsworks";
       version = "1.3.7";
       sha256 = "d0367cedd608068cf27e84b1690086c7915639578181a2790f584b787dcadbb9";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon OpsWorks SDK";
       license = "unknown";
     }) {};

  "amazonka-rds_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-rds";
       version = "0.3.3";
       sha256 = "999d555b1ed516730e3dfafb6bec1532ecfd888189112b2107658bcec90b49c0";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Relational Database Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-rds_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-rds";
       version = "0.3.4";
       sha256 = "fce1af2a8d30665a6a2c29d16528515d291101831cb7320b4f148499ac0528ca";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Relational Database Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-rds_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-rds";
       version = "0.3.6";
       sha256 = "d40f097f828d4ffb66498ebe17de09da43e0b53a195424eff64541993f92bd80";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Relational Database Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-rds" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-rds";
       version = "1.3.7";
       sha256 = "a874b42d38fd50279d7dfbb4a08b3633dc35a8e2f140598c0aabbec3bf152a75";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Relational Database Service SDK";
       license = "unknown";
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "amazonka-redshift_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-redshift";
       version = "0.3.3";
       sha256 = "f917d8790154c4ad5789c2bca96c2b7e9f52266f2cb573232f0e5dd314a93bf2";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Redshift SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-redshift_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-redshift";
       version = "0.3.4";
       sha256 = "36c8d67725fae30e07e469e7f9f7a5faddab7eb7ab8c4f3d59dcc50b971a4da3";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Redshift SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-redshift_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-redshift";
       version = "0.3.6";
       sha256 = "f9ba346247ef45a078de0c6694ff70c65ed445e4a9b2022677151a0f2557b4a4";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Redshift SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-redshift" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-redshift";
       version = "1.3.7";
       sha256 = "cd6797859fd724b5d470b3bcf01c1bec167ad1c247de115a767c6ba5ed268d01";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Redshift SDK";
       license = "unknown";
     }) {};

  "amazonka-route53_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-route53";
       version = "0.3.3";
       sha256 = "3141ee2340b30fa63c09a9296a6f002863e88dfb55817a0d34fa198e578b2501";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Route 53 SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-route53_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-route53";
       version = "0.3.4";
       sha256 = "7e2211c8ab5832869f15c38102615a050e12196d45f82c7605534e2a193e4715";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Route 53 SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-route53_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-route53";
       version = "0.3.6";
       sha256 = "a333aa9f557713465ff6e6cb4d931bc38b532a7f1fea063d14f9a2fbcb2764f6";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Route 53 SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-route53_0_3_6_1" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-route53";
       version = "0.3.6.1";
       sha256 = "bc26681aa326f53075e8ec47c419249dfb231517362188784da99bc49c27ad94";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Route 53 SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-route53" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-route53";
       version = "1.3.7";
       sha256 = "cc6811f83c7282d1cd20d145fe317d6116a9731bd4ee58923d84924634fbc208";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Route 53 SDK";
       license = "unknown";
     }) {};

  "amazonka-route53-domains_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-route53-domains";
       version = "0.3.3";
       sha256 = "ccf6fb806af411e2ff5d9906d06075f1590121eb022f1e677c18a92469e9e4da";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Route 53 Domains SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-route53-domains_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-route53-domains";
       version = "0.3.4";
       sha256 = "e277f557ae9335d7dd4515e540578cc9c6104b54977ba7f07c98b9e70caf1b97";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Route 53 Domains SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-route53-domains_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-route53-domains";
       version = "0.3.6";
       sha256 = "1b4fa06c87ee69370584cffbdef5fd0c7fa9a3fd43637bac1bb295c14b9fbe8d";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Route 53 Domains SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-route53-domains" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-route53-domains";
       version = "1.3.7";
       sha256 = "b2a5143e58f517ef9d3b5768acd220b3404cbc13b20248a983a977e73f3920dc";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Route 53 Domains SDK";
       license = "unknown";
     }) {};

  "amazonka-s3_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-s3";
       version = "0.3.3";
       sha256 = "3003cdda5635bdf52c5a4bbaceaf4db1beb67d6cab7806667d9a4621e9ec0d62";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Storage Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-s3_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-s3";
       version = "0.3.4";
       sha256 = "b6252cf56950187632e1454f4a27f91316dc2ff6ae3c3ff45d9ef769ed713e56";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Storage Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-s3_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-s3";
       version = "0.3.6";
       sha256 = "69b37d3713b5ff745109877cdfcb766ca71b6ccc7b15d312afd2654e9e6985e0";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Storage Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-s3" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , lens, tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-s3";
       version = "1.3.7";
       sha256 = "da865c6a32f1d07c8ff28bcb1f2905b2e0cedf19e0f5c00ca975ac84ff9b1620";
       libraryHaskellDepends = [ amazonka-core base lens text ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       doCheck = false;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Storage Service SDK";
       license = "unknown";
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "amazonka-sdb_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-sdb";
       version = "0.3.3";
       sha256 = "989376fcd3756df53414136f337c74b24bcd7e3b5cd6f1ab5bee8addd5c56a98";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon SimpleDB SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-sdb_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-sdb";
       version = "0.3.4";
       sha256 = "219eecda9402ac4cb6fcdedaa7aa7b33bcda60265df1ae34caa3e210d2234f4b";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon SimpleDB SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-sdb_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-sdb";
       version = "0.3.6";
       sha256 = "8c06d2a7912416580f4301231e6883242d31132473917d2fdc3f605973d45cf3";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon SimpleDB SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-sdb" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-sdb";
       version = "1.3.7";
       sha256 = "6cf65455e4b56ef50f6ebed0b93463439c8ab51c3e33c74634b7046a6b341d71";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon SimpleDB SDK";
       license = "unknown";
     }) {};

  "amazonka-ses_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-ses";
       version = "0.3.3";
       sha256 = "1aba1a1664ac52b99de09a1512e3fe564d1247e41334e327a689799884bd12a3";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Email Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-ses_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-ses";
       version = "0.3.4";
       sha256 = "24533de8fb05b9ad47d440373c0c0b31a4322b689fd6ffc1ad1c6f9fdd500a68";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Email Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-ses_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-ses";
       version = "0.3.6";
       sha256 = "bd6f22d69cd44073423631390eaba47eb2a539d9ae3912e9111a0677eb08f3b8";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Email Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-ses" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-ses";
       version = "1.3.7";
       sha256 = "42d593776aea6d9bc5a9a8ec8ef9eefea413d413d3586fb0231733aceb4a29b3";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Email Service SDK";
       license = "unknown";
     }) {};

  "amazonka-sns_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-sns";
       version = "0.3.3";
       sha256 = "293c5c955d1e735b529999a2e5460697b0a8d02ffb7c11982bf83dc8500f6290";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Notification Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-sns_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-sns";
       version = "0.3.4";
       sha256 = "4263e807e0a3c8cce8f224903f7d5c60dbe7a925b0094a18504a58b729fe99de";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Notification Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-sns_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-sns";
       version = "0.3.6";
       sha256 = "aaaebf5a3d8851a6139216154922b1d49ae2474c00ace8e5eb33f6daccb07401";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Notification Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-sns" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-sns";
       version = "1.3.7";
       sha256 = "ea691aec73e2859e074bb86c7bdf3f04e8eb58b512686e887fc714403c612ee4";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Notification Service SDK";
       license = "unknown";
     }) {};

  "amazonka-sqs_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-sqs";
       version = "0.3.3";
       sha256 = "db282bbc46aa17d50cbf76021734b208c7f3079d5f7e7af90315f86bfa060a0c";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Queue Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-sqs_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-sqs";
       version = "0.3.4";
       sha256 = "a4223ca1503cadb86cfe73c0c2f52575e3fd013cbe3f5564cc9155b8c3b1802d";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Queue Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-sqs_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-sqs";
       version = "0.3.6";
       sha256 = "88f733f5885372c0faf052be2da8dae0d8605eccfdb2b3e290b7fc1e50431f13";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Queue Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-sqs" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-sqs";
       version = "1.3.7";
       sha256 = "c18e3c60413c9a949b885622a10e7ea221ebb0b9f65c4d1c57c07941de969172";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Queue Service SDK";
       license = "unknown";
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "amazonka-ssm_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-ssm";
       version = "0.3.3";
       sha256 = "d35b0914db37efa12edbb338f084856e92dd7e033fc32e017ea26c03d69a686a";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Systems Management Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-ssm_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-ssm";
       version = "0.3.4";
       sha256 = "f163a6edd65f1214c8623cce8eec0974c6845683d0cb7d5814f415357536e70e";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Systems Management Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-ssm_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-ssm";
       version = "0.3.6";
       sha256 = "e08c7d2682d2cb75a8f758787bff680897da29e2a0e3f75f355501d8a140fff7";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Systems Management Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-ssm" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-ssm";
       version = "1.3.7";
       sha256 = "5b990dafc0066327e197c5838a3ec562471933f7e0eed2bd15f94249859f20da";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Systems Management Service SDK";
       license = "unknown";
     }) {};

  "amazonka-storagegateway_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-storagegateway";
       version = "0.3.3";
       sha256 = "0b110b8e44fbbd242a1794aa4e179d6225019835528ff6d05374e11e1023f9bb";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Storage Gateway SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-storagegateway_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-storagegateway";
       version = "0.3.4";
       sha256 = "be1b7d9e666b5b365a92cd50cde89ea40215c56bee4f64767ce01b84598adc04";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Storage Gateway SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-storagegateway_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-storagegateway";
       version = "0.3.6";
       sha256 = "5fe0192f8a898ddd657e2768888f652611133c25fe5861f2b0db51e0f8954ab2";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Storage Gateway SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-storagegateway" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-storagegateway";
       version = "1.3.7";
       sha256 = "d43de277a9262445fcbce966863622132c4a0d72273fa7bfd9efb32bdbc20348";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Storage Gateway SDK";
       license = "unknown";
     }) {};

  "amazonka-sts_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-sts";
       version = "0.3.3";
       sha256 = "d2d2396640fca1265f5e907a50c8985e1e08e17ee640a80a0e1c8019fefef753";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Security Token Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-sts_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-sts";
       version = "0.3.4";
       sha256 = "5f00b19a5921c4555ad03f9360a29f4d6f9ebc6c94edd1244a9a66d9d9d6b2ba";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Security Token Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-sts_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-sts";
       version = "0.3.6";
       sha256 = "c1953e60af48baf7e2cfd5247e4eff8fcdbeaf966bd6ffc7b29bac74aed8ca24";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Security Token Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-sts" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-sts";
       version = "1.3.7";
       sha256 = "cb113a4d42ec49d05b3199802d3233ac8bdf3e85115bfcdd155a98c1a9003486";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Security Token Service SDK";
       license = "unknown";
     }) {};

  "amazonka-support_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-support";
       version = "0.3.3";
       sha256 = "0c96121bde29b25c41e3eb2067a09ab388d28f75144db6a9f2b8f1fd08aa6817";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Support SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-support_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-support";
       version = "0.3.4";
       sha256 = "05c71bccd2cd055b37d432a7f6a15a5f4c43f3510d9829225cab9dc0961dfecf";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Support SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-support_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-support";
       version = "0.3.6";
       sha256 = "c6e36708c2a7db345f39b8c63358b87474aa0028e52a7c8fe52b6f340ac2ea45";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Support SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-support" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-support";
       version = "1.3.7";
       sha256 = "6c8b40c5dd291a5b53ce16348b219c40b33e2c94e65b8478f242ff93c0d6c0d2";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Support SDK";
       license = "unknown";
     }) {};

  "amazonka-swf_0_3_3" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-swf";
       version = "0.3.3";
       sha256 = "5dc210d018bc5c39ba687a7a922489402ad286a7c0edc6e0e967cf45dbc93dd3";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Workflow Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-swf_0_3_4" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-swf";
       version = "0.3.4";
       sha256 = "2d519371aee2ad8c175b10d78de2d26fbe63386f548349b784a3c8771a61eaf0";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Workflow Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-swf_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-swf";
       version = "0.3.6";
       sha256 = "cce163f16a103629248313a237fc6d80eaaba162d64f0bdef96df9930e6b3256";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Workflow Service SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-swf" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-swf";
       version = "1.3.7";
       sha256 = "b95a998ca50d79913d8deb8c7572554726e4a3778c891301659ef8829d7119b0";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       doCheck = false;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon Simple Workflow Service SDK";
       license = "unknown";
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "amazonka-test" = callPackage
    ({ mkDerivation, 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
     }:
     mkDerivation {
       pname = "amazonka-test";
       version = "1.3.7";
       sha256 = "0d7410f8b76d9e1b8be76529868cf2267445219b3ca21499ae231d736a42f8d9";
       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
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Common functionality for Amazonka library test-suites";
       license = "unknown";
     }) {};

  "amazonka-waf" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-waf";
       version = "1.3.7";
       sha256 = "431d34671308da866b8f2738a88d84cf81c73fd5731decc5d94cd87159b012cb";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon WAF SDK";
       license = "unknown";
     }) {};

  "amazonka-workspaces_0_3_6" = callPackage
    ({ mkDerivation, amazonka-core, base }:
     mkDerivation {
       pname = "amazonka-workspaces";
       version = "0.3.6";
       sha256 = "93974eb065de3787313543981b5aa0d0bd9c7b1a3ca6b331ce90585794a894c3";
       libraryHaskellDepends = [ amazonka-core base ];
       jailbreak = true;
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon WorkSpaces SDK";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amazonka-workspaces" = callPackage
    ({ mkDerivation, amazonka-core, amazonka-test, base, bytestring
     , tasty, tasty-hunit, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "amazonka-workspaces";
       version = "1.3.7";
       sha256 = "52a3bc3c4a2f0f461042dfc54f8fc5f51e51ac62c8477acf4aa1e4ecc368b9c9";
       libraryHaskellDepends = [ amazonka-core base ];
       testHaskellDepends = [
         amazonka-core amazonka-test base bytestring tasty tasty-hunit text
         time unordered-containers
       ];
       homepage = "https://github.com/brendanhay/amazonka";
       description = "Amazon WorkSpaces SDK";
       license = "unknown";
     }) {};

  "ampersand" = callPackage
    ({ mkDerivation, base, bytestring, conduit, containers, csv
     , directory, filepath, graphviz, hashable, HStringTemplate, lens
     , MissingH, mtl, old-locale, old-time, pandoc, pandoc-types, parsec
     , process, QuickCheck, simple-sql-parser, split, SpreadsheetML
     , text, time, transformers, utf8-string, wl-pprint, xlsx, zlib
     }:
     mkDerivation {
       pname = "ampersand";
       version = "3.1.0";
       sha256 = "f52e3339321a5bac4539c4e5ab8cc91190499db43520bfdc2b63e8093df36744";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers csv directory filepath graphviz hashable
         HStringTemplate lens MissingH mtl old-locale old-time pandoc
         pandoc-types parsec process simple-sql-parser split SpreadsheetML
         text time utf8-string wl-pprint xlsx zlib
       ];
       testHaskellDepends = [
         base bytestring conduit containers directory filepath hashable lens
         MissingH mtl old-locale pandoc pandoc-types parsec QuickCheck
         simple-sql-parser text time transformers utf8-string wl-pprint xlsx
         zlib
       ];
       jailbreak = true;
       homepage = "http://wiki.tarski.nl";
       description = "Toolsuite for automated design of business processes";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amqp_0_10_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, clock, connection
     , containers, data-binary-ieee754, hspec, hspec-expectations
     , monad-control, network, network-uri, split, text, vector, xml
     }:
     mkDerivation {
       pname = "amqp";
       version = "0.10.1";
       sha256 = "acae29894f3b6849391661f38750c8d6ecf048de1b34f8c3f6a2c11fe0094da8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring clock connection containers
         data-binary-ieee754 monad-control network network-uri split text
         vector
       ];
       executableHaskellDepends = [ base containers xml ];
       testHaskellDepends = [
         base binary bytestring clock connection containers
         data-binary-ieee754 hspec hspec-expectations network split text
         vector
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/hreinhardt/amqp";
       description = "Client library for AMQP servers (currently only RabbitMQ)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amqp_0_12_2" = callPackage
    ({ mkDerivation, base, binary, bytestring, clock, connection
     , containers, data-binary-ieee754, hspec, hspec-expectations
     , monad-control, network, network-uri, split, text, vector, xml
     }:
     mkDerivation {
       pname = "amqp";
       version = "0.12.2";
       sha256 = "4fd91bca6d02cad36bf67b7e96c6a8cac1b5053c88719e53e009b6797b47d31e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring clock connection containers
         data-binary-ieee754 monad-control network network-uri split text
         vector
       ];
       executableHaskellDepends = [ base containers xml ];
       testHaskellDepends = [
         base binary bytestring clock connection containers
         data-binary-ieee754 hspec hspec-expectations network network-uri
         split text vector
       ];
       doCheck = false;
       homepage = "https://github.com/hreinhardt/amqp";
       description = "Client library for AMQP servers (currently only RabbitMQ)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amqp_0_12_3" = callPackage
    ({ mkDerivation, base, binary, bytestring, clock, connection
     , containers, data-binary-ieee754, hspec, hspec-expectations
     , monad-control, network, network-uri, split, text, vector, xml
     }:
     mkDerivation {
       pname = "amqp";
       version = "0.12.3";
       sha256 = "157da565f33b31c50d4e9f80fdba251265ca30ea604eae9f2f3bbfa18d857b9e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring clock connection containers
         data-binary-ieee754 monad-control network network-uri split text
         vector
       ];
       executableHaskellDepends = [ base containers xml ];
       testHaskellDepends = [
         base binary bytestring clock connection containers
         data-binary-ieee754 hspec hspec-expectations network network-uri
         split text vector
       ];
       doCheck = false;
       homepage = "https://github.com/hreinhardt/amqp";
       description = "Client library for AMQP servers (currently only RabbitMQ)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amqp_0_13_0" = callPackage
    ({ mkDerivation, base, binary, bytestring, clock, connection
     , containers, data-binary-ieee754, hspec, hspec-expectations
     , monad-control, network, network-uri, split, stm, text, vector
     , xml
     }:
     mkDerivation {
       pname = "amqp";
       version = "0.13.0";
       sha256 = "52da5e3ef6c20b0431968689c45e64ec328cf33dfb274d522cf8c78ea6b7d3e2";
       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 ];
       testHaskellDepends = [
         base binary bytestring clock connection containers
         data-binary-ieee754 hspec hspec-expectations network network-uri
         split stm text vector
       ];
       doCheck = false;
       homepage = "https://github.com/hreinhardt/amqp";
       description = "Client library for AMQP servers (currently only RabbitMQ)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "amqp" = callPackage
    ({ mkDerivation, base, binary, bytestring, clock, connection
     , containers, data-binary-ieee754, hspec, hspec-expectations
     , monad-control, network, network-uri, split, stm, text, vector
     , xml
     }:
     mkDerivation {
       pname = "amqp";
       version = "0.13.1";
       sha256 = "3ea6523228f1c2bf0622d52ebf73c9e3c2e2af637a7ea29908c07ff9fa0dd4ae";
       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 ];
       testHaskellDepends = [
         base binary bytestring clock connection containers
         data-binary-ieee754 hspec hspec-expectations network network-uri
         split stm text vector
       ];
       doCheck = false;
       homepage = "https://github.com/hreinhardt/amqp";
       description = "Client library for AMQP servers (currently only RabbitMQ)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "amqp-conduit" = callPackage
    ({ mkDerivation, amqp, base, bytestring, conduit, exceptions, hspec
     , HUnit, lifted-base, monad-control, mtl, resourcet, text
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "amqp-conduit";
       version = "0.2.0.0";
       sha256 = "cb2bf9a5752cf5b03b955a522403d1cb1a6554133a0b6fcf9f762d21aebf8ad6";
       libraryHaskellDepends = [
         amqp base conduit exceptions lifted-base monad-control mtl
         resourcet text transformers transformers-base
       ];
       testHaskellDepends = [
         amqp base bytestring conduit hspec HUnit resourcet transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/tatac1/amqp-conduit/";
       description = "Conduit bindings for AMQP (see amqp package)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "amrun" = callPackage
    ({ mkDerivation, base, deepseq, parsec }:
     mkDerivation {
       pname = "amrun";
       version = "0.0.0.5";
       sha256 = "1ff735e5138ca7c2cd5b3009f5163f48af427e9b8c076f273562672535fc0af8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base deepseq parsec ];
       description = "Interpreter for AM";
       license = "GPL";
     }) {};

  "analyze-client" = callPackage
    ({ mkDerivation, base, bytestring, http-conduit
     , MonadCatchIO-transformers, mtl, snap, snap-core, time
     }:
     mkDerivation {
       pname = "analyze-client";
       version = "0.1.0.2";
       sha256 = "5a6fa9bfcd6b40bb195eff29dfe67242072bc9c186f9f8927383216174cb9a89";
       libraryHaskellDepends = [
         base bytestring http-conduit MonadCatchIO-transformers mtl snap
         snap-core time
       ];
       homepage = "https://github.com/dbp/analyze-client";
       description = "Client for analyze service";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "anansi" = callPackage
    ({ mkDerivation, base, bytestring, containers, monads-tf, options
     , parsec, system-argv0, system-fileio, system-filepath, text
     }:
     mkDerivation {
       pname = "anansi";
       version = "0.4.8";
       sha256 = "aa08d4dcf76ad4d98d20fc2fd30df6fd02bc1ac07d7de01ce320e6ae92cff9bb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers monads-tf options parsec system-argv0
         system-fileio system-filepath text
       ];
       executableHaskellDepends = [
         base bytestring containers monads-tf options parsec system-argv0
         system-fileio system-filepath text
       ];
       homepage = "https://john-millikin.com/software/anansi/";
       description = "Simple literate programming preprocessor";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "anansi-hscolour" = callPackage
    ({ mkDerivation, anansi, base, bytestring, containers, hscolour
     , monads-tf, text
     }:
     mkDerivation {
       pname = "anansi-hscolour";
       version = "0.1.2";
       sha256 = "bcbbea9c098532e9b43bc83e4906879f427b4df44cd9ca4ca26a54a62821d339";
       libraryHaskellDepends = [
         anansi base bytestring containers hscolour monads-tf text
       ];
       homepage = "https://john-millikin.com/software/anansi/";
       description = "Colorized looms for Anansi";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "anansi-pandoc" = callPackage
    ({ mkDerivation, anansi, base, bytestring, containers, monads-tf
     , pandoc, text
     }:
     mkDerivation {
       pname = "anansi-pandoc";
       version = "0.1.3";
       sha256 = "b1dfde3b67cb7cc95f7c6c5bd82a915c4361e8d24e2565eedabcf2321638438f";
       libraryHaskellDepends = [
         anansi base bytestring containers monads-tf pandoc text
       ];
       jailbreak = true;
       homepage = "https://john-millikin.com/software/anansi/";
       description = "Looms which use Pandoc to parse and produce a variety of formats";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "anatomy" = callPackage
    ({ mkDerivation, atomo, base, blaze-html, bytestring, containers
     , directory, filepath, hashable, haskeline, highlighter, mtl
     , parsec, pretty, pretty-show, tagsoup, text, time, vector
     }:
     mkDerivation {
       pname = "anatomy";
       version = "0.4";
       sha256 = "241c64a8eb4bc2eadbbb1ad307078d9140013e2693f30d5c4f3daeff5d1fea77";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         atomo base blaze-html bytestring containers directory filepath
         hashable haskeline highlighter mtl parsec pretty pretty-show
         tagsoup text time vector
       ];
       executableHaskellDepends = [
         atomo base blaze-html bytestring containers directory filepath
         hashable haskeline highlighter mtl parsec pretty pretty-show
         tagsoup text time vector
       ];
       homepage = "http://atomo-lang.org/";
       description = "Anatomy: Atomo documentation system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "android" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "android";
       version = "0.0.2";
       sha256 = "85b112bebb356f4def496e61421651b9e81060af8cab107dbadaf075ae9ac0f2";
       libraryHaskellDepends = [ base process ];
       homepage = "https://github.com/keera-studios/android-haskell";
       description = "Android methods exposed to Haskell";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "android-lint-summary" = callPackage
    ({ mkDerivation, base, basic-prelude, data-default, directory
     , filemanip, hspec, hxt, lens, mtl, optparse-applicative
     , QuickCheck, rainbow, stringable, terminal-size, text
     }:
     mkDerivation {
       pname = "android-lint-summary";
       version = "0.2.1";
       sha256 = "a1bfbfddc1c16150a882388c51b6174fc17c7a804c26e49c5ecbc8e5baab62ea";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base basic-prelude data-default directory filemanip hxt lens mtl
         optparse-applicative rainbow stringable terminal-size text
       ];
       executableHaskellDepends = [
         base basic-prelude data-default directory filemanip mtl
         optparse-applicative rainbow stringable terminal-size text
       ];
       testHaskellDepends = [
         base basic-prelude directory hspec hxt QuickCheck stringable
       ];
       homepage = "https://github.com/passy/android-lint-summary";
       description = "A pretty printer for Android Lint errors";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "angel" = callPackage
    ({ mkDerivation, base, configurator, containers, mtl, old-locale
     , optparse-applicative, process, stm, tasty, tasty-hunit
     , tasty-quickcheck, text, time, transformers, unix
     , unordered-containers
     }:
     mkDerivation {
       pname = "angel";
       version = "0.6.2";
       sha256 = "caff0b06481dc3858b059e2faa12afdad66152c0341020dc53cceacf28e2e358";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base configurator containers mtl old-locale optparse-applicative
         process stm text time transformers unix unordered-containers
       ];
       testHaskellDepends = [
         base configurator containers mtl old-locale process stm tasty
         tasty-hunit tasty-quickcheck text time transformers unix
         unordered-containers
       ];
       doCheck = false;
       homepage = "http://github.com/MichaelXavier/Angel";
       description = "Process management and supervision daemon";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "animalcase" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "animalcase";
       version = "0.1.0.2";
       sha256 = "117b8a5021cab8d1ca9f968784d1d092418aa136a0ab7ff4a370239a7dd24b33";
       libraryHaskellDepends = [ base bytestring text ];
       homepage = "https://github.com/ibotty/animalcase";
       description = "Convert camelCase to snake_case and vice versa";
       license = stdenv.lib.licenses.mit;
     }) {};

  "annotated-wl-pprint_0_6_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "annotated-wl-pprint";
       version = "0.6.0";
       sha256 = "3d29f11396fb0675fff25254a9f4354aa763a659fa10a48829d15fed087792e7";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/david-christiansen/annotated-wl-pprint";
       description = "The Wadler/Leijen Pretty Printer, with annotation support";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "annotated-wl-pprint" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "annotated-wl-pprint";
       version = "0.7.0";
       sha256 = "0c262d7fe13a9a50216438ec882c13e25f31236b886a5692e3c35b85cd773d18";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/david-christiansen/annotated-wl-pprint";
       description = "The Wadler/Leijen Pretty Printer, with annotation support";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "anonymous-sums" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "anonymous-sums";
       version = "0.4.0.0";
       sha256 = "116626dd139f7ba57b66d790915ff21cdf09f267da16f873f396ae76aad16749";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       homepage = "http://www.github.com/massysett/anonymous-sums";
       description = "Anonymous sum types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "anonymous-sums-tests" = callPackage
    ({ mkDerivation, anonymous-sums, base, QuickCheck }:
     mkDerivation {
       pname = "anonymous-sums-tests";
       version = "0.4.0.0";
       sha256 = "0bc000e28170968316920d342b08af5fab81eaa19ce4ef5fa216d9df473bee28";
       libraryHaskellDepends = [ anonymous-sums base QuickCheck ];
       homepage = "http://www.github.com/massysett/anonymous-sums";
       description = "QuickCheck functions to accompany the anonymous-sums package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ansi-pretty" = callPackage
    ({ mkDerivation, aeson, ansi-wl-pprint, array, base, bytestring
     , containers, generics-sop, nats, scientific, semigroups, tagged
     , text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "ansi-pretty";
       version = "0.1.1.0";
       sha256 = "46190d94e4fc2aa01c8bc4dfc1caf59fe38a0ed4a0c22d4d0567637d64b5ff45";
       libraryHaskellDepends = [
         aeson ansi-wl-pprint array base bytestring containers generics-sop
         nats scientific semigroups tagged text time unordered-containers
         vector
       ];
       homepage = "https://github.com/futurice/haskell-ansi-pretty#readme";
       description = "AnsiPretty for ansi-wl-pprint";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ansi-terminal_0_6_2_1" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "ansi-terminal";
       version = "0.6.2.1";
       sha256 = "965a38671ddd195b243af9d0284faedb52b852eace5f7cced11e6fcf2e47b7f6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base unix ];
       executableHaskellDepends = [ base unix ];
       homepage = "https://github.com/feuerbach/ansi-terminal";
       description = "Simple ANSI terminal support, with Windows compatibility";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ansi-terminal_0_6_2_2" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "ansi-terminal";
       version = "0.6.2.2";
       sha256 = "da082cfcbd7f65b808adea6c9915ad58643b8a22c7bcd21d3dbaf091828dd4bf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base unix ];
       executableHaskellDepends = [ base unix ];
       homepage = "https://github.com/feuerbach/ansi-terminal";
       description = "Simple ANSI terminal support, with Windows compatibility";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ansi-terminal" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "ansi-terminal";
       version = "0.6.2.3";
       sha256 = "4dc02cb53e9ca7c8800bbdfc0337b961e5a945382cd09a6a40c6170126e0ee42";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base unix ];
       executableHaskellDepends = [ base unix ];
       homepage = "https://github.com/feuerbach/ansi-terminal";
       description = "Simple ANSI terminal support, with Windows compatibility";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ansi-wl-pprint_0_6_7_1" = callPackage
    ({ mkDerivation, ansi-terminal, base }:
     mkDerivation {
       pname = "ansi-wl-pprint";
       version = "0.6.7.1";
       sha256 = "d980c265cacf6d6aa37a24d056e730b678680e07d3ab87210affb415de0ac1af";
       revision = "1";
       editedCabalFile = "3ab6d9878470a4f5ec495d6aea47396172d162518aa37abf8e50fe58d6323715";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ ansi-terminal base ];
       executableHaskellDepends = [ ansi-terminal base ];
       jailbreak = true;
       homepage = "http://github.com/batterseapower/ansi-wl-pprint";
       description = "The Wadler/Leijen Pretty Printer for colored ANSI terminal output";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ansi-wl-pprint_0_6_7_2" = callPackage
    ({ mkDerivation, ansi-terminal, base }:
     mkDerivation {
       pname = "ansi-wl-pprint";
       version = "0.6.7.2";
       sha256 = "015ec4414242089fff5d6d567b392b6bb4fa5f85afff7f0708566082e1d91774";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ ansi-terminal base ];
       executableHaskellDepends = [ ansi-terminal base ];
       homepage = "http://github.com/batterseapower/ansi-wl-pprint";
       description = "The Wadler/Leijen Pretty Printer for colored ANSI terminal output";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ansi-wl-pprint" = callPackage
    ({ mkDerivation, ansi-terminal, base }:
     mkDerivation {
       pname = "ansi-wl-pprint";
       version = "0.6.7.3";
       sha256 = "3789ecaa89721eabef58ddc5711f7fd1ff67e262da1659f3b20d38a9e1f5b708";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ ansi-terminal base ];
       executableHaskellDepends = [ ansi-terminal base ];
       homepage = "http://github.com/ekmett/ansi-wl-pprint";
       description = "The Wadler/Leijen Pretty Printer for colored ANSI terminal output";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ansigraph" = callPackage
    ({ mkDerivation, ansi-terminal, base }:
     mkDerivation {
       pname = "ansigraph";
       version = "0.1.0.0";
       sha256 = "ba653a0c6fe36488714fce8a77e553b1c3cadbcbd5e6c6fe53449f25bdae8a40";
       libraryHaskellDepends = [ ansi-terminal base ];
       homepage = "https://github.com/BlackBrane/ansigraph";
       description = "Terminal-based graphing via ANSI and Unicode";
       license = stdenv.lib.licenses.mit;
     }) {};

  "antagonist" = callPackage
    ({ mkDerivation, antisplice, base, chatty, chatty-utils, ironforge
     , mtl, shakespeare, text, time, time-locale-compat, yesod
     , yesod-auth
     }:
     mkDerivation {
       pname = "antagonist";
       version = "0.1.0.29";
       sha256 = "e91e99d72c990663a2e58ebdf9f397bb9963a6a58dbb0470abb31072809579b6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         antisplice base chatty chatty-utils mtl shakespeare text time
         time-locale-compat yesod yesod-auth
       ];
       executableHaskellDepends = [
         antisplice base chatty chatty-utils ironforge mtl shakespeare text
         time time-locale-compat yesod yesod-auth
       ];
       homepage = "http://doomanddarkness.eu/pub/antisplice";
       description = "A web interface to Antisplice dungeons";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "antfarm" = callPackage
    ({ mkDerivation, base, containers, HUnit, minimorph, mtl, parsec
     , test-framework, test-framework-hunit, text, transformers
     }:
     mkDerivation {
       pname = "antfarm";
       version = "0.1.0.0";
       sha256 = "4dc7c0e40f1678f2dd3120c209dd8bfdcaabc58b673882c12fd802b54f7354e8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers minimorph mtl parsec text transformers
       ];
       executableHaskellDepends = [ base containers minimorph mtl text ];
       testHaskellDepends = [
         base HUnit minimorph test-framework test-framework-hunit text
         transformers
       ];
       homepage = "http://hub.darcs.net/kowey/antfarm";
       description = "Referring expressions for definitions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "anticiv" = callPackage
    ({ mkDerivation, antisplice, base, chatty, chatty-text
     , chatty-utils, ctpl, directory, ironforge, mtl, network, plugins
     , time, transformers
     }:
     mkDerivation {
       pname = "anticiv";
       version = "0.1.0.5";
       sha256 = "f03bbab75225647bbd53462bbaa9114e4994b07b59d7e3a85d4f3deaa750bd6b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         antisplice base chatty chatty-text chatty-utils ctpl ironforge mtl
         network plugins time transformers
       ];
       executableHaskellDepends = [
         antisplice base chatty chatty-text chatty-utils ctpl directory
         ironforge mtl network plugins time transformers
       ];
       jailbreak = true;
       description = "This is an IRC bot for Mafia and Resistance";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "antigate" = callPackage
    ({ mkDerivation, base, bytestring, data-default, deepseq
     , exceptions, failure, http-client, http-conduit, resourcet, safe
     , text, transformers
     }:
     mkDerivation {
       pname = "antigate";
       version = "2.0.1";
       sha256 = "69047d6143571082d63cd9b59cf42b63203be56674707bb17f767e812771a26d";
       libraryHaskellDepends = [
         base bytestring data-default deepseq exceptions failure http-client
         http-conduit resourcet safe text transformers
       ];
       homepage = "https://github.com/exbb2/antigate";
       description = "Interface for antigate.com captcha recognition API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "antimirov" = callPackage
    ({ mkDerivation, base, containers, QuickCheck }:
     mkDerivation {
       pname = "antimirov";
       version = "0.1.0";
       sha256 = "38a628a36affb43a949815591b252ff023348ddcda40da3614a064c1a12b5e29";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers QuickCheck ];
       executableHaskellDepends = [ base containers QuickCheck ];
       description = "Define the language containment (=subtyping) relation on regulare expressions";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "antiquoter" = callPackage
    ({ mkDerivation, base, syb, template-haskell }:
     mkDerivation {
       pname = "antiquoter";
       version = "0.1.1.0";
       sha256 = "3ec665651a974b5574de44a2e3ae479a2d8ccb73ee64e364b0eb7c755a8c65e3";
       libraryHaskellDepends = [ base syb template-haskell ];
       description = "Combinator library for quasi- and anti-quoting";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "antisplice" = callPackage
    ({ mkDerivation, base, chatty, chatty-utils, haskeline, mtl
     , template-haskell, text, time, transformers
     }:
     mkDerivation {
       pname = "antisplice";
       version = "0.17.1.0";
       sha256 = "de325d8b473db1eec25c630f07266fbd6262cb6452252f0bed02065e9f3888b8";
       libraryHaskellDepends = [
         base chatty chatty-utils haskeline mtl template-haskell text time
         transformers
       ];
       homepage = "http://doomanddarkness.eu/pub/antisplice";
       description = "An engine for text-based dungeons";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "antlrc" = callPackage
    ({ mkDerivation, antlr3c, base, bytestring, c2hs, enumerator
     , haskell98, regex-posix
     }:
     mkDerivation {
       pname = "antlrc";
       version = "0.0.2";
       sha256 = "ed213e6b5c5963157c02d0bbdaad14c7c4acbd21b4da37de96314863371353c2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base haskell98 ];
       librarySystemDepends = [ antlr3c ];
       libraryToolDepends = [ c2hs ];
       executableHaskellDepends = [
         base bytestring enumerator haskell98 regex-posix
       ];
       homepage = "https://github.com/markwright/antlrc";
       description = "Haskell binding to the ANTLR parser generator C runtime library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {antlr3c = null;};

  "anydbm" = callPackage
    ({ mkDerivation, base, containers, MissingH, mtl }:
     mkDerivation {
       pname = "anydbm";
       version = "1.0.7";
       sha256 = "d33410fc5fad79bd5a5bcc24248f6e5a7a3133ede5111c31a8c58068b219b3e7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers MissingH mtl ];
       executableHaskellDepends = [ base containers MissingH mtl ];
       homepage = "http://software.complete.org/anydbm";
       description = "Interface for DBM-like database systems";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aosd" = callPackage
    ({ mkDerivation, base, bindings-DSL, cairo, colour
     , language-haskell-extract, libaosd, monad-control, pango
     , template-haskell, transformers, X11
     }:
     mkDerivation {
       pname = "aosd";
       version = "0.2.1";
       sha256 = "06eea06ed5dd81649b97d27643cde2831e61f9ffde7d326f62c8622baf1faa7e";
       libraryHaskellDepends = [
         base bindings-DSL cairo colour monad-control pango transformers X11
       ];
       libraryPkgconfigDepends = [ libaosd ];
       testHaskellDepends = [
         base colour language-haskell-extract pango template-haskell
       ];
       description = "Bindings to libaosd, a library for Cairo-based on-screen displays";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {libaosd = null;};

  "ap-reflect" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ap-reflect";
       version = "0.2";
       sha256 = "42087f76e791ecc541b1156e967517ab078468978b878ce535691b21938d00c6";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/cmc-msu-ai/ap-reflect";
       description = "Partial evaluation reflection a la simple-reflect";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "apache-md5" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, MonadRandom, openssl
     , process, random, test-framework, test-framework-hunit
     , transformers
     }:
     mkDerivation {
       pname = "apache-md5";
       version = "0.6.1.4";
       sha256 = "c84f882f6aca7b72d89ee662d358f40fe89ab3267ec418f3bee24a0d80b096b7";
       revision = "2";
       editedCabalFile = "e41d43eba938331a51fb0ead7cd004c6f539820c06aed48a77eb67e04eee39f2";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ openssl ];
       testHaskellDepends = [
         base bytestring HUnit MonadRandom process random test-framework
         test-framework-hunit transformers
       ];
       testSystemDepends = [ openssl ];
       homepage = "https://github.com/trskop/apache-md5";
       description = "Apache specific MD5 digest algorighm";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) openssl;};

  "apelsin" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , directory, filepath, glib, gtk, HTTP, mtl, network, process
     , transformers, tremulous-query, xdg-basedir
     }:
     mkDerivation {
       pname = "apelsin";
       version = "1.2.3";
       sha256 = "54a4544b4e88766dabdc7e2d88ea14731f686158793b798b7d5bfa06ee214721";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring containers deepseq directory filepath glib
         gtk HTTP mtl network process transformers tremulous-query
         xdg-basedir
       ];
       homepage = "http://ojeling.net/apelsin";
       description = "Server and community browser for the game Tremulous";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "api-builder" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal
     , containers, hspec, HTTP, http-client, http-client-tls, http-types
     , text, transformers
     }:
     mkDerivation {
       pname = "api-builder";
       version = "0.11.0.0";
       sha256 = "d8df94d14ffa9f0e60c88cf75eb221281c89251af67ac0a2068b3f774a0916c7";
       libraryHaskellDepends = [
         aeson base bifunctors bytestring HTTP http-client http-client-tls
         http-types text transformers
       ];
       testHaskellDepends = [
         aeson base bytestring Cabal containers hspec http-client text
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/intolerable/api-builder";
       description = "Library for easily building REST API wrappers in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "api-opentheory-unicode" = callPackage
    ({ mkDerivation, base, bytestring, directory, opentheory-unicode }:
     mkDerivation {
       pname = "api-opentheory-unicode";
       version = "1.2";
       sha256 = "08558a637339b4d291ee499ccd37a05969f372966fcc7cd740b933de569eebd7";
       libraryHaskellDepends = [ base bytestring opentheory-unicode ];
       testHaskellDepends = [
         base bytestring directory opentheory-unicode
       ];
       description = "OpenTheory unicode character API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "api-tools" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, alex, array, attoparsec, base
     , base64-bytestring, bytestring, Cabal, case-insensitive
     , containers, deepseq, happy, lens, old-locale, QuickCheck
     , regex-compat-tdfa, safe, safecopy, tasty, tasty-hunit
     , tasty-quickcheck, template-haskell, text, time
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "api-tools";
       version = "0.5.2";
       sha256 = "86f742435d8dae3ffea3f6085c6f94342f25eafc00be1c985d3a0212a39aa25d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty array attoparsec base base64-bytestring
         bytestring Cabal case-insensitive containers deepseq lens
         old-locale QuickCheck regex-compat-tdfa safe safecopy
         template-haskell text time unordered-containers vector
       ];
       libraryToolDepends = [ alex happy ];
       executableHaskellDepends = [
         aeson aeson-pretty array attoparsec base base64-bytestring
         bytestring case-insensitive containers lens old-locale QuickCheck
         regex-compat-tdfa safe safecopy template-haskell text time
         unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-pretty array attoparsec base base64-bytestring
         bytestring Cabal case-insensitive containers lens old-locale
         QuickCheck regex-compat-tdfa safe safecopy tasty tasty-hunit
         tasty-quickcheck template-haskell text time unordered-containers
         vector
       ];
       jailbreak = true;
       homepage = "http://github.com/iconnect/api-tools";
       description = "DSL for generating API boilerplate and docs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "apiary_1_4_3" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, blaze-markup
     , bytestring, bytestring-read, case-insensitive, data-default-class
     , exceptions, hashable, http-date, http-types, HUnit, mime-types
     , monad-control, mtl, process, stringsearch, tasty, tasty-hunit
     , tasty-quickcheck, template-haskell, text, time, transformers
     , transformers-base, types-compat, unix-compat
     , unordered-containers, vault, wai, wai-extra, web-routing
     }:
     mkDerivation {
       pname = "apiary";
       version = "1.4.3";
       sha256 = "4cb377f5f081c80a5d11ffe09daad890528ed3f5e67b59265f9acc61677bcefc";
       revision = "2";
       editedCabalFile = "7627c6f119ddb3d762f2baf62d0c18cc25befd8037762cbec9290e36b03504ad";
       libraryHaskellDepends = [
         base blaze-builder blaze-html blaze-markup bytestring
         bytestring-read case-insensitive data-default-class exceptions
         hashable http-date http-types mime-types monad-control mtl process
         stringsearch template-haskell text time transformers
         transformers-base types-compat unix-compat unordered-containers
         vault wai web-routing
       ];
       testHaskellDepends = [
         base bytestring http-types HUnit mtl tasty tasty-hunit
         tasty-quickcheck wai wai-extra
       ];
       jailbreak = true;
       homepage = "https://github.com/philopon/apiary";
       description = "Simple and type safe web framework that generate web API documentation";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "apiary" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, blaze-markup
     , bytestring, bytestring-read, case-insensitive, data-default-class
     , exceptions, hashable, http-date, http-types, HUnit, mime-types
     , monad-control, mtl, process, stringsearch, tasty, tasty-hunit
     , tasty-quickcheck, template-haskell, text, time, transformers
     , transformers-base, types-compat, unix-compat
     , unordered-containers, vault, wai, wai-extra, web-routing
     }:
     mkDerivation {
       pname = "apiary";
       version = "1.4.5";
       sha256 = "6c6f898924b6209f33ef81bc0e2c7ceb166fc04825a8ffb4d6c5732f41429313";
       revision = "3";
       editedCabalFile = "f33e4f880c07f8f174844ce36e701e62dbad0f0feb4f908d30bd76d3d2309f2a";
       libraryHaskellDepends = [
         base blaze-builder blaze-html blaze-markup bytestring
         bytestring-read case-insensitive data-default-class exceptions
         hashable http-date http-types mime-types monad-control mtl process
         stringsearch template-haskell text time transformers
         transformers-base types-compat unix-compat unordered-containers
         vault wai wai-extra web-routing
       ];
       testHaskellDepends = [
         base bytestring http-types HUnit mtl tasty tasty-hunit
         tasty-quickcheck wai wai-extra
       ];
       homepage = "https://github.com/philopon/apiary";
       description = "Simple and type safe web framework that generate web API documentation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "apiary-authenticate" = callPackage
    ({ mkDerivation, apiary, apiary-session, authenticate, base
     , blaze-builder, bytestring, cereal, data-default-class
     , http-client, http-client-tls, http-types, monad-control
     , resourcet, text, types-compat, wai, web-routing
     }:
     mkDerivation {
       pname = "apiary-authenticate";
       version = "1.4.0";
       sha256 = "40dbdb0d6799ba7091ae9b72929c7d62a74dd251b5a6e01f8979314d75dbd107";
       revision = "4";
       editedCabalFile = "5888af016171726e81bde323d1cd9044a24b70930c1fe5946ac0336a0f23f193";
       libraryHaskellDepends = [
         apiary apiary-session authenticate base blaze-builder bytestring
         cereal data-default-class http-client http-client-tls http-types
         monad-control resourcet text types-compat wai web-routing
       ];
       homepage = "https://github.com/philopon/apiary";
       description = "authenticate support for apiary web framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "apiary-clientsession" = callPackage
    ({ mkDerivation, apiary, apiary-cookie, apiary-session, base
     , bytestring, cereal, clientsession, data-default-class, time
     , unix-compat, vault
     }:
     mkDerivation {
       pname = "apiary-clientsession";
       version = "1.4.0";
       sha256 = "a6bba1337d2ee7ded7303f2801b09b9d93cdafb93f5115328c797bef3e6126fd";
       revision = "2";
       editedCabalFile = "b3780175a0912ef55de02d916822dbe38b98acec5705a63f808517cda16ab90c";
       libraryHaskellDepends = [
         apiary apiary-cookie apiary-session base bytestring cereal
         clientsession data-default-class time unix-compat vault
       ];
       homepage = "https://github.com/philopon/apiary";
       description = "clientsession support for apiary web framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "apiary-cookie" = callPackage
    ({ mkDerivation, apiary, base, blaze-builder, blaze-html
     , bytestring, cookie, time, types-compat, wai, web-routing
     }:
     mkDerivation {
       pname = "apiary-cookie";
       version = "1.4.0";
       sha256 = "3dcf4cf38377685340ec5c6ab105a0df3ba2b0a4d0d7079fc88593bd15eeeb04";
       revision = "3";
       editedCabalFile = "5b9c1a2c95bbedcb6b12196953ce1ebbe8e7c825fbb8ae5e0ddb4c846d3a752b";
       libraryHaskellDepends = [
         apiary base blaze-builder blaze-html bytestring cookie time
         types-compat wai web-routing
       ];
       homepage = "https://github.com/philopon/apiary";
       description = "Cookie support for apiary web framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "apiary-eventsource" = callPackage
    ({ mkDerivation, apiary, base, blaze-builder, wai-extra }:
     mkDerivation {
       pname = "apiary-eventsource";
       version = "1.4.0";
       sha256 = "a7c9f566fea8501864ac194d744dfe94c0ee04d174ccb51161c4a64243bd0176";
       revision = "1";
       editedCabalFile = "368e1b555b07ff026b4753cab0364d0f70a4e2536166f756bde35f8ce9fb9ae6";
       libraryHaskellDepends = [ apiary base blaze-builder wai-extra ];
       homepage = "https://github.com/philopon/apiary";
       description = "eventsource support for apiary web framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "apiary-helics" = callPackage
    ({ mkDerivation, apiary, base, bytestring, data-default-class
     , helics, helics-wai, monad-control, text, transformers
     , types-compat, vault, wai
     }:
     mkDerivation {
       pname = "apiary-helics";
       version = "1.4.0";
       sha256 = "0a4dc7d59aa5cc626922d10e61bfad4fd56628c48701919d51b239f5a175a9e2";
       revision = "1";
       editedCabalFile = "80ce4b1a9dd5c7a30099392219d0077b9281b9ceeabbb01843f12754df0b0827";
       libraryHaskellDepends = [
         apiary base bytestring data-default-class helics helics-wai
         monad-control text transformers types-compat vault wai
       ];
       jailbreak = true;
       homepage = "https://github.com/philopon/apiary";
       description = "helics support for apiary web framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "apiary-logger" = callPackage
    ({ mkDerivation, apiary, base, data-default-class, fast-logger
     , lifted-base, monad-control, monad-logger, transformers
     , transformers-base, types-compat
     }:
     mkDerivation {
       pname = "apiary-logger";
       version = "1.4.0";
       sha256 = "884cf856a25685db351f76ab2df43126456cfe4c1a8640b72ac055623518c05d";
       revision = "3";
       editedCabalFile = "03f6b1ac0e588631c2deed8459e527f935a74a86c15455c3f509270ba5bbd5f7";
       libraryHaskellDepends = [
         apiary base data-default-class fast-logger lifted-base
         monad-control monad-logger transformers transformers-base
         types-compat
       ];
       homepage = "https://github.com/philopon/apiary";
       description = "fast-logger support for apiary web framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "apiary-memcached" = callPackage
    ({ mkDerivation, apiary, base, bytestring, data-default-class
     , memcached-binary, monad-control, text, transformers, types-compat
     }:
     mkDerivation {
       pname = "apiary-memcached";
       version = "1.4.0";
       sha256 = "7e3d225c9ac983d798b88a1e8ebc0221852174d0f0765daa8e9e20e6d79193e7";
       revision = "1";
       editedCabalFile = "7a332392add31b3f5ef9fcc2e69069de3a23bdbfdcfeececc47d2832ec767c29";
       libraryHaskellDepends = [
         apiary base bytestring data-default-class memcached-binary
         monad-control text transformers types-compat
       ];
       homepage = "https://github.com/philopon/apiary";
       description = "memcached client for apiary web framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "apiary-mongoDB" = callPackage
    ({ mkDerivation, apiary, base, bson, data-default-class
     , lifted-base, monad-control, mongoDB, resource-pool, text, time
     , transformers, types-compat
     }:
     mkDerivation {
       pname = "apiary-mongoDB";
       version = "1.4.0";
       sha256 = "8d97a32e5d55334d1a4f5d318d6a590a74c0b8ad6c84877956728318b89f36eb";
       revision = "1";
       editedCabalFile = "e2578f19108129ed47946fa7369c86203610d5b447a6a7a8f1af5f2537d55a4b";
       libraryHaskellDepends = [
         apiary base bson data-default-class lifted-base monad-control
         mongoDB resource-pool text time transformers types-compat
       ];
       homepage = "https://github.com/philopon/apiary";
       description = "mongoDB support for apiary web framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "apiary-persistent" = callPackage
    ({ mkDerivation, apiary, apiary-logger, base, monad-control
     , monad-logger, persistent, resource-pool, resourcet, transformers
     , transformers-base, types-compat, web-routing
     }:
     mkDerivation {
       pname = "apiary-persistent";
       version = "1.4.0";
       sha256 = "09c6c5730d6ad65b544e994f2d73f5412aae92aac093fd308234c8bea68f4a02";
       revision = "2";
       editedCabalFile = "7f1c18de1d41b15397df81d9a3377e109cc07f6efc07390584e0e2952d34e889";
       libraryHaskellDepends = [
         apiary apiary-logger base monad-control monad-logger persistent
         resource-pool resourcet transformers transformers-base types-compat
         web-routing
       ];
       homepage = "https://github.com/philopon/apiary";
       description = "persistent support for apiary web framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "apiary-purescript" = callPackage
    ({ mkDerivation, apiary, base, bytestring, data-default-class
     , filepath, Glob, parsec, purescript, text, transformers
     , types-compat, unordered-containers
     }:
     mkDerivation {
       pname = "apiary-purescript";
       version = "1.4.0";
       sha256 = "5f0e15fb72ae61b44349488bb945c1cd9d63b54986c73bbbd9cb207531172d7c";
       revision = "1";
       editedCabalFile = "9f716a5d9173c31c6472a4bf7decc34523bdc761540d440f5d0ad4f9521bf98c";
       libraryHaskellDepends = [
         apiary base bytestring data-default-class filepath Glob parsec
         purescript text transformers types-compat unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/philopon/apiary";
       description = "purescript compiler for apiary web framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "apiary-session" = callPackage
    ({ mkDerivation, apiary, base, types-compat, wai, web-routing }:
     mkDerivation {
       pname = "apiary-session";
       version = "1.4.0";
       sha256 = "434cd8b985a95bd4c72dde7ac521768d1c1402f3cc8b4835dded6736bdbcd74a";
       revision = "2";
       editedCabalFile = "777f476e799ceaa21a20e42c6382baec92644fc898e11aea09dcfa96a5e90034";
       libraryHaskellDepends = [
         apiary base types-compat wai web-routing
       ];
       homepage = "https://github.com/philopon/apiary";
       description = "session support for apiary web framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "apiary-websockets" = callPackage
    ({ mkDerivation, apiary, base, wai-websockets, web-routing
     , websockets
     }:
     mkDerivation {
       pname = "apiary-websockets";
       version = "1.4.0";
       sha256 = "e15e7e9281b72d9fa2419c1d3dbbf0c11e08dc139fe0d0242a5612a181ff545b";
       revision = "1";
       editedCabalFile = "5162825445fc14b48d11a0a1f63d67e8d66a8c5aaeaf1e117a1f2302474d7581";
       libraryHaskellDepends = [
         apiary base wai-websockets web-routing websockets
       ];
       homepage = "https://github.com/philopon/apiary";
       description = "websockets support for apiary web framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "apis" = callPackage
    ({ mkDerivation, aeson, base, containers, deepseq, directory
     , ecma262, exceptions, filemanip, filepath, hslogger, hxt, mtl
     , opendatatable, split, template-haskell, text, th-lift, time
     , transformers, unordered-containers, utf8-string, yql
     }:
     mkDerivation {
       pname = "apis";
       version = "0.0.1";
       sha256 = "f8988b196e83e1bfc445f05cb3a860ed54bcabce3ecd44094d1347a757e85b1e";
       libraryHaskellDepends = [
         aeson base containers deepseq directory ecma262 exceptions
         filemanip filepath hslogger hxt mtl opendatatable split
         template-haskell text th-lift time transformers
         unordered-containers utf8-string yql
       ];
       jailbreak = true;
       homepage = "https://github.com/fabianbergmark/APIs";
       description = "A Template Haskell library for generating type safe API calls";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "apotiki" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, binary, bytestring
     , containers, crypto-api, cryptohash, directory, http-types
     , old-time, openpgp, openpgp-asciiarmor, openpgp-crypto-api, scotty
     , strict, tar, text, transformers, wai-extra, wai-middleware-static
     , zlib
     }:
     mkDerivation {
       pname = "apotiki";
       version = "0.5.2";
       sha256 = "e73a4d8fd2175715e0391715a3fb5a3c0ee5b188587c3a5c93baf8a9150d30e6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base binary bytestring containers crypto-api
         cryptohash directory http-types old-time openpgp openpgp-asciiarmor
         openpgp-crypto-api scotty strict tar text transformers wai-extra
         wai-middleware-static zlib
       ];
       executableHaskellDepends = [
         aeson attoparsec base binary bytestring containers crypto-api
         cryptohash directory http-types old-time openpgp openpgp-asciiarmor
         openpgp-crypto-api scotty strict tar text transformers wai-extra
         wai-middleware-static zlib
       ];
       jailbreak = true;
       homepage = "https://github.com/pyr/apotiki";
       description = "a faster debian repository";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "app-lens" = callPackage
    ({ mkDerivation, base, containers, lens, mtl }:
     mkDerivation {
       pname = "app-lens";
       version = "0.1.0.1";
       sha256 = "717cb2d1abc9add860d6e058b2da8ba45a124f8a637b4ab5984a89a42d485627";
       libraryHaskellDepends = [ base containers lens mtl ];
       jailbreak = true;
       homepage = "https://bitbucket.org/kztk/app-lens";
       description = "applicative (functional) bidirectional programming beyond composition chains";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "app-settings" = callPackage
    ({ mkDerivation, base, containers, directory, hspec, HUnit, mtl
     , parsec, text
     }:
     mkDerivation {
       pname = "app-settings";
       version = "0.2.0.7";
       sha256 = "bd6a675de64863a61459670cb8469c629273d3d43b515b6f7e34cc146a07f9f8";
       libraryHaskellDepends = [
         base containers directory mtl parsec text
       ];
       testHaskellDepends = [
         base containers directory hspec HUnit mtl parsec text
       ];
       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 }:
     mkDerivation {
       pname = "appar";
       version = "0.1.4";
       sha256 = "58ea66abe4dd502d2fc01eecdb0828d5e214704a3c1b33b1f8b33974644c4b26";
       libraryHaskellDepends = [ base bytestring ];
       description = "A simple applicative parser";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "appc" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, hspec
     , hspec-smallcheck, optparse-applicative, semver, smallcheck, text
     , uuid
     }:
     mkDerivation {
       pname = "appc";
       version = "0.0.6";
       sha256 = "ba4a9a1cc478b98eb8d6498535f903cbc66e708a6cba6d7abb59ea74e53cda62";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers semver text uuid
       ];
       executableHaskellDepends = [
         aeson base bytestring containers optparse-applicative semver text
         uuid
       ];
       testHaskellDepends = [
         aeson base hspec hspec-smallcheck semver smallcheck text uuid
       ];
       description = "app container types and tools";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "applicative-extras" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "applicative-extras";
       version = "0.1.8";
       sha256 = "285fa07fedb7c53fe0f9e2e72ba1e85fe8cac66f04b6f0f4b426a0b52b727aeb";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/chriseidhof/applicative-extras/";
       description = "Instances for Applicative";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "applicative-fail" = callPackage
    ({ mkDerivation, base, bifunctors, checkers, dlist, mtl, QuickCheck
     , tasty, tasty-quickcheck, transformers, transformers-base
     }:
     mkDerivation {
       pname = "applicative-fail";
       version = "1.1.1";
       sha256 = "81009f9845d4eacfcbaad4a3214036b7a2dfa703687d6bfacb48fbf6b7067385";
       libraryHaskellDepends = [
         base bifunctors dlist mtl transformers transformers-base
       ];
       testHaskellDepends = [
         base checkers mtl QuickCheck tasty tasty-quickcheck
       ];
       homepage = "https://bitbucket.org/s9gf4ult/applicative-fail";
       description = "Applicative functor and monad which collects all your fails";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "applicative-numbers" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "applicative-numbers";
       version = "0.1.3";
       sha256 = "80abc54b03853dbdcc10a53ae19f9938381f42727037092226ea59f3fda1d266";
       libraryHaskellDepends = [ base ];
       homepage = "http://haskell.org/haskellwiki/applicative-numbers";
       description = "Applicative-based numeric instances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "applicative-parsec" = callPackage
    ({ mkDerivation, base, containers, lens, mtl, QuickCheck
     , test-framework, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "applicative-parsec";
       version = "0.1.0.0";
       sha256 = "3d67780128bd15d5cd0a03745f632e9c05b6a95564baa44466f262756992c28b";
       libraryHaskellDepends = [ base containers lens mtl text ];
       testHaskellDepends = [
         base mtl QuickCheck test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://www.github.com/ktvoelker/AParsec";
       description = "An applicative parser combinator library";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "applicative-quoters" = callPackage
    ({ mkDerivation, base, haskell-src-meta, template-haskell }:
     mkDerivation {
       pname = "applicative-quoters";
       version = "0.1.0.8";
       sha256 = "f45d567b408bacb17ef567857affb5cdf69299dd5b57fd559370a291404ba282";
       libraryHaskellDepends = [ base haskell-src-meta template-haskell ];
       description = "Quasiquoters for idiom brackets and an applicative do-notation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "apply-refact_0_1_0_0" = callPackage
    ({ mkDerivation, base, containers, directory, filemanip, filepath
     , ghc, ghc-exactprint, mtl, optparse-applicative, process, refact
     , silently, syb, tasty, tasty-expected-failure, tasty-golden
     , temporary-rc, transformers, unix-compat
     }:
     mkDerivation {
       pname = "apply-refact";
       version = "0.1.0.0";
       sha256 = "0eb90d46b7b12981a2bd8c872d9f54185010aa400ff8bc657ede7e5a495c64d9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory ghc ghc-exactprint mtl process refact syb
       ];
       executableHaskellDepends = [
         base containers directory filemanip filepath ghc ghc-exactprint mtl
         optparse-applicative process refact syb temporary-rc transformers
         unix-compat
       ];
       testHaskellDepends = [
         base containers directory filemanip filepath ghc ghc-exactprint mtl
         optparse-applicative process refact silently syb tasty
         tasty-expected-failure tasty-golden temporary-rc transformers
         unix-compat
       ];
       description = "Perform refactorings specified by the refact library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "apply-refact" = callPackage
    ({ mkDerivation, base, containers, directory, filemanip, filepath
     , ghc, ghc-exactprint, mtl, optparse-applicative, process, refact
     , silently, syb, tasty, tasty-expected-failure, tasty-golden
     , temporary, transformers, unix-compat
     }:
     mkDerivation {
       pname = "apply-refact";
       version = "0.2.0.0";
       sha256 = "f74abeae9f6ad6e3ab5b00b108e99c4351ff26f691f5a0c1d3662b2b18648d5c";
       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
       ];
       testHaskellDepends = [
         base containers directory filemanip filepath ghc ghc-exactprint mtl
         optparse-applicative process refact silently syb tasty
         tasty-expected-failure tasty-golden temporary transformers
         unix-compat
       ];
       description = "Perform refactorings specified by the refact library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "apportionment" = callPackage
    ({ mkDerivation, base, containers, utility-ht }:
     mkDerivation {
       pname = "apportionment";
       version = "0.0.0.2";
       sha256 = "352d9564ffdb01d3312a1087f8badc544b3478185cbc27d4ca29fc1f18c9f82b";
       libraryHaskellDepends = [ base containers utility-ht ];
       homepage = "http://hub.darcs.net/thielema/apportionment";
       description = "Round a set of numbers while maintaining its sum";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "approx-rand-test" = callPackage
    ({ mkDerivation, base, Chart, Chart-diagrams, colour, conduit
     , containers, data-default, data-default-class, filepath, HUnit
     , ieee754, lens, mersenne-random-pure64, monad-mersenne-random, mtl
     , statistics, test-framework, test-framework-hunit, text
     , transformers, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "approx-rand-test";
       version = "0.2.1";
       sha256 = "81d4b44621cb43f8c9ecbc90fd71c953826dc4c6c0790ad1e40770e774e15c9d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base mersenne-random-pure64 monad-mersenne-random mtl statistics
         transformers vector
       ];
       executableHaskellDepends = [
         base Chart Chart-diagrams colour conduit containers data-default
         data-default-class filepath lens mersenne-random-pure64
         monad-mersenne-random mtl statistics text vector vector-algorithms
       ];
       testHaskellDepends = [
         base HUnit ieee754 mersenne-random-pure64 monad-mersenne-random mtl
         test-framework test-framework-hunit vector
       ];
       jailbreak = true;
       homepage = "http://github.com/danieldk/approx-rand-test";
       description = "Approximate randomization test";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "approximate_0_2_1_1" = callPackage
    ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq
     , directory, distributive, doctest, filepath, generic-deriving
     , ghc-prim, hashable, hashable-extras, lens, log-domain, pointed
     , safecopy, semigroupoids, semigroups, simple-reflect, vector
     }:
     mkDerivation {
       pname = "approximate";
       version = "0.2.1.1";
       sha256 = "99c3aa397b15a56b2d2546f7ef1f333b5989879266409670c57a62ecc3174ca1";
       libraryHaskellDepends = [
         base binary bytes cereal comonad deepseq distributive
         generic-deriving ghc-prim hashable hashable-extras lens log-domain
         pointed safecopy semigroupoids semigroups vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       jailbreak = true;
       homepage = "http://github.com/analytics/approximate/";
       description = "Approximate discrete values and numbers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "approximate_0_2_2" = callPackage
    ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq
     , directory, doctest, filepath, ghc-prim, hashable, hashable-extras
     , lens, log-domain, pointed, safecopy, semigroupoids, semigroups
     , simple-reflect, vector
     }:
     mkDerivation {
       pname = "approximate";
       version = "0.2.2";
       sha256 = "b8eb3b247bf17aff2d770a4f53074956e83678579214da324d7a0e947772a9fa";
       libraryHaskellDepends = [
         base binary bytes cereal comonad deepseq ghc-prim hashable
         hashable-extras lens log-domain pointed safecopy semigroupoids
         semigroups vector
       ];
       testHaskellDepends = [
         base directory doctest filepath semigroups simple-reflect
       ];
       jailbreak = true;
       homepage = "http://github.com/analytics/approximate/";
       description = "Approximate discrete values and numbers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "approximate_0_2_2_1" = callPackage
    ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq
     , directory, doctest, filepath, ghc-prim, hashable, hashable-extras
     , lens, log-domain, pointed, safecopy, semigroupoids, semigroups
     , simple-reflect, vector
     }:
     mkDerivation {
       pname = "approximate";
       version = "0.2.2.1";
       sha256 = "e9c07dfb9fd95c373309c366383c858e6d83bd0c8d641e1d31dee5434f1109c0";
       libraryHaskellDepends = [
         base binary bytes cereal comonad deepseq ghc-prim hashable
         hashable-extras lens log-domain pointed safecopy semigroupoids
         semigroups vector
       ];
       testHaskellDepends = [
         base directory doctest filepath semigroups simple-reflect
       ];
       jailbreak = true;
       homepage = "http://github.com/analytics/approximate/";
       description = "Approximate discrete values and numbers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "approximate_0_2_2_2" = callPackage
    ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq
     , directory, doctest, filepath, ghc-prim, hashable, hashable-extras
     , lens, log-domain, pointed, safecopy, semigroupoids, semigroups
     , simple-reflect, vector
     }:
     mkDerivation {
       pname = "approximate";
       version = "0.2.2.2";
       sha256 = "b101ce547ef8b9e82f488982df7946601393c57496e434c84fa6ca7a7907c210";
       libraryHaskellDepends = [
         base binary bytes cereal comonad deepseq ghc-prim hashable
         hashable-extras lens log-domain pointed safecopy semigroupoids
         semigroups vector
       ];
       testHaskellDepends = [
         base directory doctest filepath semigroups simple-reflect
       ];
       jailbreak = true;
       homepage = "http://github.com/analytics/approximate/";
       description = "Approximate discrete values and numbers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "approximate" = callPackage
    ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq
     , directory, doctest, filepath, ghc-prim, hashable, hashable-extras
     , lens, log-domain, pointed, safecopy, semigroupoids, semigroups
     , simple-reflect, vector
     }:
     mkDerivation {
       pname = "approximate";
       version = "0.2.2.3";
       sha256 = "20fdc16cbd36bd592c6e2c5b6bd38866e8c3eb010e71607e6f609e6355302bac";
       libraryHaskellDepends = [
         base binary bytes cereal comonad deepseq ghc-prim hashable
         hashable-extras lens log-domain pointed safecopy semigroupoids
         semigroups vector
       ];
       testHaskellDepends = [
         base directory doctest filepath semigroups simple-reflect
       ];
       homepage = "http://github.com/analytics/approximate/";
       description = "Approximate discrete values and numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "approximate-equality" = callPackage
    ({ mkDerivation, base, type-level-natural-number }:
     mkDerivation {
       pname = "approximate-equality";
       version = "1.1.0.2";
       sha256 = "03a11e2bde0b81fcb97947d5dc4302d6712af9d9d405a4968e006ea3caf2bb5f";
       libraryHaskellDepends = [ base type-level-natural-number ];
       homepage = "http://github.com/gcross/approximate-equality";
       description = "Newtype wrappers for approximate equality";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ar-timestamp-wiper" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "ar-timestamp-wiper";
       version = "0.1.0";
       sha256 = "3fcf5dc856ed7cd722073a8c1f2b556e9c62628e08fe40311f0cc4c31bf861be";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring ];
       executableHaskellDepends = [ base bytestring ];
       homepage = "https://github.com/nh2/ar-timestamp-wiper";
       description = "Wipes time stamps from .a files (like ar -D)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "arb-fft" = callPackage
    ({ mkDerivation, base, containers, criterion, directory, filepath
     , primitive, QuickCheck, tasty, tasty-quickcheck, transformers
     , vector
     }:
     mkDerivation {
       pname = "arb-fft";
       version = "0.2.0.2";
       sha256 = "b719edb18b07ec45ce091d9d0269b846e36844a63a2da2f613bd87b3bf53b0fb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers criterion directory filepath primitive transformers
         vector
       ];
       executableHaskellDepends = [ base containers criterion vector ];
       testHaskellDepends = [
         base containers QuickCheck tasty tasty-quickcheck vector
       ];
       jailbreak = true;
       homepage = "https://github.com/ian-ross/arb-fft";
       description = "Pure Haskell arbitrary length FFT library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "arbb-vm" = callPackage
    ({ mkDerivation, arbb_dev, base, bytestring, cereal, containers
     , directory, mtl, pretty
     }:
     mkDerivation {
       pname = "arbb-vm";
       version = "0.1.1.20";
       sha256 = "684fda58cae1f7a4e11acc368d4c5eed1894004f96d09cd92e223d6a5b56614c";
       libraryHaskellDepends = [
         base bytestring cereal containers directory mtl pretty
       ];
       librarySystemDepends = [ arbb_dev ];
       homepage = "https://github.com/svenssonjoel/arbb-vm/wiki";
       description = "FFI binding to the Intel Array Building Blocks (ArBB) virtual machine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {arbb_dev = null;};

  "arbtt_0_8_1_4" = callPackage
    ({ mkDerivation, aeson, array, base, binary, bytestring
     , bytestring-progress, containers, deepseq, directory, filepath
     , HUnit, libXScrnSaver, old-locale, parsec, pcre-light
     , process-extras, strict, tasty, tasty-golden, tasty-hunit
     , terminal-progress-bar, time, transformers, unix, utf8-string, X11
     }:
     mkDerivation {
       pname = "arbtt";
       version = "0.8.1.4";
       sha256 = "ff58e9e0c2c7ed13668b9a4af7175747f5e2f9080727d0a5fa0e6f5b0459cd97";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson array base binary bytestring bytestring-progress containers
         deepseq directory filepath old-locale parsec pcre-light strict
         terminal-progress-bar time transformers unix utf8-string X11
       ];
       executableSystemDepends = [ libXScrnSaver ];
       testHaskellDepends = [
         base binary bytestring containers deepseq directory HUnit
         old-locale parsec pcre-light process-extras tasty tasty-golden
         tasty-hunit time transformers unix utf8-string
       ];
       jailbreak = true;
       homepage = "http://arbtt.nomeata.de/";
       description = "Automatic Rule-Based Time Tracker";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.xorg) libXScrnSaver;};

  "arbtt_0_9_0_1" = callPackage
    ({ mkDerivation, aeson, array, base, binary, bytestring
     , bytestring-progress, containers, deepseq, directory, filepath
     , HUnit, libXScrnSaver, old-locale, parsec, pcre-light
     , process-extras, strict, tasty, tasty-golden, tasty-hunit
     , terminal-progress-bar, time, transformers, unix, utf8-string, X11
     }:
     mkDerivation {
       pname = "arbtt";
       version = "0.9.0.1";
       sha256 = "33a02d914e7ab92ad2ffb2701c5d6a656b9ae6e7f652dc64e85b8c7a638f0a74";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson array base binary bytestring bytestring-progress containers
         deepseq directory filepath old-locale parsec pcre-light strict
         terminal-progress-bar time transformers unix utf8-string X11
       ];
       executableSystemDepends = [ libXScrnSaver ];
       testHaskellDepends = [
         base binary bytestring containers deepseq directory HUnit
         old-locale parsec pcre-light process-extras tasty tasty-golden
         tasty-hunit time transformers unix utf8-string
       ];
       jailbreak = true;
       homepage = "http://arbtt.nomeata.de/";
       description = "Automatic Rule-Based Time Tracker";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.xorg) libXScrnSaver;};

  "arbtt_0_9_0_2" = callPackage
    ({ mkDerivation, aeson, array, base, binary, bytestring
     , bytestring-progress, containers, deepseq, directory, filepath
     , HUnit, libXScrnSaver, old-locale, parsec, pcre-light
     , process-extras, strict, tasty, tasty-golden, tasty-hunit
     , terminal-progress-bar, time, transformers, unix, utf8-string, X11
     }:
     mkDerivation {
       pname = "arbtt";
       version = "0.9.0.2";
       sha256 = "8c86176ff3399f65786d4fb9754a82d91ffd155e2d1215ae60cc999b75c66529";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson array base binary bytestring bytestring-progress containers
         deepseq directory filepath old-locale parsec pcre-light strict
         terminal-progress-bar time transformers unix utf8-string X11
       ];
       executableSystemDepends = [ libXScrnSaver ];
       testHaskellDepends = [
         base binary bytestring containers deepseq directory HUnit
         old-locale parsec pcre-light process-extras tasty tasty-golden
         tasty-hunit time transformers unix utf8-string
       ];
       jailbreak = true;
       homepage = "http://arbtt.nomeata.de/";
       description = "Automatic Rule-Based Time Tracker";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.xorg) libXScrnSaver;};

  "arbtt_0_9_0_4" = callPackage
    ({ mkDerivation, aeson, array, base, binary, bytestring
     , bytestring-progress, containers, deepseq, directory, filepath
     , libXScrnSaver, parsec, pcre-light, process-extras, strict, tasty
     , tasty-golden, tasty-hunit, terminal-progress-bar, time
     , transformers, unix, utf8-string, X11
     }:
     mkDerivation {
       pname = "arbtt";
       version = "0.9.0.4";
       sha256 = "bbe0f67106f2e0aa9cb7724b6fa9b456fedfe9320557449bde4ace30353e1f0b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson array base binary bytestring bytestring-progress containers
         deepseq directory filepath parsec pcre-light strict
         terminal-progress-bar time transformers unix utf8-string X11
       ];
       executableSystemDepends = [ libXScrnSaver ];
       testHaskellDepends = [
         base binary bytestring containers deepseq directory parsec
         pcre-light process-extras tasty tasty-golden tasty-hunit time
         transformers unix utf8-string
       ];
       jailbreak = true;
       homepage = "http://arbtt.nomeata.de/";
       description = "Automatic Rule-Based Time Tracker";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.xorg) libXScrnSaver;};

  "arbtt_0_9_0_5" = callPackage
    ({ mkDerivation, aeson, array, base, binary, bytestring
     , bytestring-progress, containers, deepseq, directory, filepath
     , libXScrnSaver, parsec, pcre-light, process-extras, strict, tasty
     , tasty-golden, tasty-hunit, terminal-progress-bar, time
     , transformers, unix, utf8-string, X11
     }:
     mkDerivation {
       pname = "arbtt";
       version = "0.9.0.5";
       sha256 = "c0cbdf53f1ff7c98874a1b91d3145edc1fc24fe8020d65b2b9f22bd031d203b7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson array base binary bytestring bytestring-progress containers
         deepseq directory filepath parsec pcre-light strict
         terminal-progress-bar time transformers unix utf8-string X11
       ];
       executableSystemDepends = [ libXScrnSaver ];
       testHaskellDepends = [
         base binary bytestring containers deepseq directory parsec
         pcre-light process-extras tasty tasty-golden tasty-hunit time
         transformers unix utf8-string
       ];
       homepage = "http://arbtt.nomeata.de/";
       description = "Automatic Rule-Based Time Tracker";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.xorg) libXScrnSaver;};

  "arbtt_0_9_0_7" = callPackage
    ({ mkDerivation, aeson, array, base, binary, bytestring
     , bytestring-progress, containers, deepseq, directory, filepath
     , libXScrnSaver, parsec, pcre-light, process-extras, strict, tasty
     , tasty-golden, tasty-hunit, terminal-progress-bar, time
     , transformers, unix, utf8-string, X11
     }:
     mkDerivation {
       pname = "arbtt";
       version = "0.9.0.7";
       sha256 = "3a588f9228533df6233877a6be2612f4d4cb1adc2e2e190d9fb0cf46772ccba5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson array base binary bytestring bytestring-progress containers
         deepseq directory filepath parsec pcre-light strict
         terminal-progress-bar time transformers unix utf8-string X11
       ];
       executableSystemDepends = [ libXScrnSaver ];
       testHaskellDepends = [
         base binary bytestring containers deepseq directory parsec
         pcre-light process-extras tasty tasty-golden tasty-hunit time
         transformers unix utf8-string
       ];
       homepage = "http://arbtt.nomeata.de/";
       description = "Automatic Rule-Based Time Tracker";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.xorg) libXScrnSaver;};

  "arbtt" = callPackage
    ({ mkDerivation, aeson, array, base, binary, bytestring
     , bytestring-progress, containers, deepseq, directory, filepath
     , libXScrnSaver, parsec, pcre-light, process-extras, strict, tasty
     , tasty-golden, tasty-hunit, terminal-progress-bar, time
     , transformers, unix, utf8-string, X11
     }:
     mkDerivation {
       pname = "arbtt";
       version = "0.9.0.8";
       sha256 = "cde0e72d4df6612c04ac7c4061fbd8a86dc5b993c28de82f046d85c2b71602bb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson array base binary bytestring bytestring-progress containers
         deepseq directory filepath parsec pcre-light strict
         terminal-progress-bar time transformers unix utf8-string X11
       ];
       executableSystemDepends = [ libXScrnSaver ];
       testHaskellDepends = [
         base binary bytestring containers deepseq directory parsec
         pcre-light process-extras tasty tasty-golden tasty-hunit time
         transformers unix utf8-string
       ];
       homepage = "http://arbtt.nomeata.de/";
       description = "Automatic Rule-Based Time Tracker";
       license = "GPL";
     }) {inherit (pkgs.xorg) libXScrnSaver;};

  "archive" = callPackage
    ({ mkDerivation, base, bytestring, debian, debian-mirror, directory
     , Extra, filepath, help, HUnit, mtl, network, old-locale, pretty
     , process, progress, regex-compat, regex-posix, time, unix
     , Unixutils, xhtml
     }:
     mkDerivation {
       pname = "archive";
       version = "1.2.12";
       sha256 = "39184dfed32f9dc6fe8fde0d4e937d749675ef6a84e7bb968c98585d6bcbaf65";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring debian debian-mirror directory Extra filepath help
         HUnit mtl network old-locale pretty process progress regex-compat
         regex-posix time unix Unixutils xhtml
       ];
       jailbreak = true;
       description = "A library and programs for creating hardlinked incremental archives or backups";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {debian-mirror = null; help = null;};

  "archiver" = callPackage
    ({ mkDerivation, base, bytestring, containers, curl, HTTP, network
     , process, random
     }:
     mkDerivation {
       pname = "archiver";
       version = "0.6.2.1";
       sha256 = "428223fb0944894f262f5ce76ebd2d69615c30875a6225f24f1652909092fba5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base curl HTTP network ];
       executableHaskellDepends = [
         base bytestring containers process random
       ];
       description = "Archive supplied URLs in WebCite & Internet Archive";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "archlinux" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, filepath
     , pretty
     }:
     mkDerivation {
       pname = "archlinux";
       version = "1.3";
       sha256 = "a2cb945735719b5e40450ac9d5d8d6fe1b2b4c90043ce43040b82397867d3714";
       libraryHaskellDepends = [
         base Cabal containers directory filepath pretty
       ];
       homepage = "http://github.com/archhaskell/";
       description = "Support for working with Arch Linux packages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "archlinux-web" = callPackage
    ({ mkDerivation, archlinux, base, Cabal, containers, csv, deepseq
     , directory, filepath, HTTP, json, old-time, parallel, pretty
     , prettyclass, process, strict-concurrency, xhtml
     }:
     mkDerivation {
       pname = "archlinux-web";
       version = "0.1";
       sha256 = "88e468f17ef1f58682f15494703c652b1b3b95094483c368cd9008577b9ff2e7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         archlinux base Cabal containers csv deepseq directory filepath HTTP
         json old-time parallel pretty prettyclass process
         strict-concurrency xhtml
       ];
       executableHaskellDepends = [
         archlinux base Cabal containers csv deepseq directory filepath HTTP
         json old-time parallel pretty prettyclass process
         strict-concurrency xhtml
       ];
       homepage = "http://code.haskell.org/~dons/code/archlinux";
       description = "Website maintenance for Arch Linux packages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "archnews" = callPackage
    ({ mkDerivation, base, containers, download-curl, feed, tagsoup }:
     mkDerivation {
       pname = "archnews";
       version = "0.2";
       sha256 = "da3fd4073fb2528961a2a9d5e7e144e7fb4f360e2a81acf74cc63bcc0437ebec";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers download-curl feed tagsoup
       ];
       homepage = "http://archhaskell.wordpress.com/";
       description = "Convert Arch Linux package updates in RSS to pretty markdown";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "arff" = callPackage
    ({ mkDerivation, base, binary, bytestring, bytestring-lexing
     , bytestring-show, old-locale, time
     }:
     mkDerivation {
       pname = "arff";
       version = "0.1.0";
       sha256 = "45c1aebf62d65e89da12f82f131735f27db005f84b25e5f12e4f4f4227998ad7";
       libraryHaskellDepends = [
         base binary bytestring bytestring-lexing bytestring-show old-locale
         time
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~StefanKersten/code/arff";
       description = "Generate Attribute-Relation File Format (ARFF) files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "arghwxhaskell" = callPackage
    ({ mkDerivation, base, directory, wx }:
     mkDerivation {
       pname = "arghwxhaskell";
       version = "0.8.2.0";
       sha256 = "6b88ad21393cde84f137f280826de31f121f35cf99c6c3472e423611723cdd5b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory wx ];
       homepage = "https://wiki.haskell.org/Argh!";
       description = "An interpreter for the Argh! programming language in wxHaskell";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "argon" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, Cabal
     , containers, directory, docopt, filepath, ghc, ghc-paths
     , ghc-syb-utils, hlint, hspec, lens-simple, pathwalk, pipes
     , pipes-group, QuickCheck, syb
     }:
     mkDerivation {
       pname = "argon";
       version = "0.4.0.0";
       sha256 = "49cd357e23dc8aaf1d055bde5030ea12ed4e0b18edc4550a595028e26e582899";
       revision = "1";
       editedCabalFile = "6b1f69222554d70ac99998239cdf836ddbb10d7cc83ec6c1e050c97b894c4060";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal base bytestring Cabal containers directory
         filepath ghc ghc-paths ghc-syb-utils lens-simple pathwalk pipes
         pipes-group syb
       ];
       executableHaskellDepends = [ base docopt pipes ];
       testHaskellDepends = [
         aeson ansi-terminal base bytestring Cabal containers directory
         docopt filepath ghc ghc-paths ghc-syb-utils hlint hspec lens-simple
         pathwalk pipes pipes-group QuickCheck syb
       ];
       doCheck = false;
       homepage = "http://github.com/rubik/argon";
       description = "Measure your code's complexity";
       license = stdenv.lib.licenses.isc;
     }) {};

  "argon_0_4_1_0" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, Cabal
     , containers, directory, docopt, filepath, ghc, ghc-paths
     , ghc-syb-utils, hlint, hspec, lens-simple, pipes, pipes-bytestring
     , pipes-files, pipes-group, pipes-safe, QuickCheck, syb
     }:
     mkDerivation {
       pname = "argon";
       version = "0.4.1.0";
       sha256 = "d93c50ae118a4493bdc5ed94e5f3d1eaa434e78422c79e28476329bad4475bea";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal base bytestring Cabal containers directory ghc
         ghc-paths ghc-syb-utils lens-simple pipes pipes-bytestring
         pipes-files pipes-group pipes-safe syb
       ];
       executableHaskellDepends = [ base docopt pipes pipes-safe ];
       testHaskellDepends = [
         aeson ansi-terminal base filepath ghc hlint hspec pipes pipes-safe
         QuickCheck
       ];
       homepage = "http://github.com/rubik/argon";
       description = "Measure your code's complexity";
       license = stdenv.lib.licenses.isc;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "argon2" = callPackage
    ({ mkDerivation, base, bytestring, QuickCheck, tasty
     , tasty-quickcheck, text, transformers
     }:
     mkDerivation {
       pname = "argon2";
       version = "1.1.0";
       sha256 = "42fc5495434739408115cd932e7b3a6853e4f999e86bd408422ed0abfa19837a";
       libraryHaskellDepends = [ base bytestring text transformers ];
       testHaskellDepends = [
         base bytestring QuickCheck tasty tasty-quickcheck text
       ];
       homepage = "https://github.com/ocharles/argon2.git";
       description = "Haskell bindings to libargon2 - the reference implementation of the Argon2 password-hashing function";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "argparser" = callPackage
    ({ mkDerivation, base, containers, HTF, HUnit }:
     mkDerivation {
       pname = "argparser";
       version = "0.3.4";
       sha256 = "e645c7a587d1a82f4e550fc5ac22c4c615c1c59429f2cff52dd393ca2a91ed7a";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [ base containers HTF HUnit ];
       description = "Command line parsing framework for console applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "arguedit" = callPackage
    ({ mkDerivation, base, bimap, containers, glib, gtk, HDBC, indents
     , mtl, parsec
     }:
     mkDerivation {
       pname = "arguedit";
       version = "0.1.0.1";
       sha256 = "0657b7fbfb06b495c17369c6c902244280f545bea531f0904c8344256baa469f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bimap containers glib gtk HDBC indents mtl parsec
       ];
       jailbreak = true;
       description = "A computer assisted argumentation transcription and editing software";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ariadne" = callPackage
    ({ mkDerivation, async, base, bert, Cabal, containers, data-lens
     , data-lens-fd, data-lens-template, directory, filepath
     , haskell-names, haskell-packages, haskell-src-exts, hse-cpp
     , hslogger, mtl, stm, tagged, tasty, tasty-hunit, transformers
     , utf8-string
     }:
     mkDerivation {
       pname = "ariadne";
       version = "0.1.2.3";
       sha256 = "e322ce03c8247071a83a8baeeae9dfe8d263a81ae74e4466a1841f48fcb01e0a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async base bert Cabal containers data-lens data-lens-fd
         data-lens-template directory filepath haskell-names
         haskell-packages haskell-src-exts hse-cpp hslogger mtl stm tagged
         transformers utf8-string
       ];
       testHaskellDepends = [
         base bert containers directory filepath haskell-src-exts tasty
         tasty-hunit utf8-string
       ];
       homepage = "https://github.com/feuerbach/ariadne";
       description = "Go-to-definition for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "arion" = callPackage
    ({ mkDerivation, base, containers, directory, filemanip, fsnotify
     , hspec, process, regex-posix, safe, split, system-filepath, text
     , time, transformers
     }:
     mkDerivation {
       pname = "arion";
       version = "0.1.0.8";
       sha256 = "1c3fe9db9733470f21b013d4368c2a02feba35ca172c3cf6cb1f3c5cff5af980";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filemanip fsnotify process regex-posix
         safe split system-filepath text transformers
       ];
       testHaskellDepends = [
         base containers directory filemanip fsnotify hspec process
         regex-posix safe split system-filepath text time
       ];
       homepage = "http://github.com/karun012/arion";
       description = "Watcher and runner for Hspec";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "arith-encode" = callPackage
    ({ mkDerivation, arithmoi, array, base, binary, Cabal, containers
     , fgl, hashable, HUnit-Plus, unordered-containers
     }:
     mkDerivation {
       pname = "arith-encode";
       version = "1.0.0";
       sha256 = "a83230d5d237ba3d12ed23418488bc522d0eb0add734b55f184c35c1981415f3";
       libraryHaskellDepends = [
         arithmoi array base binary Cabal containers fgl hashable
         unordered-containers
       ];
       testHaskellDepends = [
         arithmoi array base binary Cabal containers fgl hashable HUnit-Plus
         unordered-containers
       ];
       homepage = "https://github.com/emc2/arith-encode";
       description = "A practical arithmetic encoding (aka Godel numbering) library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "arithmatic" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "arithmatic";
       version = "0.1.0.1";
       sha256 = "487edb83b111065637d8ad313788aa43df14654cf098f5de682cd06322f641e1";
       libraryHaskellDepends = [ base ];
       description = "Basic arithmatic in haskell";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "arithmetic" = callPackage
    ({ mkDerivation, base, containers, opentheory, opentheory-bits
     , opentheory-divides, opentheory-prime, opentheory-primitive
     , QuickCheck, random
     }:
     mkDerivation {
       pname = "arithmetic";
       version = "1.2";
       sha256 = "f3ef6add91a72f24640b9f4836b322c9278609558b09ef0c592df9194c6f377a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers opentheory opentheory-bits opentheory-divides
         opentheory-primitive QuickCheck random
       ];
       executableHaskellDepends = [
         base containers opentheory opentheory-bits opentheory-divides
         opentheory-primitive QuickCheck random
       ];
       testHaskellDepends = [
         base containers opentheory opentheory-bits opentheory-divides
         opentheory-prime opentheory-primitive QuickCheck random
       ];
       description = "Natural number arithmetic";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "arithmoi_0_4_1_1" = callPackage
    ({ mkDerivation, array, base, containers, ghc-prim, integer-gmp
     , mtl, random
     }:
     mkDerivation {
       pname = "arithmoi";
       version = "0.4.1.1";
       sha256 = "3d267d61de58acaa4955216a219027ba34d59509040c1695d44db3db88a8990b";
       revision = "2";
       editedCabalFile = "8bf01e402d887e4d95dad0189e75420b125c15bc6234784929535a08c471298a";
       configureFlags = [ "-f-llvm" ];
       libraryHaskellDepends = [
         array base containers ghc-prim integer-gmp mtl random
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/dafis/arithmoi";
       description = "Efficient basic number-theoretic functions. Primes, powers, integer logarithms.";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "arithmoi_0_4_1_2" = callPackage
    ({ mkDerivation, array, base, containers, ghc-prim, integer-gmp
     , mtl, random
     }:
     mkDerivation {
       pname = "arithmoi";
       version = "0.4.1.2";
       sha256 = "355985f9aaab6d303b612adc9dd47a346d49adc35c9bdd10634610d768b30c44";
       configureFlags = [ "-f-llvm" ];
       libraryHaskellDepends = [
         array base containers ghc-prim integer-gmp mtl random
       ];
       jailbreak = true;
       homepage = "https://github.com/cartazio/arithmoi";
       description = "Efficient basic number-theoretic functions. Primes, powers, integer logarithms.";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "arithmoi" = callPackage
    ({ mkDerivation, array, base, containers, ghc-prim, hspec
     , integer-gmp, mtl, random
     }:
     mkDerivation {
       pname = "arithmoi";
       version = "0.4.1.3";
       sha256 = "2e623924079d3f8733fd31bf40a30ee0051dd0c3e3ae4b13a7afb5f2300413c9";
       configureFlags = [ "-f-llvm" ];
       libraryHaskellDepends = [
         array base containers ghc-prim integer-gmp mtl random
       ];
       testHaskellDepends = [ base hspec ];
       homepage = "https://github.com/cartazio/arithmoi";
       description = "Efficient basic number-theoretic functions. Primes, powers, integer logarithms.";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "armada" = callPackage
    ({ mkDerivation, base, GLUT, mtl, OpenGL, stm }:
     mkDerivation {
       pname = "armada";
       version = "0.1";
       sha256 = "816deba97cab5b0acc93e3e3dd81720176cd732661fad7aec997e40a344bd5a3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base GLUT mtl OpenGL stm ];
       description = "Space-based real time strategy game";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "arpa" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "arpa";
       version = "0.0.0.0";
       sha256 = "a39843fd9c4fb503f711e79bc989c2be4515cd312cec81077f3174a7363ac88e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/sfischer13/haskell-arpa";
       description = "Library for reading ARPA n-gram models";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "array_0_5_1_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "array";
       version = "0.5.1.0";
       sha256 = "b84bc8a6cd4526888a165e111ed23ba7af6c743608774d41604636a8990c1fa2";
       libraryHaskellDepends = [ base ];
       description = "Mutable and immutable arrays";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "array-forth" = callPackage
    ({ mkDerivation, array, base, HUnit, mcmc-synthesis
     , modular-arithmetic, MonadRandom, OddWord, QuickCheck, split
     , test-framework-hunit, test-framework-quickcheck2
     , test-framework-th, vector
     }:
     mkDerivation {
       pname = "array-forth";
       version = "0.2.1.4";
       sha256 = "b5c02405214a5216299069c4050ad5302ab7f8473171bbf3464ca6f8fc9d720e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base mcmc-synthesis modular-arithmetic MonadRandom OddWord
         split vector
       ];
       executableHaskellDepends = [ base split vector ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework-hunit
         test-framework-quickcheck2 test-framework-th
       ];
       jailbreak = true;
       description = "A simple interpreter for arrayForth, the language used on GreenArrays chips";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "array-memoize" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "array-memoize";
       version = "0.6.0";
       sha256 = "76c88cb3ed04875821a5601f6a1c40f4e15ef8cb36e8a3d4004df956d1db05dc";
       libraryHaskellDepends = [ array base ];
       description = "Memoization combinators using arrays for finite sub-domains of functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "array-primops" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "array-primops";
       version = "0.1.0.0";
       sha256 = "dd181c8211dee3b4c13066fc7f58e599dd0d0d7990c1082583d2ed68807e1c87";
       libraryHaskellDepends = [ base ghc-prim ];
       description = "Extra foreign primops for primitive arrays";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "array-utils" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "array-utils";
       version = "0.3";
       sha256 = "56cdcb53e0e36a9d9a92682282dba88f4c9fae1a18b9891b3a593650577d07be";
       libraryHaskellDepends = [ array base ];
       description = "Primitive functions for updating many elements in mutable arrays at once";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "arrow-improve" = callPackage
    ({ mkDerivation, arrows, base, pointed, profunctors, semigroupoids
     }:
     mkDerivation {
       pname = "arrow-improve";
       version = "0.1.0.0";
       sha256 = "87732be0845b028324507888f36b976258523711474cb0b00a445243ce46f45e";
       libraryHaskellDepends = [
         arrows base pointed profunctors semigroupoids
       ];
       jailbreak = true;
       homepage = "https://github.com/prophile/arrow-improve/";
       description = "Improved arrows";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "arrow-list_0_6_1_5" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "arrow-list";
       version = "0.6.1.5";
       sha256 = "b59bb0183bb90fceb8b46a14e39aa077983ce7dfe6d7df787529ae9db3e41944";
       libraryHaskellDepends = [ base containers mtl ];
       homepage = "https://github.com/silkapp/arrow-list";
       description = "List arrows for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "arrow-list" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "arrow-list";
       version = "0.7";
       sha256 = "33f836f23648aa2cea11533f7a9941127c397eecdca105b2084dded9e039d5d8";
       libraryHaskellDepends = [ base containers mtl ];
       homepage = "https://github.com/silkapp/arrow-list";
       description = "List arrows for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "arrowapply-utils" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "arrowapply-utils";
       version = "0.2";
       sha256 = "31c2b7f29d84c72e51d75bd388012faeeb124d167ff6ddb64baa3066d8adea0b";
       libraryHaskellDepends = [ base ];
       description = "Utilities for working with ArrowApply instances more naturally";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "arrowp" = callPackage
    ({ mkDerivation, array, base, containers, haskell-src }:
     mkDerivation {
       pname = "arrowp";
       version = "0.5.0.2";
       sha256 = "9d1aef80d0dde1a87c520783d219aa6d3b694008fe2990a169abc68e70d11a28";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base containers haskell-src ];
       homepage = "http://www.haskell.org/arrows/";
       description = "preprocessor translating arrow notation into Haskell 98";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "arrows" = callPackage
    ({ mkDerivation, base, Stream }:
     mkDerivation {
       pname = "arrows";
       version = "0.4.4.1";
       sha256 = "5b104bd8f8fac5ad0fd194088819423302e52c2a796cc99f6d32bbc134bfebe2";
       libraryHaskellDepends = [ base Stream ];
       homepage = "http://www.haskell.org/arrows/";
       description = "Arrow classes and transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "artery" = callPackage
    ({ mkDerivation, base, containers, profunctors, transformers }:
     mkDerivation {
       pname = "artery";
       version = "0.1.1";
       sha256 = "19ab592489c73529276f1bd40e9822772f65974dfecffb701092352bae9248bb";
       libraryHaskellDepends = [
         base containers profunctors transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/fumieval/artery";
       description = "A simple, arrow-based reactive programming";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "arx" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , bytestring-nums, containers, file-embed, parsec, process
     , shell-escape, template-haskell
     }:
     mkDerivation {
       pname = "arx";
       version = "0.2.1";
       sha256 = "9d6f2a8e04209f9e208814b8aa8c693a4ea005ce7138d00e959214067fd34970";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring bytestring-nums containers
         file-embed parsec process shell-escape template-haskell
       ];
       executableHaskellDepends = [
         attoparsec base blaze-builder bytestring bytestring-nums containers
         file-embed parsec process shell-escape template-haskell
       ];
       homepage = "http://github.com/solidsnack/arx/";
       description = "Archive execution tool";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "arxiv" = callPackage
    ({ mkDerivation, base, parsec, split, tagsoup }:
     mkDerivation {
       pname = "arxiv";
       version = "0.0.1";
       sha256 = "b0b731fa2a38b038af86627e11bc00bcbdefc8c4a4bd3bd2d8842308c8465ac1";
       revision = "1";
       editedCabalFile = "746311e6003440248df63acd19e428cbdbf5c95cdd3ee0993d2c89c7b2ceada7";
       libraryHaskellDepends = [ base parsec split tagsoup ];
       homepage = "http://github.com/toschoo/Haskell-Libs";
       description = "A client for the Arxiv API";
       license = "LGPL";
     }) {};

  "ascetic" = callPackage
    ({ mkDerivation, base, MissingH }:
     mkDerivation {
       pname = "ascetic";
       version = "0.0.0.4";
       sha256 = "134f75c63a466d492005faa3a323cd798c8f2b8d71804807dcb69b9530bab1b0";
       libraryHaskellDepends = [ base MissingH ];
       description = "Generic markup builder";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ascii" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , hashable, text
     }:
     mkDerivation {
       pname = "ascii";
       version = "0.0.4.1";
       sha256 = "fbee4b1b3429ab7c95e87644a9571d6c53ae9efd08671ac979cd4efd8615fcf6";
       libraryHaskellDepends = [
         base blaze-builder bytestring case-insensitive hashable text
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/ascii";
       description = "Type-safe, bytestring-based ASCII values. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ascii-progress" = callPackage
    ({ mkDerivation, async, base, concurrent-output, data-default
     , hspec, QuickCheck, time
     }:
     mkDerivation {
       pname = "ascii-progress";
       version = "0.3.2.0";
       sha256 = "51a70a0d1fd39138f6d143bf52080c765d0f0b69d5af887f2fa80a950448c771";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base concurrent-output data-default time
       ];
       testHaskellDepends = [
         async base concurrent-output data-default hspec QuickCheck time
       ];
       homepage = "https://github.com/yamadapc/haskell-ascii-progress";
       description = "A simple progress bar for the console";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ascii-vector-avc" = callPackage
    ({ mkDerivation, attoparsec, base, binary, bytestring, deepseq
     , deepseq-generics, HUnit, split, zlib
     }:
     mkDerivation {
       pname = "ascii-vector-avc";
       version = "0.1.0.0";
       sha256 = "e4f37b6e17bb2400354db3783206ebaa6d41e4549b08a4c757f41d2030e3a726";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base binary bytestring deepseq deepseq-generics HUnit
         split zlib
       ];
       executableHaskellDepends = [
         attoparsec base binary bytestring deepseq deepseq-generics HUnit
         split zlib
       ];
       jailbreak = true;
       description = "Process Ascii Vectors for Advantest 93k";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "ascii85-conduit" = callPackage
    ({ mkDerivation, base, bytestring, conduit, hspec }:
     mkDerivation {
       pname = "ascii85-conduit";
       version = "0.1.0.0";
       sha256 = "856abadac7fa9e61307089f0455df72ff6de4cee7b297bf6e72bcbe183e138a4";
       libraryHaskellDepends = [ base bytestring conduit ];
       testHaskellDepends = [ base bytestring conduit hspec ];
       jailbreak = true;
       description = "Conduit for encoding ByteString into Ascii85";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "asciidiagram_1_1_1_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , FontyFruity, JuicyPixels, lens, linear, mtl, optparse-applicative
     , rasterific-svg, svg-tree, text, vector
     }:
     mkDerivation {
       pname = "asciidiagram";
       version = "1.1.1.1";
       sha256 = "35a970f884ec83b2c931ed851f9a3c54032465511b9738bd333d90664325ef5b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers FontyFruity JuicyPixels lens linear mtl
         rasterific-svg svg-tree text vector
       ];
       executableHaskellDepends = [
         base bytestring directory filepath FontyFruity JuicyPixels
         optparse-applicative rasterific-svg svg-tree text
       ];
       jailbreak = true;
       description = "Pretty rendering of Ascii diagram into svg or png";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "asciidiagram" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , FontyFruity, JuicyPixels, lens, linear, mtl, optparse-applicative
     , rasterific-svg, svg-tree, text, vector
     }:
     mkDerivation {
       pname = "asciidiagram";
       version = "1.2";
       sha256 = "5ea87f5932463b8cb62873a0551fdbbf17525b45819ffb54ebcf5de400e8d098";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers FontyFruity JuicyPixels lens linear mtl
         rasterific-svg svg-tree text vector
       ];
       executableHaskellDepends = [
         base bytestring directory filepath FontyFruity JuicyPixels
         optparse-applicative rasterific-svg svg-tree text
       ];
       description = "Pretty rendering of Ascii diagram into svg or png";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "asic" = callPackage
    ({ mkDerivation, asil, base, bytestring, utf8-string }:
     mkDerivation {
       pname = "asic";
       version = "1.2";
       sha256 = "cf393fbf5b2c7893bc53b1da4db79c366d537a4ec5cc1d4537ca90089a9bf770";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ asil base bytestring utf8-string ];
       homepage = "http://www.pros.upv.es/fittest/";
       description = "Action Script Instrumentation Compiler";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "asil" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , data-binary-ieee754, directory, filepath, haskell-src-exts, mtl
     , pretty, utf8-string, uuagc, zip-archive, zlib
     }:
     mkDerivation {
       pname = "asil";
       version = "1.2";
       sha256 = "9d63a2a19e6e7598018abd3bd9f7698664e1db6beca412a8773ca4a9676bf9fe";
       libraryHaskellDepends = [
         array base binary bytestring containers data-binary-ieee754
         directory filepath haskell-src-exts mtl pretty utf8-string uuagc
         zip-archive zlib
       ];
       homepage = "http://www.pros.upv.es/fittest/";
       description = "Action Script Instrumentation Library";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "asn1-data_0_7_1" = callPackage
    ({ mkDerivation, base, bytestring, cereal, mtl, text }:
     mkDerivation {
       pname = "asn1-data";
       version = "0.7.1";
       sha256 = "f9a8a8ec41e89ebb4af6bd6b8a4c45515e44d7d61524d02b52881bfe7caf4783";
       revision = "1";
       editedCabalFile = "6c8f01076a88b9ea0f2ce9b5fa2b09dc658332bd4dedfbc8d6e7fae25ea5ed1f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring cereal mtl text ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-asn1-data";
       description = "ASN1 data reader and writer in RAW, BER and DER forms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "asn1-data" = callPackage
    ({ mkDerivation, base, bytestring, cereal, mtl, text }:
     mkDerivation {
       pname = "asn1-data";
       version = "0.7.2";
       sha256 = "83999c03cbc993f7e0dea010942a4dc39ae986c498c57eadc1e5ee1b4e23aca1";
       revision = "1";
       editedCabalFile = "1543bc1ee13d3f4b9ee6f9445edede596d5fe7f8a4551333b54634aad5b112a3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring cereal mtl text ];
       homepage = "https://github.com/vincenthz/hs-asn1/tree/master/data";
       description = "ASN1 data reader and writer in RAW, BER and DER forms";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "asn1-encoding_0_9_0" = callPackage
    ({ mkDerivation, asn1-types, base, bytestring, hourglass, mtl
     , tasty, tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "asn1-encoding";
       version = "0.9.0";
       sha256 = "17e9194f41b5a85a733fb54ee4a0c8466f6f67462f53c1e8a05b3d42fda7a30b";
       libraryHaskellDepends = [
         asn1-types base bytestring hourglass mtl
       ];
       testHaskellDepends = [
         asn1-types base bytestring hourglass mtl tasty tasty-quickcheck
         text
       ];
       homepage = "http://github.com/vincenthz/hs-asn1";
       description = "ASN1 data reader and writer in RAW, BER and DER forms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "asn1-encoding_0_9_2" = callPackage
    ({ mkDerivation, asn1-types, base, bytestring, hourglass, mtl
     , tasty, tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "asn1-encoding";
       version = "0.9.2";
       sha256 = "786e6bdd6caf35807339c6c5770a3ef76a2c7cc4ff8eaea43567d9b539206f21";
       libraryHaskellDepends = [
         asn1-types base bytestring hourglass mtl
       ];
       testHaskellDepends = [
         asn1-types base bytestring hourglass mtl tasty tasty-quickcheck
         text
       ];
       homepage = "http://github.com/vincenthz/hs-asn1";
       description = "ASN1 data reader and writer in RAW, BER and DER forms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "asn1-encoding" = callPackage
    ({ mkDerivation, asn1-types, base, bytestring, hourglass, mtl
     , tasty, tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "asn1-encoding";
       version = "0.9.3";
       sha256 = "90d7e05806977e683a468a4112270c9745c07f52452915db6a8fb19b752d7106";
       libraryHaskellDepends = [ asn1-types base bytestring hourglass ];
       testHaskellDepends = [
         asn1-types base bytestring hourglass mtl tasty tasty-quickcheck
         text
       ];
       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_0_9_0" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring, mtl
     , text
     }:
     mkDerivation {
       pname = "asn1-parse";
       version = "0.9.0";
       sha256 = "e3c94b982c34e944c549b7854d738d50158eee0267598ac5f1bbfb66391f0954";
       revision = "1";
       editedCabalFile = "f624dd2168154a726f97a980f1f37d5cfdd5ec845c91b83942ef93f8f5719c8c";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base bytestring mtl text
       ];
       homepage = "http://github.com/vincenthz/hs-asn1";
       description = "Simple monadic parser for ASN1 stream types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "asn1-parse_0_9_1" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring, mtl
     }:
     mkDerivation {
       pname = "asn1-parse";
       version = "0.9.1";
       sha256 = "e18087baa87225a5ea41c9758f7499b362ba6293931cb9c5bc3548c90f3133de";
       revision = "1";
       editedCabalFile = "9dff7d71ac8bc8c2165071385785b8dcab5d59e2d92c266d2a16f2c31e8e3fd4";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base bytestring mtl
       ];
       homepage = "https://github.com/vincenthz/hs-asn1";
       description = "Simple monadic parser for ASN1 stream types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "asn1-parse" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring }:
     mkDerivation {
       pname = "asn1-parse";
       version = "0.9.4";
       sha256 = "c6a328f570c69db73f8d2416f9251e8a03753f90d5d19e76cbe69509a3ceb708";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base bytestring
       ];
       homepage = "https://github.com/vincenthz/hs-asn1";
       description = "Simple monadic parser for ASN1 stream types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "asn1-types_0_3_0" = callPackage
    ({ mkDerivation, base, bytestring, hourglass }:
     mkDerivation {
       pname = "asn1-types";
       version = "0.3.0";
       sha256 = "b998dad88b94f8da7058df52f03936d66c81a2d012549c87affeecac5cb5a8aa";
       libraryHaskellDepends = [ base bytestring hourglass ];
       homepage = "http://github.com/vincenthz/hs-asn1-types";
       description = "ASN.1 types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "asn1-types_0_3_1" = callPackage
    ({ mkDerivation, base, bytestring, hourglass, memory }:
     mkDerivation {
       pname = "asn1-types";
       version = "0.3.1";
       sha256 = "4ae6d47503a0ebf40584ea9d733eb572ac2dd607556dff1211b25602b34f2ec6";
       libraryHaskellDepends = [ base bytestring hourglass memory ];
       homepage = "http://github.com/vincenthz/hs-asn1-types";
       description = "ASN.1 types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "asn1-types" = callPackage
    ({ mkDerivation, base, bytestring, hourglass, memory }:
     mkDerivation {
       pname = "asn1-types";
       version = "0.3.2";
       sha256 = "0c571fff4a10559c6a630d4851ba3cdf1d558185ce3dcfca1136f9883d647217";
       libraryHaskellDepends = [ base bytestring hourglass memory ];
       homepage = "http://github.com/vincenthz/hs-asn1-types";
       description = "ASN.1 types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "asn1dump" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring, pem
     }:
     mkDerivation {
       pname = "asn1dump";
       version = "0.1.0";
       sha256 = "47d2f16ca97224fe7a67d7316943df5143db969b48a6183a71e3deb900e86d16";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         asn1-encoding asn1-types base bytestring pem
       ];
       homepage = "http://github.com/vincenthz/hs-asn1dump";
       description = "Dump ASN1 structure";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "assembler" = callPackage
    ({ mkDerivation, base, containers, ghc-binary, parsec }:
     mkDerivation {
       pname = "assembler";
       version = "0.0.1";
       sha256 = "1a0bd26ce9c09050a7d7d55fcc1aeb54cf114f71498b115a2c91e1339b753cb3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ghc-binary parsec ];
       executableHaskellDepends = [ base containers ghc-binary parsec ];
       jailbreak = true;
       description = "Haskell Assembler";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {ghc-binary = null;};

  "assert" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, directory, filepath
     , system-posix-redirect
     }:
     mkDerivation {
       pname = "assert";
       version = "0.0.1.2";
       sha256 = "26e1f26aadab9615aa6a13fe6a233675af4c1613ab2e2dc37071a29ad4cdcc5f";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base bytestring Cabal directory filepath system-posix-redirect
       ];
       homepage = "https://github.com/liyang/assert";
       description = "Helpers for Control.Exception.assert";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "assert-failure" = callPackage
    ({ mkDerivation, base, pretty-show, text }:
     mkDerivation {
       pname = "assert-failure";
       version = "0.1.1.0";
       sha256 = "a13e63825502aa2568fd531fef8422676246e63b3e905c94108827eb21a4b225";
       libraryHaskellDepends = [ base pretty-show text ];
       homepage = "https://github.com/Mikolaj/assert-failure";
       description = "Syntactic sugar improving 'assert' and 'error'";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "assertions" = callPackage
    ({ mkDerivation, ansi-terminal, base, containers, interpolate
     , process
     }:
     mkDerivation {
       pname = "assertions";
       version = "0.1.0.4";
       sha256 = "487ec9ffc04507eff67fe762f65b275835d8ee02221223300c0bccbccc3257ac";
       libraryHaskellDepends = [ ansi-terminal base containers ];
       testHaskellDepends = [ base interpolate process ];
       description = "A simple testing framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "assimp" = callPackage
    ({ mkDerivation, assimp, base, c2hs, haskell98, vect }:
     mkDerivation {
       pname = "assimp";
       version = "0.1";
       sha256 = "f0136d61be5b8e58c7117d81d55f8a1fb18556f80a585a8c5b013604b6390e4a";
       libraryHaskellDepends = [ base haskell98 vect ];
       librarySystemDepends = [ assimp ];
       libraryToolDepends = [ c2hs ];
       description = "The Assimp asset import library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) assimp;};

  "astar" = callPackage
    ({ mkDerivation, base, containers, PSQueue }:
     mkDerivation {
       pname = "astar";
       version = "0.2.1";
       sha256 = "6815cdca09d9b40459c2dc180d35f9be2f5c67748f969644a2154cae94affe61";
       libraryHaskellDepends = [ base containers PSQueue ];
       description = "General A* search algorithm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "astrds" = callPackage
    ({ mkDerivation, base, containers, directory, MonadRandom, mtl
     , OpenGL, random, SDL, SDL-image, SDL-mixer, SDL-ttf, unix
     }:
     mkDerivation {
       pname = "astrds";
       version = "0.1.1";
       sha256 = "fa6b33559e99940af41e104af554cc826735d61438ff0ebb14fe866a7e3162fd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory MonadRandom mtl OpenGL random SDL
         SDL-image SDL-mixer SDL-ttf unix
       ];
       jailbreak = true;
       description = "an incomplete 2d space game";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "astview" = callPackage
    ({ mkDerivation, astview-utils, base, bytestring, containers
     , directory, filepath, glade, glib, Glob, gtk, gtksourceview2, hint
     , mtl, process, syb
     }:
     mkDerivation {
       pname = "astview";
       version = "0.1.4";
       sha256 = "f42772a41c1803733423af36e95721171b9afdef9a6beb1ddf20934dd7e26453";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         astview-utils base bytestring containers directory filepath glade
         glib Glob gtk gtksourceview2 hint mtl process syb
       ];
       description = "A GTK-based abstract syntax tree viewer for custom languages and parsers";
       license = stdenv.lib.licenses.bsdOriginal;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "astview-utils" = callPackage
    ({ mkDerivation, base, containers, syb }:
     mkDerivation {
       pname = "astview-utils";
       version = "0.1";
       sha256 = "d6bb2e6f129e6c852480403c09c1ee8887936af4b424ce5f88a735569fa518e7";
       libraryHaskellDepends = [ base containers syb ];
       description = "Interfacing between hint and astview";
       license = stdenv.lib.licenses.bsdOriginal;
     }) {};

  "async_2_0_1_6" = callPackage
    ({ mkDerivation, base, HUnit, stm, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "async";
       version = "2.0.1.6";
       sha256 = "7fca19e99fd4771fead99ff764497993f2e15c0ffbe8fa7cc49db148259edf19";
       libraryHaskellDepends = [ base stm ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "https://github.com/simonmar/async";
       description = "Run IO operations asynchronously and wait for their results";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "async_2_0_2" = callPackage
    ({ mkDerivation, base, HUnit, stm, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "async";
       version = "2.0.2";
       sha256 = "db54d384259eee2f3ca525821f45fe509b9a101fbf3a8df7132aa9622626fd2b";
       libraryHaskellDepends = [ base stm ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       homepage = "https://github.com/simonmar/async";
       description = "Run IO operations asynchronously and wait for their results";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "async" = callPackage
    ({ mkDerivation, base, HUnit, stm, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "async";
       version = "2.1.0";
       sha256 = "93c37611f9c68b5cdc8cd9960ae77a7fbc25da83cae90137ef1378d857f22c2f";
       libraryHaskellDepends = [ base stm ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       homepage = "https://github.com/simonmar/async";
       description = "Run IO operations asynchronously and wait for their results";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "async-dejafu" = callPackage
    ({ mkDerivation, base, dejafu, exceptions, HUnit, hunit-dejafu }:
     mkDerivation {
       pname = "async-dejafu";
       version = "0.1.0.0";
       sha256 = "e926c16affb72d552066367a52bc53b02c1d59ac741ede1e80248149668d53bf";
       libraryHaskellDepends = [ base dejafu exceptions ];
       testHaskellDepends = [ base dejafu HUnit hunit-dejafu ];
       homepage = "https://github.com/barrucadu/dejafu";
       description = "Run MonadConc operations asynchronously and wait for their results";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "async-extras" = callPackage
    ({ mkDerivation, async, base, lifted-async, lifted-base
     , monad-control, SafeSemaphore, stm, transformers-base
     }:
     mkDerivation {
       pname = "async-extras";
       version = "0.1.2.0";
       sha256 = "d0ff0c9a29e3acfe926bc4d4be83642944c9b0eab2bd2a177c75d14ed8bcfb8c";
       libraryHaskellDepends = [
         async base lifted-async lifted-base monad-control SafeSemaphore stm
         transformers-base
       ];
       homepage = "http://github.com/jfischoff/async-extras";
       description = "Extra Utilities for the Async Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "async-manager" = callPackage
    ({ mkDerivation, async, base, stm, unordered-containers }:
     mkDerivation {
       pname = "async-manager";
       version = "0.1.1.0";
       sha256 = "93199c669c6fcf28f9676ae482e98416ff784ede72a6cfeb51afd8e9811d5c00";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ async base stm unordered-containers ];
       executableHaskellDepends = [ async base stm unordered-containers ];
       jailbreak = true;
       homepage = "http://github.com/jfischoff/async-manager";
       description = "A thread manager for async";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "async-pool" = callPackage
    ({ mkDerivation, async, base, containers, fgl, hspec, monad-control
     , stm, time, transformers, transformers-base
     }:
     mkDerivation {
       pname = "async-pool";
       version = "0.9.0";
       sha256 = "3083cc4a45ebda8d44d25ed143f670cbdc877603ba1d37353a7dee088c172581";
       libraryHaskellDepends = [
         async base containers fgl monad-control stm transformers
         transformers-base
       ];
       testHaskellDepends = [
         async base containers fgl hspec monad-control stm time transformers
         transformers-base
       ];
       description = "A modified version of async that supports worker groups and many-to-many task dependencies";
       license = stdenv.lib.licenses.mit;
     }) {};

  "asynchronous-exceptions" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "asynchronous-exceptions";
       version = "1.1.0.1";
       sha256 = "1ad5b98f306f55365f27909eafa753f747f36c3ede2b62cb605107c36714dd6d";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/feuerbach/asynchronous-exceptions";
       description = "Distinguish between synchronous and asynchronous exceptions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "aterm" = callPackage
    ({ mkDerivation, array, base, containers, ghc-prim }:
     mkDerivation {
       pname = "aterm";
       version = "0.1.0.1";
       sha256 = "706ae520b6356ac41957c43670876383c8533d23cbbdc8b2c71c999f63944a09";
       libraryHaskellDepends = [ array base containers ghc-prim ];
       homepage = "https://svn-agbkb.informatik.uni-bremen.de/Hets/trunk/atermlib";
       description = "serialisation for Haskell values with sharing support";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "aterm-utils" = callPackage
    ({ mkDerivation, aterm, base, mtl, transformers, wl-pprint }:
     mkDerivation {
       pname = "aterm-utils";
       version = "0.2.0.2";
       sha256 = "40ce898c1159d27c2bc6cf20100d57736afc6ae9a0d81a208740d1dc5b15d37b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ aterm base mtl transformers wl-pprint ];
       executableHaskellDepends = [ aterm base transformers wl-pprint ];
       homepage = "https://github.com/GaloisInc/aterm-utils";
       description = "Utility functions for working with aterms as generated by Minitermite";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "atl" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "atl";
       version = "15409.2";
       sha256 = "0273021bd03c2210b6dab28a24ccc6c16a14c365d7fd0403ccc00d3d7207c2af";
       libraryHaskellDepends = [ base ];
       description = "Arrow Transformer Library";
       license = "LGPL";
     }) {};

  "atlassian-connect-core" = callPackage
    ({ mkDerivation, aeson, atlassian-connect-descriptor, base
     , base64-bytestring, bytestring, case-insensitive, cipher-aes
     , configurator, containers, cryptohash, hostname, http-client
     , http-client-tls, http-media, http-types, jwt, mtl, network
     , network-api-support, network-uri, snap, snap-core, split, text
     , time, time-units, transformers
     }:
     mkDerivation {
       pname = "atlassian-connect-core";
       version = "0.7.0.1";
       sha256 = "febe860cd0151f4b26c9180c71ca7526b99c204e20dc5b03e8a63b827214ee9a";
       libraryHaskellDepends = [
         aeson atlassian-connect-descriptor base base64-bytestring
         bytestring case-insensitive cipher-aes configurator containers
         cryptohash hostname http-client http-client-tls http-media
         http-types jwt mtl network network-api-support network-uri snap
         snap-core split text time time-units transformers
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/ajknoll/atlassian-connect-core";
       description = "Atlassian Connect snaplet for the Snap Framework and helper code";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "atlassian-connect-descriptor" = callPackage
    ({ mkDerivation, aeson, base, bytestring, Cabal, cases, HUnit
     , network, network-uri, scientific, text, time-units
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "atlassian-connect-descriptor";
       version = "0.4.3.1";
       sha256 = "9e7ebc206c9625dd511cc20ade5952b972091c1aafa617086578fd9f33099b84";
       libraryHaskellDepends = [
         aeson base cases network network-uri text time-units
         unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring Cabal cases HUnit network network-uri
         scientific text time-units unordered-containers vector
       ];
       jailbreak = true;
       description = "Code that helps you create a valid Atlassian Connect Descriptor";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "atmos" = callPackage
    ({ mkDerivation, base, dimensional, dimensional-tf, HUnit
     , test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "atmos";
       version = "0.3.0.0";
       sha256 = "6d53dff23edae529d31084bcb9606ac0b2268c2b8664f693e9841af670883ed4";
       libraryHaskellDepends = [ base dimensional dimensional-tf ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       description = "1976 US Standard Atmosphere Model";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "atmos-dimensional" = callPackage
    ({ mkDerivation, atmos, base, dimensional }:
     mkDerivation {
       pname = "atmos-dimensional";
       version = "0.1.2";
       sha256 = "2d8d4ba5079055577ccf71e59bdae68e329b403456f758181a680efbc36534a7";
       libraryHaskellDepends = [ atmos base dimensional ];
       description = "dimensional wrapper on atmos package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "atmos-dimensional-tf" = callPackage
    ({ mkDerivation, atmos, base, dimensional-tf }:
     mkDerivation {
       pname = "atmos-dimensional-tf";
       version = "0.1.2";
       sha256 = "154e24d2d7bc76a8b08f5f542626256c8c79d6031fb8341be06ab375efd9e215";
       libraryHaskellDepends = [ atmos base dimensional-tf ];
       description = "dimensional-tf wrapper on atmos package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "atom" = callPackage
    ({ mkDerivation, base, bimap, containers, mtl, process, syb }:
     mkDerivation {
       pname = "atom";
       version = "1.0.13";
       sha256 = "0720875ecde70f5b006a511852df7a3d47279c6553f517a3803b8b80d3f83484";
       libraryHaskellDepends = [ base bimap containers mtl process syb ];
       homepage = "http://tomahawkins.org";
       description = "An EDSL for embedded hard realtime applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "atom-basic" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, network
     , network-uri, text, time
     }:
     mkDerivation {
       pname = "atom-basic";
       version = "0.2.3";
       sha256 = "eeda4762c5f41029a6cddc56005db42d7761f4bbe23fe275f3223ef3afe6b4f9";
       libraryHaskellDepends = [
         base base64-bytestring bytestring network network-uri text time
       ];
       description = "Basic Atom feed construction";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "atom-conduit" = callPackage
    ({ mkDerivation, base, conduit, conduit-parse, data-default
     , exceptions, foldl, hlint, lens, mono-traversable, parsers
     , quickcheck-instances, resourcet, tasty, tasty-hunit
     , tasty-quickcheck, text, time, timerep, total, uri-bytestring
     , xml-conduit, xml-conduit-parse, xml-types
     }:
     mkDerivation {
       pname = "atom-conduit";
       version = "0.2.0.0";
       sha256 = "3dc3d6b784ebb2dc6a8cfc901f4c75351de5254efb6d12c6242d2cd5605e780e";
       libraryHaskellDepends = [
         base conduit conduit-parse exceptions foldl lens mono-traversable
         parsers text time timerep total uri-bytestring xml-conduit
         xml-conduit-parse xml-types
       ];
       testHaskellDepends = [
         base conduit conduit-parse data-default exceptions hlint lens
         mono-traversable parsers quickcheck-instances resourcet tasty
         tasty-hunit tasty-quickcheck text time uri-bytestring xml-conduit
         xml-conduit-parse xml-types
       ];
       description = "Streaming parser/renderer for the Atom 1.0 standard (RFC 4287).";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "atom-msp430" = callPackage
    ({ mkDerivation, atom, base, mtl }:
     mkDerivation {
       pname = "atom-msp430";
       version = "0.5.3";
       sha256 = "9a4973653ad4652192e2069584a186cfd630f7300f890ca564a3ade1ca78010a";
       libraryHaskellDepends = [ atom base mtl ];
       homepage = "https://github.com/eightyeight/atom-msp430";
       description = "Convenience functions for using Atom with the MSP430 microcontroller family";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "atomic-primops_0_8" = callPackage
    ({ mkDerivation, base, ghc-prim, primitive }:
     mkDerivation {
       pname = "atomic-primops";
       version = "0.8";
       sha256 = "c0e19e8005bb7320a0a9f6eaa5b464adb14aa88308e9922249305eeaa42f6471";
       libraryHaskellDepends = [ base ghc-prim primitive ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "atomic-primops" = callPackage
    ({ mkDerivation, base, ghc-prim, primitive }:
     mkDerivation {
       pname = "atomic-primops";
       version = "0.8.0.2";
       sha256 = "6684b0f7f11922a5a8d038155e634ecffa32c95800326fbe6f2a45eadf07f0a0";
       libraryHaskellDepends = [ base ghc-prim primitive ];
       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-primops-foreign" = callPackage
    ({ mkDerivation, base, bits-atomic, HUnit, test-framework
     , test-framework-hunit, time
     }:
     mkDerivation {
       pname = "atomic-primops-foreign";
       version = "0.6.2";
       sha256 = "f5ced9cbff2cfabde28dab10f953162e3654a962f075e8e828d668d27b5ecddd";
       revision = "1";
       editedCabalFile = "fd1067adbd96e923226347dccaa9e3e221439702fe7824c86db44eb5b7f6c318";
       libraryHaskellDepends = [ base bits-atomic ];
       testHaskellDepends = [
         base bits-atomic HUnit test-framework test-framework-hunit time
       ];
       jailbreak = true;
       homepage = "https://github.com/rrnewton/haskell-lockfree/wiki";
       description = "An atomic counter implemented using the FFI";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "atomic-primops-vector" = callPackage
    ({ mkDerivation, atomic-primops, base, primitive, vector }:
     mkDerivation {
       pname = "atomic-primops-vector";
       version = "0.1.0.1";
       sha256 = "07ef111ffb8ba7804862d6843a2006b714a9d76f261e9831249a9d1f7ba49554";
       libraryHaskellDepends = [ atomic-primops base primitive vector ];
       testHaskellDepends = [ base vector ];
       jailbreak = true;
       description = "Atomic operations on Data.Vector types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "atomic-write" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, hspec
     , temporary, text, unix-compat
     }:
     mkDerivation {
       pname = "atomic-write";
       version = "0.2.0.4";
       sha256 = "891bf2cf364bae578fe74d320324d635850865b6fa887cfe9fb4b9b0bbdf09f8";
       libraryHaskellDepends = [
         base bytestring directory filepath temporary text unix-compat
       ];
       testHaskellDepends = [
         base bytestring directory filepath hspec temporary text unix-compat
       ];
       homepage = "https://github.com/stackbuilders/atomic-write";
       description = "Atomically write to a file";
       license = stdenv.lib.licenses.mit;
     }) {};

  "atomo" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , filepath, hashable, haskeline, hint, mtl, parsec, pretty
     , regex-pcre, template-haskell, text, time, vector
     }:
     mkDerivation {
       pname = "atomo";
       version = "0.4.0.2";
       sha256 = "a8f38a901f07059717b062e237ad077d5c7b238d864c67330a25fed424317e41";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers directory filepath hashable hint
         mtl parsec pretty regex-pcre template-haskell text time vector
       ];
       executableHaskellDepends = [
         array base bytestring containers directory filepath hashable
         haskeline hint mtl parsec pretty regex-pcre template-haskell text
         time vector
       ];
       jailbreak = true;
       homepage = "http://atomo-lang.org/";
       description = "A highly dynamic, extremely simple, very fun programming language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "atp-haskell" = callPackage
    ({ mkDerivation, applicative-extras, base, containers, HUnit, mtl
     , parsec, pretty, template-haskell, time
     }:
     mkDerivation {
       pname = "atp-haskell";
       version = "1.10";
       sha256 = "a6e9178c6db9de5a2c1ad4a158d1730f2e3e5eb1b20f9a06a7263597fe8a1d32";
       libraryHaskellDepends = [
         applicative-extras base containers HUnit mtl parsec pretty
         template-haskell time
       ];
       testHaskellDepends = [ base containers HUnit time ];
       homepage = "https://github.com/seereason/atp-haskell";
       description = "Translation from Ocaml to Haskell of John Harrison's ATP code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "atrans" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "atrans";
       version = "0.1.1.0";
       sha256 = "9119df84f2dacc53935238c4c225f26937e25898d91b8c2d973e4cf467249b66";
       libraryHaskellDepends = [ base mtl ];
       homepage = "https://github.com/aphorisme/atrans";
       description = "A small collection of monad (transformer) instances";
       license = stdenv.lib.licenses.mit;
     }) {};

  "attempt" = callPackage
    ({ mkDerivation, base, failure }:
     mkDerivation {
       pname = "attempt";
       version = "0.4.0.1";
       sha256 = "b0e7e461d07a4ebc5364b048748bdbe6bee742eb1504213242730aa31b0178bf";
       libraryHaskellDepends = [ base failure ];
       homepage = "http://github.com/snoyberg/attempt/tree/master";
       description = "Concrete data type for handling extensible exceptions as failures. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "atto-lisp_0_2_2" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-textual
     , bytestring, containers, deepseq, HUnit, test-framework
     , test-framework-hunit, text
     }:
     mkDerivation {
       pname = "atto-lisp";
       version = "0.2.2";
       sha256 = "0c4a703f37bd8dbcada5813a2d81179737aded6183a1a2944bf691aaa86a908e";
       revision = "1";
       editedCabalFile = "feb39753d89c58abac767ed3fe5644428b5d15d83c69f7b26b282f3b9969f2fa";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-textual bytestring containers
         deepseq text
       ];
       testHaskellDepends = [
         attoparsec base bytestring HUnit test-framework
         test-framework-hunit text
       ];
       jailbreak = true;
       homepage = "http://github.com/nominolo/atto-lisp";
       description = "Efficient parsing and serialisation of S-Expressions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "atto-lisp" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-textual
     , bytestring, containers, deepseq, HUnit, test-framework
     , test-framework-hunit, text
     }:
     mkDerivation {
       pname = "atto-lisp";
       version = "0.2.2.2";
       sha256 = "24bacde886e3ee8adf50cb33f34b935a254cdd415bebd7c81ac75b8dfb0a0066";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-textual bytestring containers
         deepseq text
       ];
       testHaskellDepends = [
         attoparsec base bytestring HUnit test-framework
         test-framework-hunit text
       ];
       homepage = "http://github.com/nominolo/atto-lisp";
       description = "Efficient parsing and serialisation of S-Expressions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "attoparsec_0_12_1_2" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , QuickCheck, scientific, test-framework
     , test-framework-quickcheck2, text, vector
     }:
     mkDerivation {
       pname = "attoparsec";
       version = "0.12.1.2";
       sha256 = "8cc20cb490a1d4650aaab28a214fd54776b23f904b0f5070780daae646f65fed";
       libraryHaskellDepends = [
         array base bytestring containers deepseq scientific text
       ];
       testHaskellDepends = [
         array base bytestring deepseq QuickCheck scientific test-framework
         test-framework-quickcheck2 text vector
       ];
       homepage = "https://github.com/bos/attoparsec";
       description = "Fast combinator parsing for bytestrings and text";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "attoparsec_0_12_1_3" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , QuickCheck, quickcheck-unicode, scientific, test-framework
     , test-framework-quickcheck2, text, vector
     }:
     mkDerivation {
       pname = "attoparsec";
       version = "0.12.1.3";
       sha256 = "4e20c9c8b9c3f42efa9493fa9bd5befc173b725345d27731d090f4348199bad4";
       libraryHaskellDepends = [
         array base bytestring containers deepseq scientific text
       ];
       testHaskellDepends = [
         array base bytestring deepseq QuickCheck quickcheck-unicode
         scientific test-framework test-framework-quickcheck2 text vector
       ];
       homepage = "https://github.com/bos/attoparsec";
       description = "Fast combinator parsing for bytestrings and text";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "attoparsec_0_12_1_5" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , QuickCheck, quickcheck-unicode, scientific, test-framework
     , test-framework-quickcheck2, text, vector
     }:
     mkDerivation {
       pname = "attoparsec";
       version = "0.12.1.5";
       sha256 = "388bf78177d4b8b870db7fb291d103691ccf171d97d2944f09cc62d01516348c";
       libraryHaskellDepends = [
         array base bytestring containers deepseq scientific text
       ];
       testHaskellDepends = [
         array base bytestring deepseq QuickCheck quickcheck-unicode
         scientific test-framework test-framework-quickcheck2 text vector
       ];
       homepage = "https://github.com/bos/attoparsec";
       description = "Fast combinator parsing for bytestrings and text";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "attoparsec_0_12_1_6" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , QuickCheck, quickcheck-unicode, scientific, test-framework
     , test-framework-quickcheck2, text, vector
     }:
     mkDerivation {
       pname = "attoparsec";
       version = "0.12.1.6";
       sha256 = "ce0bb68c3a232dc981412b44211395ee04b0c18075777c30493d4e0f1edc06a8";
       libraryHaskellDepends = [
         array base bytestring containers deepseq scientific text
       ];
       testHaskellDepends = [
         array base bytestring deepseq QuickCheck quickcheck-unicode
         scientific test-framework test-framework-quickcheck2 text vector
       ];
       homepage = "https://github.com/bos/attoparsec";
       description = "Fast combinator parsing for bytestrings and text";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "attoparsec" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , QuickCheck, quickcheck-unicode, scientific, test-framework
     , test-framework-quickcheck2, text, transformers, vector
     }:
     mkDerivation {
       pname = "attoparsec";
       version = "0.13.0.1";
       sha256 = "ce880acb45142eafd872e01d9af57d8dbb95c9f2b9a27f01ca9912ba4e9ef932";
       libraryHaskellDepends = [
         array base bytestring containers deepseq scientific text
         transformers
       ];
       testHaskellDepends = [
         array base bytestring containers deepseq QuickCheck
         quickcheck-unicode scientific test-framework
         test-framework-quickcheck2 text transformers vector
       ];
       homepage = "https://github.com/bos/attoparsec";
       description = "Fast combinator parsing for bytestrings and text";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "attoparsec-arff" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring }:
     mkDerivation {
       pname = "attoparsec-arff";
       version = "0.0";
       sha256 = "047b5a786f704e20fdb102754c35b12ae91d61551133d026d4ae557c8b01c9c9";
       libraryHaskellDepends = [ attoparsec base bytestring ];
       description = "An ARFF file parser using Attoparsec";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "attoparsec-binary" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring }:
     mkDerivation {
       pname = "attoparsec-binary";
       version = "0.2";
       sha256 = "05e6445b20b396c99275de3e37bf8bb18559a5666ad5136907857bf574e77a0b";
       libraryHaskellDepends = [ attoparsec base bytestring ];
       description = "Binary processing extensions to Attoparsec";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "attoparsec-conduit" = callPackage
    ({ mkDerivation, base, conduit }:
     mkDerivation {
       pname = "attoparsec-conduit";
       version = "1.1.0";
       sha256 = "3e809f4e354ef392cd7266dc35b8f660cb5810974159c5106a0c3ed7bf1db6a3";
       libraryHaskellDepends = [ base conduit ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Consume attoparsec parsers via conduit. (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "attoparsec-csv" = callPackage
    ({ mkDerivation, attoparsec, base, text }:
     mkDerivation {
       pname = "attoparsec-csv";
       version = "0.1.0.1";
       sha256 = "1be03800c7f8fcfade041affd567716f4102984464e068f5ec2ddb834c7a017e";
       libraryHaskellDepends = [ attoparsec base text ];
       jailbreak = true;
       homepage = "https://github.com/robinbb/attoparsec-csv";
       description = "A parser for CSV files that uses Attoparsec";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "attoparsec-enumerator_0_3_3" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, enumerator, text }:
     mkDerivation {
       pname = "attoparsec-enumerator";
       version = "0.3.3";
       sha256 = "3cf105cdc29120a5c21487708783155a35fd9d4df29f72e56c22ed93f85aa77c";
       libraryHaskellDepends = [
         attoparsec base bytestring enumerator text
       ];
       jailbreak = true;
       homepage = "https://john-millikin.com/software/attoparsec-enumerator/";
       description = "Pass input from an enumerator to an Attoparsec parser";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "attoparsec-enumerator" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, enumerator, text }:
     mkDerivation {
       pname = "attoparsec-enumerator";
       version = "0.3.4";
       sha256 = "be95a763ebbec5529f486e62e49ce6709f14e688138fc36cff5590613690f588";
       libraryHaskellDepends = [
         attoparsec base bytestring enumerator text
       ];
       homepage = "https://john-millikin.com/software/attoparsec-enumerator/";
       description = "Pass input from an enumerator to an Attoparsec parser";
       license = stdenv.lib.licenses.mit;
     }) {};

  "attoparsec-expr_0_1_1_1" = callPackage
    ({ mkDerivation, attoparsec, base }:
     mkDerivation {
       pname = "attoparsec-expr";
       version = "0.1.1.1";
       sha256 = "83293b583e94d32e6e86073038c23def80d9c860e8a046f6dd8f0d9c2e2d6024";
       libraryHaskellDepends = [ attoparsec base ];
       jailbreak = true;
       description = "Port of parsec's expression parser to attoparsec";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "attoparsec-expr" = callPackage
    ({ mkDerivation, attoparsec, base }:
     mkDerivation {
       pname = "attoparsec-expr";
       version = "0.1.1.2";
       sha256 = "8d4cd436112ce9007d2831776d4c5102a5322c48993229d2d41e259c07bb457c";
       libraryHaskellDepends = [ attoparsec base ];
       description = "Port of parsec's expression parser to attoparsec";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "attoparsec-iteratee" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, iteratee
     , transformers
     }:
     mkDerivation {
       pname = "attoparsec-iteratee";
       version = "0.4.0";
       sha256 = "5a5cbcd73aa9219efae6038af2012c4b59b1b95e2e7ffbc40a113e3226eca7c8";
       libraryHaskellDepends = [
         attoparsec base bytestring iteratee transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/gregorycollins";
       description = "An adapter to convert attoparsec Parsers into blazing-fast Iteratees";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "attoparsec-parsec" = callPackage
    ({ mkDerivation, attoparsec, base, hspec, markdown-unlit, parsec
     , QuickCheck, text
     }:
     mkDerivation {
       pname = "attoparsec-parsec";
       version = "0.1.3";
       sha256 = "f8f3dcb1417720d352c7401917b66f3d2c1d6ef3b1fa744ca8486bc667702356";
       libraryHaskellDepends = [ attoparsec base parsec text ];
       testHaskellDepends = [
         attoparsec base hspec markdown-unlit QuickCheck text
       ];
       description = "An Attoparsec compatibility layer for Parsec";
       license = stdenv.lib.licenses.mit;
     }) {};

  "attoparsec-text" = callPackage
    ({ mkDerivation, array, attoparsec, base, containers, text }:
     mkDerivation {
       pname = "attoparsec-text";
       version = "0.8.5.3";
       sha256 = "258c59ab01b7bc7bd6ba614a8209272b18caaf894e594b8d02082a1d2e1504e3";
       libraryHaskellDepends = [ array attoparsec base containers text ];
       jailbreak = true;
       homepage = "http://patch-tag.com/r/felipe/attoparsec-text/home";
       description = "(deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "attoparsec-text-enumerator" = callPackage
    ({ mkDerivation, attoparsec-text, base, enumerator, text }:
     mkDerivation {
       pname = "attoparsec-text-enumerator";
       version = "0.2.0.1";
       sha256 = "ff85052120fc1fac70f67d97f918d284760456096bab9313d03290102567ce31";
       libraryHaskellDepends = [ attoparsec-text base enumerator text ];
       jailbreak = true;
       description = "(deprecated)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "attoparsec-trans" = callPackage
    ({ mkDerivation, attoparsec, base, transformers }:
     mkDerivation {
       pname = "attoparsec-trans";
       version = "0.1.1.0";
       sha256 = "472999fbb9ba157b4cdabb3fd933b9e3c8414879843963ab1c21e708e1a14b53";
       libraryHaskellDepends = [ attoparsec base transformers ];
       homepage = "https://github.com/srijs/haskell-attoparsec-trans";
       description = "Interleaved effects for attoparsec parsers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "attosplit" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring }:
     mkDerivation {
       pname = "attosplit";
       version = "0.1.0.0";
       sha256 = "e4f9ae353ebeb1e2c36aa905838a2545a6e25826c72e1a3aee808064d3445007";
       libraryHaskellDepends = [ attoparsec base bytestring ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/attosplit";
       description = "Split a lazy bytestring at boundaries defined by an attoparsec parser";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "atuin" = callPackage
    ({ mkDerivation, array, base, Cabal, directory, epic, haskell98 }:
     mkDerivation {
       pname = "atuin";
       version = "0.1.1";
       sha256 = "537e67f5ba092f3ca95af187b4a47420380fb5f66fb4bbe777beaa34e8b6aef2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base Cabal directory epic haskell98
       ];
       homepage = "http://www.dcs.st-and.ac.uk/~eb/epic.php";
       description = "Embedded Turtle language compiler in Haskell, with Epic output";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "audacity" = callPackage
    ({ mkDerivation, base, deepseq, utility-ht }:
     mkDerivation {
       pname = "audacity";
       version = "0.0";
       sha256 = "1f578e6cf8bfc5524a9e49ff306a736ab1c5db2a8a4ab4a3e4f47cb34a2fd7ed";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base deepseq utility-ht ];
       homepage = "http://code.haskell.org/~thielema/audacity";
       description = "Interchange with the Audacity sound signal editor";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "audiovisual" = callPackage
    ({ mkDerivation, base, boundingboxes, colors, deepseq, directory
     , filepath, free, freetype2, hashable, JuicyPixels
     , JuicyPixels-util, lens, linear, mtl, objective, random
     , template-haskell, transformers, vector, void, WAVE
     }:
     mkDerivation {
       pname = "audiovisual";
       version = "0.0";
       sha256 = "70dcafa4522d6b0cf13076872bf92069611775e370c2033d8ea35051f6d64c62";
       libraryHaskellDepends = [
         base boundingboxes colors deepseq directory filepath free freetype2
         hashable JuicyPixels JuicyPixels-util lens linear mtl objective
         random template-haskell transformers vector void WAVE
       ];
       homepage = "https://github.com/fumieval/audiovisual";
       description = "A battery-included audiovisual framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "augeas" = callPackage
    ({ mkDerivation, augeas, base, bytestring, directory, HUnit, unix
     }:
     mkDerivation {
       pname = "augeas";
       version = "0.6.1";
       sha256 = "45e763193c57505975c331f51fba1440db5c98fce95732d6d89499084fa2e623";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring directory unix ];
       libraryPkgconfigDepends = [ augeas ];
       executableHaskellDepends = [ HUnit ];
       executableSystemDepends = [ augeas ];
       executablePkgconfigDepends = [ augeas ];
       homepage = "http://trac.haskell.org/augeas";
       description = "A Haskell FFI wrapper for the Augeas API";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) augeas;};

  "augur" = callPackage
    ({ mkDerivation, base, bytestring, classify, containers, directory
     , filepath, HaXml, mtl, process
     }:
     mkDerivation {
       pname = "augur";
       version = "2008.11.17";
       sha256 = "d97550b21210b51a1b58ca530ecb3595d7c57b61ac4f9f2f04a49a9ffe706bcb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring classify containers directory filepath HaXml mtl
         process
       ];
       jailbreak = true;
       description = "Renaming media collections in a breeze";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aur" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, filepath, lens
     , lens-aeson, mtl, text, vector, wreq
     }:
     mkDerivation {
       pname = "aur";
       version = "4.0.2";
       sha256 = "918c575536b17ce232e023b0c7e408f1c156a580cc770f78be2953190a465d8e";
       libraryHaskellDepends = [
         aeson aeson-pretty base filepath lens lens-aeson mtl text vector
         wreq
       ];
       homepage = "https://github.com/fosskers/haskell-aur";
       description = "Access metadata from the Arch Linux User Repository";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "authenticate_1_3_2_10" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
     , case-insensitive, conduit, containers, http-conduit, http-types
     , monad-control, network-uri, resourcet, tagstream-conduit, text
     , transformers, unordered-containers, xml-conduit
     }:
     mkDerivation {
       pname = "authenticate";
       version = "1.3.2.10";
       sha256 = "c44dec73e5c24f2e62a9a0c0b7622cd91bd0abdc07fec067ee43d72bcb44c3b7";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder bytestring case-insensitive
         conduit containers http-conduit http-types monad-control
         network-uri resourcet tagstream-conduit text transformers
         unordered-containers xml-conduit
       ];
       homepage = "http://github.com/yesodweb/authenticate";
       description = "Authentication methods for Haskell web applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "authenticate_1_3_2_11" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
     , case-insensitive, conduit, containers, http-conduit, http-types
     , monad-control, network-uri, resourcet, tagstream-conduit, text
     , transformers, unordered-containers, xml-conduit
     }:
     mkDerivation {
       pname = "authenticate";
       version = "1.3.2.11";
       sha256 = "049388bf2ebf9017f3854462e1e2af57366959528e815017651e8da112577ff6";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder bytestring case-insensitive
         conduit containers http-conduit http-types monad-control
         network-uri resourcet tagstream-conduit text transformers
         unordered-containers xml-conduit
       ];
       homepage = "http://github.com/yesodweb/authenticate";
       description = "Authentication methods for Haskell web applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "authenticate" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
     , case-insensitive, conduit, containers, http-conduit, http-types
     , monad-control, network-uri, resourcet, tagstream-conduit, text
     , transformers, unordered-containers, xml-conduit
     }:
     mkDerivation {
       pname = "authenticate";
       version = "1.3.3";
       sha256 = "6807cd32c5ff9b23cd6f184ffd7fb7f99c4a7f0dc645eae82f2d6dfbd1899bbe";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder bytestring case-insensitive
         conduit containers http-conduit http-types monad-control
         network-uri resourcet tagstream-conduit text transformers
         unordered-containers xml-conduit
       ];
       homepage = "http://github.com/yesodweb/authenticate";
       description = "Authentication methods for Haskell web applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "authenticate-kerberos" = callPackage
    ({ mkDerivation, base, process, text }:
     mkDerivation {
       pname = "authenticate-kerberos";
       version = "1.0.0";
       sha256 = "b839b22799a8f002bcf22b865e664bc197f136a064b37adb30b8136253ec681a";
       libraryHaskellDepends = [ base process text ];
       homepage = "http://github.com/yesodweb/authenticate";
       description = "Authentication methods for Haskell web applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "authenticate-ldap" = callPackage
    ({ mkDerivation, base, LDAP, text, transformers }:
     mkDerivation {
       pname = "authenticate-ldap";
       version = "0.0.3";
       sha256 = "c553e23553500dabb18f0a5f997d564a5f5b03934eec08ff95805079e8205df3";
       libraryHaskellDepends = [ base LDAP text transformers ];
       jailbreak = true;
       homepage = "http://github.com:mlitchard/authenticate-ldap";
       description = "LDAP authentication for Haskell web applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "authenticate-oauth" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring
     , crypto-pubkey-types, data-default, http-client, http-types
     , random, RSA, SHA, time, transformers
     }:
     mkDerivation {
       pname = "authenticate-oauth";
       version = "1.5.1.1";
       sha256 = "eb9f15ebc6eb4a9ce08115c729e3e6803b28e35edf0ab5bc19fed64f9a2fc30b";
       revision = "1";
       editedCabalFile = "aee0c275e41e83d208bdfbc6634ea463df5dfb3780218b73e1b5599a0c11476e";
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder bytestring crypto-pubkey-types
         data-default http-client http-types random RSA SHA time
         transformers
       ];
       homepage = "http://github.com/yesodweb/authenticate";
       description = "Library to authenticate with OAuth for Haskell web applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "authinfo-hs" = callPackage
    ({ mkDerivation, attoparsec, base, network, text }:
     mkDerivation {
       pname = "authinfo-hs";
       version = "0.1.0.0";
       sha256 = "e5d2f6b8d158b84a29001d779447e463d70403ebeb0fde4bea0dbd283cf160cb";
       libraryHaskellDepends = [ attoparsec base network text ];
       homepage = "http://github.com/robgssp/authinfo-hs";
       description = "Password querying for .authinfo";
       license = stdenv.lib.licenses.mit;
     }) {};

  "authoring" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, citation-resolve, containers
     , data-default, haskell-src-meta, HaTeX, lens, mtl, parsers, safe
     , template-haskell, text, transformers, trifecta
     }:
     mkDerivation {
       pname = "authoring";
       version = "0.3.4";
       sha256 = "6402eecdfb6945f2f0c8b62afc3795fde0454ed3fe4c19de66ee6236577edd49";
       libraryHaskellDepends = [
         ansi-wl-pprint base citation-resolve containers data-default
         haskell-src-meta HaTeX lens mtl parsers safe template-haskell text
         transformers trifecta
       ];
       homepage = "http://github.com/nushio3/authoring";
       description = "A library for writing papers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "auto" = callPackage
    ({ mkDerivation, base, base-orphans, bytestring, cereal, containers
     , deepseq, MonadRandom, profunctors, random, semigroups
     , transformers
     }:
     mkDerivation {
       pname = "auto";
       version = "0.4.3.0";
       sha256 = "c836cdc107b3d131129340b74285c55b8d65dc217e3c6f0a79bdc742a0062c8e";
       libraryHaskellDepends = [
         base base-orphans bytestring cereal containers deepseq MonadRandom
         profunctors random semigroups transformers
       ];
       homepage = "https://github.com/mstksg/auto";
       description = "Denotative, locally stateful programming DSL & platform";
       license = stdenv.lib.licenses.mit;
     }) {};

  "auto-update_0_1_2" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "auto-update";
       version = "0.1.2";
       sha256 = "14fcf02d5e78db86e438dc1fdfcc9e2e290d170bad96ececfe135f2903e99131";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/yesodweb/wai";
       description = "Efficiently run periodic, on-demand actions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "auto-update_0_1_2_1" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "auto-update";
       version = "0.1.2.1";
       sha256 = "97d3228ab744ca24b0838a001cb56be24f905e3237581ada800274219cbc4132";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/yesodweb/wai";
       description = "Efficiently run periodic, on-demand actions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "auto-update_0_1_2_2" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "auto-update";
       version = "0.1.2.2";
       sha256 = "7b3000c330055d4059fe8d9ab044c29e3a57b4dc31b88ea386a75a886b6144db";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/yesodweb/wai";
       description = "Efficiently run periodic, on-demand actions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "auto-update" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "auto-update";
       version = "0.1.3";
       sha256 = "3d8e11271d9c0bacefd663143af60c530dd7483b70582bae56e64b6716891509";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/yesodweb/wai";
       description = "Efficiently run periodic, on-demand actions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "autonix-deps" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, conduit
     , containers, errors, filepath, lens, libarchive-conduit, mtl
     , optparse-applicative, process, regex-tdfa, resourcet, semigroups
     , text, transformers, xml
     }:
     mkDerivation {
       pname = "autonix-deps";
       version = "0.3.0.0";
       sha256 = "9baa7c387af363674385b7bdb5df57904dd752ebb5a73fde53d492dab8d9e256";
       libraryHaskellDepends = [
         aeson aeson-pretty base bytestring conduit containers errors
         filepath lens libarchive-conduit mtl optparse-applicative process
         regex-tdfa resourcet semigroups text transformers xml
       ];
       description = "Library for Nix expression dependency generation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "autonix-deps-kf5" = callPackage
    ({ mkDerivation, autonix-deps, base, bytestring, conduit
     , containers, filepath, lens, mtl, text, transformers
     }:
     mkDerivation {
       pname = "autonix-deps-kf5";
       version = "0.3.0.0";
       sha256 = "c19068cbae9ba93f0b1e634ee948c52f6680ef886b779183622800d3457f555a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         autonix-deps base bytestring conduit containers filepath lens mtl
         text transformers
       ];
       executableHaskellDepends = [
         autonix-deps base containers lens mtl
       ];
       description = "Generate dependencies for KDE 5 Nix expressions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "autoproc" = callPackage
    ({ mkDerivation, base, directory, mtl, process, unix }:
     mkDerivation {
       pname = "autoproc";
       version = "0.1.2";
       sha256 = "c574e182b1eae253e7d63b8d6c3b648d57b5508e465e36146536a12c0556347b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory mtl process unix ];
       homepage = "http://code.haskell.org/autoproc";
       description = "EDSL for Procmail scripts";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "avahi" = callPackage
    ({ mkDerivation, base, dbus-core, text }:
     mkDerivation {
       pname = "avahi";
       version = "0.1.1";
       sha256 = "002a431d7d5d5a1d47827756f97a24ca88cdfc88127b687cd0e88d7133e04b2c";
       libraryHaskellDepends = [ base dbus-core text ];
       description = "Minimal DBus bindings for Avahi daemon (http://avahi.org)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "avatar-generator" = callPackage
    ({ mkDerivation, base, JuicyPixels, random }:
     mkDerivation {
       pname = "avatar-generator";
       version = "0.1.0.1";
       sha256 = "ff87c2530ce71ae090c4f29d41c0765652746a93b91f99a53d5125a3dd37369c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base JuicyPixels random ];
       jailbreak = true;
       homepage = "http://github.com/keera-studios/avatar-generator";
       description = "A simple random avatar icon generator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "average" = callPackage
    ({ mkDerivation, base, semigroups, vector-space }:
     mkDerivation {
       pname = "average";
       version = "0.6.1";
       sha256 = "3029e01ef5c46892eb0b6561283635a6da409b59a3c1cf93d1092cd6f87c138f";
       revision = "1";
       editedCabalFile = "90c8c1d4ece76a1f1b43f1a6bef7ba15340a2bec8e2efbb465884d6b50b5d174";
       libraryHaskellDepends = [ base semigroups vector-space ];
       description = "An average (arithmetic mean) monoid";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "avers_0_0_13" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , bytestring, clock, containers, cryptohash, filepath, hspec
     , inflections, MonadRandom, mtl, network, network-uri
     , resource-pool, rethinkdb-client-driver, safe, scrypt, stm
     , template-haskell, text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "avers";
       version = "0.0.13";
       sha256 = "419abfc046fdb3561d20ed65e4dfc07e140e1cc03406832060d5b218a3cf3f18";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring bytestring clock containers
         cryptohash filepath inflections MonadRandom mtl network network-uri
         resource-pool rethinkdb-client-driver safe scrypt stm
         template-haskell text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base16-bytestring bytestring containers
         cryptohash hspec inflections MonadRandom mtl resource-pool
         rethinkdb-client-driver scrypt stm text time unordered-containers
         vector
       ];
       description = "empty";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "avers" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , bytestring, clock, containers, cryptohash, filepath, hspec
     , inflections, MonadRandom, mtl, network, network-uri
     , resource-pool, rethinkdb-client-driver, safe, scrypt, stm
     , template-haskell, text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "avers";
       version = "0.0.14";
       sha256 = "44eb3978af5da284cc152237ea5217d5706815bd1c46be1fb63251fb99e58aa1";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring bytestring clock containers
         cryptohash filepath inflections MonadRandom mtl network network-uri
         resource-pool rethinkdb-client-driver safe scrypt stm
         template-haskell text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base16-bytestring bytestring containers
         cryptohash hspec inflections MonadRandom mtl resource-pool
         rethinkdb-client-driver scrypt stm text time unordered-containers
         vector
       ];
       description = "empty";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "avers-api_0_0_1" = callPackage
    ({ mkDerivation, aeson, avers, base, bytestring, cookie, servant
     , text, time
     }:
     mkDerivation {
       pname = "avers-api";
       version = "0.0.1";
       sha256 = "a4b129911501494d231ecb13397b8bcac05ec6225a4122ec9b4f00e31b4cbd1b";
       libraryHaskellDepends = [
         aeson avers base bytestring cookie servant text time
       ];
       doHaddock = false;
       homepage = "http://github.com/wereHamster/avers-api";
       description = "Types describing the core and extended Avers APIs";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "avers-api" = callPackage
    ({ mkDerivation, aeson, avers, base, bytestring, cookie, servant
     , text, time
     }:
     mkDerivation {
       pname = "avers-api";
       version = "0.0.2";
       sha256 = "c2f61dc6c15dc4976584ab68c086488b8d7a0ab21ff4b50c0236e3ef0f8fe4f8";
       libraryHaskellDepends = [
         aeson avers base bytestring cookie servant text time
       ];
       doHaddock = false;
       homepage = "http://github.com/wereHamster/avers-api";
       description = "Types describing the core and extended Avers APIs";
       license = stdenv.lib.licenses.mit;
     }) {};

  "avers-server_0_0_1" = callPackage
    ({ mkDerivation, aeson, avers, avers-api, base, bytestring
     , bytestring-conversion, cookie, either, http-types, mtl
     , resource-pool, rethinkdb-client-driver, servant, servant-server
     , text, time, transformers, wai, wai-websockets, websockets
     }:
     mkDerivation {
       pname = "avers-server";
       version = "0.0.1";
       sha256 = "e61d4ec267e3ad71096360dde4081da4e044bb1a39b2b29b507c28ae5cae06c0";
       libraryHaskellDepends = [
         aeson avers avers-api base bytestring bytestring-conversion cookie
         either http-types mtl resource-pool rethinkdb-client-driver servant
         servant-server text time transformers wai wai-websockets websockets
       ];
       homepage = "http://github.com/wereHamster/avers-server";
       description = "Server implementation of the Avers API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "avers-server" = callPackage
    ({ mkDerivation, aeson, avers, avers-api, base, base64-bytestring
     , bytestring, bytestring-conversion, cookie, cryptohash, either
     , http-types, mtl, resource-pool, rethinkdb-client-driver, servant
     , servant-server, text, time, transformers, wai, wai-websockets
     , websockets
     }:
     mkDerivation {
       pname = "avers-server";
       version = "0.0.2";
       sha256 = "0f02f100dd5ebaf8e3a538ef3075ecb61dbe38c1d9fad9f3e7735708ca96a55f";
       libraryHaskellDepends = [
         aeson avers avers-api base base64-bytestring bytestring
         bytestring-conversion cookie cryptohash either http-types mtl
         resource-pool rethinkdb-client-driver servant servant-server text
         time transformers wai wai-websockets websockets
       ];
       homepage = "http://github.com/wereHamster/avers-server";
       description = "Server implementation of the Avers API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "avl-static" = callPackage
    ({ mkDerivation, base, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "avl-static";
       version = "0.1.0.0";
       sha256 = "20b0a9f7a858d980dadc96704709e5e2e1d448dcb17aa53f6064ad7a332f348f";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       description = "A compile-time balanced AVL tree";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "avr-shake" = callPackage
    ({ mkDerivation, base, dependent-sum, mtl, process, shake }:
     mkDerivation {
       pname = "avr-shake";
       version = "0.0.1.2";
       sha256 = "60102786473f189ea0f97d97b91d9de5a2867dde466b96386c28afbe22e056cc";
       libraryHaskellDepends = [ base dependent-sum mtl process shake ];
       jailbreak = true;
       homepage = "https://github.com/mokus0/avr-shake";
       description = "AVR Crosspack actions for shake build systems";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "awesome-prelude" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "awesome-prelude";
       version = "0.1.0.0";
       sha256 = "cf5edb7500a02aaba7400f3baab984680898dbedc0cf5b09ded2ca40568e6e57";
       libraryHaskellDepends = [ base ];
       homepage = "https://notabug.org/koz.ross/awesome-prelude";
       description = "A prelude which I can be happy with. Based on base-prelude.";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "awesomium" = callPackage
    ({ mkDerivation, aeson, attoparsec, awesomium-raw, base, containers
     , text, vector
     }:
     mkDerivation {
       pname = "awesomium";
       version = "0.1.0.0";
       sha256 = "02ab23a054aab002dd2ddc32aa896966a8627da33911e523a20d67c2a94da861";
       libraryHaskellDepends = [
         aeson attoparsec awesomium-raw base containers text vector
       ];
       description = "High-level Awesomium bindings";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "awesomium-glut" = callPackage
    ({ mkDerivation, awesomium, awesomium-raw, base, GLUT }:
     mkDerivation {
       pname = "awesomium-glut";
       version = "0.1.0.0";
       sha256 = "edfe81d9c3bc77dd1da7c46d5b92a21b1f6e10f53967f0d2294648d1237eb09c";
       libraryHaskellDepends = [ awesomium awesomium-raw base GLUT ];
       description = "Utilities for using Awesomium with GLUT";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "awesomium-raw" = callPackage
    ({ mkDerivation, awesomium, base, c2hs }:
     mkDerivation {
       pname = "awesomium-raw";
       version = "0.1.0.0";
       sha256 = "cbdbce6189dcf74993971c87f1afc6ebf8490d875c71aab526c8a3f5b2a65136";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ awesomium ];
       libraryToolDepends = [ c2hs ];
       description = "Low-level Awesomium bindings";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {awesomium = null;};

  "aws_0_11" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, blaze-builder, byteable, bytestring
     , case-insensitive, cereal, conduit, conduit-extra, containers
     , cryptohash, data-default, directory, errors, filepath
     , http-client, http-conduit, http-types, lifted-base, monad-control
     , mtl, network, old-locale, QuickCheck, quickcheck-instances
     , resourcet, safe, scientific, tagged, tasty, tasty-quickcheck
     , text, time, transformers, transformers-base, unordered-containers
     , utf8-string, vector, xml-conduit
     }:
     mkDerivation {
       pname = "aws";
       version = "0.11";
       sha256 = "496dafa5f847a4401d8ec34c45e11e77ee558ea9dc09caef2680f7c2c8c907a7";
       revision = "1";
       editedCabalFile = "60b1c78a946c4c45dae2771dfedeebacb1229e0f61d03dbf3ed76dbcbbb96c13";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         blaze-builder byteable bytestring case-insensitive cereal conduit
         conduit-extra containers cryptohash data-default directory filepath
         http-conduit http-types lifted-base monad-control mtl network
         old-locale resourcet safe scientific tagged text time transformers
         unordered-containers utf8-string vector xml-conduit
       ];
       testHaskellDepends = [
         aeson base bytestring errors http-client lifted-base monad-control
         mtl QuickCheck quickcheck-instances resourcet tagged tasty
         tasty-quickcheck text time transformers transformers-base
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/aristidb/aws";
       description = "Amazon Web Services (AWS) for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws_0_11_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, blaze-builder, byteable, bytestring
     , case-insensitive, cereal, conduit, conduit-extra, containers
     , cryptohash, data-default, directory, errors, filepath
     , http-client, http-conduit, http-types, lifted-base, monad-control
     , mtl, network, old-locale, QuickCheck, quickcheck-instances
     , resourcet, safe, scientific, tagged, tasty, tasty-quickcheck
     , text, time, transformers, transformers-base, unordered-containers
     , utf8-string, vector, xml-conduit
     }:
     mkDerivation {
       pname = "aws";
       version = "0.11.2";
       sha256 = "f1e3df0c141823f384f3410c9eef92eb410b716b0caa6534aec67dacb82b1697";
       revision = "2";
       editedCabalFile = "9759b26f78a14b3e31eb516e471af0ad00840793a0029170c5e27ffaf14e1838";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         blaze-builder byteable bytestring case-insensitive cereal conduit
         conduit-extra containers cryptohash data-default directory filepath
         http-conduit http-types lifted-base monad-control mtl network
         old-locale resourcet safe scientific tagged text time transformers
         unordered-containers utf8-string vector xml-conduit
       ];
       testHaskellDepends = [
         aeson base bytestring errors http-client lifted-base monad-control
         mtl QuickCheck quickcheck-instances resourcet tagged tasty
         tasty-quickcheck text time transformers transformers-base
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/aristidb/aws";
       description = "Amazon Web Services (AWS) for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws_0_11_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, blaze-builder, byteable, bytestring
     , case-insensitive, cereal, conduit, conduit-extra, containers
     , cryptohash, data-default, directory, errors, filepath
     , http-client, http-conduit, http-types, lifted-base, monad-control
     , mtl, network, old-locale, QuickCheck, quickcheck-instances
     , resourcet, safe, scientific, tagged, tasty, tasty-quickcheck
     , text, time, transformers, transformers-base, unordered-containers
     , utf8-string, vector, xml-conduit
     }:
     mkDerivation {
       pname = "aws";
       version = "0.11.3";
       sha256 = "14a9a9f4435f92b9a0364de66469e293f3ad09c7fe54aacce3486280866de30a";
       revision = "2";
       editedCabalFile = "73e3d00ce401c09e55bfd27b2d73afff8709d43967718182c5ebc8b406d6bcf6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         blaze-builder byteable bytestring case-insensitive cereal conduit
         conduit-extra containers cryptohash data-default directory filepath
         http-conduit http-types lifted-base monad-control mtl network
         old-locale resourcet safe scientific tagged text time transformers
         unordered-containers utf8-string vector xml-conduit
       ];
       testHaskellDepends = [
         aeson base bytestring errors http-client lifted-base monad-control
         mtl QuickCheck quickcheck-instances resourcet tagged tasty
         tasty-quickcheck text time transformers transformers-base
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/aristidb/aws";
       description = "Amazon Web Services (AWS) for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws_0_11_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, blaze-builder, byteable, bytestring
     , case-insensitive, cereal, conduit, conduit-extra, containers
     , cryptohash, data-default, directory, errors, filepath
     , http-client, http-conduit, http-types, lifted-base, monad-control
     , mtl, network, old-locale, QuickCheck, quickcheck-instances
     , resourcet, safe, scientific, tagged, tasty, tasty-quickcheck
     , text, time, transformers, transformers-base, unordered-containers
     , utf8-string, vector, xml-conduit
     }:
     mkDerivation {
       pname = "aws";
       version = "0.11.4";
       sha256 = "33c254d949af40c55f3f82c95b76bd9d456039fef44ecd675f343fc14e9857d6";
       revision = "1";
       editedCabalFile = "ce643c305e10f780d10157dfe4eb51ce840b206a7ba736616f445d38725ec02f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         blaze-builder byteable bytestring case-insensitive cereal conduit
         conduit-extra containers cryptohash data-default directory filepath
         http-conduit http-types lifted-base monad-control mtl network
         old-locale resourcet safe scientific tagged text time transformers
         unordered-containers utf8-string vector xml-conduit
       ];
       testHaskellDepends = [
         aeson base bytestring errors http-client lifted-base monad-control
         mtl QuickCheck quickcheck-instances resourcet tagged tasty
         tasty-quickcheck text time transformers transformers-base
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/aristidb/aws";
       description = "Amazon Web Services (AWS) for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws_0_12_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, blaze-builder, byteable, bytestring
     , case-insensitive, cereal, conduit, conduit-extra, containers
     , cryptohash, data-default, directory, errors, filepath
     , http-client, http-conduit, http-types, lifted-base, monad-control
     , mtl, network, old-locale, QuickCheck, quickcheck-instances
     , resourcet, safe, scientific, tagged, tasty, tasty-quickcheck
     , text, time, transformers, transformers-base, unordered-containers
     , utf8-string, vector, xml-conduit
     }:
     mkDerivation {
       pname = "aws";
       version = "0.12.1";
       sha256 = "6c85bac359ea94d78f287b45c6e7e981dc260a1c029a7888ed752a1c0e64d32b";
       revision = "1";
       editedCabalFile = "15033cfa014e706515a9d2b59c4996a921e41bfd9a460d7f8388d3faa55e9ff5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         blaze-builder byteable bytestring case-insensitive cereal conduit
         conduit-extra containers cryptohash data-default directory filepath
         http-conduit http-types lifted-base monad-control mtl network
         old-locale resourcet safe scientific tagged text time transformers
         unordered-containers utf8-string vector xml-conduit
       ];
       testHaskellDepends = [
         aeson base bytestring errors http-client lifted-base monad-control
         mtl QuickCheck quickcheck-instances resourcet tagged tasty
         tasty-quickcheck text time transformers transformers-base
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/aristidb/aws";
       description = "Amazon Web Services (AWS) for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, blaze-builder, byteable, bytestring
     , case-insensitive, cereal, conduit, conduit-extra, containers
     , cryptohash, data-default, directory, errors, filepath
     , http-client, http-conduit, http-types, lifted-base, monad-control
     , mtl, network, old-locale, QuickCheck, quickcheck-instances
     , resourcet, safe, scientific, tagged, tasty, tasty-quickcheck
     , text, time, transformers, transformers-base, unordered-containers
     , utf8-string, vector, xml-conduit
     }:
     mkDerivation {
       pname = "aws";
       version = "0.13.0";
       sha256 = "3504c96a00d12fa0fe4ae5ab4dafa3eec7ca576a02ed7906cff70a75625a75a6";
       revision = "1";
       editedCabalFile = "57beb101b4203e6784df90817aadfbda98972052e31f85fa620f2d7dcdf6a446";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         blaze-builder byteable bytestring case-insensitive cereal conduit
         conduit-extra containers cryptohash data-default directory filepath
         http-conduit http-types lifted-base monad-control mtl network
         old-locale resourcet safe scientific tagged text time transformers
         unordered-containers utf8-string vector xml-conduit
       ];
       testHaskellDepends = [
         aeson base bytestring errors http-client lifted-base monad-control
         mtl QuickCheck quickcheck-instances resourcet tagged tasty
         tasty-quickcheck text time transformers transformers-base
       ];
       doCheck = false;
       homepage = "http://github.com/aristidb/aws";
       description = "Amazon Web Services (AWS) for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aws-cloudfront-signer" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, base64-bytestring
     , bytestring, crypto-pubkey-types, RSA, time
     }:
     mkDerivation {
       pname = "aws-cloudfront-signer";
       version = "1.1.0.3";
       sha256 = "389a125ad8e06e79db8d4d7144dd5254bc3ebde81588fa9ece0b661cf72ad681";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base base64-bytestring bytestring
         crypto-pubkey-types RSA time
       ];
       homepage = "http://github.com/iconnect/aws-cloudfront-signer";
       description = "For signing AWS CloudFront HTTP URL requests";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aws-configuration-tools" = callPackage
    ({ mkDerivation, aws, aws-general, aws-kinesis, base
     , base-unicode-symbols, bytestring, configuration-tools, mtl, text
     , transformers
     }:
     mkDerivation {
       pname = "aws-configuration-tools";
       version = "0.1.0.0";
       sha256 = "6b94bd4f41fc9a4ff58dd8741ba0cb618d804ca0362c6804348ecb5842831c77";
       revision = "2";
       editedCabalFile = "536eacac6f54fbeb3e823d5b751eaa8cf1bb45a69f1d0bf54bdbff6245eb93e9";
       libraryHaskellDepends = [
         aws aws-general aws-kinesis base base-unicode-symbols bytestring
         configuration-tools mtl text transformers
       ];
       description = "Configuration types, parsers & renderers for AWS services";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws-dynamodb-conduit" = callPackage
    ({ mkDerivation, aeson, attoparsec-trans, aws, base, bytestring
     , conduit, containers, http-conduit, http-types, json-togo
     , resourcet, text, transformers
     }:
     mkDerivation {
       pname = "aws-dynamodb-conduit";
       version = "0.1.0.6";
       sha256 = "170d0c83bfc29fc9df118467c15d0c8cfc68d7e4b5788ef95ba8518bd8e95b97";
       libraryHaskellDepends = [
         aeson attoparsec-trans aws base bytestring conduit containers
         http-conduit http-types json-togo resourcet text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/srijs/haskell-aws-dynamodb-query";
       description = "Conduit-based interface for AWS DynamoDB";
       license = stdenv.lib.licenses.mit;
     }) {};

  "aws-dynamodb-streams" = callPackage
    ({ mkDerivation, aeson, attoparsec, aws, aws-general, base
     , base-unicode-symbols, base16-bytestring, base64-bytestring
     , byteable, bytestring, case-insensitive, conduit, conduit-extra
     , containers, cryptohash, http-conduit, http-types, mtl, old-locale
     , parsers, profunctors, resourcet, scientific, text, time
     }:
     mkDerivation {
       pname = "aws-dynamodb-streams";
       version = "0.1.0.0";
       sha256 = "22137e5436c28c481bcb93b86a24ad5d5dcbe7904b292d58dc5e86a3a98c157b";
       libraryHaskellDepends = [
         aeson attoparsec aws aws-general base base-unicode-symbols
         base16-bytestring base64-bytestring byteable bytestring
         case-insensitive conduit conduit-extra containers cryptohash
         http-conduit http-types mtl old-locale parsers profunctors
         resourcet scientific text time
       ];
       jailbreak = true;
       description = "Haskell bindings for Amazon DynamoDB Streams";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws-ec2" = callPackage
    ({ mkDerivation, aeson, aws, base, base16-bytestring
     , base64-bytestring, blaze-builder, byteable, bytestring
     , conduit-extra, containers, cryptohash, http-conduit, http-types
     , mtl, optparse-applicative, resourcet, scientific
     , template-haskell, text, time, unordered-containers, vector
     , xml-conduit, yaml
     }:
     mkDerivation {
       pname = "aws-ec2";
       version = "0.3.3";
       sha256 = "8d52e45cf9c37d728d1c76db6653ff56dbec853c1b924b46b1519387cc2aa3f4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aws base base16-bytestring base64-bytestring blaze-builder
         byteable bytestring conduit-extra containers cryptohash
         http-conduit http-types mtl resourcet scientific template-haskell
         text time unordered-containers vector xml-conduit
       ];
       executableHaskellDepends = [
         aeson aws base bytestring containers optparse-applicative text
         unordered-containers vector yaml
       ];
       homepage = "https://github.com/zalora/aws-ec2";
       description = "AWS EC2/VPC, ELB and CloudWatch client library for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aws-elastic-transcoder" = callPackage
    ({ mkDerivation, aeson, aws, aws-sign4, base, bytestring, Cabal
     , conduit, containers, http-conduit, http-types, QuickCheck
     , regex-compat, safe, text, time, transformers
     }:
     mkDerivation {
       pname = "aws-elastic-transcoder";
       version = "0.2.0.2";
       sha256 = "896b7cdb17313b8a5e848de797ab61a3d1ab3779b6bf2d571cda50e5317ebe09";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aws aws-sign4 base bytestring conduit containers http-conduit
         http-types QuickCheck regex-compat safe text time transformers
       ];
       testHaskellDepends = [
         aeson base Cabal containers QuickCheck regex-compat safe text
       ];
       homepage = "http://github.com/iconnect/aws-elastic-transcoder";
       description = "Haskell suite for the Elastic Transcoder service";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws-general" = callPackage
    ({ mkDerivation, aeson, attoparsec, aws, base, base16-bytestring
     , blaze-builder, byteable, bytestring, case-insensitive, charset
     , cryptohash, deepseq, directory, either, errors, hashable
     , http-types, parsers, QuickCheck, quickcheck-instances, tagged
     , tasty, tasty-quickcheck, text, time, transformers
     }:
     mkDerivation {
       pname = "aws-general";
       version = "0.2.2";
       sha256 = "32bbac44b37056c861cd762172b504605b810e7873a2889b69f80b13f8195e23";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring blaze-builder byteable
         bytestring case-insensitive cryptohash deepseq hashable http-types
         parsers QuickCheck quickcheck-instances text time transformers
       ];
       testHaskellDepends = [
         attoparsec aws base bytestring case-insensitive charset directory
         either errors http-types parsers QuickCheck quickcheck-instances
         tagged tasty tasty-quickcheck text time transformers
       ];
       homepage = "https://github.com/alephcloud/hs-aws-general";
       description = "Bindings for Amazon Web Services (AWS) General Reference";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws-kinesis" = callPackage
    ({ mkDerivation, aeson, aws, aws-general, base, base64-bytestring
     , blaze-builder, bytestring, conduit, conduit-extra, deepseq
     , errors, http-conduit, http-types, mtl, parsers, QuickCheck
     , quickcheck-instances, resourcet, tagged, tasty, tasty-quickcheck
     , text, time, transformers
     }:
     mkDerivation {
       pname = "aws-kinesis";
       version = "0.1.5";
       sha256 = "3f2a155f4da902ffbcf243bfdd42f0d8396e9f3378608abc2845b3fc8b73f15a";
       libraryHaskellDepends = [
         aeson aws aws-general base base64-bytestring blaze-builder
         bytestring conduit conduit-extra deepseq http-conduit http-types
         parsers QuickCheck quickcheck-instances resourcet text time
         transformers
       ];
       testHaskellDepends = [
         aeson aws aws-general base bytestring errors mtl QuickCheck tagged
         tasty tasty-quickcheck text transformers
       ];
       homepage = "https://github.com/alephcloud/hs-aws-kinesis";
       description = "Bindings for Amazon Kinesis";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws-kinesis-client" = callPackage
    ({ mkDerivation, aeson, aws, aws-configuration-tools, aws-general
     , aws-kinesis, base, base-unicode-symbols, bytestring, conduit
     , configuration-tools, containers, data-carousel
     , enclosed-exceptions, http-conduit, kan-extensions, lens
     , lens-action, lifted-async, lifted-base, monad-control, mtl, nats
     , optparse-applicative, random, resourcet, stm, stm-chans
     , stm-queue-extras, text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "aws-kinesis-client";
       version = "0.4.0.2";
       sha256 = "9dd7dfb150fba911b57722fe452b244924cc8460cceaf5fc455c72dbb0d0cfef";
       revision = "1";
       editedCabalFile = "4bd055f19f3ced5d6f52eec169220d7c5159cfa521128a3118aedecc9c3ad2f3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aws aws-kinesis base base-unicode-symbols conduit containers
         data-carousel enclosed-exceptions http-conduit kan-extensions lens
         lens-action lifted-async lifted-base monad-control mtl nats random
         resourcet stm stm-chans stm-queue-extras text transformers
         unordered-containers
       ];
       executableHaskellDepends = [
         aeson aws aws-configuration-tools aws-general aws-kinesis base
         base-unicode-symbols bytestring conduit configuration-tools
         http-conduit kan-extensions lens lifted-async lifted-base
         monad-control mtl optparse-applicative text transformers
       ];
       jailbreak = true;
       description = "A producer & consumer client library for AWS Kinesis";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws-kinesis-reshard" = callPackage
    ({ mkDerivation, aws, aws-general, aws-kinesis, aws-sdk, base
     , base-unicode-symbols, bytestring, conduit, either, hoist-error
     , lens, lens-action, lifted-async, lifted-base, monad-control, mtl
     , optparse-applicative, resourcet, text, time, transformers
     }:
     mkDerivation {
       pname = "aws-kinesis-reshard";
       version = "0.1.0.1";
       sha256 = "d6d2b95013ae338cba04d19f35e9233eeb4298bde3e2db5fce3f66d3741af1ec";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aws aws-general aws-kinesis aws-sdk base base-unicode-symbols
         bytestring conduit hoist-error lens lens-action lifted-async
         lifted-base monad-control mtl optparse-applicative resourcet text
         time transformers
       ];
       executableHaskellDepends = [
         aws aws-general aws-kinesis aws-sdk base base-unicode-symbols
         conduit either hoist-error lens lens-action lifted-async
         lifted-base monad-control mtl optparse-applicative resourcet text
         time transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/alephcloud/hs-aws-kinesis-reshard";
       description = "Reshard AWS Kinesis streams in response to Cloud Watch metrics";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws-lambda" = callPackage
    ({ mkDerivation, aeson, aws-general, base, base-unicode-symbols
     , bytestring, containers, exceptions, filepath, http-client
     , http-types, lens, lens-action, lens-aeson, mtl, old-locale, text
     , time, wreq, zip-archive
     }:
     mkDerivation {
       pname = "aws-lambda";
       version = "0.1.0.1";
       sha256 = "0959e5714d666412ddffb11ac13e3b1c00125564c4061ae0e1cde7ed0dc2c9b7";
       libraryHaskellDepends = [
         aeson aws-general base base-unicode-symbols bytestring containers
         exceptions filepath http-client http-types lens lens-action
         lens-aeson mtl old-locale text time wreq zip-archive
       ];
       jailbreak = true;
       homepage = "https://github.com/alephcloud/hs-aws-lambda";
       description = "Haskell bindings for AWS Lambda";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws-performance-tests" = callPackage
    ({ mkDerivation, aeson, async, aws, base, bytestring
     , configuration-tools, containers, dlist, errors, http-client, lens
     , lifted-base, monad-control, mtl, optparse-applicative, resourcet
     , statistics, text, time, transformers, vector
     }:
     mkDerivation {
       pname = "aws-performance-tests";
       version = "0.1.1";
       sha256 = "1c06449bc8a23844ea703be05212462e0ee5ac9ea8a9d66a279c0701a75436d5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aws base errors lifted-base monad-control mtl text
         transformers
       ];
       executableHaskellDepends = [
         async aws base bytestring configuration-tools containers dlist
         errors http-client lens monad-control optparse-applicative
         resourcet statistics text time transformers vector
       ];
       homepage = "http://github.com/alephcloud/hs-aws-performance-tests";
       description = "Performance Tests for the Haskell bindings for Amazon Web Services (AWS)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws-route53" = callPackage
    ({ mkDerivation, aws, base, bytestring, containers, http-conduit
     , http-types, old-locale, resourcet, text, time, xml-conduit
     , xml-hamlet
     }:
     mkDerivation {
       pname = "aws-route53";
       version = "0.1.2.1";
       sha256 = "b67317d4949a2e6649392bb6fd1e72767c3658670dbd52867ca2169ca7e6b5bc";
       libraryHaskellDepends = [
         aws base bytestring containers http-conduit http-types old-locale
         resourcet text time xml-conduit xml-hamlet
       ];
       description = "Amazon Route53 DNS service plugin for the aws package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aws-sdk" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, conduit
     , conduit-extra, containers, data-default, hspec, http-conduit
     , http-types, HUnit, iproute, lifted-base, monad-control, mtl
     , old-locale, parallel, parsec, QuickCheck, random, resourcet, safe
     , SHA, simple-config, strptime, template-haskell, text, time, tls
     , transformers, transformers-base, xml-conduit, xml-types
     }:
     mkDerivation {
       pname = "aws-sdk";
       version = "0.12.4";
       sha256 = "2b17ef4d7b4dafe9a50b967685627c43405792a8c6ab498cb0dec7d6dc74bc7e";
       libraryHaskellDepends = [
         base base64-bytestring bytestring conduit conduit-extra containers
         data-default http-conduit http-types iproute lifted-base
         monad-control mtl old-locale parallel parsec resourcet safe SHA
         simple-config strptime template-haskell text time tls transformers
         transformers-base xml-conduit xml-types
       ];
       testHaskellDepends = [
         base conduit hspec http-conduit HUnit iproute lifted-base
         monad-control QuickCheck random resourcet text time tls
         transformers
       ];
       homepage = "http://worksap-ate.github.com/aws-sdk";
       description = "AWS SDK for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws-sdk-text-converter" = callPackage
    ({ mkDerivation, base, bytestring, hspec, HUnit, iproute
     , QuickCheck, safe, strptime, template-haskell, text, time
     , time-locale-compat
     }:
     mkDerivation {
       pname = "aws-sdk-text-converter";
       version = "0.4.1";
       sha256 = "ce1318fcd18b191477d7e5a45bef4a62988a876a57c86e4cd01a26ea1e610713";
       libraryHaskellDepends = [
         base bytestring iproute safe strptime template-haskell text time
         time-locale-compat
       ];
       testHaskellDepends = [
         base bytestring hspec HUnit iproute QuickCheck safe strptime
         template-haskell text time time-locale-compat
       ];
       homepage = "https://github.com/yunomu/aws-sdk-text-converter";
       description = "The text converter for aws-sdk";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aws-sdk-xml-unordered" = callPackage
    ({ mkDerivation, aws-sdk-text-converter, base, bytestring, conduit
     , containers, hspec, lifted-base, mtl, resourcet, text
     , unordered-containers, xml-conduit, xml-types
     }:
     mkDerivation {
       pname = "aws-sdk-xml-unordered";
       version = "0.3.1";
       sha256 = "cd1a21ed61a5173f26019c1ff945a985ca4ba7934ccc80622addc46b83a12039";
       libraryHaskellDepends = [
         aws-sdk-text-converter base conduit containers lifted-base mtl
         resourcet text unordered-containers xml-conduit xml-types
       ];
       testHaskellDepends = [
         base bytestring conduit hspec mtl resourcet text xml-conduit
       ];
       homepage = "https://github.com/worksap-ate/aws-sdk-xml-unordered";
       description = "The xml parser for aws-sdk package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "aws-sign4" = callPackage
    ({ mkDerivation, attempt, aws, base, blaze-builder, byteable
     , bytestring, bytestring-lexing, Cabal, case-insensitive
     , cryptohash, directory, filepath, http-types, old-locale, safe
     , text, time
     }:
     mkDerivation {
       pname = "aws-sign4";
       version = "1.1.0.1";
       sha256 = "10ca8ce6cccd77d126b5640c36c665a17b187ba985c752e2d49f92f7d06d84cb";
       libraryHaskellDepends = [
         aws base blaze-builder byteable bytestring case-insensitive
         cryptohash http-types old-locale safe time
       ];
       testHaskellDepends = [
         attempt aws base blaze-builder byteable bytestring
         bytestring-lexing Cabal case-insensitive cryptohash directory
         filepath http-types old-locale safe text time
       ];
       jailbreak = true;
       homepage = "http://github.com/iconnect/aws-sign4";
       description = "Amazon Web Services (AWS) Signature v4 HTTP request signer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "aws-sns" = callPackage
    ({ mkDerivation, aeson, aws, aws-general, base, blaze-builder
     , bytestring, conduit, containers, errors, http-conduit, http-types
     , mtl, parsers, QuickCheck, resourcet, tagged, tasty
     , tasty-quickcheck, text, time, transformers, xml-conduit
     }:
     mkDerivation {
       pname = "aws-sns";
       version = "0.1";
       sha256 = "f5cadcfc0191fd2e2764cfb6c64366845e82ae3dfd7d82f62ea6af601b952eec";
       libraryHaskellDepends = [
         aeson aws aws-general base blaze-builder bytestring conduit
         containers http-conduit http-types parsers QuickCheck resourcet
         text time transformers xml-conduit
       ];
       testHaskellDepends = [
         aeson aws aws-general base bytestring errors mtl QuickCheck tagged
         tasty tasty-quickcheck text transformers
       ];
       homepage = "https://github.com/alephcloud/hs-aws-sns";
       description = "Bindings for AWS SNS Version 2013-03-31";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "azure-acs" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, conduit
     , conduit-extra, connection, http-conduit, http-types, network
     , time
     }:
     mkDerivation {
       pname = "azure-acs";
       version = "0.0.1.1";
       sha256 = "b43c0f5098d04479c56960d1de54850ee7befb35e002524941a5776baa27fb25";
       libraryHaskellDepends = [
         attoparsec base bytestring conduit conduit-extra connection
         http-conduit http-types network time
       ];
       homepage = "https://github.com/kapilash/hs-azure";
       description = "Windows Azure ACS";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "azure-service-api" = callPackage
    ({ mkDerivation, base, binary, bytestring, case-insensitive
     , certificate, crypto-pubkey-types, http-conduit, hxt, hxt-xpath
     , pretty, resourcet, tls, tls-extra, transformers
     }:
     mkDerivation {
       pname = "azure-service-api";
       version = "0.1.0.0";
       sha256 = "0fba3a22a18bab53531230e734ce5eec4cd6e377a29b017a638f238726498b27";
       libraryHaskellDepends = [
         base binary bytestring case-insensitive certificate
         crypto-pubkey-types http-conduit hxt hxt-xpath pretty resourcet tls
         tls-extra transformers
       ];
       jailbreak = true;
       homepage = "github.com/haskell-distributed/azure-service-api";
       description = "Haskell bindings for the Microsoft Azure Service Management API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "azure-servicebus" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, azure-acs, base
     , bytestring, case-insensitive, conduit, connection, http-client
     , http-conduit, http-types, network, text
     }:
     mkDerivation {
       pname = "azure-servicebus";
       version = "0.1.6.0";
       sha256 = "23d47ab6ed45c46be18b1eafc10061f040ec6a87451b1d5d8a2d844a8253e8c5";
       libraryHaskellDepends = [
         aeson async attoparsec azure-acs base bytestring case-insensitive
         conduit connection http-client http-conduit http-types network text
       ];
       jailbreak = true;
       homepage = "https://github.com/kapilash/hs-azure";
       description = "Haskell wrapper over Microsoft Azure ServiceBus REST API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "azurify" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring
     , case-insensitive, cmdargs, conduit, data-default, directory
     , http-conduit, http-date, http-types, hxt, hxt-unicode, network
     , old-locale, SHA, text, time, transformers, unix-compat
     , utf8-string
     }:
     mkDerivation {
       pname = "azurify";
       version = "0.4.0.5";
       sha256 = "2f397c5993965e3aa377463f04254fcc62a546c088be15b4e367f3887fbc135b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring bytestring case-insensitive conduit
         data-default http-conduit http-date http-types hxt hxt-unicode
         network old-locale SHA text time transformers unix-compat
         utf8-string
       ];
       executableHaskellDepends = [
         base base64-bytestring bytestring case-insensitive cmdargs conduit
         data-default directory http-conduit http-date http-types hxt
         hxt-unicode network old-locale SHA text time transformers
         unix-compat utf8-string
       ];
       homepage = "http://arnovanlumig.com/azure";
       description = "A simple library for accessing Azure blob storage";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "b-tree" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , errors, filepath, lens, mmap, mtl, pipes, pipes-interleave
     , QuickCheck, transformers, vector
     }:
     mkDerivation {
       pname = "b-tree";
       version = "0.1.2";
       sha256 = "201ba85e9a14b13adc759734ef0cda7ec16d5efc64189eac59f206ed734745a4";
       libraryHaskellDepends = [
         base binary bytestring containers directory errors filepath lens
         mmap mtl pipes pipes-interleave transformers vector
       ];
       testHaskellDepends = [ base binary containers pipes QuickCheck ];
       jailbreak = true;
       homepage = "http://github.com/bgamari/b-tree";
       description = "Immutable disk-based B* trees";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "b9_0_5_8" = callPackage
    ({ mkDerivation, aeson, async, base, bifunctors, binary, bytestring
     , conduit, conduit-extra, ConfigFile, directory, filepath, free
     , hspec, hspec-expectations, mtl, optparse-applicative, parsec
     , pretty, pretty-show, process, QuickCheck, random, semigroups, syb
     , template, text, time, transformers, unordered-containers, vector
     , yaml
     }:
     mkDerivation {
       pname = "b9";
       version = "0.5.8";
       sha256 = "71c30f016937045d4400b835f97e94913e929fa5d130a1fe2cc5ece4eb930f65";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bifunctors binary bytestring conduit conduit-extra
         ConfigFile directory filepath free mtl parsec pretty pretty-show
         process QuickCheck random semigroups syb template text time
         transformers unordered-containers vector yaml
       ];
       executableHaskellDepends = [
         base bytestring optparse-applicative
       ];
       testHaskellDepends = [
         aeson base bytestring hspec hspec-expectations QuickCheck
         semigroups text unordered-containers vector yaml
       ];
       homepage = "https://github.com/sheyll/b9-vm-image-builder";
       description = "A tool and library for building virtual machine images";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "b9_0_5_10" = callPackage
    ({ mkDerivation, aeson, async, base, bifunctors, binary, boxes
     , bytestring, conduit, conduit-extra, ConfigFile, directory
     , filepath, free, hspec, hspec-expectations, mtl
     , optparse-applicative, parsec, pretty, pretty-show, process
     , QuickCheck, random, semigroups, syb, template, text, time
     , transformers, unordered-containers, vector, yaml
     }:
     mkDerivation {
       pname = "b9";
       version = "0.5.10";
       sha256 = "df1b11037ace168568c378259b59f6d9a6ccc81ac339389237e825349ee6edb9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bifunctors binary boxes bytestring conduit
         conduit-extra ConfigFile directory filepath free mtl parsec pretty
         pretty-show process QuickCheck random semigroups syb template text
         time transformers unordered-containers vector yaml
       ];
       executableHaskellDepends = [
         base bytestring directory optparse-applicative
       ];
       testHaskellDepends = [
         aeson base bytestring hspec hspec-expectations QuickCheck
         semigroups text unordered-containers vector yaml
       ];
       homepage = "https://github.com/sheyll/b9-vm-image-builder";
       description = "A tool and library for building virtual machine images";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "b9_0_5_13" = callPackage
    ({ mkDerivation, aeson, async, base, bifunctors, binary, boxes
     , bytestring, conduit, conduit-extra, ConfigFile, directory
     , filepath, free, hspec, hspec-expectations, mtl
     , optparse-applicative, parsec, pretty, pretty-show, process
     , QuickCheck, random, semigroups, syb, template, text, time
     , transformers, unordered-containers, vector, yaml
     }:
     mkDerivation {
       pname = "b9";
       version = "0.5.13";
       sha256 = "377c0d8a52f9803a45ae9f49fa3589331f6734b1a0bb56eb45e518d86cc19911";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bifunctors binary boxes bytestring conduit
         conduit-extra ConfigFile directory filepath free mtl parsec pretty
         pretty-show process QuickCheck random semigroups syb template text
         time transformers unordered-containers vector yaml
       ];
       executableHaskellDepends = [
         base bytestring directory optparse-applicative
       ];
       testHaskellDepends = [
         aeson base bytestring hspec hspec-expectations QuickCheck
         semigroups text unordered-containers vector yaml
       ];
       homepage = "https://github.com/sheyll/b9-vm-image-builder";
       description = "A tool and library for building virtual machine images";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "b9_0_5_14" = callPackage
    ({ mkDerivation, aeson, async, base, bifunctors, binary, boxes
     , bytestring, conduit, conduit-extra, ConfigFile, directory
     , filepath, free, hashable, hspec, hspec-expectations, mtl
     , optparse-applicative, parallel, parsec, pretty, pretty-show
     , process, QuickCheck, random, semigroups, syb, template, text
     , time, transformers, unordered-containers, vector, yaml
     }:
     mkDerivation {
       pname = "b9";
       version = "0.5.14";
       sha256 = "91c6cc0304fdfb4428c872fa532e62748f5944f239f69c27f6b6ac0d81bb8d95";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bifunctors binary boxes bytestring conduit
         conduit-extra ConfigFile directory filepath free hashable mtl
         parallel parsec pretty pretty-show process QuickCheck random
         semigroups syb template text time transformers unordered-containers
         vector yaml
       ];
       executableHaskellDepends = [
         base bytestring directory optparse-applicative
       ];
       testHaskellDepends = [
         aeson base bytestring hspec hspec-expectations QuickCheck
         semigroups text unordered-containers vector yaml
       ];
       homepage = "https://github.com/sheyll/b9-vm-image-builder";
       description = "A tool and library for building virtual machine images";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "b9_0_5_16" = callPackage
    ({ mkDerivation, aeson, async, base, bifunctors, binary, boxes
     , bytestring, conduit, conduit-extra, ConfigFile, directory
     , filepath, free, hashable, hspec, hspec-expectations, mtl
     , optparse-applicative, parallel, parsec, pretty, pretty-show
     , process, QuickCheck, random, semigroups, syb, template, text
     , time, transformers, unordered-containers, vector, yaml
     }:
     mkDerivation {
       pname = "b9";
       version = "0.5.16";
       sha256 = "f45b85a017c70df42dd461b2cd63967cc3fd1cc2653863686ab7edf8989de6d0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bifunctors binary boxes bytestring conduit
         conduit-extra ConfigFile directory filepath free hashable mtl
         parallel parsec pretty pretty-show process QuickCheck random
         semigroups syb template text time transformers unordered-containers
         vector yaml
       ];
       executableHaskellDepends = [
         base bytestring directory optparse-applicative
       ];
       testHaskellDepends = [
         aeson base bytestring hspec hspec-expectations QuickCheck
         semigroups text unordered-containers vector yaml
       ];
       homepage = "https://github.com/sheyll/b9-vm-image-builder";
       description = "A tool and library for building virtual machine images";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "b9" = callPackage
    ({ mkDerivation, aeson, async, base, bifunctors, binary, boxes
     , bytestring, conduit, conduit-extra, ConfigFile, directory
     , filepath, free, hashable, hspec, hspec-expectations, mtl
     , optparse-applicative, parallel, parsec, pretty, pretty-show
     , process, QuickCheck, random, semigroups, syb, template, text
     , time, transformers, unordered-containers, vector, yaml
     }:
     mkDerivation {
       pname = "b9";
       version = "0.5.17";
       sha256 = "5f28b7f1043cfb405c8e6b4247b9c3ef434816069ec8cf30b1a74dc530a368df";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bifunctors binary boxes bytestring conduit
         conduit-extra ConfigFile directory filepath free hashable mtl
         parallel parsec pretty pretty-show process QuickCheck random
         semigroups syb template text time transformers unordered-containers
         vector yaml
       ];
       executableHaskellDepends = [
         base bytestring directory optparse-applicative
       ];
       testHaskellDepends = [
         aeson base bytestring hspec hspec-expectations QuickCheck
         semigroups text unordered-containers vector yaml
       ];
       homepage = "https://github.com/sheyll/b9-vm-image-builder";
       description = "A tool and library for building virtual machine images";
       license = stdenv.lib.licenses.mit;
     }) {};

  "babylon" = callPackage
    ({ mkDerivation, array, base, containers, random, wx, wxcore }:
     mkDerivation {
       pname = "babylon";
       version = "0.3";
       sha256 = "0e6e87ee55be91093e36fe048a9ef3efd712bcd3b8eac3ece6a9bd9648b09e89";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers random wx wxcore
       ];
       description = "An implementation of a simple 2-player board game";
       license = "GPL";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "backdropper" = callPackage
    ({ mkDerivation, base, directory, haskell98, hslogger, old-time
     , process, random
     }:
     mkDerivation {
       pname = "backdropper";
       version = "1.2";
       sha256 = "5e522f3aa25ad7ba5060df41b095621d182c1908d9d740b64e963ee7c505bbfc";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [
         base directory haskell98 hslogger old-time process random
       ];
       jailbreak = true;
       description = "Rotates backdrops for X11 displays using Imagemagic";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "backtracking-exceptions" = callPackage
    ({ mkDerivation, base, either, free, kan-extensions, mtl
     , semigroupoids, semigroups, transformers
     }:
     mkDerivation {
       pname = "backtracking-exceptions";
       version = "0.1.0.0";
       sha256 = "e29a9e117daeb62cbb1070fe947c97288df21fa05b3711f2da5c7b6649259fd4";
       libraryHaskellDepends = [
         base either free kan-extensions mtl semigroupoids semigroups
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/tapuu/backtracking-exceptions";
       description = "A monad transformer for backtracking exceptions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "backward-state" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "backward-state";
       version = "0.1.0.2";
       sha256 = "5579bc4be23e25324129dae278a768fb804909e64044de6581d7be2136a87daa";
       libraryHaskellDepends = [ base transformers ];
       jailbreak = true;
       homepage = "https://github.com/luqui/backward-state";
       description = "A state monad that runs the state in reverse through the computation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bacteria" = callPackage
    ({ mkDerivation, base, gd, X11 }:
     mkDerivation {
       pname = "bacteria";
       version = "1.1";
       sha256 = "6557c0567da7d9ff9da386a2b9e327858dc32ea185a41574769802b446b9c7a7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base gd X11 ];
       homepage = "http://www.dmwit.com/bacteria";
       description = "braindead utility to compose Xinerama backgrounds";
       license = "unknown";
     }) {};

  "bag" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "bag";
       version = "0.1";
       sha256 = "99ae38d2f41d6a763f85a03239aee8f29523fb84c118b533b1358deaf27bc7a2";
       libraryHaskellDepends = [ base ];
       description = "A simple stable bag";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bake_0_2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cmdargs, deepseq
     , directory, extra, filepath, hashable, HTTP, http-types, process
     , random, shake, text, time, wai, warp
     }:
     mkDerivation {
       pname = "bake";
       version = "0.2";
       sha256 = "3cbe8686de36d98dd3bb106cb6a05cfdc4adc4593f27178dc6ba8cb90b4ef5c8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring cmdargs deepseq directory extra filepath
         hashable HTTP http-types random shake text time wai warp
       ];
       executableHaskellDepends = [
         aeson base bytestring cmdargs deepseq directory extra filepath
         hashable HTTP http-types process random shake text time wai warp
       ];
       homepage = "https://github.com/ndmitchell/bake#readme";
       description = "Continuous integration system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bake" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cmdargs, containers
     , deepseq, direct-sqlite, directory, disk-free-space, extra
     , filepath, hashable, HTTP, http-types, old-locale, process, random
     , safe, shake, smtp-mail, sqlite-simple, text, time, transformers
     , unordered-containers, wai, warp
     }:
     mkDerivation {
       pname = "bake";
       version = "0.4";
       sha256 = "ff0b6eb38e68f2542713074da3c64368e3a56c029dadb9c1e011262c223abbf7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring cmdargs containers deepseq direct-sqlite
         directory disk-free-space extra filepath hashable HTTP http-types
         old-locale random safe shake smtp-mail sqlite-simple text time
         transformers unordered-containers wai warp
       ];
       executableHaskellDepends = [
         aeson base bytestring cmdargs containers deepseq direct-sqlite
         directory disk-free-space extra filepath hashable HTTP http-types
         old-locale process random safe shake smtp-mail sqlite-simple text
         time transformers unordered-containers wai warp
       ];
       homepage = "https://github.com/ndmitchell/bake#readme";
       description = "Continuous integration system";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bamboo" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default
     , directory, filepath, gravatar, hack, hack-contrib, haskell98, mps
     , mtl, network, old-locale, old-time, pandoc, parsec, parsedate
     , process, time, unix, utf8-string, xhtml, zlib
     }:
     mkDerivation {
       pname = "bamboo";
       version = "2010.2.25";
       sha256 = "b166e81cbb9962a4784a159c2168a8c4dfeef699a7565998ef07cf9d98f5266d";
       libraryHaskellDepends = [
         base bytestring containers data-default directory filepath gravatar
         hack hack-contrib haskell98 mps mtl network old-locale old-time
         pandoc parsec parsedate process time unix utf8-string xhtml zlib
       ];
       homepage = "http://github.com/nfjinjing/bamboo/tree/master";
       description = "A blog engine on Hack";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bamboo-launcher" = callPackage
    ({ mkDerivation, bamboo, bamboo-theme-blueprint, base, bytestring
     , data-default, hack, hack-contrib, hack-handler-hyena, haskell98
     , mps, process
     }:
     mkDerivation {
       pname = "bamboo-launcher";
       version = "2010.2.25";
       sha256 = "ad6d32100a34c256de43d4f8efcc93762736d2ce6fdc2155056eae2ec798e2f6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         bamboo bamboo-theme-blueprint base bytestring data-default hack
         hack-contrib hack-handler-hyena haskell98 mps process
       ];
       homepage = "http://github.com/nfjinjing/bamboo-launcher";
       description = "bamboo-launcher";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bamboo-plugin-highlight" = callPackage
    ({ mkDerivation, bamboo, base, bytestring, hack, hack-contrib
     , highlighting-kate, hxt, mps, xhtml
     }:
     mkDerivation {
       pname = "bamboo-plugin-highlight";
       version = "2009.7.5";
       sha256 = "0cabc85ce1232c51454c35c7a4d9acb19e7cd2830494a5b166607375abba1039";
       libraryHaskellDepends = [
         bamboo base bytestring hack hack-contrib highlighting-kate hxt mps
         xhtml
       ];
       homepage = "http://github.com/nfjinjing/bamboo-plugin-highlight/";
       description = "A highlight middleware";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bamboo-plugin-photo" = callPackage
    ({ mkDerivation, base, bytestring, data-default, directory
     , filepath, hack, hack-contrib, haskell98, hxt, mps, utf8-string
     , xhtml
     }:
     mkDerivation {
       pname = "bamboo-plugin-photo";
       version = "2009.7.5";
       sha256 = "50c9c65f674560f0f3ee668bde418839e6cdedb3fca5a5ef43bc42cd204033a6";
       libraryHaskellDepends = [
         base bytestring data-default directory filepath hack hack-contrib
         haskell98 hxt mps utf8-string xhtml
       ];
       homepage = "http://github.com/nfjinjing/hack/tree/master";
       description = "A photo album middleware";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bamboo-theme-blueprint" = callPackage
    ({ mkDerivation, bamboo, base, bytestring, containers, data-default
     , gravatar, hack, hack-contrib, hcheat, mps, network, rss
     , utf8-string, xhtml
     }:
     mkDerivation {
       pname = "bamboo-theme-blueprint";
       version = "2010.2.25.1";
       sha256 = "fd8be619f0b0f3066631ac9b471333425dbc7d597e4cc9437874926ac5df90f1";
       libraryHaskellDepends = [
         bamboo base bytestring containers data-default gravatar hack
         hack-contrib hcheat mps network rss utf8-string xhtml
       ];
       homepage = "http://github.com/nfjinjing/bamboo-theme-blueprint";
       description = "bamboo blueprint theme";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bamboo-theme-mini-html5" = callPackage
    ({ mkDerivation, bamboo, base, base64-string, bytestring, cgi
     , containers, data-default, directory, filepath, gravatar, hack
     , hack-contrib, haskell98, hcheat, moe, mps, mtl, network
     , old-locale, old-time, parsec, parsedate, process, rss, time, unix
     , utf8-string, xhtml, yuuko, zlib
     }:
     mkDerivation {
       pname = "bamboo-theme-mini-html5";
       version = "2009.11.27";
       sha256 = "a6257e155686423d9a2553e9c846b49264a9a616d849a7331cef1982b14cf00b";
       libraryHaskellDepends = [
         bamboo base base64-string bytestring cgi containers data-default
         directory filepath gravatar hack hack-contrib haskell98 hcheat moe
         mps mtl network old-locale old-time parsec parsedate process rss
         time unix utf8-string xhtml yuuko zlib
       ];
       homepage = "http://github.com/nfjinjing/bamboo-theme-mini-html5";
       description = "bamboo mini html5 theme";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bamse" = callPackage
    ({ mkDerivation, base, com, directory, filepath, HUnit, old-time
     , pretty, process, QuickCheck, regex-compat
     }:
     mkDerivation {
       pname = "bamse";
       version = "0.9.5";
       sha256 = "c8f016f0b599cbea967aeb308e0e463fe5e641656a3cf7b5b7c5559cb9f7d3db";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base com directory filepath old-time pretty process regex-compat
       ];
       executableHaskellDepends = [ HUnit QuickCheck ];
       description = "A Windows Installer (MSI) generator framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bamstats" = callPackage
    ({ mkDerivation, base, cmdargs, samtools }:
     mkDerivation {
       pname = "bamstats";
       version = "0.4";
       sha256 = "44642317eb9ba0a1935bf14e70f80da99ac51ee1f8bdfeb647018944e021137d";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [ base cmdargs samtools ];
       homepage = "http://blog.malde.org/posts/bamstats.html";
       description = "A program to extract various information from BAM alignmnet files";
       license = "GPL";
     }) {};

  "bank-holiday-usa" = callPackage
    ({ mkDerivation, base, hspec, HUnit, QuickCheck, time }:
     mkDerivation {
       pname = "bank-holiday-usa";
       version = "0.1.1";
       sha256 = "5fbd4b6a9cc86717530430dae50e6fe2fc049d336e97c8bb7ebcec25d738448b";
       libraryHaskellDepends = [ base time ];
       testHaskellDepends = [ base hspec HUnit QuickCheck time ];
       homepage = "https://github.com/tippenein/BankHoliday";
       description = "A library for determining US bank holidays";
       license = stdenv.lib.licenses.mit;
     }) {};

  "bank-holidays-england_0_1_0_2" = callPackage
    ({ mkDerivation, base, containers, hspec, QuickCheck, time }:
     mkDerivation {
       pname = "bank-holidays-england";
       version = "0.1.0.2";
       sha256 = "425c2f8633f458fcb223f98912c5a62c4cede0ec57a147d738ce256e8e2b564e";
       libraryHaskellDepends = [ base containers time ];
       testHaskellDepends = [ base containers hspec QuickCheck time ];
       jailbreak = true;
       homepage = "https://bitbucket.org/davecturner/bank-holidays-england";
       description = "Calculation of bank holidays in England and Wales";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bank-holidays-england" = callPackage
    ({ mkDerivation, base, containers, hspec, QuickCheck, time }:
     mkDerivation {
       pname = "bank-holidays-england";
       version = "0.1.0.3";
       sha256 = "459f6aee4b04a28059d20eb7064d3849704be3fc7a9efce8fa712401940a608a";
       libraryHaskellDepends = [ base containers time ];
       testHaskellDepends = [ base containers hspec QuickCheck time ];
       homepage = "https://bitbucket.org/davecturner/bank-holidays-england";
       description = "Calculation of bank holidays in England and Wales";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "banwords" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, data-default, HUnit
     , test-framework, test-framework-hunit, text, vector
     }:
     mkDerivation {
       pname = "banwords";
       version = "0.2.0.1";
       sha256 = "d627b46520274c921a92d76bcf75ab9e68325456c1dad9f53332440f0cf8b68e";
       libraryHaskellDepends = [
         attoparsec base bytestring data-default text vector
       ];
       testHaskellDepends = [
         attoparsec base HUnit test-framework test-framework-hunit text
         vector
       ];
       jailbreak = true;
       homepage = "https://github.com/fanjam/banwords";
       description = "Generalized word blacklister";
       license = stdenv.lib.licenses.mit;
     }) {};

  "barchart" = callPackage
    ({ mkDerivation, base, cmdargs, csv, diagrams, filepath }:
     mkDerivation {
       pname = "barchart";
       version = "0.1.1.1";
       sha256 = "feed5f59c6f721f7d73eac1be53e7982c19ac96dd46b6601c3ed83d974511298";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base csv diagrams filepath ];
       executableHaskellDepends = [ base cmdargs csv diagrams filepath ];
       jailbreak = true;
       homepage = "http://sebfisch.github.com/haskell-barchart";
       description = "Creating Bar Charts in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "barcodes-code128" = callPackage
    ({ mkDerivation, base, bytestring, HPDF }:
     mkDerivation {
       pname = "barcodes-code128";
       version = "0.1.0";
       sha256 = "af4ec35570d85202ee03e51b75967ffc586a852e8e9c712e3b2fd9aba0ec7491";
       libraryHaskellDepends = [ base bytestring HPDF ];
       jailbreak = true;
       description = "Generate Code 128 barcodes as PDFs";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "barecheck_0_2_0_6" = callPackage
    ({ mkDerivation, base, containers, QuickCheck, text, time }:
     mkDerivation {
       pname = "barecheck";
       version = "0.2.0.6";
       sha256 = "60fe129b5843b68e6827f2345ed5c50f98db5a77ed729dee9373b46ddb2d7f2b";
       libraryHaskellDepends = [ base containers QuickCheck text time ];
       jailbreak = true;
       homepage = "http://github.com/massysett/barecheck";
       description = "QuickCheck implementations for common types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "barecheck" = callPackage
    ({ mkDerivation, base, containers, QuickCheck, text, time }:
     mkDerivation {
       pname = "barecheck";
       version = "0.2.0.8";
       sha256 = "470d1042ec1a345f8c4d131828918d977085500eeef340b0c2ca85fd32254a42";
       libraryHaskellDepends = [ base containers QuickCheck text time ];
       jailbreak = true;
       homepage = "http://github.com/massysett/barecheck";
       description = "QuickCheck implementations for common types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "barley" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , ghc, ghc-prim, html, plugins, snap-core, snap-server, text
     , transformers, unix-compat
     }:
     mkDerivation {
       pname = "barley";
       version = "0.3.0.2";
       sha256 = "50ec73e7fc50355d5f2e2b7a074f0df9cc1bd279c6f1a0ac039770da571aff45";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory filepath ghc ghc-prim html
         plugins snap-core snap-server text transformers unix-compat
       ];
       jailbreak = true;
       description = "A web based environment for learning and tinkering with Haskell";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "barrie" = callPackage
    ({ mkDerivation, base, containers, filepath, glib, gtk }:
     mkDerivation {
       pname = "barrie";
       version = "0.4.1";
       sha256 = "dba75cfbe104624461975d2475e3002964c3d5b671a75ec919638c6d5a543982";
       libraryHaskellDepends = [ base containers filepath glib gtk ];
       homepage = "http://thewhitelion.org/haskell/barrie";
       description = "Declarative Gtk GUI library";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "barrier" = callPackage
    ({ mkDerivation, base, blaze-svg, bytestring, lens-family-core
     , tasty, tasty-golden, template-haskell, text, unordered-containers
     }:
     mkDerivation {
       pname = "barrier";
       version = "0.1.0";
       sha256 = "9f7c56af995b47791ee0ffa69c27d3de0b895125dbd5fe0c84d8b621467f90ba";
       revision = "2";
       editedCabalFile = "bcb912e8105f792720b8515ddf9b37d6a1eecd17cb325cc40bd688641068e9e6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-svg bytestring template-haskell text
         unordered-containers
       ];
       testHaskellDepends = [
         base bytestring lens-family-core tasty tasty-golden
       ];
       homepage = "https://github.com/philopon/barrier";
       description = "Shield.io style badge generator";
       license = stdenv.lib.licenses.mit;
     }) {};

  "barrier-monad" = callPackage
    ({ mkDerivation, base, comonad, mtl, transformers }:
     mkDerivation {
       pname = "barrier-monad";
       version = "0.1.0.1";
       sha256 = "d5962991329b0922df49fb5010045dc6ea9b6eda849f5ffcd67466cb83609604";
       libraryHaskellDepends = [ base comonad mtl transformers ];
       jailbreak = true;
       description = "Implementation of barrier monad, can use custom front/back type";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base_4_8_2_0" = callPackage
    ({ mkDerivation, ghc-prim, rts }:
     mkDerivation {
       pname = "base";
       version = "4.8.2.0";
       sha256 = "f2bc9eb2773f74c231a25f32dc3b47b704cccc6b9064b6e1140dded364fafe8c";
       libraryHaskellDepends = [ ghc-prim rts ];
       description = "Basic libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-compat_0_5_0" = callPackage
    ({ mkDerivation, base, errorcall-eq-instance, hspec, QuickCheck
     , setenv
     }:
     mkDerivation {
       pname = "base-compat";
       version = "0.5.0";
       sha256 = "a1058da0ff74d88c8724917fc15903a6b025108259a5a060cec86165dd7597fe";
       revision = "1";
       editedCabalFile = "fe2fe0eabffaa7009a32f3dc7ba952d90f595717a12feb33ed72a12f36514713";
       libraryHaskellDepends = [ base errorcall-eq-instance setenv ];
       testHaskellDepends = [ base hspec QuickCheck ];
       jailbreak = true;
       description = "A compatibility layer for base";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-compat_0_6_0" = callPackage
    ({ mkDerivation, base, hspec, QuickCheck, setenv }:
     mkDerivation {
       pname = "base-compat";
       version = "0.6.0";
       sha256 = "dbd3cff437aaad52632814d9ff8dea2919d5eea6f6f4429ef82955d0aa2fc8e7";
       libraryHaskellDepends = [ base setenv ];
       testHaskellDepends = [ base hspec QuickCheck ];
       description = "A compatibility layer for base";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-compat_0_8_2" = callPackage
    ({ mkDerivation, base, hspec, QuickCheck, unix }:
     mkDerivation {
       pname = "base-compat";
       version = "0.8.2";
       sha256 = "3810c7273168a66e4b8f1051ee0c144c6728607382b17eae658bbcfe3e1ca90a";
       revision = "1";
       editedCabalFile = "33e1ec007653de82e28dde3dad46769c97b180ea6700256f6af707b2dcba95e7";
       libraryHaskellDepends = [ base unix ];
       testHaskellDepends = [ base hspec QuickCheck ];
       description = "A compatibility layer for base";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-compat" = callPackage
    ({ mkDerivation, base, hspec, QuickCheck, unix }:
     mkDerivation {
       pname = "base-compat";
       version = "0.9.0";
       sha256 = "8317b62e0655cd0f1ce46856df50ec948d829065e870b8ccf63dc7223c6c04c1";
       libraryHaskellDepends = [ base unix ];
       testHaskellDepends = [ base hspec QuickCheck ];
       description = "A compatibility layer for base";
       license = stdenv.lib.licenses.mit;
     }) {};

  "base-generics" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-generics";
       version = "0.1.0.1";
       sha256 = "bab2aaa9a35d39ab5aa07999ca68bb619e24abb4c5863584fa379c6b0c9d66a6";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/HaskellZhangSong/base-generics";
       description = "This library provides some instances for extra GHC.Generic typeclass such as Int8, Word16 and some unboxed types as well.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "base-io-access" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-io-access";
       version = "0.4.0.0";
       sha256 = "c3886b6203a5f963dcb249efb7bc87c33b17e5cc97276d91c38248019b451134";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/bheklilr/base-io-access";
       description = "The IO functions included in base delimited into small, composable classes";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "base-noprelude" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-noprelude";
       version = "4.8.2.0";
       sha256 = "bd4ab7685a14d82f7586074b1af88e22a8401e552a439286710592e3a2d763c7";
       libraryHaskellDepends = [ base ];
       doHaddock = false;
       homepage = "https://github.com/hvr/base-noprelude";
       description = "\"base\" package sans \"Prelude\" module";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "base-orphans_0_4_3" = callPackage
    ({ mkDerivation, base, ghc-prim, hspec, QuickCheck }:
     mkDerivation {
       pname = "base-orphans";
       version = "0.4.3";
       sha256 = "405b6499679805b5361277e4d101240ab7848ffc009621fc29bbae2519ebfc0d";
       revision = "2";
       editedCabalFile = "a29b52bb0bcf5ec63ab526d5382553497cc5eb40ac02752c75c43752cf464344";
       libraryHaskellDepends = [ base ghc-prim ];
       testHaskellDepends = [ base hspec QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/haskell-compat/base-orphans#readme";
       description = "Backwards-compatible orphan instances for base";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-orphans_0_4_4" = callPackage
    ({ mkDerivation, base, ghc-prim, hspec, QuickCheck }:
     mkDerivation {
       pname = "base-orphans";
       version = "0.4.4";
       sha256 = "f4323cc2ae2b25ce228d7291ff65ac5e6c583070b53eaf21dd509ebe25bf0f42";
       revision = "1";
       editedCabalFile = "4f1dd28434e9bc39a1f6993e6659b4c80c121fe225c65e1d47fe590432308979";
       libraryHaskellDepends = [ base ghc-prim ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "https://github.com/haskell-compat/base-orphans#readme";
       description = "Backwards-compatible orphan instances for base";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-orphans_0_4_5" = callPackage
    ({ mkDerivation, base, ghc-prim, hspec, QuickCheck }:
     mkDerivation {
       pname = "base-orphans";
       version = "0.4.5";
       sha256 = "16b70764247f1545b76c51b1d93dfe98dc78076a710db777e213d61690053da7";
       libraryHaskellDepends = [ base ghc-prim ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "https://github.com/haskell-compat/base-orphans#readme";
       description = "Backwards-compatible orphan instances for base";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-orphans_0_5_0" = callPackage
    ({ mkDerivation, base, ghc-prim, hspec, QuickCheck }:
     mkDerivation {
       pname = "base-orphans";
       version = "0.5.0";
       sha256 = "05ea25f680c0acc65a99acbb39413761181b334566c9be1fcac1c1df8a2d6428";
       libraryHaskellDepends = [ base ghc-prim ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "https://github.com/haskell-compat/base-orphans#readme";
       description = "Backwards-compatible orphan instances for base";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-orphans" = callPackage
    ({ mkDerivation, base, ghc-prim, hspec, QuickCheck }:
     mkDerivation {
       pname = "base-orphans";
       version = "0.5.1";
       sha256 = "a571bf43f54d4d576b2c9b494a722f60c624896c2f6c38365af7b87d1b31facb";
       libraryHaskellDepends = [ base ghc-prim ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "https://github.com/haskell-compat/base-orphans#readme";
       description = "Backwards-compatible orphan instances for base";
       license = stdenv.lib.licenses.mit;
     }) {};

  "base-prelude_0_1_6" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-prelude";
       version = "0.1.6";
       sha256 = "9539712cba6640c4634f2f54906ac813be63f29d3f52a8f1150462e5f89088d1";
       revision = "1";
       editedCabalFile = "60c82205932a5c1dcc626eb232a8c8ade062fb8ec60c5e2730e51356e3abfba0";
       libraryHaskellDepends = [ base ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/base-prelude";
       description = "The most complete prelude formed from only the \"base\" package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-prelude_0_1_7" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-prelude";
       version = "0.1.7";
       sha256 = "172b3231e607773291cd6e285810ae0c3e9db769e7f815d729fe74ac8be4ef77";
       revision = "1";
       editedCabalFile = "9b8f5bbf4656bfc7c9e2bc4a94f6584f2273ed65f3f7c6e16aff98282eeb49dc";
       libraryHaskellDepends = [ base ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/base-prelude";
       description = "The most complete prelude formed from only the \"base\" package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-prelude_0_1_8" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-prelude";
       version = "0.1.8";
       sha256 = "f43a48d3cbe3df0fa6806de5012b291a46e066a15dd220cc81a10f20800dbf85";
       revision = "1";
       editedCabalFile = "043b9968fd57ee65b7f074afcf44f2bf2581f8f257cae82ab3c6027ac7b6ceff";
       libraryHaskellDepends = [ base ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/base-prelude";
       description = "The most complete prelude formed from only the \"base\" package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-prelude_0_1_11" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-prelude";
       version = "0.1.11";
       sha256 = "56856e65535151c8733b0003b6409a473d409656cb75ea5063784993470bd73c";
       revision = "1";
       editedCabalFile = "3ffe858720e8bab040fa715d76af5ec0ae0c0b97aa811e98c00488186f1842e6";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/base-prelude";
       description = "The most complete prelude formed from only the \"base\" package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-prelude_0_1_14" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-prelude";
       version = "0.1.14";
       sha256 = "f241799e5060b77da9de77fcb1b0373a622e485460571f45e276b034ad7ef227";
       libraryHaskellDepends = [ base ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/base-prelude";
       description = "The most complete prelude formed from only the \"base\" package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-prelude_0_1_15" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-prelude";
       version = "0.1.15";
       sha256 = "86325d7ab3a4c263864bad50a72e523230aa40716925bae03643248b80ca8433";
       libraryHaskellDepends = [ base ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/base-prelude";
       description = "The most complete prelude formed from only the \"base\" package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-prelude_0_1_16" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-prelude";
       version = "0.1.16";
       sha256 = "fa2e4d608054793d611714b4eca1319356cfea906a23400ec55862c3eb5af9cc";
       libraryHaskellDepends = [ base ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/base-prelude";
       description = "The most complete prelude formed from only the \"base\" package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-prelude_0_1_17" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-prelude";
       version = "0.1.17";
       sha256 = "b81dd342725a57050e018e8fdcc4ce8e5222ce9fbdc894577bf86b15ddb2b035";
       libraryHaskellDepends = [ base ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/base-prelude";
       description = "The most complete prelude formed from only the \"base\" package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-prelude_0_1_19" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-prelude";
       version = "0.1.19";
       sha256 = "8b0f04c4e9406880ece5152d8c74b3468905bbbcfbd907200168f951ef3fb302";
       libraryHaskellDepends = [ base ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/base-prelude";
       description = "The most complete prelude formed from only the \"base\" package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-prelude_0_1_20" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-prelude";
       version = "0.1.20";
       sha256 = "0adb753a2f638b432c79bb02e39ce417adff6d4e9f51046b423ac2931074b0c8";
       libraryHaskellDepends = [ base ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/base-prelude";
       description = "The most complete prelude formed from only the \"base\" package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-prelude_0_1_21" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-prelude";
       version = "0.1.21";
       sha256 = "72650e69fd615191be08bed82e07c623b0c17b0b52113b418bc3b2093d74a3a5";
       libraryHaskellDepends = [ base ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/base-prelude";
       description = "The most complete prelude formed from only the \"base\" package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "base-prelude" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-prelude";
       version = "1";
       sha256 = "ee443310c2b3a18471f05b3c8c05ce39ea6f7825a0bf78028a06d59b3f28469c";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/nikita-volkov/base-prelude";
       description = "The most complete prelude formed from only the \"base\" package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "base-unicode-symbols" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base-unicode-symbols";
       version = "0.2.2.4";
       sha256 = "a2f841430fec32edba778b74bde83bf0170ada7c5e2e59d7187c8f06d92dcca9";
       libraryHaskellDepends = [ base ];
       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 }:
     mkDerivation {
       pname = "base16-bytestring";
       version = "0.1.1.6";
       sha256 = "5afe65a152c5418f5f4e3579a5e0d5ca19c279dc9bf31c1a371ccbe84705c449";
       libraryHaskellDepends = [ base bytestring ghc-prim ];
       homepage = "http://github.com/bos/base16-bytestring";
       description = "Fast base16 (hex) encoding and decoding for ByteStrings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "base32-bytestring" = callPackage
    ({ mkDerivation, base, bits-extras, bytestring, cpu, hspec
     , QuickCheck
     }:
     mkDerivation {
       pname = "base32-bytestring";
       version = "0.2.1.0";
       sha256 = "74bee674a45705347954f4e7e6eda01c123751fa51ac846b7ff97e39b81b187c";
       libraryHaskellDepends = [ base bits-extras bytestring cpu ];
       testHaskellDepends = [ base bytestring hspec QuickCheck ];
       homepage = "https://github.com/pxqr/base32-bytestring";
       description = "Fast base32 and base32hex codec for ByteStrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "base32string" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, hspec, text }:
     mkDerivation {
       pname = "base32string";
       version = "0.9.1";
       sha256 = "9e931613aeba5f630f9292fc99131388f406e4b34d8f050515ed93aaf632ea32";
       libraryHaskellDepends = [ aeson base binary bytestring text ];
       testHaskellDepends = [ base binary bytestring hspec text ];
       homepage = "http://www.leonmergen.com/opensource.html";
       description = "Fast and safe representation of a Base-32 string";
       license = stdenv.lib.licenses.mit;
     }) {};

  "base58-bytestring" = callPackage
    ({ mkDerivation, base, bytestring, quickcheck-assertions
     , quickcheck-instances, tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "base58-bytestring";
       version = "0.1.0";
       sha256 = "c2dbf598f3415053e12cca84b90fa7c0c1b02f3b784cce0157264baebf2d40d3";
       libraryHaskellDepends = [ base bytestring ];
       testHaskellDepends = [
         base bytestring quickcheck-assertions quickcheck-instances tasty
         tasty-quickcheck
       ];
       homepage = "https://bitbucket.org/s9gf4ult/base58-bytestring";
       description = "Implementation of BASE58 transcoding for ByteStrings";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "base58address" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, cryptohash
     , QuickCheck, test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "base58address";
       version = "0.4";
       sha256 = "eafcd789caed5a39a9e85eddc5ecf7554a812779eed302ebe45e98d479ea257c";
       libraryHaskellDepends = [
         base binary bytestring containers cryptohash
       ];
       testHaskellDepends = [
         base binary bytestring containers cryptohash QuickCheck
         test-framework test-framework-quickcheck2
       ];
       homepage = "https://github.com/singpolyma/base58address";
       description = "Parsing and serialization for Base58 addresses (Bitcoin and Ripple)";
       license = "unknown";
     }) {};

  "base58string" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, hspec, text }:
     mkDerivation {
       pname = "base58string";
       version = "0.10.0";
       sha256 = "3b72607dd76e30a5054acea656c3805f7191e27d67884a7db5fbc73c17e9c088";
       libraryHaskellDepends = [ aeson base binary bytestring text ];
       testHaskellDepends = [ base binary bytestring hspec text ];
       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, containers, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "base64-bytestring";
       version = "1.0.0.1";
       sha256 = "ab25abf4b00a2f52b270bc3ed43f1d59f16c8eec9d7dffb14df1e9265b233b50";
       libraryHaskellDepends = [ base bytestring ];
       testHaskellDepends = [
         base bytestring containers HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/bos/base64-bytestring";
       description = "Fast base64 encoding and decoding for ByteStrings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "base64-conduit" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, conduit
     , hspec, QuickCheck, transformers
     }:
     mkDerivation {
       pname = "base64-conduit";
       version = "1.0.0.1";
       sha256 = "e9993085827215538c236b0300a94c57e513e884bf965714011818ef86ddf01f";
       libraryHaskellDepends = [
         base base64-bytestring bytestring conduit
       ];
       testHaskellDepends = [
         base base64-bytestring bytestring conduit hspec QuickCheck
         transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Base64-encode and decode streams of bytes. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "base64-string" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "base64-string";
       version = "0.2";
       sha256 = "3ec896ca7261ad4ddeffbaa3bdf4d5cb61775250c303fca9929aa9a56acc705e";
       libraryHaskellDepends = [ base ];
       homepage = "http://urchin.earth.li/~ian/cabal/base64-string/";
       description = "Base64 implementation for String's";
       license = "unknown";
     }) {};

  "base91" = callPackage
    ({ mkDerivation, base, bytestring, mono-traversable, QuickCheck
     , text
     }:
     mkDerivation {
       pname = "base91";
       version = "2.1.0";
       sha256 = "d68a86077e9a982f7344e1b596a92d7a6d50e3388b7f99a4b2e4525bf8d1e9d3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mono-traversable ];
       executableHaskellDepends = [
         base bytestring mono-traversable text
       ];
       testHaskellDepends = [
         base bytestring mono-traversable QuickCheck text
       ];
       homepage = "https://github.com/ajg/base91";
       description = "A Generic Base91 Encoder & Decoder";
       license = stdenv.lib.licenses.mit;
     }) {};

  "basex-client" = callPackage
    ({ mkDerivation, base, network, pureMD5, utf8-string }:
     mkDerivation {
       pname = "basex-client";
       version = "0.2.0.0";
       sha256 = "90f165babb781cb9a38107c32bd9c0d2cbee836f2120c7c2bf39b1e1a5ef1d0d";
       libraryHaskellDepends = [ base network pureMD5 utf8-string ];
       description = "A BaseX client for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "bash" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , hxt-regex-xmlschema, mtl, SHA, shell-escape
     }:
     mkDerivation {
       pname = "bash";
       version = "0.1.8";
       sha256 = "c070fd6efd7d750fcd1302589b251689de854f0bf5047f6282766fb2ba8267f3";
       libraryHaskellDepends = [
         base binary bytestring containers hxt-regex-xmlschema mtl SHA
         shell-escape
       ];
       homepage = "http://github.com/solidsnack/bash";
       description = "Bash generation library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "basic-lens" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "basic-lens";
       version = "0.0.0";
       sha256 = "d2ee8a48909db7f6bbf3deae03d9cfbbdfcce86932f0cae8fb59bf6d0c10ed61";
       revision = "1";
       editedCabalFile = "dcb1e49555431b94fedf161e3a2169213eea59167a34eb20b91be22baac9e170";
       libraryHaskellDepends = [ base ];
       description = "Basic lens type and functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "basic-prelude_0_3_10" = callPackage
    ({ mkDerivation, base, bytestring, containers, hashable
     , lifted-base, ReadArgs, safe, system-filepath, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "basic-prelude";
       version = "0.3.10";
       sha256 = "a94c0c94ece5b21bc6ca9a939a118185c5c1e9acdbf93cb46114df79a21d0180";
       libraryHaskellDepends = [
         base bytestring containers hashable lifted-base ReadArgs safe
         system-filepath text transformers unordered-containers vector
       ];
       homepage = "https://github.com/snoyberg/basic-prelude";
       description = "An enhanced core prelude; a common foundation for alternate preludes";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "basic-prelude_0_3_11" = callPackage
    ({ mkDerivation, base, bytestring, containers, hashable
     , lifted-base, ReadArgs, safe, system-filepath, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "basic-prelude";
       version = "0.3.11";
       sha256 = "86368bff6df4fb89cbc3427b5872a2326d4f520e3db466c4e844704ed452cb16";
       libraryHaskellDepends = [
         base bytestring containers hashable lifted-base ReadArgs safe
         system-filepath text transformers unordered-containers vector
       ];
       homepage = "https://github.com/snoyberg/basic-prelude";
       description = "An enhanced core prelude; a common foundation for alternate preludes";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "basic-prelude_0_3_11_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, hashable
     , lifted-base, ReadArgs, safe, system-filepath, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "basic-prelude";
       version = "0.3.11.1";
       sha256 = "8376f54341837ea6e6c1410e1e3dd5b4905e90320cab9a5ae2536f54a5c1fa14";
       libraryHaskellDepends = [
         base bytestring containers hashable lifted-base ReadArgs safe
         system-filepath text transformers unordered-containers vector
       ];
       homepage = "https://github.com/snoyberg/basic-prelude";
       description = "An enhanced core prelude; a common foundation for alternate preludes";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "basic-prelude_0_3_12" = callPackage
    ({ mkDerivation, base, bytestring, containers, hashable
     , lifted-base, ReadArgs, safe, system-filepath, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "basic-prelude";
       version = "0.3.12";
       sha256 = "da7a606d1f1e2ecfdd25f21385993c440528d8b20c62661de4ea6bc751ebbce2";
       libraryHaskellDepends = [
         base bytestring containers hashable lifted-base ReadArgs safe
         system-filepath text transformers unordered-containers vector
       ];
       homepage = "https://github.com/snoyberg/basic-prelude";
       description = "An enhanced core prelude; a common foundation for alternate preludes";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "basic-prelude_0_3_13" = callPackage
    ({ mkDerivation, base, bytestring, containers, hashable
     , lifted-base, ReadArgs, safe, system-filepath, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "basic-prelude";
       version = "0.3.13";
       sha256 = "b47c4ca08e43591b05a48f50aafc7490f1f9d808919ce820aeddd1e46481d84d";
       libraryHaskellDepends = [
         base bytestring containers hashable lifted-base ReadArgs safe
         system-filepath text transformers unordered-containers vector
       ];
       homepage = "https://github.com/snoyberg/basic-prelude";
       description = "An enhanced core prelude; a common foundation for alternate preludes";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "basic-prelude" = callPackage
    ({ mkDerivation, base, bytestring, containers, filepath, hashable
     , lifted-base, ReadArgs, safe, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "basic-prelude";
       version = "0.5.0";
       sha256 = "d1f562338ed9934a02b4fadc9f9a33f467d10105dbe03f527b47d4ae536210d1";
       revision = "1";
       editedCabalFile = "2ddf5a9d3413a8e7c877c488f63451357fcde4d187f7c560f5281a0c4856fd0b";
       libraryHaskellDepends = [
         base bytestring containers filepath hashable lifted-base ReadArgs
         safe text transformers unordered-containers vector
       ];
       homepage = "https://github.com/snoyberg/basic-prelude";
       description = "An enhanced core prelude; a common foundation for alternate preludes";
       license = stdenv.lib.licenses.mit;
     }) {};

  "basic-sop" = callPackage
    ({ mkDerivation, base, deepseq, generics-sop, QuickCheck, text }:
     mkDerivation {
       pname = "basic-sop";
       version = "0.2.0.0";
       sha256 = "8bec41c8501e9db661eea4d789ba167b6d0492c8fa69233826644c388656a891";
       libraryHaskellDepends = [
         base deepseq generics-sop QuickCheck text
       ];
       description = "Basic examples and functions for generics-sop";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "baskell" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec, pretty, unix }:
     mkDerivation {
       pname = "baskell";
       version = "0.1.1";
       sha256 = "b484ca78f28edaf76ea8ba507ff8ad39fda544ee6f4c4465c5249ef2332367ed";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers mtl parsec pretty unix
       ];
       homepage = "http://www.cs.mu.oz.au/~bjpop/code.html";
       description = "An interpreter for a small functional language";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "battlenet" = callPackage
    ({ mkDerivation, aeson, base, containers, http-conduit, text }:
     mkDerivation {
       pname = "battlenet";
       version = "0.2.0.0";
       sha256 = "aa775ac1f5ae6b30208d56f12580247dbaefd4dd5c8dcba192495d6a2c8af4db";
       libraryHaskellDepends = [
         aeson base containers http-conduit text
       ];
       jailbreak = true;
       homepage = "https://github.com/teozkr/hs-battlenet/";
       description = "API client for Battle.Net";
       license = stdenv.lib.licenses.mit;
     }) {};

  "battlenet-yesod" = callPackage
    ({ mkDerivation, base, battlenet, http-conduit, text, yesod-core }:
     mkDerivation {
       pname = "battlenet-yesod";
       version = "0.2.0.0";
       sha256 = "df03b4fc8e3b5ca453cf7bc28c7f3ff7714baedb2654356494dc06053341df14";
       libraryHaskellDepends = [
         base battlenet http-conduit text yesod-core
       ];
       jailbreak = true;
       homepage = "https://github.com/teozkr/hs-battlenet/";
       description = "Yesod integration for the battlenet package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "battleships" = callPackage
    ({ mkDerivation, aeson, array, attoparsec, base, base64-bytestring
     , blaze-svg, bytestring, cereal, colour, containers, cookie
     , crypto-random, data-default, diagrams-lib, diagrams-svg
     , fast-logger, filepath, hamlet, hjsmin, MonadRandom, mtl
     , shakespeare-js, shakespeare-text, SimpleAES, template-haskell
     , text, transformers, wai-extra, wai-handler-fastcgi, wai-logger
     , word8, yaml, yesod, yesod-core, yesod-routes, yesod-static
     }:
     mkDerivation {
       pname = "battleships";
       version = "1.0.0";
       sha256 = "8db2614e525344a663f4961130fa819b582adedfef02c99be50799362336e9e5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array attoparsec base base64-bytestring blaze-svg bytestring
         cereal colour containers cookie data-default diagrams-lib
         diagrams-svg fast-logger filepath hamlet hjsmin MonadRandom mtl
         shakespeare-js shakespeare-text SimpleAES template-haskell text
         transformers wai-extra wai-logger word8 yaml yesod yesod-core
         yesod-routes yesod-static
       ];
       executableHaskellDepends = [
         base blaze-svg bytestring containers crypto-random diagrams-lib
         diagrams-svg filepath MonadRandom mtl transformers
         wai-handler-fastcgi yesod
       ];
       jailbreak = true;
       homepage = "https://github.com/zrho/afp";
       description = "A web-based implementation of battleships including an AI opponent";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bayes-stack" = callPackage
    ({ mkDerivation, base, cereal, containers, deepseq, digamma
     , enummapset, gamma, ghc-prim, logfloat, mtl, mwc-random, pretty
     , random-fu, random-source, rvar, statistics, stm, transformers
     , vector
     }:
     mkDerivation {
       pname = "bayes-stack";
       version = "0.2.0.1";
       sha256 = "b4744dcd95d77bd49dbeabef9e498db5ff410a7ebacb6ab665eab9d6ada5e4db";
       libraryHaskellDepends = [
         base cereal containers deepseq digamma enummapset gamma ghc-prim
         logfloat mtl mwc-random pretty random-fu random-source rvar
         statistics stm transformers vector
       ];
       homepage = "https://github.com/bgamari/bayes-stack";
       description = "Framework for inferring generative probabilistic models with Gibbs sampling";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bbdb" = callPackage
    ({ mkDerivation, base, mtl, parsec }:
     mkDerivation {
       pname = "bbdb";
       version = "0.5";
       sha256 = "03a1cc86802658fe10d6967d6d29ce07451173ae8f8d0197758fc7108139ee8e";
       libraryHaskellDepends = [ base mtl parsec ];
       homepage = "http://www.nadineloveshenry.com/haskell/database-bbdb.html";
       description = "Ability to read, write, and examine BBDB files";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "bbi" = callPackage
    ({ mkDerivation, base, bytestring, cereal, conduit, containers, mtl
     , zlib
     }:
     mkDerivation {
       pname = "bbi";
       version = "0.1.0";
       sha256 = "4fd495f092457cca89e8e4562f735022507085b0c928b7d8fe92ea020fa32878";
       libraryHaskellDepends = [
         base bytestring cereal conduit containers mtl zlib
       ];
       description = "Tools for reading Big Binary Indexed files, e.g., bigBed, bigWig";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bcrypt_0_0_6" = callPackage
    ({ mkDerivation, base, bytestring, entropy }:
     mkDerivation {
       pname = "bcrypt";
       version = "0.0.6";
       sha256 = "25ae42a5078129dbe51111977b31f529a9c31e3400483ab41113dc79f651540c";
       libraryHaskellDepends = [ base bytestring entropy ];
       description = "Haskell bindings to the bcrypt password hash";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bcrypt" = callPackage
    ({ mkDerivation, base, bytestring, entropy, memory }:
     mkDerivation {
       pname = "bcrypt";
       version = "0.0.8";
       sha256 = "9cd100975d7349190a1d8ed6459d9e2677a74385ce86b35f2da3f5c582e11100";
       libraryHaskellDepends = [ base bytestring entropy memory ];
       description = "Haskell bindings to the bcrypt password hash";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bdd" = callPackage
    ({ mkDerivation, base, directory, HUnit, mtl, process
     , test-framework, test-framework-hunit, transformers
     }:
     mkDerivation {
       pname = "bdd";
       version = "0.2.0.0";
       sha256 = "98a8b2ae926daa85d989c917442e4101e511eb97e0747d6ac631e789f5c41c9e";
       libraryHaskellDepends = [ base HUnit mtl transformers ];
       testHaskellDepends = [
         base directory HUnit mtl process test-framework
         test-framework-hunit
       ];
       homepage = "http://github.com/humane-software/haskell-bdd";
       description = "Behavior-Driven Development DSL";
       license = stdenv.lib.licenses.mit;
     }) {};

  "bdelta" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "bdelta";
       version = "0.1.1.1";
       sha256 = "9ce7c5228bb7750050b6cd3b7a9f942f9669a181bd61a300eea445ee1bbdea9f";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://github.com/joeyadams/haskell-bytestring-delta";
       description = "Simple, fast binary diff/patch";
       license = stdenv.lib.licenses.mit;
     }) {};

  "bdo" = callPackage
    ({ mkDerivation, aeson, base, network, text, url }:
     mkDerivation {
       pname = "bdo";
       version = "1.0.1";
       sha256 = "0259e3a8e8a5a8cbc9f0d7458e4de16c2e13dfa41dde5fba47dc3e61033d8cd7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ aeson base network text url ];
       executableHaskellDepends = [ aeson base network text url ];
       description = "Update CSS in the browser without reloading the page";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "beam" = callPackage
    ({ mkDerivation, base, conduit, containers, convertible, HDBC
     , HDBC-sqlite3, microlens, mtl, pretty, semigroups, tagged, text
     , time, uniplate
     }:
     mkDerivation {
       pname = "beam";
       version = "0.3.2.0";
       sha256 = "1a6facf70119515b46b05e336bff59254d8e69f38cfeca6a65625e130fb26b5a";
       libraryHaskellDepends = [
         base conduit containers convertible HDBC HDBC-sqlite3 microlens mtl
         pretty semigroups tagged text time uniplate
       ];
       homepage = "http://travis.athougies.net/projects/beam.html";
       description = "A type-safe SQL mapper for Haskell that doesn't use Template Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "beamable" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, ghc-prim
     , integer-gmp, murmur-hash, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "beamable";
       version = "0.1.1.1";
       sha256 = "473c8e6f1c3fcbd5ea637489948fab7528b2bcb28105691e956695493d380d19";
       libraryHaskellDepends = [
         base blaze-builder bytestring ghc-prim integer-gmp murmur-hash
       ];
       testHaskellDepends = [
         base blaze-builder bytestring ghc-prim integer-gmp murmur-hash
         QuickCheck test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       description = "Generic serializer/deserializer with compact representation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "beautifHOL" = callPackage
    ({ mkDerivation, array, base, haskell98, mtl }:
     mkDerivation {
       pname = "beautifHOL";
       version = "0.11";
       sha256 = "f12f28bac7d1c9b6db82c58ecb5c9eeff1afddc495a8c5cf310b4074c30f6496";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base haskell98 mtl ];
       homepage = "http://www.cs.indiana.edu/~lepike/pub_pages/holpp.html";
       description = "A pretty-printer for higher-order logic";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bed-and-breakfast" = callPackage
    ({ mkDerivation, array, base, binary, deepseq, QuickCheck
     , template-haskell
     }:
     mkDerivation {
       pname = "bed-and-breakfast";
       version = "0.4.3";
       sha256 = "dfb8b41460db8e35b28405ac03fa02e1056034516e64dcb34eb9acb9c1390305";
       revision = "1";
       editedCabalFile = "3efbed0b49112bb9addddcd87fdb8ffe58f14497c16a2aba9deb39e10dae0d4f";
       libraryHaskellDepends = [
         array base binary deepseq template-haskell
       ];
       testHaskellDepends = [ base QuickCheck ];
       jailbreak = true;
       homepage = "https://hackage.haskell.org/package/bed-and-breakfast";
       description = "Efficient Matrix operations in 100% Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bein" = callPackage
    ({ mkDerivation, base, bytestring, containers, convertible, Crypto
     , directory, filepath, happstack-server, happstack-util, hdaemonize
     , HDBC, HDBC-postgresql, hsyslog, mtl, network, old-locale, parsec
     , process, random, stm, time, unix, utf8-string, xhtml
     }:
     mkDerivation {
       pname = "bein";
       version = "0.3.3";
       sha256 = "909976d41ee5a723a8eb0e6ebda267f748b74a220f04ed2780b8b59594f806eb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers convertible Crypto directory filepath
         happstack-server happstack-util hdaemonize HDBC HDBC-postgresql
         hsyslog mtl network old-locale parsec process random stm time unix
         utf8-string xhtml
       ];
       description = "Bein is a provenance and workflow management system for bioinformatics";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "benchmark-function" = callPackage
    ({ mkDerivation, base, process, random, time }:
     mkDerivation {
       pname = "benchmark-function";
       version = "0.1.0.0";
       sha256 = "abb023c298bb0ad58e376f668e7b11ce3f89be786fb8e6eeeae9d4008053abb1";
       libraryHaskellDepends = [ base process random time ];
       homepage = "xy30.com";
       description = "Test the time it takes to run a haskell function";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "benchpress" = callPackage
    ({ mkDerivation, base, mtl, time }:
     mkDerivation {
       pname = "benchpress";
       version = "0.2.2.7";
       sha256 = "d09b80fd61f18ba76f19772a8fb013d1aa1fd78590826c6fab12601778c562e6";
       libraryHaskellDepends = [ base mtl time ];
       homepage = "https://github.com/WillSewell/benchpress";
       description = "Micro-benchmarking with detailed statistics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bencode" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, parsec }:
     mkDerivation {
       pname = "bencode";
       version = "0.6.0.0";
       sha256 = "3b8efdfecee9bc486d9bcdbb633b7128ca235360f102478a7e0f8c895281f68a";
       libraryHaskellDepends = [
         base binary bytestring containers parsec
       ];
       description = "Parser and printer for bencoded data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bencoding" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, deepseq
     , ghc-prim, hspec, mtl, pretty, QuickCheck, text
     }:
     mkDerivation {
       pname = "bencoding";
       version = "0.4.3.0";
       sha256 = "8c5dd6aa1ea6ac20260fc5df8d94257acde5800de78ca278d1241e8fd01bcd38";
       libraryHaskellDepends = [
         attoparsec base bytestring deepseq ghc-prim mtl pretty text
       ];
       testHaskellDepends = [
         attoparsec base bytestring containers ghc-prim hspec QuickCheck
       ];
       jailbreak = true;
       homepage = "https://github.com/cobit/bencoding";
       description = "A library for encoding and decoding of BEncode data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "berkeleydb" = callPackage
    ({ mkDerivation, base, binary, bytestring, db }:
     mkDerivation {
       pname = "berkeleydb";
       version = "2008.10.31";
       sha256 = "775083f70fc92545268d4eb314e057f9517d56e845869cc022abf61040ec1fe3";
       libraryHaskellDepends = [ base binary bytestring ];
       librarySystemDepends = [ db ];
       description = "Pretty BerkeleyDB v4 binding";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) db;};

  "berp" = callPackage
    ({ mkDerivation, array, base, containers, directory
     , extensible-exceptions, filepath, ghc, ghc-paths, ghc-prim
     , haskeline, haskell-src-exts, language-python, monads-tf
     , parseargs, process, template-haskell, transformers
     }:
     mkDerivation {
       pname = "berp";
       version = "0.0.2";
       sha256 = "0974f3484d3fc2e48cfb07aceff017757e7c7d93d35b56e58e3644eebc0dd518";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers ghc-prim monads-tf template-haskell
         transformers
       ];
       executableHaskellDepends = [
         base containers directory extensible-exceptions filepath ghc
         ghc-paths haskeline haskell-src-exts language-python monads-tf
         parseargs process transformers
       ];
       jailbreak = true;
       homepage = "http://wiki.github.com/bjpop/berp/";
       description = "An implementation of Python 3";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bert" = callPackage
    ({ mkDerivation, async, base, binary, binary-conduit, bytestring
     , conduit, conduit-extra, containers, mtl, network, parsec
     , smallcheck, tasty, tasty-hunit, tasty-smallcheck, time, unix
     , void
     }:
     mkDerivation {
       pname = "bert";
       version = "1.2.2.4";
       sha256 = "e4e907e3353a9967196c973a363bc8742670587f42e9de0ac639a4c836f58bed";
       libraryHaskellDepends = [
         base binary binary-conduit bytestring conduit conduit-extra
         containers mtl network parsec time unix void
       ];
       testHaskellDepends = [
         async base binary bytestring containers network smallcheck tasty
         tasty-hunit tasty-smallcheck
       ];
       homepage = "https://github.com/feuerbach/bert";
       description = "BERT implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "besout" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "besout";
       version = "0.2.0.1";
       sha256 = "41d3af0a84244fde61e4c902dd2e30e995a38df4e4f279cae6c1c968ac45662f";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Extended GCD of polynomials over F_p[x]";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bet" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, binary, bytestring
     , containers, exceptions, HsOpenSSL, http-client
     , http-client-openssl, lens, mtl, QuickCheck, semigroupoids
     , semigroups, test-framework, test-framework-quickcheck2
     , test-framework-th, text, time
     }:
     mkDerivation {
       pname = "bet";
       version = "0.1.2.3";
       sha256 = "a818d927e09c0386842658f70682089c16bc241961834af07fdbb0155015c13f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bifunctors binary bytestring containers exceptions
         HsOpenSSL http-client http-client-openssl lens mtl semigroupoids
         semigroups text time
       ];
       testHaskellDepends = [
         base lens QuickCheck semigroups test-framework
         test-framework-quickcheck2 test-framework-th
       ];
       jailbreak = true;
       homepage = "https://github.com/Noeda/bet/";
       description = "Betfair API bindings. Bet on sports on betting exchanges.";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "betacode" = callPackage
    ({ mkDerivation, attoparsec, base, errors, hashable, hspec
     , QuickCheck, smallcheck, text, text-icu
     }:
     mkDerivation {
       pname = "betacode";
       version = "0.1.0.0";
       sha256 = "eb605947326191c2f0fb956cd6bf5e4e3a39e419b11d1e0762640840ae16c467";
       libraryHaskellDepends = [
         attoparsec base errors hashable text text-icu
       ];
       testHaskellDepends = [ base hspec QuickCheck smallcheck ];
       jailbreak = true;
       description = "A codec for beta code (http://en.wikipedia.org/wiki/Beta_Code).";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "between" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "between";
       version = "0.11.0.0";
       sha256 = "8337351326c5a613d9b7520b6a8203234c04454e23550a81739beaa6f671465d";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/trskop/between";
       description = "Function combinator \"between\" and derived combinators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bf-cata" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "bf-cata";
       version = "1.1";
       sha256 = "fcbf7d687adbbc8fa7d522b47d82581115d07453f08fa33b39a5132145f31739";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.cs.uu.nl/wiki/HUT/WebHome";
       license = "LGPL";
     }) {};

  "bff" = callPackage
    ({ mkDerivation, base, bimap, category-extras, containers, derive
     , haskell98, mtl, template-haskell, unix
     }:
     mkDerivation {
       pname = "bff";
       version = "0.3.1.2";
       sha256 = "5d44be6c1890b08ed18b8ebac8cf2565747f2c20f143edb7c0d0c311e73dbec4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bimap category-extras containers derive haskell98 mtl
         template-haskell unix
       ];
       jailbreak = true;
       description = "Bidirectionalization for Free! (POPL'09)";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bff-mono" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "bff-mono";
       version = "0.2.3";
       sha256 = "1913352257cdcc3196714c1e4a8db30f9619e6beddc758d03b2f0019b3745ce3";
       libraryHaskellDepends = [ base containers mtl ];
       homepage = "https://bitbucket.org/kztk/bff-mono/";
       description = "\"Bidirectionalization for Free\" for Monomorphic Transformations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bgmax" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, time }:
     mkDerivation {
       pname = "bgmax";
       version = "0.1.0.1";
       sha256 = "ba68978e53d15d069ac31064069d641a89bfee1d5133c05670848112076ce271";
       libraryHaskellDepends = [ attoparsec base bytestring time ];
       jailbreak = true;
       homepage = "http://github.com/jonpetterbergman/bgmax";
       description = "Parse BgMax-files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bgzf" = callPackage
    ({ mkDerivation, base, bytestring, mtl, parallel, pipes
     , streaming-commons
     }:
     mkDerivation {
       pname = "bgzf";
       version = "0.1.0.0";
       sha256 = "3bcfc63b15d3eb0729193ec811ae2925e5febd1de0230876b9d1e8a68a59bcd2";
       libraryHaskellDepends = [
         base bytestring mtl parallel pipes streaming-commons
       ];
       description = "Blocked GZip";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bibtex" = callPackage
    ({ mkDerivation, base, latex, parsec, utility-ht }:
     mkDerivation {
       pname = "bibtex";
       version = "0.1.0.5";
       sha256 = "dd06fbd5d597a558f059775b258ae526baa41c656a92e7d8a45646c64c1bc74b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base latex parsec utility-ht ];
       homepage = "http://www.haskell.org/haskellwiki/BibTeX";
       description = "Parse, format and processing BibTeX files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bidirectionalization-combined" = callPackage
    ({ mkDerivation, base, bytestring, cgi, containers, directory, hint
     , mtl, parsec, pretty, template-haskell, unix, utf8-string, xhtml
     }:
     mkDerivation {
       pname = "bidirectionalization-combined";
       version = "0.1.0.1";
       sha256 = "d5c85467fe98881290a82417ce3482e88e2f782eddf514f63f2a8f07f957942d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cgi containers directory hint mtl parsec pretty
         template-haskell unix utf8-string xhtml
       ];
       homepage = "http://www.kb.ecei.tohoku.ac.jp/~kztk/b18n-combined/desc.html";
       description = "Prototype Implementation of Combining Syntactic and Semantic Bidirectionalization (ICFP'10)";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bidispec" = callPackage
    ({ mkDerivation, base, bytestring, mtl }:
     mkDerivation {
       pname = "bidispec";
       version = "0.1.3";
       sha256 = "e41dbe6d53345d0893c2825e0316d9c99f685e58870e98b94894ed70e1d43079";
       libraryHaskellDepends = [ base bytestring mtl ];
       description = "Specification of generators and parsers";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bidispec-extras" = callPackage
    ({ mkDerivation, base, bytestring, dataenc, mtl }:
     mkDerivation {
       pname = "bidispec-extras";
       version = "0.1";
       sha256 = "3583e5fb2f6be1d4fd85adf4b60baa89b3810a27a84c40d3f8fb193c4cc4da46";
       libraryHaskellDepends = [ base bytestring dataenc mtl ];
       jailbreak = true;
       description = "Extra helper functions for bidirectional specifications";
       license = "LGPL";
     }) {};

  "bifunctors_4_2" = callPackage
    ({ mkDerivation, base, semigroupoids, semigroups, tagged }:
     mkDerivation {
       pname = "bifunctors";
       version = "4.2";
       sha256 = "c661f4fc9a9f868309d30ad51dc2c803655f46cf722d5761166f2bb0b110b23f";
       libraryHaskellDepends = [ base semigroupoids semigroups tagged ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/bifunctors/";
       description = "Bifunctors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bifunctors_4_2_1" = callPackage
    ({ mkDerivation, base, semigroupoids, semigroups, tagged }:
     mkDerivation {
       pname = "bifunctors";
       version = "4.2.1";
       sha256 = "cf8e6eed293f195ecb6e9e14115b5d3653cd32c6ff18971f4510988cc0a7c47f";
       libraryHaskellDepends = [ base semigroupoids semigroups tagged ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/bifunctors/";
       description = "Bifunctors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bifunctors_5" = callPackage
    ({ mkDerivation, base, semigroups, tagged }:
     mkDerivation {
       pname = "bifunctors";
       version = "5";
       sha256 = "41df923a03f15ba2d00335aea2409ebf48ee7585f0a1101f1ec282fe5a07298d";
       libraryHaskellDepends = [ base semigroups tagged ];
       homepage = "http://github.com/ekmett/bifunctors/";
       description = "Bifunctors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bifunctors_5_1" = callPackage
    ({ mkDerivation, base, containers, hspec, QuickCheck, semigroups
     , tagged, template-haskell, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "bifunctors";
       version = "5.1";
       sha256 = "0bd9de8dfe8c3c33555cc59fa423edf624761b850252fa2051097e97574635dd";
       revision = "1";
       editedCabalFile = "b4c4393c49cb8a9f4dbae48fc68fcd1fdc1797f73a9a60320068c8704573432b";
       libraryHaskellDepends = [
         base containers semigroups tagged template-haskell
       ];
       testHaskellDepends = [
         base hspec QuickCheck transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/bifunctors/";
       description = "Bifunctors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bifunctors_5_2" = callPackage
    ({ mkDerivation, base, comonad, containers, hspec, QuickCheck
     , semigroups, tagged, template-haskell, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "bifunctors";
       version = "5.2";
       sha256 = "46e173dac5863a7b8404b44ab1ead2de94e743d24a2de571ff086cfb8748de14";
       libraryHaskellDepends = [
         base comonad containers semigroups tagged template-haskell
         transformers
       ];
       testHaskellDepends = [
         base hspec QuickCheck transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/bifunctors/";
       description = "Bifunctors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bifunctors" = callPackage
    ({ mkDerivation, base, comonad, containers, hspec, QuickCheck
     , semigroups, tagged, template-haskell, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "bifunctors";
       version = "5.2.1";
       sha256 = "cbb459178a8c72cbb695361b518ae17ed3664e3ad207a34276f4d2990107e9cb";
       libraryHaskellDepends = [
         base comonad containers semigroups tagged template-haskell
         transformers transformers-compat
       ];
       testHaskellDepends = [
         base hspec QuickCheck transformers transformers-compat
       ];
       doHaddock = false;
       homepage = "http://github.com/ekmett/bifunctors/";
       description = "Bifunctors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bighugethesaurus" = callPackage
    ({ mkDerivation, base, HTTP, split }:
     mkDerivation {
       pname = "bighugethesaurus";
       version = "0.1.0.0";
       sha256 = "3af008b07f35f4a83f53d5c119956195e2cc897396b63f3415cfa0f7561f13c8";
       libraryHaskellDepends = [ base HTTP split ];
       description = "API wrapper for Big Huge Thesaurus";
       license = "GPL";
     }) {};

  "billboard-parser" = callPackage
    ({ mkDerivation, base, directory, filepath, HarmTrace-Base, HUnit
     , ListLike, mtl, parseargs, uu-parsinglib
     }:
     mkDerivation {
       pname = "billboard-parser";
       version = "1.0.0.1";
       sha256 = "055071b6a9ef63a46a6ac97ce1fdf407eef0460bd45f5331a65d9d4f78c111ca";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory filepath HarmTrace-Base HUnit ListLike mtl
         uu-parsinglib
       ];
       executableHaskellDepends = [
         base directory filepath HarmTrace-Base HUnit ListLike mtl parseargs
         uu-parsinglib
       ];
       jailbreak = true;
       homepage = "http://ddmal.music.mcgill.ca/billboard";
       description = "A parser for the Billboard chord dataset";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "billeksah-forms" = callPackage
    ({ mkDerivation, base, billeksah-pane, billeksah-services, Cabal
     , containers, directory, filepath, glib, gtk, mtl, parsec, pretty
     , transformers
     }:
     mkDerivation {
       pname = "billeksah-forms";
       version = "1.0.0";
       sha256 = "ba16b1337d896711c774214e2215b620f915dc4e289f6848f0db7560a7c09a24";
       libraryHaskellDepends = [
         base billeksah-pane billeksah-services Cabal containers directory
         filepath glib gtk mtl parsec pretty transformers
       ];
       jailbreak = true;
       homepage = "http://www.leksah.org";
       description = "Leksah library";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "billeksah-main" = callPackage
    ({ mkDerivation, base, billeksah-services, containers, directory
     , filepath, mtl, parsec, plugins, pretty, transformers
     }:
     mkDerivation {
       pname = "billeksah-main";
       version = "1.0.0";
       sha256 = "9ddada672e1f371ef4982e9fc8d46004282cdb9168ed075213b07fb81d36cfb7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base billeksah-services containers directory filepath mtl parsec
         plugins pretty transformers
       ];
       jailbreak = true;
       homepage = "http://www.leksah.org";
       description = "Leksah plugin base";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "billeksah-main-static" = callPackage
    ({ mkDerivation, base, billeksah-forms, billeksah-pane
     , billeksah-services, containers, directory, filepath, leksah-dummy
     , leksah-main, leksah-plugin-pane, mtl, parsec, pretty
     , transformers
     }:
     mkDerivation {
       pname = "billeksah-main-static";
       version = "1.0.0";
       sha256 = "fe483abfb484fd0f7a7a4c694da490e8129d237e996485e7ee421bf56da39fbc";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base billeksah-forms billeksah-pane billeksah-services containers
         directory filepath leksah-dummy leksah-main leksah-plugin-pane mtl
         parsec pretty transformers
       ];
       jailbreak = true;
       homepage = "http://www.leksah.org";
       description = "Leksah plugin base";
       license = "LGPL";
       broken = true;
     }) {leksah-dummy = null; leksah-main = null; 
         leksah-plugin-pane = null;};

  "billeksah-pane" = callPackage
    ({ mkDerivation, base, billeksah-services, containers, directory
     , filepath, glib, gtk, mtl, parsec, pretty, time, transformers
     }:
     mkDerivation {
       pname = "billeksah-pane";
       version = "1.0.0";
       sha256 = "6fab58f1f72a1732f17d35091908547ae003479c3d9484374ec08fe8da927fb2";
       libraryHaskellDepends = [
         base billeksah-services containers directory filepath glib gtk mtl
         parsec pretty time transformers
       ];
       jailbreak = true;
       homepage = "http://www.leksah.org";
       description = "Leksah library";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "billeksah-services" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, mtl, parsec
     , pretty, transformers
     }:
     mkDerivation {
       pname = "billeksah-services";
       version = "1.0.0";
       sha256 = "96c79fe9a1babbd0fc9f6b5a0bd7b4cae4f49b2b8c08fdb157965366755e7a01";
       libraryHaskellDepends = [
         base containers directory filepath mtl parsec pretty transformers
       ];
       jailbreak = true;
       homepage = "http://www.leksah.org";
       description = "Leksah library";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bimap_0_3_0" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "bimap";
       version = "0.3.0";
       sha256 = "21c6072c8dd47b908c2985f58e35a6c53d9854b3a83845d1976abff77fcf39c9";
       libraryHaskellDepends = [ base containers ];
       homepage = "https://github.com/joelwilliamson/bimap";
       description = "Bidirectional mapping between two key types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bimap" = callPackage
    ({ mkDerivation, base, containers, exceptions, QuickCheck
     , template-haskell
     }:
     mkDerivation {
       pname = "bimap";
       version = "0.3.2";
       sha256 = "148fc2d9784aa79faf49a979881a2304102a70d13e32fa8ce9f18ab466dc3db8";
       libraryHaskellDepends = [ base containers exceptions ];
       testHaskellDepends = [
         base containers exceptions QuickCheck template-haskell
       ];
       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
     , 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
       ];
       description = "Two-column database server";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bimaps" = callPackage
    ({ mkDerivation, aeson, base, binary, cereal, containers, deepseq
     , hashable, primitive, QuickCheck, storable-tuple, test-framework
     , test-framework-quickcheck2, test-framework-th
     , unordered-containers, vector, vector-binary-instances
     , vector-th-unbox
     }:
     mkDerivation {
       pname = "bimaps";
       version = "0.0.0.4";
       sha256 = "0722d747a505ac7444c7ec87b956e58081fee65ddbf45ac7f5bd26f3f08cf275";
       libraryHaskellDepends = [
         aeson base binary cereal containers deepseq hashable primitive
         storable-tuple unordered-containers vector vector-binary-instances
         vector-th-unbox
       ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
         test-framework-th
       ];
       jailbreak = true;
       homepage = "https://github.com/choener/bimaps";
       description = "bijections with multiple implementations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "binary_0_7_6_1" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , directory, filepath, HUnit, QuickCheck, random, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "binary";
       version = "0.7.6.1";
       sha256 = "8f85cafc15be660757878a665d024ce595d4422fead174e20a501c9ec8f81067";
       libraryHaskellDepends = [ array base bytestring containers ];
       testHaskellDepends = [
         array base bytestring Cabal containers directory filepath HUnit
         QuickCheck random test-framework test-framework-quickcheck2
       ];
       homepage = "https://github.com/kolmodin/binary";
       description = "Binary serialisation for Haskell values using lazy ByteStrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary_0_8_2_1" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , directory, filepath, HUnit, QuickCheck, random, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "binary";
       version = "0.8.2.1";
       sha256 = "2452e32eccfe74214f689805745a11de1018f22eb19682772df23cce8816b750";
       libraryHaskellDepends = [ array base bytestring containers ];
       testHaskellDepends = [
         array base bytestring Cabal containers directory filepath HUnit
         QuickCheck random test-framework test-framework-quickcheck2
       ];
       homepage = "https://github.com/kolmodin/binary";
       description = "Binary serialisation for Haskell values using lazy ByteStrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-bits" = callPackage
    ({ mkDerivation, base, binary, bytestring, QuickCheck, random
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "binary-bits";
       version = "0.5";
       sha256 = "16534a018a4754d8d1eab051711c23fb741f41a0d141b289001c52824b5be794";
       libraryHaskellDepends = [ base binary bytestring ];
       testHaskellDepends = [
         base binary bytestring QuickCheck random test-framework
         test-framework-quickcheck2
       ];
       description = "Bit parsing/writing on top of binary";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "binary-communicator" = callPackage
    ({ mkDerivation, base, binary, bytestring, mtl }:
     mkDerivation {
       pname = "binary-communicator";
       version = "1.0.2.2";
       sha256 = "68c267c40d08bb0a574a35bb8bc2eab06172e1084fbf1fdeeb2d7015a9e56cf0";
       libraryHaskellDepends = [ base binary bytestring mtl ];
       description = "Flexible way to ease transmission of binary data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "binary-conduit" = callPackage
    ({ mkDerivation, base, binary, bytestring, conduit, hspec
     , QuickCheck, quickcheck-assertions, resourcet, vector
     }:
     mkDerivation {
       pname = "binary-conduit";
       version = "1.2.3";
       sha256 = "d9a18707bfbc583d8ac8bedc2ff5cf89c8e490575b5c75e2bc4192729cefb07a";
       revision = "1";
       editedCabalFile = "9cb1c58171575429a65947d1ef7e22c1501b4ca9becc07904c7b4a5066345e29";
       libraryHaskellDepends = [
         base binary bytestring conduit resourcet vector
       ];
       testHaskellDepends = [
         base binary bytestring conduit hspec QuickCheck
         quickcheck-assertions resourcet
       ];
       homepage = "http://github.com/qnikst/binary-conduit/";
       description = "data serialization/deserialization conduit library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "binary-derive" = callPackage
    ({ mkDerivation, base, binary, ghc-prim }:
     mkDerivation {
       pname = "binary-derive";
       version = "0.1.0";
       sha256 = "7433551080e23843fb4ed8f819f2c04dca13eb7d37dbd36a30065358fa7564e5";
       libraryHaskellDepends = [ base binary ghc-prim ];
       jailbreak = true;
       description = "Automatic deriving of Binary using GHC.Generics";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-enum" = callPackage
    ({ mkDerivation, base, binary }:
     mkDerivation {
       pname = "binary-enum";
       version = "0.1.2.0";
       sha256 = "15e7d259293db928980579cc8898dc6d545ffeaa5be97635cb93bb65a6a68688";
       libraryHaskellDepends = [ base binary ];
       homepage = "https://github.com/tolysz/binary-enum";
       description = "Simple wrappers around enum types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "binary-file" = callPackage
    ({ mkDerivation, base, bytestring, monads-tf, peggy
     , template-haskell
     }:
     mkDerivation {
       pname = "binary-file";
       version = "0.15.25";
       sha256 = "3f22fd8d60909e1f3f26e741ca5fa6126fa4de6427f5d3f7ce4c6fe3437ef6d0";
       libraryHaskellDepends = [
         base bytestring monads-tf peggy template-haskell
       ];
       homepage = "https://skami.iocikun.jp/haskell/packages/binary-file";
       description = "read/write binary file";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-generic" = callPackage
    ({ mkDerivation, base, binary, bytestring, data-binary-ieee754, syb
     , text
     }:
     mkDerivation {
       pname = "binary-generic";
       version = "0.2.1";
       sha256 = "ff69574128b926f4feeb161e2c4dd18be2e60bb32e7f9cb3239ce5cd8372cf30";
       libraryHaskellDepends = [
         base binary bytestring data-binary-ieee754 syb text
       ];
       homepage = "http://github.com/lpeterse/binary-generic";
       description = "Generic binary serialisation using binary and syb";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "binary-indexed-tree" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "binary-indexed-tree";
       version = "0.1";
       sha256 = "8dd0f54f68c36f107dfbc35412e873c4bbf057d16629417df38e3996f9ac4bb3";
       libraryHaskellDepends = [ array base ];
       description = "Binary Indexed Trees (a.k.a. Fenwick Trees).";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-list_1_0_1_0" = callPackage
    ({ mkDerivation, base, binary, bytestring, deepseq, phantom-state
     , transformers
     }:
     mkDerivation {
       pname = "binary-list";
       version = "1.0.1.0";
       sha256 = "a91dd9013dce6f4efaf46f2a9e7042783eff181bdd68d908bf055b9b8e9a03b5";
       libraryHaskellDepends = [
         base binary bytestring deepseq phantom-state transformers
       ];
       description = "Lists of length a power of two";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-list_1_1_0_2" = callPackage
    ({ mkDerivation, base, binary, bytestring, deepseq, phantom-state
     , transformers
     }:
     mkDerivation {
       pname = "binary-list";
       version = "1.1.0.2";
       sha256 = "8d61b3a6e06604b60decd447983fcc1b687a995c35f20bbde08dc9c0bd21ca00";
       libraryHaskellDepends = [
         base binary bytestring deepseq phantom-state transformers
       ];
       description = "Lists of length a power of two";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-list" = callPackage
    ({ mkDerivation, base, binary, bytestring, deepseq, phantom-state
     , transformers
     }:
     mkDerivation {
       pname = "binary-list";
       version = "1.1.1.0";
       sha256 = "ddd429eaadab064a5f1438e8fc3c593e04dbd79ca22251b9f7edcb5a6f2cd00d";
       libraryHaskellDepends = [
         base binary bytestring deepseq phantom-state transformers
       ];
       description = "Lists of length a power of two";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "binary-literal-qq" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "binary-literal-qq";
       version = "1.0";
       sha256 = "5506586d39e0d8b311516c05dc8eeaa8589782d0340cf45c853f68eab3687d4d";
       revision = "1";
       editedCabalFile = "61a53a601a913dd5fe5d52bc552f965d62d448ecea220dc1acb4884b67f54667";
       libraryHaskellDepends = [ base template-haskell ];
       description = "Extends Haskell with binary literals";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "binary-orphans_0_1_1_0" = callPackage
    ({ mkDerivation, aeson, base, binary, hashable
     , quickcheck-instances, scientific, tagged, tasty, tasty-quickcheck
     , text, text-binary, time, unordered-containers, vector
     , vector-binary-instances
     }:
     mkDerivation {
       pname = "binary-orphans";
       version = "0.1.1.0";
       sha256 = "a34b6ea3a5485859c3d83aa6d1e4535e05590ef543d01482beba757db1d14431";
       revision = "5";
       editedCabalFile = "04d4634220183ff3286ee57fe7726a692a8e80e7b10c9c13ba96d0b8847e6ff1";
       libraryHaskellDepends = [
         aeson base binary hashable scientific tagged text text-binary time
         unordered-containers vector vector-binary-instances
       ];
       testHaskellDepends = [
         aeson base binary hashable quickcheck-instances scientific tagged
         tasty tasty-quickcheck text time unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/phadej/binary-orphans#readme";
       description = "Orphan instances for binary";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-orphans_0_1_2_0" = callPackage
    ({ mkDerivation, aeson, base, binary, hashable
     , quickcheck-instances, scientific, tagged, tasty, tasty-quickcheck
     , text, text-binary, time, unordered-containers, vector
     , vector-binary-instances
     }:
     mkDerivation {
       pname = "binary-orphans";
       version = "0.1.2.0";
       sha256 = "7f83406c0b9c08df9d0d731f9616333f74422d5559fa1b1dc7c56aaf415605ab";
       revision = "1";
       editedCabalFile = "59c5a80316379f3d17a5b06e2ca47e04505c2dedc4bc0d06c7d2bfb9eb6c8661";
       libraryHaskellDepends = [
         aeson base binary hashable scientific tagged text text-binary time
         unordered-containers vector vector-binary-instances
       ];
       testHaskellDepends = [
         aeson base binary hashable quickcheck-instances scientific tagged
         tasty tasty-quickcheck text time unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/phadej/binary-orphans#readme";
       description = "Orphan instances for binary";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-orphans_0_1_3_0" = callPackage
    ({ mkDerivation, aeson, base, binary, hashable
     , quickcheck-instances, scientific, semigroups, tagged, tasty
     , tasty-quickcheck, text, text-binary, time, unordered-containers
     , vector, vector-binary-instances
     }:
     mkDerivation {
       pname = "binary-orphans";
       version = "0.1.3.0";
       sha256 = "a42edfe603aea009310a0139acda6a7c385f5b65dfbc084dd17323bd786366cb";
       libraryHaskellDepends = [
         aeson base binary hashable scientific semigroups tagged text
         text-binary time unordered-containers vector
         vector-binary-instances
       ];
       testHaskellDepends = [
         aeson base binary hashable quickcheck-instances scientific
         semigroups tagged tasty tasty-quickcheck text time
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/phadej/binary-orphans#readme";
       description = "Orphan instances for binary";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-orphans" = callPackage
    ({ mkDerivation, aeson, base, binary, hashable
     , quickcheck-instances, scientific, semigroups, tagged, tasty
     , tasty-quickcheck, text, text-binary, time, unordered-containers
     , vector, vector-binary-instances
     }:
     mkDerivation {
       pname = "binary-orphans";
       version = "0.1.4.0";
       sha256 = "0a952a7521747a7aacf4aa1638674130262f2efacb7121727c1932d49017f742";
       revision = "3";
       editedCabalFile = "b81b44514f6b9e69bb1cb36484268470dd9268112d974960fb6070a4bb1f307c";
       libraryHaskellDepends = [
         aeson base binary hashable scientific semigroups tagged text
         text-binary time unordered-containers vector
         vector-binary-instances
       ];
       testHaskellDepends = [
         aeson base binary hashable quickcheck-instances scientific
         semigroups tagged tasty tasty-quickcheck text time
         unordered-containers vector
       ];
       homepage = "https://github.com/phadej/binary-orphans#readme";
       description = "Orphan instances for binary";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "binary-parser_0_5_0_1" = callPackage
    ({ mkDerivation, base-prelude, bytestring, success, text
     , transformers
     }:
     mkDerivation {
       pname = "binary-parser";
       version = "0.5.0.1";
       sha256 = "df8c5eae56a2f80e0e52d6d9ec820d2206495edd8183bf98f57070608f3f7f32";
       libraryHaskellDepends = [
         base-prelude bytestring success text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/binary-parser";
       description = "A highly-efficient but limited parser API specialised for bytestrings";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-parser_0_5_1" = callPackage
    ({ mkDerivation, base-prelude, bytestring, success, text
     , transformers
     }:
     mkDerivation {
       pname = "binary-parser";
       version = "0.5.1";
       sha256 = "6e068b0c0d2cce0944ec79a8ddf9ff270834166a80a46db29d7bd61fb8f35e13";
       libraryHaskellDepends = [
         base-prelude bytestring success text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/binary-parser";
       description = "A highly-efficient but limited parser API specialised for bytestrings";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-parser" = callPackage
    ({ mkDerivation, base-prelude, bytestring, success, text
     , transformers
     }:
     mkDerivation {
       pname = "binary-parser";
       version = "0.5.2";
       sha256 = "712d30f26f8423704437e02bd5cc98cfff48fdbac0499e8cb41998f289245545";
       libraryHaskellDepends = [
         base-prelude bytestring success text transformers
       ];
       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-protocol" = callPackage
    ({ mkDerivation, base, binary, bytestring, mtl }:
     mkDerivation {
       pname = "binary-protocol";
       version = "1.0";
       sha256 = "7084bcca057dcb968587d9c67fbc34d4a384aaaacab39b4fb4e803210993c6c2";
       libraryHaskellDepends = [ base binary bytestring mtl ];
       jailbreak = true;
       homepage = "http://github.com/gcross/binary-protocol";
       description = "Monad to ease implementing a binary network protocol";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "binary-protocol-zmq" = callPackage
    ({ mkDerivation, base, binary, bytestring, mtl, zeromq-haskell }:
     mkDerivation {
       pname = "binary-protocol-zmq";
       version = "0.2";
       sha256 = "beaad38fb11794b368e69f3b84d46809440a1afae26110401c79c9c0a6b94a92";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring mtl zeromq-haskell
       ];
       homepage = "http://github.com/NicolasT/binary-protocol-zmq";
       description = "Monad to ease implementing a binary network protocol over ZeroMQ";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-search_0_1" = callPackage
    ({ mkDerivation, base, containers, directory, doctest, filepath
     , hspec, QuickCheck
     }:
     mkDerivation {
       pname = "binary-search";
       version = "0.1";
       sha256 = "c315c3c8a5b2c10f09cd53733143ada978e804ebc917c2d0b4163fedaf0c480b";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [
         base directory doctest filepath hspec QuickCheck
       ];
       description = "Binary and exponential searches";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-search" = callPackage
    ({ mkDerivation, base, containers, directory, doctest, filepath
     , hspec, QuickCheck, transformers
     }:
     mkDerivation {
       pname = "binary-search";
       version = "1.0.0.3";
       sha256 = "b0e32df46aeddceac57bd6afa940f84f275f82fb251479e10fadd7c14414f6fa";
       libraryHaskellDepends = [ base containers transformers ];
       testHaskellDepends = [
         base directory doctest filepath hspec QuickCheck
       ];
       doCheck = false;
       description = "Binary and exponential searches";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-shared" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, mtl }:
     mkDerivation {
       pname = "binary-shared";
       version = "0.8.3";
       sha256 = "830116505018fc43de09867bea9039b0bfa29e77564efa8c3f3b708933c098b2";
       libraryHaskellDepends = [ base binary bytestring containers mtl ];
       homepage = "http://www.leksah.org";
       description = "Sharing for the binary package";
       license = "GPL";
     }) {};

  "binary-state" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, mtl }:
     mkDerivation {
       pname = "binary-state";
       version = "0.1.1";
       sha256 = "f44da50068bf57b2bea5dc7ef70aa4bb6fb14272bde724fc887c57417dc7631b";
       libraryHaskellDepends = [ base binary bytestring containers mtl ];
       description = "Simple wrapper around Data.Binary, which adds StateT to Get/Put monads.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "binary-store" = callPackage
    ({ mkDerivation, base, binary, binary-list, binary-transform
     , bytestring, bzlib, deepseq, QuickCheck, reinterpret-cast, tasty
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "binary-store";
       version = "0.1.0.1";
       sha256 = "349fed71d8f2d7f74aa1026def2ae4ab61bac17f67055f827fe51af9516050f2";
       libraryHaskellDepends = [
         base binary binary-list binary-transform bytestring bzlib deepseq
         reinterpret-cast
       ];
       testHaskellDepends = [
         base binary-list QuickCheck tasty tasty-quickcheck
       ];
       jailbreak = true;
       description = "Format to store data using the binary transform";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {binary-transform = null;};

  "binary-streams" = callPackage
    ({ mkDerivation, base, binary, bytestring, Cabal
     , cabal-test-quickcheck, io-streams, QuickCheck
     }:
     mkDerivation {
       pname = "binary-streams";
       version = "0.1.0.1";
       sha256 = "bb12c7ed35d87f293ac6ab84412214e267daa167ab4c5eb503da1d9af42c4ece";
       libraryHaskellDepends = [ base binary bytestring io-streams ];
       testHaskellDepends = [
         base binary bytestring Cabal cabal-test-quickcheck io-streams
         QuickCheck
       ];
       homepage = "http://github.com/jonpetterbergman/binary-streams";
       description = "data serialization/deserialization io-streams library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-strict" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, mtl }:
     mkDerivation {
       pname = "binary-strict";
       version = "0.4.8.3";
       sha256 = "8eb8fb5bd9fdae7bc39df27e3273bdf7e7903c88c517c5646616dd8f04a92cb1";
       libraryHaskellDepends = [ array base bytestring containers mtl ];
       homepage = "https://github.com/idontgetoutmuch/binary-low-level";
       description = "Binary deserialisation using strict ByteStrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-tagged_0_1_1_0" = callPackage
    ({ mkDerivation, aeson, array, base, bifunctors, binary
     , binary-orphans, bytestring, containers, generics-sop, hashable
     , quickcheck-instances, scientific, SHA, tagged, tasty
     , tasty-quickcheck, text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "binary-tagged";
       version = "0.1.1.0";
       sha256 = "90cc9ae7d2d7bd24f0e8bd919ab948c26a478e96fbb0572905b2518948febdc0";
       revision = "1";
       editedCabalFile = "fd550ffa78871db7e461ba3fba5b85ec3bafe4c75a60f4f70237df6812045926";
       libraryHaskellDepends = [
         aeson array base binary bytestring containers generics-sop hashable
         scientific SHA tagged text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson array base bifunctors binary binary-orphans bytestring
         containers generics-sop hashable quickcheck-instances scientific
         SHA tagged tasty tasty-quickcheck text time unordered-containers
         vector
       ];
       jailbreak = true;
       homepage = "https://github.com/phadej/binary-tagged#readme";
       description = "Tagged binary serialisation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-tagged_0_1_2_0" = callPackage
    ({ mkDerivation, aeson, array, base, bifunctors, binary
     , binary-orphans, bytestring, containers, generics-sop, hashable
     , quickcheck-instances, scientific, SHA, tagged, tasty
     , tasty-quickcheck, text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "binary-tagged";
       version = "0.1.2.0";
       sha256 = "0c1b4aded3fb3677cd85d2e3feb515b980260b3ecf98029193c8b48e6808e793";
       libraryHaskellDepends = [
         aeson array base binary bytestring containers generics-sop hashable
         scientific SHA tagged text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson array base bifunctors binary binary-orphans bytestring
         containers generics-sop hashable quickcheck-instances scientific
         SHA tagged tasty tasty-quickcheck text time unordered-containers
         vector
       ];
       jailbreak = true;
       homepage = "https://github.com/phadej/binary-tagged#readme";
       description = "Tagged binary serialisation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-tagged_0_1_3_0" = callPackage
    ({ mkDerivation, aeson, array, base, bifunctors, binary
     , binary-orphans, bytestring, containers, generics-sop, hashable
     , quickcheck-instances, scientific, SHA, tagged, tasty
     , tasty-quickcheck, text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "binary-tagged";
       version = "0.1.3.0";
       sha256 = "8fc82ca1d43043b73fcd4ec2179efcf219fa6f9b10b2283c5f8176c8762ba9c3";
       libraryHaskellDepends = [
         aeson array base binary bytestring containers generics-sop hashable
         scientific SHA tagged text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson array base bifunctors binary binary-orphans bytestring
         containers generics-sop hashable quickcheck-instances scientific
         SHA tagged tasty tasty-quickcheck text time unordered-containers
         vector
       ];
       homepage = "https://github.com/phadej/binary-tagged#readme";
       description = "Tagged binary serialisation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binary-tagged" = callPackage
    ({ mkDerivation, aeson, array, base, bifunctors, binary
     , binary-orphans, bytestring, containers, generics-sop, hashable
     , quickcheck-instances, scientific, SHA, tagged, tasty
     , tasty-quickcheck, text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "binary-tagged";
       version = "0.1.3.1";
       sha256 = "cdd99120148015a56d92ebc38380f9ea9254d6272e5d0952dae4e55eaf52252f";
       libraryHaskellDepends = [
         aeson array base binary bytestring containers generics-sop hashable
         scientific SHA tagged text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson array base bifunctors binary binary-orphans bytestring
         containers generics-sop hashable quickcheck-instances scientific
         SHA tagged tasty tasty-quickcheck text time unordered-containers
         vector
       ];
       homepage = "https://github.com/phadej/binary-tagged#readme";
       description = "Tagged binary serialisation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "binary-typed" = callPackage
    ({ mkDerivation, base, binary, bytestring, murmur-hash, tasty
     , tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "binary-typed";
       version = "1.0";
       sha256 = "85f3708802c52bca66bc5fdc560704cedd1cc63e313fcaab7638196ff7d05609";
       libraryHaskellDepends = [ base binary bytestring murmur-hash ];
       testHaskellDepends = [
         base binary bytestring tasty tasty-hunit tasty-quickcheck
       ];
       homepage = "https://github.com/quchen/binary-typed";
       description = "Type-safe binary serialization";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "binarydefer" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "binarydefer";
       version = "1.2.2";
       sha256 = "77bc6c3a9e96808da81a7b06a5d8a67375b9679cd80520eb0a438e1b6729021b";
       libraryHaskellDepends = [ base ];
       description = "Binary serialization with deferred loading";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bind-marshal" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, ghc-prim
     , monads-tf, mtl, numeric-prelude, random, stm, strict
     , transformers, type-level-tf, unix
     }:
     mkDerivation {
       pname = "bind-marshal";
       version = "0.1";
       sha256 = "26eb9954e33e39fcc4cd735731e3a7ab6baf90e3e2ed1eeb3e29f3df1857318f";
       libraryHaskellDepends = [
         base bytestring containers deepseq ghc-prim monads-tf mtl
         numeric-prelude random stm strict transformers type-level-tf unix
       ];
       jailbreak = true;
       homepage = "https://github.com/coreyoconnor/bind-marshal";
       description = "Data marshaling library that uses type level equations to optimize buffering";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binding-core" = callPackage
    ({ mkDerivation, base, HTF, HUnit, QuickCheck, random, stm }:
     mkDerivation {
       pname = "binding-core";
       version = "0.2.2";
       sha256 = "3fee58e46c8a77a03629869d148ed91b9e740a224d3c044567c2ebc952b62763";
       revision = "1";
       editedCabalFile = "1aeacdf0ebf89a2f515ab0ef767ed86f44b4b22f740ac23d1afd76df391955c6";
       libraryHaskellDepends = [ base stm ];
       testHaskellDepends = [ base HTF HUnit QuickCheck random ];
       homepage = "https://bitbucket.org/accursoft/binding";
       description = "Data Binding";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "binding-gtk" = callPackage
    ({ mkDerivation, base, binding-core, directory, gtk, mtl }:
     mkDerivation {
       pname = "binding-gtk";
       version = "0.2.1";
       sha256 = "799ff85197ac4038d6b14efba48a2960b1312dab898674d8c40ecec047b0c850";
       revision = "1";
       editedCabalFile = "9e435774bd5d6a7d9dd1e96dd9293d6a739f7ecde23838571d30866ac4628cb5";
       libraryHaskellDepends = [ base binding-core gtk mtl ];
       testHaskellDepends = [ base binding-core directory gtk ];
       homepage = "https://bitbucket.org/accursoft/binding";
       description = "Data Binding in Gtk2Hs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "binding-wx" = callPackage
    ({ mkDerivation, base, binding-core, directory, stm, wx, wxcore }:
     mkDerivation {
       pname = "binding-wx";
       version = "0.2.1";
       sha256 = "91e4d03ac5ee7ea6c66c5c0fce1c1c476cdb75257c4ed544afd057079459cb1e";
       revision = "1";
       editedCabalFile = "0307431866ac8b7f34ece32a684a3c70aa1b36ce74c05d815f249d1effe2efb2";
       libraryHaskellDepends = [ base binding-core stm wx wxcore ];
       testHaskellDepends = [ base binding-core directory wx ];
       homepage = "https://bitbucket.org/accursoft/binding";
       description = "Data Binding in WxHaskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "bindings" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "bindings";
       version = "0.1.2";
       sha256 = "201a9d879af1dfdcb9ae4d775c14424eff7018db63c831f66fdf59e97c709f7d";
       libraryHaskellDepends = [ base ];
       description = "Deprecated package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bindings-DSL_1_0_21" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "bindings-DSL";
       version = "1.0.21";
       sha256 = "69d62182115b55e2d640137d097c6e529e394391cc6c36b6319bf2e964a27939";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/jwiegley/bindings-dsl/wiki";
       description = "FFI domain specific language, on top of hsc2hs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bindings-DSL_1_0_22" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "bindings-DSL";
       version = "1.0.22";
       sha256 = "99cf4f0edffa11af4c9ec359babc8b34325c710b50d5e8035cdc5d3a470f7976";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/jwiegley/bindings-dsl/wiki";
       description = "FFI domain specific language, on top of hsc2hs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bindings-DSL" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "bindings-DSL";
       version = "1.0.23";
       sha256 = "eb6c76448eeb2a9a17135b08eec0dd09e1917a9f6ab702cea0b2070bd19c10e7";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/jwiegley/bindings-dsl/wiki";
       description = "FFI domain specific language, on top of hsc2hs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bindings-EsounD" = callPackage
    ({ mkDerivation, base, bindings-audiofile, bindings-DSL, esound }:
     mkDerivation {
       pname = "bindings-EsounD";
       version = "0.1.0.1";
       sha256 = "ce5d54c92d37e67a62bcfa90d54f4151ce09a27e17166bd790fc4c60607b873a";
       libraryHaskellDepends = [ base bindings-audiofile bindings-DSL ];
       libraryPkgconfigDepends = [ esound ];
       homepage = "http://cielonegro.org/Bindings-EsounD.html";
       description = "Low level bindings to EsounD (ESD; Enlightened Sound Daemon)";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {esound = null;};

  "bindings-GLFW" = callPackage
    ({ mkDerivation, base, bindings-DSL, HUnit, libX11, libXcursor
     , libXext, libXfixes, libXi, libXinerama, libXrandr, libXxf86vm
     , mesa, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "bindings-GLFW";
       version = "3.1.1.4";
       sha256 = "35bbb18f6e3821f88ac72f8d3b307da3e991d7d9ae9565b81a56fb994e72f3c1";
       libraryHaskellDepends = [ base bindings-DSL ];
       librarySystemDepends = [
         libX11 libXcursor libXext libXfixes libXi libXinerama libXrandr
         libXxf86vm mesa
       ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       doCheck = false;
       description = "Low-level bindings to GLFW OpenGL library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXcursor; 
         inherit (pkgs.xorg) libXext; inherit (pkgs.xorg) libXfixes; 
         inherit (pkgs.xorg) libXi; inherit (pkgs.xorg) libXinerama; 
         inherit (pkgs.xorg) libXrandr; inherit (pkgs.xorg) libXxf86vm; 
         inherit (pkgs) mesa;};

  "bindings-K8055" = callPackage
    ({ mkDerivation, base, K8055D }:
     mkDerivation {
       pname = "bindings-K8055";
       version = "0.1.2";
       sha256 = "40e40cc74f8afbbab8518b985e20e29044a720a09a3d5c048c2ff504f7504f35";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ K8055D ];
       homepage = "https://github.com/jputcu/bindings-K8055";
       description = "Bindings to Velleman K8055 dll";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {K8055D = null;};

  "bindings-apr" = callPackage
    ({ mkDerivation, apr-1, base, bindings-DSL }:
     mkDerivation {
       pname = "bindings-apr";
       version = "0.1";
       sha256 = "d324f6517ad3615aa7065e5f2a247f146655a7315ac70006ef0ded4bce0f873b";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ apr-1 ];
       jailbreak = true;
       homepage = "http://cielonegro.org/Bindings-APR.html";
       description = "Low level bindings to Apache Portable Runtime (APR)";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {apr-1 = null;};

  "bindings-apr-util" = callPackage
    ({ mkDerivation, apr-util-1, base, bindings-apr, bindings-DSL }:
     mkDerivation {
       pname = "bindings-apr-util";
       version = "0.1";
       sha256 = "9d93dae4cb05d24a2fe50778bdf972df23ca0be5e8f85a85bb744e757720206b";
       libraryHaskellDepends = [ base bindings-apr bindings-DSL ];
       libraryPkgconfigDepends = [ apr-util-1 ];
       jailbreak = true;
       homepage = "http://cielonegro.org/Bindings-APR.html";
       description = "Low level bindings to Apache Portable Runtime Utility (APR Utility)";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {apr-util-1 = null;};

  "bindings-audiofile" = callPackage
    ({ mkDerivation, audiofile, base, bindings-DSL }:
     mkDerivation {
       pname = "bindings-audiofile";
       version = "0.1.0.2";
       sha256 = "b21a7e8cb5ef8f6875b5880e1edb32415d8f5ad04374789e33688138868f4053";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ audiofile ];
       homepage = "http://cielonegro.org/Bindings-AudioFile.html";
       description = "Low level bindings to audiofile";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) audiofile;};

  "bindings-bfd" = callPackage
    ({ mkDerivation, alex, array, base, bfd, containers, happy, opcodes
     , unix
     }:
     mkDerivation {
       pname = "bindings-bfd";
       version = "1.2.0.0";
       sha256 = "04a3243a332831e9102936ac86a77ea6f7f6b4f88859efbc83e22b3047fe0530";
       libraryHaskellDepends = [ array base containers unix ];
       librarySystemDepends = [ bfd opcodes ];
       libraryToolDepends = [ alex happy ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/bindings-bfd/";
       description = "Bindings for libbfd, a library of the GNU `binutils'";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {bfd = null; opcodes = null;};

  "bindings-cctools" = callPackage
    ({ mkDerivation, bindings-DSL, dttools }:
     mkDerivation {
       pname = "bindings-cctools";
       version = "3.6.1.0.1.0.0.1";
       sha256 = "28e3bfedbe0a26170e1a59fe903f04d53a833018c2fb01056166369b400517cc";
       libraryHaskellDepends = [ bindings-DSL ];
       librarySystemDepends = [ dttools ];
       homepage = "http://bitbucket.org/badi/bindings-cctools";
       description = "Bindings to the CCTools WorkQueue C library";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {dttools = null;};

  "bindings-codec2" = callPackage
    ({ mkDerivation, base, binary, bindings-DSL, bytestring, codec2
     , split
     }:
     mkDerivation {
       pname = "bindings-codec2";
       version = "0.1.1.0";
       sha256 = "d6363eaa386fa3dd172d22826bd710db35a89e9640f46c9a822062275b3aeb56";
       revision = "1";
       editedCabalFile = "48e69a5b497247c96ab7a6ed3ff818bef596c712249819e63a84c4667ef5d0b1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bindings-DSL ];
       librarySystemDepends = [ codec2 ];
       executableHaskellDepends = [ base binary bytestring split ];
       homepage = "https://github.com/relrod/bindings-codec2";
       description = "Very low-level FFI bindings for Codec2";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {codec2 = null;};

  "bindings-common" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "bindings-common";
       version = "1.3.4";
       sha256 = "8b55c6b28a4d7df6854d8b94933f58ca246e917b96080fa0f1ea92dbcb4675fd";
       libraryHaskellDepends = [ base ];
       description = "This package is obsolete. Look for bindings-DSL instead.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bindings-dc1394" = callPackage
    ({ mkDerivation, base, bindings-DSL, c2hs, dc1394 }:
     mkDerivation {
       pname = "bindings-dc1394";
       version = "0.2.1";
       sha256 = "983b6814cfa968644b5ef5ad15758ed71683ff6e88ab0ee0598d6246ab12af1b";
       libraryHaskellDepends = [ base bindings-DSL ];
       librarySystemDepends = [ dc1394 ];
       libraryToolDepends = [ c2hs ];
       homepage = "http://github.com/aleator/bindings-dc1394";
       description = "Library for using firewire (iidc-1394) cameras";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {dc1394 = null;};

  "bindings-directfb" = callPackage
    ({ mkDerivation, base, bindings-DSL, bindings-posix, directfb }:
     mkDerivation {
       pname = "bindings-directfb";
       version = "0.1";
       sha256 = "f74277586542ec635a5a0013d6b81dcf62c6cada21570b52813dd9986050ab56";
       libraryHaskellDepends = [ base bindings-DSL bindings-posix ];
       libraryPkgconfigDepends = [ directfb ];
       description = "Low level bindings to DirectFB";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) directfb;};

  "bindings-eskit" = callPackage
    ({ mkDerivation, array, base, bindings-DSL, eskit }:
     mkDerivation {
       pname = "bindings-eskit";
       version = "0.0.1";
       sha256 = "e258e097a6283246517cff353b3e573652f19443d85fb5dedc0d073fc9890e48";
       libraryHaskellDepends = [ array base bindings-DSL ];
       librarySystemDepends = [ eskit ];
       libraryPkgconfigDepends = [ eskit ];
       jailbreak = true;
       homepage = "http://github.com/a1kmm/bindings-eskit";
       description = "Bindings to ESKit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {eskit = null;};

  "bindings-fann" = callPackage
    ({ mkDerivation, base, bindings-DSL, fann }:
     mkDerivation {
       pname = "bindings-fann";
       version = "0.0.2";
       sha256 = "07afc738076b0f4a5f8b5ad3acbf6ca82cbfe8d4268e5c1fcb5d2da592943ec3";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ fann ];
       description = "Low level bindings to FANN neural network library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {fann = null;};

  "bindings-fluidsynth" = callPackage
    ({ mkDerivation, base, bindings-DSL, fluidsynth }:
     mkDerivation {
       pname = "bindings-fluidsynth";
       version = "0.1.1";
       sha256 = "e5a5e12faddacbaff1303850db6bc7165ac41c4ba1c375dc3f4bfa4876ff0513";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ fluidsynth ];
       homepage = "http://github.com/bgamari/bindings-fluidsynth";
       description = "Haskell FFI bindings for fluidsynth software synthesizer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) fluidsynth;};

  "bindings-friso" = callPackage
    ({ mkDerivation, base, bindings-DSL, friso }:
     mkDerivation {
       pname = "bindings-friso";
       version = "0.1.0.0";
       sha256 = "2c1ddbe83cad25dc321f49672a6c634d0bc258917c4a17d178c2619c3110e171";
       libraryHaskellDepends = [ base bindings-DSL ];
       librarySystemDepends = [ friso ];
       description = "Low level bindings for friso";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {friso = null;};

  "bindings-glib" = callPackage
    ({ mkDerivation, base, bindings-DSL, glib }:
     mkDerivation {
       pname = "bindings-glib";
       version = "0.1.5";
       sha256 = "dd3f9c5630e7bb3d53ac9fbde0e7661bde23b6f4776ce7d2ff14dec5d777114a";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ glib ];
       description = "Low level bindings to GLib";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) glib;};

  "bindings-gobject" = callPackage
    ({ mkDerivation, base, bindings-DSL, bindings-glib, glib }:
     mkDerivation {
       pname = "bindings-gobject";
       version = "0.4";
       sha256 = "5b05bd465538bf9cb32a063942412f739faaaae3536879af771619900d784ce4";
       libraryHaskellDepends = [ base bindings-DSL bindings-glib ];
       libraryPkgconfigDepends = [ glib ];
       description = "Low level bindings supporting GObject and derived libraries";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) glib;};

  "bindings-gpgme" = callPackage
    ({ mkDerivation, base, bindings-DSL, gpgme }:
     mkDerivation {
       pname = "bindings-gpgme";
       version = "0.1.6";
       sha256 = "18e2389612197a80ea53c5a4fa9771c6e15efbabc9ab6195995714345d589457";
       libraryHaskellDepends = [ base bindings-DSL ];
       librarySystemDepends = [ gpgme ];
       homepage = "http://bitbucket.org/mauricio/bindings-gpgme";
       description = "Project bindings-* raw interface to gpgme";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) gpgme;};

  "bindings-gsl" = callPackage
    ({ mkDerivation, base, bindings-DSL, gsl }:
     mkDerivation {
       pname = "bindings-gsl";
       version = "0.2.1";
       sha256 = "7e58214f7adaf83786514e0e0d9a68c062514e77dc388d015e8bb42bb299607b";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ gsl ];
       description = "Low level bindings to GNU GSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gsl;};

  "bindings-gts" = callPackage
    ({ mkDerivation, base, bindings-DSL, bindings-glib, gts }:
     mkDerivation {
       pname = "bindings-gts";
       version = "0.1.1";
       sha256 = "709e6d7e847dd132e4d8084140a18b5c773964c2e4a7b61f6739767e789f38da";
       libraryHaskellDepends = [ base bindings-DSL bindings-glib ];
       libraryPkgconfigDepends = [ gts ];
       description = "Low level bindings supporting GTS, the GNU Triangulated Surface Library";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gts;};

  "bindings-hamlib" = callPackage
    ({ mkDerivation, base, bindings-DSL, hamlib }:
     mkDerivation {
       pname = "bindings-hamlib";
       version = "0.1.0.0";
       sha256 = "9f7671388fd67bfd86030f9ffc1f407eebebfa78b8fe3080b4b6615a74d949d9";
       revision = "1";
       editedCabalFile = "1eea9735be1dd9f54d91406fbf56da41b8d68a3760ada5e4fc4caf0658c997c9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bindings-DSL ];
       librarySystemDepends = [ hamlib ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/relrod/hamlib-haskell";
       description = "Hamlib bindings for Haskell";
       license = stdenv.lib.licenses.lgpl21;
     }) {inherit (pkgs) hamlib;};

  "bindings-hdf5" = callPackage
    ({ mkDerivation, base, bindings-DSL }:
     mkDerivation {
       pname = "bindings-hdf5";
       version = "0.1";
       sha256 = "e9580189785ec35a4f49d4b4743f6185ac6343888df868da2a8d5dcb790dd774";
       libraryHaskellDepends = [ base bindings-DSL ];
       description = "Project bindings-* raw interface to HDF5 library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bindings-levmar" = callPackage
    ({ mkDerivation, base, bindings-DSL, blas, liblapack }:
     mkDerivation {
       pname = "bindings-levmar";
       version = "1.1.0.3";
       sha256 = "809175b1ebd5675506755e53901104ea52cdc68e761c7ce01df54ace11b249b5";
       libraryHaskellDepends = [ base bindings-DSL ];
       librarySystemDepends = [ blas liblapack ];
       homepage = "https://github.com/basvandijk/bindings-levmar";
       description = "Low level bindings to the C levmar (Levenberg-Marquardt) library";
       license = "unknown";
     }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};

  "bindings-libcddb" = callPackage
    ({ mkDerivation, base, bindings-DSL, libcddb }:
     mkDerivation {
       pname = "bindings-libcddb";
       version = "0.3";
       sha256 = "de7bf3abe6a00bdef2843caedd6cc895751113cb47ef110ae32f1ec1496ecfc3";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ libcddb ];
       homepage = "http://bitbucket.org/mauricio/bindings-libcddb";
       description = "Low level binding to libcddb";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) libcddb;};

  "bindings-libffi" = callPackage
    ({ mkDerivation, base, bindings-DSL, libffi }:
     mkDerivation {
       pname = "bindings-libffi";
       version = "0.3";
       sha256 = "c9319828c5745872f748069af37743559078a4e228c7de257547692b5286418c";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ libffi ];
       description = "Low level bindings to libffi";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) libffi;};

  "bindings-libftdi" = callPackage
    ({ mkDerivation, base, bindings-DSL, libftdi, libusb }:
     mkDerivation {
       pname = "bindings-libftdi";
       version = "0.1";
       sha256 = "d11c4bc57a849a9a5a426b54a2530f8dda097772b9b59dd48c5347d9f65c6a1e";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ libftdi libusb ];
       description = "Low level bindings to libftdi";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libftdi; inherit (pkgs) libusb;};

  "bindings-librrd" = callPackage
    ({ mkDerivation, base, bindings-DSL, librrd }:
     mkDerivation {
       pname = "bindings-librrd";
       version = "0.2.0.1";
       sha256 = "1e59848307a649924813dbe238e35fcf257a2cd3d6d163d8392f249d0dc0d0b7";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ librrd ];
       homepage = "http://cielonegro.org/Bindings-librrd.html";
       description = "Low level bindings to RRDtool";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {librrd = null;};

  "bindings-libstemmer" = callPackage
    ({ mkDerivation, base, bindings-DSL, resourcet, stemmer
     , transformers
     }:
     mkDerivation {
       pname = "bindings-libstemmer";
       version = "0.1.0.0";
       sha256 = "226520baaad79625cf89b462d27ac642c63da2641c2b8bad4afb3ae06f56f40e";
       libraryHaskellDepends = [
         base bindings-DSL resourcet transformers
       ];
       librarySystemDepends = [ stemmer ];
       description = "Binding for libstemmer with low level binding";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {stemmer = null;};

  "bindings-libusb" = callPackage
    ({ mkDerivation, base, bindings-DSL, libusb }:
     mkDerivation {
       pname = "bindings-libusb";
       version = "1.4.5.0";
       sha256 = "c6a82f6fe365dda64682ba6f5079e20763d0b6e9c7d9f62256912fcccd4ddd76";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ libusb ];
       homepage = "https://github.com/basvandijk/bindings-libusb";
       description = "Low level bindings to libusb";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) libusb;};

  "bindings-libv4l2" = callPackage
    ({ mkDerivation, base, bindings-DSL, v4l2 }:
     mkDerivation {
       pname = "bindings-libv4l2";
       version = "0.1";
       sha256 = "4fbc8d81187c743450dda30d7b38b351aa77bd89041baccc6ad41af10a6c6168";
       libraryHaskellDepends = [ base bindings-DSL ];
       librarySystemDepends = [ v4l2 ];
       homepage = "https://gitorious.org/hsv4l2";
       description = "bindings to libv4l2 for Linux";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {v4l2 = null;};

  "bindings-libzip" = callPackage
    ({ mkDerivation, base, bindings-DSL, libzip }:
     mkDerivation {
       pname = "bindings-libzip";
       version = "0.10.2";
       sha256 = "e722c5da93f366bf81d390291098b43fd9bc0aa228f280bc7a0c9143a14c4897";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ libzip ];
       homepage = "http://bitbucket.org/astanin/hs-libzip/";
       description = "Low level bindings to libzip";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libzip;};

  "bindings-libzip_0_11" = callPackage
    ({ mkDerivation, base, bindings-DSL, libzip }:
     mkDerivation {
       pname = "bindings-libzip";
       version = "0.11";
       sha256 = "3243580c2f9c716e28b367b82f253a0ee16d401c332eee24eec76cb521b91343";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ libzip ];
       homepage = "http://bitbucket.org/astanin/hs-libzip/";
       description = "Low level bindings to libzip";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libzip;};

  "bindings-linux-videodev2" = callPackage
    ({ mkDerivation, base, bindings-DSL, ioctl }:
     mkDerivation {
       pname = "bindings-linux-videodev2";
       version = "0.1";
       sha256 = "b8250c711aa5c9f8034204f770b4d9ae5005ffc9125ad36ad0a10642f44411df";
       libraryHaskellDepends = [ base bindings-DSL ioctl ];
       homepage = "https://gitorious.org/hsv4l2";
       description = "bindings to Video For Linux Two (v4l2) kernel interfaces";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bindings-lxc" = callPackage
    ({ mkDerivation, base, bindings-DSL, lxc }:
     mkDerivation {
       pname = "bindings-lxc";
       version = "0.2.1";
       sha256 = "4fee45e55c7cb2ae75a83005213eb7aa2dae7ee97704db3e0cd4ae918ae13087";
       libraryHaskellDepends = [ base bindings-DSL ];
       librarySystemDepends = [ lxc ];
       homepage = "https://github.com/fizruk/bindings-lxc";
       description = "Direct Haskell bindings to LXC (Linux containers) C API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) lxc;};

  "bindings-mmap" = callPackage
    ({ mkDerivation, bindings-posix }:
     mkDerivation {
       pname = "bindings-mmap";
       version = "1.0";
       sha256 = "cd8e045221aabd352f1c6028f28f509becc8c3b6a02b4b6d4412b96a7e710da7";
       libraryHaskellDepends = [ bindings-posix ];
       description = "(deprecated) see bindings-posix instead";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bindings-mpdecimal" = callPackage
    ({ mkDerivation, base, bindings-DSL }:
     mkDerivation {
       pname = "bindings-mpdecimal";
       version = "0.8.0.0";
       sha256 = "458a10151e6a22a78ca8360573f3d842f4396ba5cd606fdd95cdb6ac774426a2";
       libraryHaskellDepends = [ base bindings-DSL ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/bindings-mpdecimal";
       description = "bindings to mpdecimal library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bindings-nettle" = callPackage
    ({ mkDerivation, base, bindings-DSL, bytestring, hspec, HUnit
     , nettle, QuickCheck, quickcheck-io
     }:
     mkDerivation {
       pname = "bindings-nettle";
       version = "0.4";
       sha256 = "f006e0348c2afe3f335c18255bc40d1ec85e5a531f2a6d5d15743fb3baf4d685";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ nettle ];
       testHaskellDepends = [
         base bytestring hspec HUnit QuickCheck quickcheck-io
       ];
       homepage = "http://floss.scru.org/bindings-nettle";
       description = "bindings to nettle crypto library";
       license = stdenv.lib.licenses.gpl3;
     }) {inherit (pkgs) nettle;};

  "bindings-parport" = callPackage
    ({ mkDerivation, base, bindings-DSL }:
     mkDerivation {
       pname = "bindings-parport";
       version = "0.0.4";
       sha256 = "723c4aafa7dd8375340b9c957fd238426e4812bd917980667c607f7c292380e0";
       libraryHaskellDepends = [ base bindings-DSL ];
       description = "parport bindings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bindings-portaudio" = callPackage
    ({ mkDerivation, base, bindings-DSL, portaudio }:
     mkDerivation {
       pname = "bindings-portaudio";
       version = "0.1";
       sha256 = "22aa0157723500351d014ef609b4a6167e9e9ae69ddcc33e71d3c908c0c09d71";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ portaudio ];
       description = "Low-level bindings to portaudio library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) portaudio;};

  "bindings-posix" = callPackage
    ({ mkDerivation, base, bindings-DSL }:
     mkDerivation {
       pname = "bindings-posix";
       version = "1.2.6";
       sha256 = "cefd0c942dab939ea0c944f56a430aef9fc1afeb66dd74de75af38e0161eeafb";
       libraryHaskellDepends = [ base bindings-DSL ];
       description = "Low level bindings to posix";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bindings-potrace" = callPackage
    ({ mkDerivation, base, bindings-DSL, potrace }:
     mkDerivation {
       pname = "bindings-potrace";
       version = "0.1";
       sha256 = "cdfe731190059b63501e6f9a9ee08f317fce820351ea3f3ca720d2445c42686d";
       libraryHaskellDepends = [ base bindings-DSL ];
       librarySystemDepends = [ potrace ];
       homepage = "https://github.com/rwbarton/bindings-potrace";
       description = "Low-level bindings to the potrace bitmap tracing library";
       license = stdenv.lib.licenses.gpl2;
     }) {inherit (pkgs) potrace;};

  "bindings-ppdev" = callPackage
    ({ mkDerivation, base, bindings-DSL, ioctl }:
     mkDerivation {
       pname = "bindings-ppdev";
       version = "0.0.3";
       sha256 = "f879b217f8418e13ee0dc8e592f7a8ce7ac45f5b5af1aba05bead20b9320fda2";
       libraryHaskellDepends = [ base bindings-DSL ioctl ];
       description = "PPDev bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "bindings-saga-cmd" = callPackage
    ({ mkDerivation, base, cmdargs, containers, directory, filepath
     , process, text, unix
     }:
     mkDerivation {
       pname = "bindings-saga-cmd";
       version = "0.1.1.1";
       sha256 = "be2e08afae8f81997bd11a1710e4c3ffb3372014b82a7cc182e0b9f0f5376586";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory filepath process unix
       ];
       executableHaskellDepends = [
         base cmdargs containers directory filepath process text unix
       ];
       homepage = "https://github.com/michelk/bindings-saga-cmd.hs";
       description = "Wrapping saga_cmd";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "bindings-sane" = callPackage
    ({ mkDerivation, base, bindings-DSL, saneBackends }:
     mkDerivation {
       pname = "bindings-sane";
       version = "0.0.1";
       sha256 = "a27eb00e69a804e65f39246611a747f3a833a87dab536c7f3cde60583a60b04b";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ saneBackends ];
       homepage = "http://floss.scru.org/bindings-sane";
       description = "FFI bindings to libsane";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {saneBackends = null;};

  "bindings-sc3" = callPackage
    ({ mkDerivation, base, bindings-DSL, scsynth }:
     mkDerivation {
       pname = "bindings-sc3";
       version = "0.4.1";
       sha256 = "adc7595676edbb7407f0a51405441635c16e6270085751821c7065293f34771f";
       libraryHaskellDepends = [ base bindings-DSL ];
       librarySystemDepends = [ scsynth ];
       homepage = "https://github.com/kaoskorobase/bindings-sc3/";
       description = "Low-level bindings to the SuperCollider synthesis engine library";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {scsynth = null;};

  "bindings-sipc" = callPackage
    ({ mkDerivation, base, sipc }:
     mkDerivation {
       pname = "bindings-sipc";
       version = "1.1";
       sha256 = "6de6370cf130d88599f1e7ff389da60089c952bdf2a8f4b699a4000e679b4ae4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ sipc ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/justinethier/hs-bindings-sipc";
       description = "Low level bindings to SIPC";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {sipc = null;};

  "bindings-sophia" = callPackage
    ({ mkDerivation, base, bindings-DSL }:
     mkDerivation {
       pname = "bindings-sophia";
       version = "0.2.0.2";
       sha256 = "26c60fe133928e674f2076cb0185d006aa150e5f106e2ae2bfa9eb6c4f5d313a";
       libraryHaskellDepends = [ base bindings-DSL ];
       description = "Low-level bindings to sophia library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bindings-sqlite3" = callPackage
    ({ mkDerivation, base, bindings-DSL, sqlite }:
     mkDerivation {
       pname = "bindings-sqlite3";
       version = "1.0.3";
       sha256 = "81f377b3bdd5f388c2885631c14a56c09502441dcb84dde0d10f94defa516038";
       libraryHaskellDepends = [ base bindings-DSL ];
       libraryPkgconfigDepends = [ sqlite ];
       description = "Low level bindings to sqlite3";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) sqlite;};

  "bindings-svm" = callPackage
    ({ mkDerivation, base, bindings-DSL }:
     mkDerivation {
       pname = "bindings-svm";
       version = "0.2.1";
       sha256 = "2b8459b795d39998f1dec01dfd7ede4690265c15bb5bcab4f0ae61246cf7d5da";
       libraryHaskellDepends = [ base bindings-DSL ];
       homepage = "http://github.com/tanimoto/bindings-svm";
       description = "Low level bindings to libsvm";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "bindings-uname" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "bindings-uname";
       version = "0.1";
       sha256 = "130e75c3fd95e232452c7d903efbfab2d2ff6c9d455b617adeaebe5d60235cd3";
       libraryHaskellDepends = [ base ];
       description = "Low-level binding to POSIX uname(3)";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "bindings-yices" = callPackage
    ({ mkDerivation, base, gmp, yices }:
     mkDerivation {
       pname = "bindings-yices";
       version = "0.3.0.2";
       sha256 = "247eb63716c11cdda9275e2e726153cf19dd1a4bbd457170a2384cc55d4d18b5";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ gmp yices ];
       description = "Bindings to the Yices theorem prover";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gmp; inherit (pkgs) yices;};

  "bindynamic" = callPackage
    ({ mkDerivation, base, binary, bytestring, rank1dynamic }:
     mkDerivation {
       pname = "bindynamic";
       version = "1.0.0.0";
       sha256 = "f1e9c392ea6a9be6a4d7200ed8060e5560ac6881c65c9423cc6e63d2bbe7246e";
       libraryHaskellDepends = [ base binary bytestring rank1dynamic ];
       homepage = "https://github.com/lspitzner/bindynamic";
       description = "A variation of Data.Dynamic.Dynamic with a Binary instance";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "binembed" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, directory
     , dlist, filepath
     }:
     mkDerivation {
       pname = "binembed";
       version = "0.1.0.3";
       sha256 = "7950ed58ae4892cab5fcd0527c1df5e0ca24d687673ce7f5da0d19e9b0d06c98";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring Cabal ];
       executableHaskellDepends = [
         base containers directory dlist filepath
       ];
       homepage = "http://code.mathr.co.uk/binembed";
       description = "Embed data into object files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "binembed-example" = callPackage
    ({ mkDerivation, base, binembed, bytestring, containers, filepath
     }:
     mkDerivation {
       pname = "binembed-example";
       version = "0.1.0.3";
       sha256 = "3e0ef2fa2f794c559351c38c891b5a90d92157018d2e8f241f53a0f1b6349c1a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binembed bytestring containers filepath
       ];
       homepage = "http://code.mathr.co.uk/binembed";
       description = "Example project using binembed to embed data in object files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "bini" = callPackage
    ({ mkDerivation, base, binary, bytestring, data-binary-ieee754 }:
     mkDerivation {
       pname = "bini";
       version = "0.1.5";
       sha256 = "b83bc415d2d08bfbaadccd8723ad4945d0cb4c519a414cc28a56572b9cd08cb4";
       libraryHaskellDepends = [
         base binary bytestring data-binary-ieee754
       ];
       description = "A collection of various methods for reading and writing bini files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bio" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, mtl, old-time, parallel, parsec, process, QuickCheck
     , random, tagsoup
     }:
     mkDerivation {
       pname = "bio";
       version = "0.5.3";
       sha256 = "42c8f9b83fea6bf51356afe1251910ba4421e0af0bb4f26431eaf385971d7eed";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers directory mtl parallel
         parsec QuickCheck tagsoup
       ];
       executableHaskellDepends = [
         base bytestring containers old-time process QuickCheck random
       ];
       jailbreak = true;
       homepage = "http://biohaskell.org/Libraries/Bio";
       description = "A bioinformatics library";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bioace" = callPackage
    ({ mkDerivation, base, bioalign, biocore, bytestring, parsec }:
     mkDerivation {
       pname = "bioace";
       version = "0.0.1";
       sha256 = "6f43645b2a0ccbca20069aa25fae6fc2ae1704a3a0c48b069852fbfb8ce16222";
       libraryHaskellDepends = [
         base bioalign biocore bytestring parsec
       ];
       homepage = "https://patch-tag.com/r/dfornika/bioace/home";
       description = "Library for reading ace assembly files";
       license = "GPL";
     }) {};

  "bioalign" = callPackage
    ({ mkDerivation, base, biocore, bytestring }:
     mkDerivation {
       pname = "bioalign";
       version = "0.0.5";
       sha256 = "b9152e81abbd7c79099520b69aeca3ff21970f1151b3c072a2994ea31b7acf00";
       libraryHaskellDepends = [ base biocore bytestring ];
       homepage = "https://patch-tag.com/r/dfornika/biophd/home";
       description = "Data structures and helper functions for calculating alignments";
       license = "GPL";
     }) {};

  "biocore" = callPackage
    ({ mkDerivation, base, bytestring, stringable }:
     mkDerivation {
       pname = "biocore";
       version = "0.3.1";
       sha256 = "212b7d7395138d4c231968e1f5bb047c03f61adc6c5eb36162602f42c24db41a";
       libraryHaskellDepends = [ base bytestring stringable ];
       description = "A bioinformatics library";
       license = "LGPL";
     }) {};

  "biofasta" = callPackage
    ({ mkDerivation, base, biocore, bytestring }:
     mkDerivation {
       pname = "biofasta";
       version = "0.0.3";
       sha256 = "6221a89cde259e8f9a2d4da11230a8a53d78b24d3367e70be5e7b1279e06e7d0";
       libraryHaskellDepends = [ base biocore bytestring ];
       homepage = "https://patch-tag.com/r/dfornika/biofasta/home";
       description = "Library for reading fasta sequence files";
       license = "GPL";
     }) {};

  "biofastq" = callPackage
    ({ mkDerivation, base, biocore, bytestring }:
     mkDerivation {
       pname = "biofastq";
       version = "0.1";
       sha256 = "74e51887569c4900f5de266eca0dd28082c8abdf6ef0f34787a91baec562a310";
       libraryHaskellDepends = [ base biocore bytestring ];
       homepage = "http://biohaskell.org/";
       description = "A library for reading FASTQ files";
       license = "LGPL";
     }) {};

  "biohazard" = callPackage
    ({ mkDerivation, aeson, array, async, attoparsec, base, binary
     , bytestring, bytestring-mmap, containers, deepseq, directory
     , exceptions, filepath, hashable, iteratee, ListLike
     , nonlinear-optimization, primitive, random, scientific, stm
     , template-haskell, text, transformers, unix, unordered-containers
     , Vec, vector, vector-algorithms, vector-th-unbox, zlib
     }:
     mkDerivation {
       pname = "biohazard";
       version = "0.6.3";
       sha256 = "063e812cb4c5c9c518363525cec4f309f9ebdf4c8af12e8bf88ca9f39edb47e5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array async attoparsec base binary bytestring bytestring-mmap
         containers directory exceptions filepath iteratee ListLike
         primitive random scientific stm template-haskell text transformers
         unix unordered-containers Vec vector vector-algorithms
         vector-th-unbox zlib
       ];
       executableHaskellDepends = [
         aeson async base binary bytestring containers deepseq directory
         exceptions hashable iteratee nonlinear-optimization random text
         transformers unordered-containers vector vector-algorithms
         vector-th-unbox
       ];
       jailbreak = true;
       homepage = "http://github.com/udo-stenzel/biohazard";
       description = "bioinformatics support library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bioinformatics-toolkit" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bbi, binary, bytestring
     , bytestring-lexing, clustering, colour, conduit, containers
     , data-default-class, double-conversion, hexpat, http-conduit
     , IntervalMap, matrices, mtl, palette, parallel, primitive, random
     , samtools, shelly, split, statistics, tasty, tasty-golden
     , tasty-hunit, text, transformers, unordered-containers, vector
     , vector-algorithms, word8
     }:
     mkDerivation {
       pname = "bioinformatics-toolkit";
       version = "0.1.0";
       sha256 = "0ce36b2dc686a77804158d70658cc0600056ae62e7d465663b75e784b52950a9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty base bbi binary bytestring bytestring-lexing
         clustering colour conduit containers data-default-class
         double-conversion hexpat http-conduit IntervalMap matrices mtl
         palette parallel primitive samtools split statistics text
         transformers unordered-containers vector vector-algorithms word8
       ];
       executableHaskellDepends = [ base bytestring shelly text ];
       testHaskellDepends = [
         base bytestring conduit data-default-class mtl random tasty
         tasty-golden tasty-hunit unordered-containers vector
       ];
       description = "A collection of bioinformatics tools";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "biophd" = callPackage
    ({ mkDerivation, base, binary, biocore, bytestring, parsec, text }:
     mkDerivation {
       pname = "biophd";
       version = "0.0.4";
       sha256 = "a31005a449218e3f383ede0a177c48ef8c7ec21ae7bc5d122bd6eb6a9e1bfb82";
       libraryHaskellDepends = [
         base binary biocore bytestring parsec text
       ];
       homepage = "https://patch-tag.com/r/dfornika/biophd/home";
       description = "Library for reading phd sequence files";
       license = "GPL";
     }) {};

  "biophd_0_0_5" = callPackage
    ({ mkDerivation, base, binary, biocore, bytestring, parsec, text }:
     mkDerivation {
       pname = "biophd";
       version = "0.0.5";
       sha256 = "c76ba5038c7778f4879b1872d53cb554c370496ca1a96ea8a1b0d50739cc7a95";
       libraryHaskellDepends = [
         base binary biocore bytestring parsec text
       ];
       homepage = "https://patch-tag.com/r/dfornika/biophd/home";
       description = "Library for reading phd sequence files";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "biophd_0_0_7" = callPackage
    ({ mkDerivation, base, binary, biocore, bytestring, old-locale
     , parsec, text, time
     }:
     mkDerivation {
       pname = "biophd";
       version = "0.0.7";
       sha256 = "bc8e0e30b7a071bb02c4632d98888a849977e7de07bd51eb443e0b6fdb0c04d9";
       libraryHaskellDepends = [
         base binary biocore bytestring old-locale parsec text time
       ];
       homepage = "https://github.com/dfornika/biophd/wiki";
       description = "Library for reading phd sequence files";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "biophd_0_0_8" = callPackage
    ({ mkDerivation, base, binary, biocore, bytestring, parsec, text
     , time, time-locale-compat
     }:
     mkDerivation {
       pname = "biophd";
       version = "0.0.8";
       sha256 = "7475e8126b9801c76ddb0d8eb93c0bb8e4a3edd3ec02631e4ee2ff1ecc767d5c";
       libraryHaskellDepends = [
         base binary biocore bytestring parsec text time time-locale-compat
       ];
       homepage = "https://github.com/dfornika/biophd/wiki";
       description = "Library for reading phd sequence files";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "biopsl" = callPackage
    ({ mkDerivation, base, biocore, bytestring, cmdargs
     , unordered-containers
     }:
     mkDerivation {
       pname = "biopsl";
       version = "0.4";
       sha256 = "b2be254020a276df342ede835a1c1b1b989763098d7d8a5536c0b86c5f7a3bed";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base biocore bytestring ];
       executableHaskellDepends = [ cmdargs unordered-containers ];
       homepage = "http://biohaskell.org/";
       description = "Library and executables for working with PSL files";
       license = "LGPL";
     }) {};

  "biosff" = callPackage
    ({ mkDerivation, array, base, binary, biocore, bytestring, cmdargs
     , mtl
     }:
     mkDerivation {
       pname = "biosff";
       version = "0.3.7.1";
       sha256 = "982f238e056c3d65bae94c505da61e91239b624a8446ecee3b03eae258c7bad7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base binary biocore bytestring ];
       executableHaskellDepends = [ array base cmdargs mtl ];
       homepage = "http://biohaskell.org/";
       description = "Library and executables for working with SFF files";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "biostockholm" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-conduit, base, biocore
     , blaze-builder, blaze-builder-conduit, bytestring, conduit
     , containers, deepseq, hspec, HUnit, QuickCheck, transformers
     , zlib-conduit
     }:
     mkDerivation {
       pname = "biostockholm";
       version = "0.3.4";
       sha256 = "e753e20bc28169ec5c9f56fe977853e21be4ab150f8b0bccae226ae910656712";
       libraryHaskellDepends = [
         attoparsec attoparsec-conduit base biocore blaze-builder
         blaze-builder-conduit bytestring conduit containers deepseq
       ];
       testHaskellDepends = [
         base biocore bytestring conduit containers hspec HUnit QuickCheck
         transformers zlib-conduit
       ];
       jailbreak = true;
       description = "Parsing and rendering of Stockholm files (used by Pfam, Rfam and Infernal)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bird" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default, hack
     , hack-handler-happstack, haskell98, MissingH, mtl, parsec, process
     , rallod
     }:
     mkDerivation {
       pname = "bird";
       version = "0.0.19";
       sha256 = "1fbbb73a2b6d926b04958af5ca47e2d7b4152ded065a223a2bf7a17959036870";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers data-default hack hack-handler-happstack
         haskell98 MissingH mtl parsec process rallod
       ];
       homepage = "http://github.com/moonmaster9000/bird";
       description = "A simple, sinatra-inspired web framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bit-array" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, numeric-qq }:
     mkDerivation {
       pname = "bit-array";
       version = "0.1.1";
       sha256 = "0c3ce1c19f6830a083b39590a8e9015b1fb430f4fb97dc5349c21c03eec72c14";
       libraryHaskellDepends = [ base numeric-qq ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "https://github.com/nikita-volkov/bit-array";
       description = "A bit array (aka bitset, bitmap, bit vector) API for numeric types";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bit-vector" = callPackage
    ({ mkDerivation, base, QuickCheck, tasty, tasty-quickcheck
     , tasty-th, vector
     }:
     mkDerivation {
       pname = "bit-vector";
       version = "0.2.0";
       sha256 = "e11768da70972a7697dcfd3323f38656b9f19f83e720d706fd58c83555a870c0";
       libraryHaskellDepends = [ base vector ];
       testHaskellDepends = [
         base QuickCheck tasty tasty-quickcheck tasty-th vector
       ];
       homepage = "https://github.com/acfoltzer/bit-vector";
       description = "Simple bit vectors for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "bitarray" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "bitarray";
       version = "0.0.1.1";
       sha256 = "b27f6f1065053a0e8e24fbf9382b7060af9962d8d150b631c682c0c58469d802";
       libraryHaskellDepends = [ array base ];
       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
     , hspec, http-client, lens, lens-aeson, text, unordered-containers
     , wreq
     }:
     mkDerivation {
       pname = "bitcoin-api";
       version = "0.12.1";
       sha256 = "c978de1519b24c5c04ff518ad1209f74f91df31d65e23592dc639219df6b3e30";
       libraryHaskellDepends = [
         aeson base base58string binary bitcoin-block bitcoin-script
         bitcoin-tx bitcoin-types bytestring hexstring lens lens-aeson text
         unordered-containers wreq
       ];
       testHaskellDepends = [
         base base58string bitcoin-script bitcoin-tx bytestring hspec
         http-client lens text wreq
       ];
       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, hspec, http-client, lens, stm
     , stm-chans, stm-conduit, text, transformers, wreq
     }:
     mkDerivation {
       pname = "bitcoin-api-extra";
       version = "0.9.1";
       sha256 = "c423c6007d0f830dd2bbc0e1bc9219980e6fb2bde684890e265e1bfce4bdd7fc";
       libraryHaskellDepends = [
         base binary bitcoin-api bitcoin-block bitcoin-tx bytestring conduit
         lens stm stm-chans stm-conduit text transformers
       ];
       testHaskellDepends = [
         base bitcoin-api bitcoin-tx bytestring conduit hspec http-client
         lens text wreq
       ];
       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, hspec, largeword, lens
     }:
     mkDerivation {
       pname = "bitcoin-block";
       version = "0.13.1";
       sha256 = "d7f57c0fe71045dab85d223dc15d64db3a15cc7fd8446bfe4ebd98cd9d417d5a";
       libraryHaskellDepends = [
         base binary bitcoin-tx bitcoin-types bytestring cryptohash
         hexstring largeword lens
       ];
       testHaskellDepends = [
         base bitcoin-tx bitcoin-types bytestring hexstring hspec
       ];
       homepage = "http://www.leonmergen.com/opensource.html";
       description = "Utility functions for manipulating bitcoin blocks";
       license = stdenv.lib.licenses.mit;
     }) {};

  "bitcoin-rpc" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal
     , containers, ghc-prim, HTTP, HUnit, mtl, network, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, unix, unordered-containers, watchdog
     }:
     mkDerivation {
       pname = "bitcoin-rpc";
       version = "0.5.0.1";
       sha256 = "e2c2d59b0ea84d1b56059c3af38fc6767c6c48b39b9da6a358d2033e0620a52f";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring cereal containers ghc-prim HTTP
         mtl network text unix unordered-containers watchdog
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring cereal containers ghc-prim HTTP
         HUnit mtl network QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 text unix unordered-containers watchdog
       ];
       jailbreak = true;
       description = "Library to communicate with the Satoshi Bitcoin daemon";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bitcoin-script" = callPackage
    ({ mkDerivation, base, base16-bytestring, binary, bytestring, hspec
     , text
     }:
     mkDerivation {
       pname = "bitcoin-script";
       version = "0.11.1";
       sha256 = "398c1d86e918731b5b2026351bb3b0b90b20606517e7c21e42f05d6c6e197b4c";
       libraryHaskellDepends = [
         base base16-bytestring binary bytestring text
       ];
       testHaskellDepends = [ base bytestring hspec ];
       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, hspec, lens
     }:
     mkDerivation {
       pname = "bitcoin-tx";
       version = "0.13.1";
       sha256 = "3bb88265353066c394e96a56b2dc555fa13d37ca7f820978b793196c6829cc00";
       libraryHaskellDepends = [
         base binary bitcoin-script bitcoin-types bytestring cryptohash
         hexstring lens
       ];
       testHaskellDepends = [
         base bitcoin-script bytestring hexstring hspec
       ];
       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
     , hspec, text
     }:
     mkDerivation {
       pname = "bitcoin-types";
       version = "0.9.2";
       sha256 = "b72f9448508b64706d5f443748dc9b8abde8e749959187ce3d8356cde0d6c40b";
       libraryHaskellDepends = [
         base base58string binary bytestring hexstring text
       ];
       testHaskellDepends = [
         base base58string bytestring hexstring hspec
       ];
       homepage = "http://www.leonmergen.com/opensource.html";
       description = "Provides consistent low-level types used commonly among Bitcoin implementations";
       license = stdenv.lib.licenses.mit;
     }) {};

  "bitly-cli" = callPackage
    ({ mkDerivation, base, Bitly, directory, filepath, regexpr }:
     mkDerivation {
       pname = "bitly-cli";
       version = "0.1.2";
       sha256 = "2d08261ae905fa57d8010600c9db39886868a662333dd6895d94a554c6a3c33c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Bitly directory filepath regexpr
       ];
       jailbreak = true;
       homepage = "http://bitbucket.org/jetxee/hs-bitly/";
       description = "A command line tool to access bit.ly URL shortener.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bitmap" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "bitmap";
       version = "0.0.2";
       sha256 = "b578f508a416cb41523bfad5b977059c04862e583cd0edf1a18a51abf37299ba";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "A library for handling and manipulating bitmaps (rectangular pixel arrays)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bitmap-opengl" = callPackage
    ({ mkDerivation, base, bitmap, OpenGL }:
     mkDerivation {
       pname = "bitmap-opengl";
       version = "0.0.1.5";
       sha256 = "fba6d684213fbf56f8ca1109ec4087433dfe9f1a780ae8ef03e5b8b837b801f3";
       libraryHaskellDepends = [ base bitmap OpenGL ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "OpenGL support for Data.Bitmap.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "bitmaps" = callPackage
    ({ mkDerivation, array, base, binary, bitmap, bytestring, cereal
     , containers, monad-state, stb-image, string-class, tagged, zlib
     }:
     mkDerivation {
       pname = "bitmaps";
       version = "0.2.6.3";
       sha256 = "e086fceb434566e770aeff2a142a4b774a451c6ab343798de58eb6bafd5a6eb1";
       libraryHaskellDepends = [
         array base binary bitmap bytestring cereal containers monad-state
         stb-image string-class tagged zlib
       ];
       homepage = "https://github.com/bairyn/bitmaps";
       description = "Bitmap library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bits" = callPackage
    ({ mkDerivation, base, bytes, directory, doctest, filepath, mtl
     , transformers
     }:
     mkDerivation {
       pname = "bits";
       version = "0.4";
       sha256 = "e626310d69e0808586a9c7cc965a0c2eb3413d643271e523fef8037fc8f4458b";
       libraryHaskellDepends = [ base bytes mtl transformers ];
       testHaskellDepends = [ base directory doctest filepath ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://github.com/analytics/bits";
       description = "Various bit twiddling and bitwise serialization primitives";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bits-atomic" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "bits-atomic";
       version = "0.1.3";
       sha256 = "e0ac3456cf0338e1d5ed33f4c3c6b932d652add2ac827c6a1b6636c6e754cb8d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       description = "Atomic bit operations on memory locations for low-level synchronization";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bits-conduit" = callPackage
    ({ mkDerivation, base, bytestring, conduit, hspec, HUnit, mtl }:
     mkDerivation {
       pname = "bits-conduit";
       version = "0.2.0.0";
       sha256 = "32b7f730be27810519f1ea32bdb82e25c187373dd407cdf0cbb629be6fa00f22";
       libraryHaskellDepends = [ base bytestring conduit mtl ];
       testHaskellDepends = [ base bytestring conduit hspec HUnit mtl ];
       jailbreak = true;
       description = "Bitstream support for Conduit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bits-extras" = callPackage
    ({ mkDerivation, base, gcc_s }:
     mkDerivation {
       pname = "bits-extras";
       version = "0.1.3";
       sha256 = "27a5dcf562e5f4c011421263859e09f65d4c382cd123abd73807f456f56cc96b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ gcc_s ];
       description = "Efficient high-level bit operations not found in Data.Bits";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {gcc_s = null;};

  "bitset" = callPackage
    ({ mkDerivation, base, deepseq, ghc-prim, gmp, integer-gmp
     , QuickCheck, tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "bitset";
       version = "1.4.8";
       sha256 = "08256dbb169a4ae122fcc8d73175bbd00f5a8c049756c240d7689bc547142141";
       libraryHaskellDepends = [ base deepseq ghc-prim integer-gmp ];
       librarySystemDepends = [ gmp ];
       testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
       jailbreak = true;
       description = "A space-efficient set data structure";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gmp;};

  "bitspeak" = callPackage
    ({ mkDerivation, base, bindings-DSL, bindings-glib
     , bindings-gobject, gdk2, gtk2, pango
     }:
     mkDerivation {
       pname = "bitspeak";
       version = "0.0.3";
       sha256 = "337ca42275c69e49cebc1240b4fe1c5feda0b2955081c0f4ce74994b5389be09";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bindings-DSL bindings-glib bindings-gobject
       ];
       executablePkgconfigDepends = [ gdk2 gtk2 pango ];
       jailbreak = true;
       description = "Proof-of-concept tool for writing using binary choices";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gdk2 = null; gtk2 = pkgs.gnome2.gtk; 
         inherit (pkgs.gnome) pango;};

  "bitstream" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, bytestring, QuickCheck
     , vector
     }:
     mkDerivation {
       pname = "bitstream";
       version = "0.2.0.4";
       sha256 = "5e0b7c80707ea244ff68e3f04073cb13764b3355fefc670e81e0fab4a5c900c8";
       libraryHaskellDepends = [
         base base-unicode-symbols bytestring vector
       ];
       testHaskellDepends = [
         base base-unicode-symbols bytestring QuickCheck vector
       ];
       jailbreak = true;
       homepage = "https://github.com/phonohawk/bitstream";
       description = "Fast, packed, strict and lazy bit streams with stream fusion";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bitstring" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "bitstring";
       version = "0.0.0";
       sha256 = "886bab3b4eb262d1c26fc28c0f1a23616ae458325da930110905737336e9a2c7";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "Lazy bit strings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bittorrent" = callPackage
    ({ mkDerivation, aeson, base, base16-bytestring, base32-bytestring
     , base64-bytestring, bencoding, binary, binary-conduit, bits-extras
     , BoundedChan, bytestring, cereal, cereal-conduit, conduit
     , containers, cryptohash, data-default, deepseq, directory, entropy
     , filepath, hashable, hspec, HTTP, IntervalMap, intset, krpc, lens
     , mmap, mtl, network, network-conduit, old-locale, pretty
     , pretty-class, QuickCheck, quickcheck-instances, resourcet
     , SafeSemaphore, split, stm, text, time, transformers
     , unordered-containers, urlencoded, vector
     }:
     mkDerivation {
       pname = "bittorrent";
       version = "0.0.0.3";
       sha256 = "d62af0bd19edefeea7cc55760c9d344646dc88eeae9bcaf656b48e61315eab94";
       libraryHaskellDepends = [
         aeson base base16-bytestring base32-bytestring base64-bytestring
         bencoding binary binary-conduit bits-extras BoundedChan bytestring
         cereal cereal-conduit conduit containers cryptohash data-default
         deepseq directory entropy filepath hashable HTTP IntervalMap intset
         krpc lens mmap mtl network network-conduit old-locale pretty
         pretty-class resourcet SafeSemaphore split stm text time
         transformers unordered-containers urlencoded vector
       ];
       testHaskellDepends = [
         aeson base bencoding bytestring cereal directory filepath hspec
         network QuickCheck quickcheck-instances text time
       ];
       jailbreak = true;
       homepage = "https://github.com/cobit/bittorrent";
       description = "Bittorrent protocol implementation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bitvec" = callPackage
    ({ mkDerivation, base, HUnit, primitive, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "bitvec";
       version = "0.1.0.1";
       sha256 = "048343cd7a5a77261b67722c3b0d4ca7da159712e0642a72968fbd7eb138ef7d";
       libraryHaskellDepends = [ base primitive vector ];
       testHaskellDepends = [
         base HUnit primitive QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 vector
       ];
       homepage = "https://github.com/mokus0/bitvec";
       description = "Unboxed vectors of bits / dense IntSets";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bitwise" = callPackage
    ({ mkDerivation, array, base, bytestring, QuickCheck }:
     mkDerivation {
       pname = "bitwise";
       version = "0.1.0.2";
       sha256 = "ae41a4f36c6d52edbfd17ad186abbf9536f46bbbda4bb2341fd6fb965d02afa4";
       libraryHaskellDepends = [ array base bytestring ];
       testHaskellDepends = [ base QuickCheck ];
       homepage = "http://code.mathr.co.uk/bitwise";
       description = "fast multi-dimensional unboxed bit packed Bool arrays";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bitx-bitcoin" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, doctest, hspec
     , http-client, http-client-tls, http-types, microlens, microlens-th
     , network, safe, scientific, split, text, time
     }:
     mkDerivation {
       pname = "bitx-bitcoin";
       version = "0.6.0.0";
       sha256 = "f08ac6744d6a1e74060de589603e0ee1355711a54c67501473526735ac6fb834";
       libraryHaskellDepends = [
         aeson base bytestring http-client http-client-tls http-types
         microlens microlens-th network scientific split text time
       ];
       testHaskellDepends = [
         aeson base bytestring directory doctest hspec http-client
         http-types microlens safe text time
       ];
       homepage = "https://github.com/tebello-thejane/bitx-haskell";
       description = "A Haskell library for working with the BitX bitcoin exchange";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bk-tree" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "bk-tree";
       version = "0.1.1";
       sha256 = "e4aba27740ee95ca2b45c9a9713599288221117c6a4123e08b39e52de07c642b";
       libraryHaskellDepends = [ base containers ];
       homepage = "https://github.com/bitonic/language-spelling";
       description = "BK-tree implementation";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "bkr" = callPackage
    ({ mkDerivation, aws, base, bytestring, directory, filepath, HDBC
     , HDBC-sqlite3, hslogger, http-conduit, MissingH, pureMD5, random
     , strict, text, unix, utf8-string
     }:
     mkDerivation {
       pname = "bkr";
       version = "0.1.2";
       sha256 = "ba5f1f1f2dfdfe9511234a9cf209ec5b1c323bf0e7394cb91f171be36d1224fe";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aws base bytestring directory filepath HDBC HDBC-sqlite3 hslogger
         http-conduit MissingH pureMD5 random strict text unix utf8-string
       ];
       executableHaskellDepends = [
         aws base bytestring directory filepath HDBC HDBC-sqlite3 hslogger
         http-conduit MissingH pureMD5 random strict text unix utf8-string
       ];
       jailbreak = true;
       homepage = "https://github.com/ingesson/bkr";
       description = "Backup utility for backing up to cloud storage services (S3 only right now)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bktrees" = callPackage
    ({ mkDerivation, array, base, containers }:
     mkDerivation {
       pname = "bktrees";
       version = "0.3.1";
       sha256 = "c9c247363b2ac469f4beabe6202a5165d7e0fb0521a89e2204d62b6011f951b4";
       libraryHaskellDepends = [ array base containers ];
       description = "A set data structure with approximate searching";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bla" = callPackage
    ({ mkDerivation, base, haskell98, unix }:
     mkDerivation {
       pname = "bla";
       version = "2009.10.20";
       sha256 = "1776b32ec39a040052363546288404dc663b38ad52f2affeae721c43aa3960fd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskell98 unix ];
       homepage = "http://github.com/nfjinjing/bla";
       description = "a stupid cron";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "black-jewel" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, directory
     , download, haskeline, HTTP, hxt, network, process, QuickCheck
     , safe, tagsoup, transformers, zlib
     }:
     mkDerivation {
       pname = "black-jewel";
       version = "0.0.0.1";
       sha256 = "8a7a714ed99e2b923cb0a7c483d1b8c28da452ff69c32ccf6d40ebc26a9b26ce";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base bytestring directory download haskeline HTTP hxt
         network process safe tagsoup transformers zlib
       ];
       testHaskellDepends = [ base QuickCheck ];
       homepage = "http://git.kaction.name/black-jewel";
       description = "The pirate bay client";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blacktip" = callPackage
    ({ mkDerivation, base, bitwise, bytestring, deepseq
     , deepseq-generics, hspec, locators, network-info, safe, split
     , system-fileio, system-filepath, time
     }:
     mkDerivation {
       pname = "blacktip";
       version = "0.1.0.1";
       sha256 = "c2586ed12cbb75556411fe6e00d6a66fa548c02e5140c833a4dd6044062d408b";
       libraryHaskellDepends = [
         base bitwise bytestring deepseq deepseq-generics locators
         network-info safe split system-fileio system-filepath time
       ];
       testHaskellDepends = [ base hspec ];
       homepage = "https://github.com/bitemyapp/blacktip";
       description = "Decentralized, k-ordered unique ID generator";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "blake2" = callPackage
    ({ mkDerivation, base, base16-bytestring, bytestring, hlint
     , QuickCheck, tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "blake2";
       version = "0.1.0";
       sha256 = "d4cdb38b973125fdd80a12f335ec536dc5c5d1dfd5611c9ebe46c3bf78841ce5";
       libraryHaskellDepends = [ base bytestring ];
       testHaskellDepends = [
         base base16-bytestring bytestring hlint QuickCheck tasty
         tasty-quickcheck
       ];
       homepage = "https://github.com/centromere/blake2";
       description = "A library providing BLAKE2";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "blakesum" = callPackage
    ({ mkDerivation, base, bytestring, text, vector }:
     mkDerivation {
       pname = "blakesum";
       version = "0.5";
       sha256 = "0fa8de7d3748d23b1a5fd0e52856458d1eb962b170deeb5f5281332c93db6396";
       libraryHaskellDepends = [ base bytestring text vector ];
       jailbreak = true;
       homepage = "https://github.com/killerswan/Haskell-BLAKE";
       description = "The BLAKE SHA-3 candidate hashes, in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blakesum-demo" = callPackage
    ({ mkDerivation, base, blakesum, bytestring, haskell98, text
     , vector
     }:
     mkDerivation {
       pname = "blakesum-demo";
       version = "0.5";
       sha256 = "a9925be27059bd9cb54b86f3337410d173c5c77b29fab9c9b9e098e60a0007b4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blakesum bytestring haskell98 text vector
       ];
       jailbreak = true;
       homepage = "https://github.com/killerswan/Haskell-BLAKE";
       description = "The BLAKE SHA-3 candidate hashes, in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blank-canvas_0_5" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring, colour
     , containers, data-default-class, http-types, kansas-comet, scotty
     , stm, text, transformers, vector, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "blank-canvas";
       version = "0.5";
       sha256 = "faadd24d34f2b73165199d5a03d8fade1db8d1a2110580b7fe9ed99daef46e16";
       revision = "1";
       editedCabalFile = "a9d9c32056144a2e5b84e96dfb3a5334aa89dc616c759e523c538a6b950d5084";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring colour containers
         data-default-class http-types kansas-comet scotty stm text
         transformers vector wai wai-extra warp
       ];
       jailbreak = true;
       homepage = "https://github.com/ku-fpg/blank-canvas/wiki";
       description = "HTML5 Canvas Graphics Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blank-canvas" = callPackage
    ({ mkDerivation, aeson, base, base-compat, base64-bytestring
     , bytestring, colour, containers, data-default-class, directory
     , http-types, kansas-comet, mime-types, process, scotty, shake, stm
     , text, text-show, time, transformers, unix, vector, wai, wai-extra
     , warp
     }:
     mkDerivation {
       pname = "blank-canvas";
       version = "0.6";
       sha256 = "2a0e5c4fc50b1ce43e56b1a11056186c21d565e225da36f90c58f8c0a70f48b3";
       revision = "3";
       editedCabalFile = "3a1b54006324de595823f744e3f2592e85629008eea36f4e5d7b206a91085fdf";
       libraryHaskellDepends = [
         aeson base base-compat base64-bytestring bytestring colour
         containers data-default-class http-types kansas-comet mime-types
         scotty stm text text-show transformers vector wai wai-extra warp
       ];
       testHaskellDepends = [
         base containers directory process shake stm text time unix vector
       ];
       doCheck = false;
       homepage = "https://github.com/ku-fpg/blank-canvas/wiki";
       description = "HTML5 Canvas Graphics Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blas" = callPackage
    ({ mkDerivation, base, ieee, QuickCheck, storable-complex }:
     mkDerivation {
       pname = "blas";
       version = "0.7.6";
       sha256 = "912e904b8ae923520c3ac4707abb28322a96009daf9ec88baffe5ebd049fcee0";
       libraryHaskellDepends = [ base ieee QuickCheck storable-complex ];
       jailbreak = true;
       homepage = "http://github.com/patperry/blas";
       description = "Bindings to the BLAS library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blas-hs" = callPackage
    ({ mkDerivation, base, blas, storable-complex, vector }:
     mkDerivation {
       pname = "blas-hs";
       version = "0.1.1.0";
       sha256 = "80e06b0927982b391d239f8656ed437cd29665969d1a078ea4e42a2bf196b086";
       libraryHaskellDepends = [ base storable-complex ];
       librarySystemDepends = [ blas ];
       testHaskellDepends = [ base vector ];
       homepage = "https://github.com/Rufflewind/blas-hs";
       description = "Low-level Haskell bindings to Blas";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) blas;};

  "blastxml" = callPackage
    ({ mkDerivation, base, biocore, bytestring, parallel, tagsoup }:
     mkDerivation {
       pname = "blastxml";
       version = "0.3.2";
       sha256 = "0c0089c42306c8189a9a26905677372d26adfde03772ae79b4742771d0de986a";
       libraryHaskellDepends = [
         base biocore bytestring parallel tagsoup
       ];
       homepage = "http://biohaskell.org/";
       description = "Library for reading Blast XML output";
       license = "LGPL";
     }) {};

  "blatex" = callPackage
    ({ mkDerivation, base, blaze-html, dates, directory, HaTeX, process
     , split, tagsoup, text
     }:
     mkDerivation {
       pname = "blatex";
       version = "0.1.0.5";
       sha256 = "8c421e5c355d374463793a6bd3815185fcd8d0e8134d72b7d6e7a916f5932479";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-html dates directory HaTeX process split tagsoup text
       ];
       jailbreak = true;
       homepage = "https://github.com/2016rshah/BlaTeX";
       description = "Blog in LaTeX";
       license = stdenv.lib.licenses.mit;
     }) {};

  "blaze" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "blaze";
       version = "0.0.2";
       sha256 = "68dcce9a0535bb6e4dcea68c4ff9cedab83509644204dfea2d9256e90667c606";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "blaze-bootstrap" = callPackage
    ({ mkDerivation, base, blaze-html, text }:
     mkDerivation {
       pname = "blaze-bootstrap";
       version = "0.1.0.1";
       sha256 = "53b54c0b55ae7a436ec7e5d4e29d50fceb1ccd459ef715236358a3c661d05163";
       libraryHaskellDepends = [ base blaze-html text ];
       homepage = "http://github.com/agrafix/blaze-bootstrap";
       description = "Blaze helper functions for bootstrap pages";
       license = stdenv.lib.licenses.mit;
     }) {};

  "blaze-builder_0_3_3_4" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "blaze-builder";
       version = "0.3.3.4";
       sha256 = "e5c1101e6a0db4ee85e0bf57fe797bdd6f5ee9542ee730a663030eb650acaf8b";
       libraryHaskellDepends = [ base bytestring text ];
       homepage = "http://github.com/meiersi/blaze-builder";
       description = "Efficient buffered output";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-builder" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, utf8-string
     }:
     mkDerivation {
       pname = "blaze-builder";
       version = "0.4.0.1";
       sha256 = "c136ec877bb8d1558409e87b77174977ae01f8dff5bddb472df8b8d4c7e0a3c5";
       libraryHaskellDepends = [ base bytestring deepseq text ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 text utf8-string
       ];
       homepage = "http://github.com/lpsmith/blaze-builder";
       description = "Efficient buffered output";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "blaze-builder-conduit" = callPackage
    ({ mkDerivation, base, conduit }:
     mkDerivation {
       pname = "blaze-builder-conduit";
       version = "1.1.0";
       sha256 = "638e76ea91eef2d92bd88f0c47a311ae29d090e9add00c979f2b5806e9b0be77";
       libraryHaskellDepends = [ base conduit ];
       doHaddock = false;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Convert streams of builders to streams of bytestrings. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "blaze-builder-enumerator_0_2_0_6" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, enumerator
     , transformers
     }:
     mkDerivation {
       pname = "blaze-builder-enumerator";
       version = "0.2.0.6";
       sha256 = "d7cfd62b51b5c4ec82609f791a191f12dfed25476b10888b216bc69d1b0abc5d";
       libraryHaskellDepends = [
         base blaze-builder bytestring enumerator transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/meiersi/blaze-builder-enumerator";
       description = "Enumeratees for the incremental conversion of builders to bytestrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-builder-enumerator" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring
     , bytestring-builder, enumerator, streaming-commons, transformers
     }:
     mkDerivation {
       pname = "blaze-builder-enumerator";
       version = "0.2.1.0";
       sha256 = "50f52918a130e81971d01782ead343cdc9bfbf7270ec1e5630943e6b5d23bf96";
       revision = "1";
       editedCabalFile = "28796d33301d22cfca6188f54699d9efd7721802bc5e9c88a394bec14c9c4fae";
       libraryHaskellDepends = [
         base blaze-builder bytestring bytestring-builder enumerator
         streaming-commons transformers
       ];
       doHaddock = false;
       homepage = "https://github.com/meiersi/blaze-builder-enumerator";
       description = "Enumeratees for the incremental conversion of builders to bytestrings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "blaze-from-html" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, tagsoup }:
     mkDerivation {
       pname = "blaze-from-html";
       version = "0.3.2.1";
       sha256 = "9ae029aee30ae8f3c4649e51b9e797ae956ebbe33f3592d07cb948fe72ff23d2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath tagsoup
       ];
       homepage = "http://jaspervdj.be/blaze";
       description = "Tool to convert HTML to BlazeHtml code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "blaze-html_0_7_0_3" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-markup, bytestring
     , containers, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "blaze-html";
       version = "0.7.0.3";
       sha256 = "7d1bba5fac7c129538c567291d5e37663034a9bce6e8efcbea2e8ed5f3dec3ca";
       libraryHaskellDepends = [
         base blaze-builder blaze-markup bytestring text
       ];
       testHaskellDepends = [
         base blaze-builder blaze-markup bytestring containers HUnit
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "http://jaspervdj.be/blaze";
       description = "A blazingly fast HTML combinator library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-html_0_7_1_0" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-markup, bytestring
     , containers, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "blaze-html";
       version = "0.7.1.0";
       sha256 = "4a92c1654ff0e5236380a9ee48b6b5322c32a0da29913cbadf3f369866f43b4f";
       libraryHaskellDepends = [
         base blaze-builder blaze-markup bytestring text
       ];
       testHaskellDepends = [
         base blaze-builder blaze-markup bytestring containers HUnit
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "http://jaspervdj.be/blaze";
       description = "A blazingly fast HTML combinator library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-html_0_8_0_2" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-markup, bytestring
     , containers, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "blaze-html";
       version = "0.8.0.2";
       sha256 = "e4e89eec2f9af3b2e706905645e2996e7a9bc56497a0e8ff4130493c4f417fc0";
       libraryHaskellDepends = [
         base blaze-builder blaze-markup bytestring text
       ];
       testHaskellDepends = [
         base blaze-builder blaze-markup bytestring containers HUnit
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "http://jaspervdj.be/blaze";
       description = "A blazingly fast HTML combinator library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-html_0_8_1_0" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-markup, bytestring
     , containers, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "blaze-html";
       version = "0.8.1.0";
       sha256 = "fb6dc0755b578928538e867ba441525d7169fcfeaabbfc4663f06bc91b6fed31";
       libraryHaskellDepends = [
         base blaze-builder blaze-markup bytestring text
       ];
       testHaskellDepends = [
         base blaze-builder blaze-markup bytestring containers HUnit
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "http://jaspervdj.be/blaze";
       description = "A blazingly fast HTML combinator library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-html" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-markup, bytestring
     , containers, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "blaze-html";
       version = "0.8.1.1";
       sha256 = "f8d2e39764b318f5dde33288f9f11a125ac51552c48b981e2b8068002728dcb6";
       libraryHaskellDepends = [
         base blaze-builder blaze-markup bytestring text
       ];
       testHaskellDepends = [
         base blaze-builder blaze-markup bytestring containers HUnit
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       homepage = "http://jaspervdj.be/blaze";
       description = "A blazingly fast HTML combinator library for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "blaze-html-contrib" = callPackage
    ({ mkDerivation, base, blaze-html, cgi, data-default, network, safe
     , text
     }:
     mkDerivation {
       pname = "blaze-html-contrib";
       version = "0.2.2";
       sha256 = "8e81227953a9e75634263f5087e856fe3e217322ec556bc2f162d0d2d6df2028";
       libraryHaskellDepends = [
         base blaze-html cgi data-default network safe text
       ];
       homepage = "https://github.com/egonSchiele/blaze-html-contrib";
       description = "Some contributions to add handy things to blaze html";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-html-hexpat" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, hexpat, text }:
     mkDerivation {
       pname = "blaze-html-hexpat";
       version = "0.1.0.0";
       sha256 = "6f9ed6e2d77b6a5e2d812ba56b7380cc8cf4e8067f406663f9b49db8b92f7c85";
       libraryHaskellDepends = [ base blaze-html bytestring hexpat text ];
       jailbreak = true;
       homepage = "https://github.com/jaspervdj/blaze-html-hexpat";
       description = "A hexpat backend for blaze-html";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-html-truncate" = callPackage
    ({ mkDerivation, base, blaze-markup, bytestring, html-truncate
     , tagsoup, text
     }:
     mkDerivation {
       pname = "blaze-html-truncate";
       version = "0.3.0.0";
       sha256 = "74fda4e761d0eddfa2ed392967333d884a150bb41141dea88a89851955c7f2b3";
       libraryHaskellDepends = [
         base blaze-markup bytestring html-truncate tagsoup text
       ];
       homepage = "http://github.com/mruegenberg/blaze-html-truncate";
       description = "A truncator for blaze-html";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "blaze-json" = callPackage
    ({ mkDerivation, aeson, base, bytestring, bytestring-builder
     , containers, data-default-class, doctest, QuickCheck, scientific
     , tasty, tasty-quickcheck, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "blaze-json";
       version = "0.2.1";
       sha256 = "0375c434a578dc5cad4fa6bd8331e75434b8998153e077af64dae382c8de19cb";
       libraryHaskellDepends = [
         base bytestring bytestring-builder containers data-default-class
         text
       ];
       testHaskellDepends = [
         aeson base doctest QuickCheck scientific tasty tasty-quickcheck
         text unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/philopon/blaze-json";
       description = "tiny library for encoding json";
       license = stdenv.lib.licenses.mit;
     }) {};

  "blaze-markup_0_6_1_1" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers, HUnit
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "blaze-markup";
       version = "0.6.1.1";
       sha256 = "ad484263f2f0978fd919627717c5a2ec923f19f401f1471ec259558ddd7306aa";
       revision = "1";
       editedCabalFile = "bca70dee335bccedc3fa134b94f69c874ce962c7f0a99f7d0d6155d6982299f0";
       libraryHaskellDepends = [ base blaze-builder bytestring text ];
       testHaskellDepends = [
         base blaze-builder bytestring containers HUnit QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "http://jaspervdj.be/blaze";
       description = "A blazingly fast markup combinator library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-markup_0_6_2_0" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers, HUnit
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "blaze-markup";
       version = "0.6.2.0";
       sha256 = "0854033de23827d93cb13cdc6530e9def0e367df7309d488cfe601def7c48a0c";
       libraryHaskellDepends = [ base blaze-builder bytestring text ];
       testHaskellDepends = [
         base blaze-builder bytestring containers HUnit QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "http://jaspervdj.be/blaze";
       description = "A blazingly fast markup combinator library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-markup_0_6_3_0" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers, HUnit
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "blaze-markup";
       version = "0.6.3.0";
       sha256 = "94422d41f9760e4fee5f689950e86401f3e2faf1935cbf56375a2674a93c05f4";
       libraryHaskellDepends = [ base blaze-builder bytestring text ];
       testHaskellDepends = [
         base blaze-builder bytestring containers HUnit QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "http://jaspervdj.be/blaze";
       description = "A blazingly fast markup combinator library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-markup_0_7_0_2" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers, HUnit
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "blaze-markup";
       version = "0.7.0.2";
       sha256 = "e4068a284834d8fe68df5ec63a037b92b7c956a82c0c72d7beca8d670fd5725c";
       libraryHaskellDepends = [ base blaze-builder bytestring text ];
       testHaskellDepends = [
         base blaze-builder bytestring containers HUnit QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "http://jaspervdj.be/blaze";
       description = "A blazingly fast markup combinator library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-markup" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers, HUnit
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "blaze-markup";
       version = "0.7.0.3";
       sha256 = "3e69a0e88dde5a6a3c8b4204d847a545f7872025a2ac4554cd5df2861aa41b20";
       libraryHaskellDepends = [ base blaze-builder bytestring text ];
       testHaskellDepends = [
         base blaze-builder bytestring containers HUnit QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
       ];
       homepage = "http://jaspervdj.be/blaze";
       description = "A blazingly fast markup combinator library for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "blaze-shields" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, blaze-svg, text }:
     mkDerivation {
       pname = "blaze-shields";
       version = "0.1.1.11";
       sha256 = "e68503738f527bd439bcff52726297d26a0c15e8ce71eb72a4edeaff6ffea4d6";
       libraryHaskellDepends = [
         base blaze-html blaze-markup blaze-svg text
       ];
       homepage = "http://githubcom/Qinka/blaze-shields";
       description = "create svg by Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "blaze-svg_0_3_4" = callPackage
    ({ mkDerivation, base, blaze-markup, mtl }:
     mkDerivation {
       pname = "blaze-svg";
       version = "0.3.4";
       sha256 = "a3e1faf76300d954dd078e8dc58b8d79ee191d04162652d2533ee29b71082018";
       libraryHaskellDepends = [ base blaze-markup mtl ];
       jailbreak = true;
       homepage = "https://github.com/deepakjois/blaze-svg";
       description = "SVG combinator library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-svg_0_3_4_1" = callPackage
    ({ mkDerivation, base, blaze-markup, mtl }:
     mkDerivation {
       pname = "blaze-svg";
       version = "0.3.4.1";
       sha256 = "376ff4fa18861f899ac2c67fef2e8e8ce99ddbc58ffc47dc9b4298cca5a0ddad";
       libraryHaskellDepends = [ base blaze-markup mtl ];
       homepage = "https://github.com/deepakjois/blaze-svg";
       description = "SVG combinator library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-svg_0_3_5" = callPackage
    ({ mkDerivation, base, blaze-markup, mtl }:
     mkDerivation {
       pname = "blaze-svg";
       version = "0.3.5";
       sha256 = "9f6979e0c9bb3e1a10b034e1ed41a7881195760ec30d30a95bcab22fd6e9a15a";
       libraryHaskellDepends = [ base blaze-markup mtl ];
       homepage = "https://github.com/deepakjois/blaze-svg";
       description = "SVG combinator library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-svg" = callPackage
    ({ mkDerivation, base, blaze-markup, mtl }:
     mkDerivation {
       pname = "blaze-svg";
       version = "0.3.6";
       sha256 = "90dff37d78bffe5ee2587bab4281c158d5d1bd3901fe359bfdcc1cb6fb387179";
       libraryHaskellDepends = [ base blaze-markup mtl ];
       homepage = "https://github.com/deepakjois/blaze-svg";
       description = "SVG combinator library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "blaze-textual_0_2_0_9" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, double-conversion
     , ghc-prim, integer-gmp, old-locale, QuickCheck, test-framework
     , test-framework-quickcheck2, text, time, vector
     }:
     mkDerivation {
       pname = "blaze-textual";
       version = "0.2.0.9";
       sha256 = "c005e4e8e33b696b7b127384e96885c1e7e66d0ee5b064bbeb330a66e50d9ebf";
       libraryHaskellDepends = [
         base blaze-builder bytestring ghc-prim integer-gmp old-locale text
         time vector
       ];
       testHaskellDepends = [
         base blaze-builder bytestring double-conversion QuickCheck
         test-framework test-framework-quickcheck2
       ];
       homepage = "http://github.com/bos/blaze-textual";
       description = "Fast rendering of common datatypes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blaze-textual" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, double-conversion
     , ghc-prim, integer-gmp, old-locale, QuickCheck, test-framework
     , test-framework-quickcheck2, 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
       ];
       testHaskellDepends = [
         base blaze-builder bytestring double-conversion QuickCheck
         test-framework test-framework-quickcheck2
       ];
       homepage = "http://github.com/bos/blaze-textual";
       description = "Fast rendering of common datatypes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "blaze-textual-native" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, ghc-prim
     , integer-gmp, old-locale, text, time, vector
     }:
     mkDerivation {
       pname = "blaze-textual-native";
       version = "0.2.1.1";
       sha256 = "4d0f00d0ac1295153c000a89e91ab7626a1b4ddc138be31087bd3049896b6fe0";
       libraryHaskellDepends = [
         base blaze-builder bytestring ghc-prim integer-gmp old-locale text
         time vector
       ];
       jailbreak = true;
       homepage = "http://github.com/mailrank/blaze-textual";
       description = "Fast rendering of common datatypes (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blazeMarker" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup }:
     mkDerivation {
       pname = "blazeMarker";
       version = "0.1.0.0";
       sha256 = "0c0dedca6cee4a5547a73f3a825925ca447bc8a86d8cf8ac41aa9fdfa91ffd0d";
       libraryHaskellDepends = [ base blaze-html blaze-markup ];
       description = "...";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "blink1" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "blink1";
       version = "0.4";
       sha256 = "128bba0aa3247b4a6546c41b0b7f85ad1869c0ec8aaa20ff2bbb8b89c9e38714";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base unix ];
       executableHaskellDepends = [ base unix ];
       description = "Control library for blink(1) LED from ThingM";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "blip" = callPackage
    ({ mkDerivation, base, bliplib, bytestring, containers, filepath
     , language-python, mtl, old-time, parseargs, pretty
     }:
     mkDerivation {
       pname = "blip";
       version = "0.2.1";
       sha256 = "c742a094cd863b4021fdab70f4e75b13a8a5e5c2f3f5091475bf21ac9c6c9f46";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bliplib bytestring containers filepath language-python mtl
         old-time parseargs pretty
       ];
       jailbreak = true;
       homepage = "https://github.com/bjpop/blip";
       description = "Python to bytecode compiler";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bliplib" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, mtl, pretty
     , utf8-string
     }:
     mkDerivation {
       pname = "bliplib";
       version = "0.2.1";
       sha256 = "1f17b3e1bbd88bbb12992ed16c0733d714f66600d7f9eb11780249efd181b444";
       libraryHaskellDepends = [
         base binary bytestring containers mtl pretty utf8-string
       ];
       jailbreak = true;
       homepage = "https://github.com/bjpop/blip";
       description = "Support code for Blip";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "blocking-transactions" = callPackage
    ({ mkDerivation, base, containers, parallel }:
     mkDerivation {
       pname = "blocking-transactions";
       version = "0.1.0.5";
       sha256 = "fa3e685693150cf03957abf7ed7da6825b6396b8419da9931b0718384091b403";
       libraryHaskellDepends = [ base containers parallel ];
       homepage = "http://www.downstairspeople.org/git/blocking-transactions.git";
       description = "Composable, blocking transactions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "blogination" = callPackage
    ({ mkDerivation, base, ConfigFile, directory, feed, filepath
     , haskell98, higherorder, highlighting-kate, mtl, old-locale
     , old-time, pandoc, regex-compat, time, utf8-string, xhtml, xml
     }:
     mkDerivation {
       pname = "blogination";
       version = "0.5";
       sha256 = "cffde658235332148228b317a0f22d3fe990142d34ef1eeb569f2cf1a364b02d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory feed filepath higherorder highlighting-kate mtl
         old-locale pandoc regex-compat time utf8-string xhtml xml
       ];
       executableHaskellDepends = [ base ConfigFile haskell98 old-time ];
       description = "Very simple static blog software";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bloodhound_0_4_0_2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, containers
     , hspec, http-client, http-types, QuickCheck, semigroups, text
     , time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "bloodhound";
       version = "0.4.0.2";
       sha256 = "531bce0b9b7a5b8f47a6e00d13e08093969e2c9348a5c74ed85e1312ffb9f409";
       libraryHaskellDepends = [
         aeson base bytestring conduit containers http-client http-types
         semigroups text time vector
       ];
       testHaskellDepends = [
         aeson base containers hspec http-client http-types QuickCheck
         semigroups text time unordered-containers vector
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/bitemyapp/bloodhound";
       description = "ElasticSearch client library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bloodhound_0_5_0_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, containers
     , directory, doctest, doctest-prop, filepath, hspec, http-client
     , http-types, QuickCheck, semigroups, text, time
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "bloodhound";
       version = "0.5.0.1";
       sha256 = "0a02f822f8e9c708da3a464ffb2fdb5e62ed4ca78a8d582bdcd2acf11d9278f3";
       libraryHaskellDepends = [
         aeson base bytestring conduit containers http-client http-types
         semigroups text time vector
       ];
       testHaskellDepends = [
         aeson base containers directory doctest doctest-prop filepath hspec
         http-client http-types QuickCheck semigroups text time
         unordered-containers vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/bitemyapp/bloodhound";
       description = "ElasticSearch client library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bloodhound_0_7_0_1" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, containers
     , data-default-class, directory, doctest, doctest-prop, exceptions
     , filepath, hspec, http-client, http-types, mtl, QuickCheck
     , quickcheck-properties, semigroups, text, time, transformers
     , unordered-containers, uri-bytestring, vector
     }:
     mkDerivation {
       pname = "bloodhound";
       version = "0.7.0.1";
       sha256 = "5ad6e6336018d1a2c796bec87b0953266c15d3d4959fa4045c37e0b5cdb2c6e4";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring containers data-default-class
         exceptions http-client http-types mtl semigroups text time
         transformers uri-bytestring vector
       ];
       testHaskellDepends = [
         aeson base bytestring containers directory doctest doctest-prop
         filepath hspec http-client http-types mtl QuickCheck
         quickcheck-properties semigroups text time unordered-containers
         vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/bitemyapp/bloodhound";
       description = "ElasticSearch client library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bloodhound" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, containers
     , data-default-class, derive, directory, doctest, doctest-prop
     , errors, exceptions, filepath, hashable, hspec, http-client
     , http-types, mtl, mtl-compat, network-uri, QuickCheck
     , quickcheck-properties, semigroups, text, time, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "bloodhound";
       version = "0.10.0.0";
       sha256 = "c4c50d48c27c1dd4fbb61b450342af50db2a26165fc941ad758ea91e1835d75a";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring containers data-default-class
         exceptions hashable http-client http-types mtl mtl-compat
         network-uri semigroups text time transformers unordered-containers
         vector
       ];
       testHaskellDepends = [
         aeson base bytestring containers derive directory doctest
         doctest-prop errors filepath hspec http-client http-types mtl
         QuickCheck quickcheck-properties semigroups text time
         unordered-containers vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/bitemyapp/bloodhound";
       description = "ElasticSearch client library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bloomfilter" = callPackage
    ({ mkDerivation, array, base, bytestring, deepseq, QuickCheck
     , random, test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "bloomfilter";
       version = "2.0.1.0";
       sha256 = "6c5e0d357d5d39efe97ae2776e8fb533fa50c1c05397c7b85020b0f098ad790f";
       libraryHaskellDepends = [ array base bytestring deepseq ];
       testHaskellDepends = [
         base bytestring QuickCheck random test-framework
         test-framework-quickcheck2
       ];
       homepage = "https://github.com/bos/bloomfilter";
       description = "Pure and impure Bloom Filter implementations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bloxorz" = callPackage
    ({ mkDerivation, base, GLFW, OpenGL }:
     mkDerivation {
       pname = "bloxorz";
       version = "0.1.2";
       sha256 = "9c675f2d148cfda55fde7fb09223b30763e06066823231049b4d14158bde3e33";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base GLFW OpenGL ];
       description = "OpenGL Logic Game";
       license = "GPL";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "blubber" = callPackage
    ({ mkDerivation, base, blubber-server, bytestring, cereal
     , containers, gloss, network, unix
     }:
     mkDerivation {
       pname = "blubber";
       version = "0.0.1";
       sha256 = "4d77ede2f3584ebb54208d402e20fd621029fa9b10a2029f8987ef67f805832d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blubber-server bytestring cereal containers gloss network unix
       ];
       jailbreak = true;
       homepage = "https://secure.plaimi.net/games/blubber.html";
       description = "The blubber client; connects to the blubber server";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "blubber-server" = callPackage
    ({ mkDerivation, base, Cabal, cereal, containers
     , data-default-class, network, pandoc, process, random, scotty
     , text, transformers, unix
     }:
     mkDerivation {
       pname = "blubber-server";
       version = "0.0.1";
       sha256 = "45424b0cdcc2522f38ac495cea54bdae2dd04348fbae9272cf5030413549c589";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base cereal containers random ];
       executableHaskellDepends = [
         base Cabal cereal containers data-default-class network pandoc
         process random scotty text transformers unix
       ];
       jailbreak = true;
       homepage = "https://secure.plaimi.net/games/blubber.html";
       description = "The blubber server, serves blubber clients";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "bluetile" = callPackage
    ({ mkDerivation, base, ConfigFile, containers, directory, filepath
     , glade, gtk, gtk2, mtl, process, random, regex-compat, unix
     , utf8-string, X11, X11-xft, xmonad, xmonad-contrib
     }:
     mkDerivation {
       pname = "bluetile";
       version = "0.6";
       sha256 = "42e14f961760de26cbae93f45009a522052e90c4b96246f2bd6ebd8e40b7ae8f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base ConfigFile containers directory filepath glade gtk mtl process
         random regex-compat unix utf8-string X11 X11-xft xmonad
         xmonad-contrib
       ];
       executablePkgconfigDepends = [ gtk2 ];
       homepage = "http://www.bluetile.org/";
       description = "full-featured tiling for the GNOME desktop environment";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gtk2 = pkgs.gnome2.gtk;};

  "bluetileutils" = callPackage
    ({ mkDerivation, base, gtk }:
     mkDerivation {
       pname = "bluetileutils";
       version = "0.2";
       sha256 = "f57d9d259dbeaf3b91e0baddc28f15bb89d0ed6490df733b48ad56507246cae2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base gtk ];
       jailbreak = true;
       description = "Utilities for Bluetile";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "blunt" = callPackage
    ({ mkDerivation, aeson, base, bytestring, clay, flow, http-types
     , jmacro, lucid, pointfree, pointful, text, wai, wai-extra
     , wai-websockets, warp, websockets, wl-pprint-text
     }:
     mkDerivation {
       pname = "blunt";
       version = "1.0.2";
       sha256 = "0cce0e687baa915e5c08272ea9e5858beda4fd2f459bfbc0022dedbce5e515dc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring clay flow http-types jmacro lucid pointfree
         pointful text wai wai-extra wai-websockets warp websockets
         wl-pprint-text
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://blunt.herokuapp.com";
       description = "Convert between pointfree and pointful expressions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "bmp" = callPackage
    ({ mkDerivation, base, binary, bytestring }:
     mkDerivation {
       pname = "bmp";
       version = "1.2.5.2";
       sha256 = "bdd8681204d79176a974100958a020bb65471752ae7819e5fad7856abd700839";
       libraryHaskellDepends = [ base binary bytestring ];
       homepage = "http://code.ouroborus.net/bmp";
       description = "Read and write uncompressed BMP image files";
       license = stdenv.lib.licenses.mit;
     }) {};

  "board-games" = callPackage
    ({ mkDerivation, array, base, cgi, containers, html, httpd-shed
     , network-uri, QuickCheck, random, transformers, utility-ht
     }:
     mkDerivation {
       pname = "board-games";
       version = "0.1.0.2";
       sha256 = "8d261347cae2f9597f696a44e558ee0988f82a3b1ae65846e60e9ce19e45f984";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base cgi containers html random transformers utility-ht
       ];
       executableHaskellDepends = [
         array base cgi containers html httpd-shed network-uri random
         transformers utility-ht
       ];
       testHaskellDepends = [
         array base containers QuickCheck random transformers utility-ht
       ];
       homepage = "http://code.haskell.org/~thielema/games/";
       description = "Three games for inclusion in a web server";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bogre-banana" = callPackage
    ({ mkDerivation, base, hogre, hois, monad-control, random
     , reactive-banana
     }:
     mkDerivation {
       pname = "bogre-banana";
       version = "0.0.1";
       sha256 = "916f9f154c4646c999d9688fe985463b969188711e85ef9cef5f2f1d42aa997e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base hogre hois monad-control random reactive-banana
       ];
       executableHaskellDepends = [ base hogre hois random ];
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bond" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, cmdargs, derive
     , Diff, directory, filepath, HUnit, monad-loops, mtl, parsec
     , pretty, process, QuickCheck, shakespeare, tasty, tasty-golden
     , tasty-hunit, tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "bond";
       version = "0.4.0.1";
       sha256 = "40d7f0ddcb4779d16ce3ce94bb0f0d2ea47d6d2c82f296027cd3d068be0622c8";
       revision = "1";
       editedCabalFile = "f90dcbaa3a55c1918957942c01f21a574c268730f37aff34c19a6cd04b4ccc6d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring filepath mtl parsec shakespeare text
       ];
       executableHaskellDepends = [
         aeson async base bytestring cmdargs directory filepath monad-loops
         process text
       ];
       testHaskellDepends = [
         aeson base bytestring cmdargs derive Diff directory filepath HUnit
         monad-loops pretty QuickCheck tasty tasty-golden tasty-hunit
         tasty-quickcheck text
       ];
       homepage = "https://github.com/Microsoft/bond";
       description = "Bond schema compiler and code generator";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bool-extras" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "bool-extras";
       version = "0.4.0";
       sha256 = "c1e8cfc6e716f089a7d24fe0cb33e2f4792ff97f81084604139d5902dc201501";
       libraryHaskellDepends = [ base ];
       homepage = "http://tom.lokhorst.eu/bool-extras";
       description = "A fold function for Bool";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "boolean-list" = callPackage
    ({ mkDerivation, base, bytestring, HUnit }:
     mkDerivation {
       pname = "boolean-list";
       version = "0.1.0.0";
       sha256 = "774f3f3313a8909505834e647b744fa53178b6a4eee5cf55b5207da5e6d7217b";
       libraryHaskellDepends = [ base bytestring HUnit ];
       jailbreak = true;
       homepage = "http://xy30.com";
       description = "convert numbers to binary coded lists";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "boolean-normal-forms" = callPackage
    ({ mkDerivation, base, cond, containers, QuickCheck, tasty
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "boolean-normal-forms";
       version = "0.0.0.1";
       sha256 = "2c8a8a9b2e868e29fab7467272c6c54792417bcd8c0e349963b3aff82137c287";
       revision = "1";
       editedCabalFile = "c4ca8c0d91be170e201800c3c26de19dea859afa56d69bdab323315e31a74075";
       libraryHaskellDepends = [ base cond containers ];
       testHaskellDepends = [
         base cond containers QuickCheck tasty tasty-quickcheck
       ];
       description = "Boolean normal form: NNF, DNF & CNF";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "boolexpr" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "boolexpr";
       version = "0.1";
       sha256 = "b6a386d2aed46d7e81c93b90fe60914cd57dee19c3621d7760ecd24b19496893";
       libraryHaskellDepends = [ base parsec ];
       description = "Boolean expressions with various representations and search queries";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bools" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "bools";
       version = "0.1.1";
       sha256 = "356681052e693ac02e0ab5bcb5f3cf426761cf1d4c3309cc0ee80e510718a700";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "boolsimplifier" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "boolsimplifier";
       version = "0.1.8";
       sha256 = "096fa9377241520ee114403fd53b51a7369187fb4dca65f19f85a727d689828f";
       libraryHaskellDepends = [ base containers ];
       description = "Simplification tools for simple propositional formulas";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "boomange" = callPackage
    ({ mkDerivation, base, containers, descrilo, directory, filepath
     , simtreelo
     }:
     mkDerivation {
       pname = "boomange";
       version = "0.1.3.1";
       sha256 = "a0e249f91c62048a2cbf1d2935deab37ff214099634c15bb308a41fa72a3e1e9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers descrilo directory filepath simtreelo
       ];
       description = "A Bookmarks manager with a HTML generator";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "boombox" = callPackage
    ({ mkDerivation, base, bytestring, comonad, semigroupoids
     , semigroups, transformers
     }:
     mkDerivation {
       pname = "boombox";
       version = "0.0";
       sha256 = "e48f0f1ee83d128bab671f1ac0077faa13e5f61f89031b77de151d1fcc8704fc";
       libraryHaskellDepends = [
         base bytestring comonad semigroupoids semigroups transformers
       ];
       homepage = "https://github.com/fumieval/boombox";
       description = "Chronokinetic stream sources and incremental consumers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "boomerang" = callPackage
    ({ mkDerivation, base, mtl, template-haskell, text }:
     mkDerivation {
       pname = "boomerang";
       version = "1.4.5.1";
       sha256 = "24381764277d0454185ea4f6862d3a7d84efd7a46f9f524f821b4052b08a46bc";
       libraryHaskellDepends = [ base mtl template-haskell text ];
       description = "Library for invertible parsing and printing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "boomslang" = callPackage
    ({ mkDerivation, base, containers, data-accessor
     , data-accessor-template, font-opengl-basic4x6, GLFW-b, MonadRandom
     , mtl, OpenGL
     }:
     mkDerivation {
       pname = "boomslang";
       version = "0.0.4";
       sha256 = "d0a6daa9d7fe0a4b3ab224bbb35e6599be26feb9adb413fad98e345a3459187b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers data-accessor data-accessor-template
         font-opengl-basic4x6 GLFW-b MonadRandom mtl OpenGL
       ];
       jailbreak = true;
       description = "Boomshine clone";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "borel" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, bimap, cassava
     , ceilometer-common, chevalier-common, configurator, containers
     , either, errors, hslogger, hspec, lens, lens-properties, marquise
     , mtl, multiset, network, network-uri, pipes, pipes-concurrency
     , pipes-safe, QuickCheck, text, time, transformers
     , unordered-containers, vaultaire-common, vector, zeromq4-haskell
     }:
     mkDerivation {
       pname = "borel";
       version = "0.18.0";
       sha256 = "a390410ad6d62f79e35509c9bc3e9ac24bccc4b74220428dbb4e210a0ef54a35";
       libraryHaskellDepends = [
         aeson async attoparsec base bimap cassava ceilometer-common
         chevalier-common configurator containers errors hslogger lens
         marquise mtl multiset network network-uri pipes pipes-concurrency
         pipes-safe text time transformers unordered-containers
         vaultaire-common vector zeromq4-haskell
       ];
       testHaskellDepends = [
         aeson async attoparsec base bimap cassava ceilometer-common
         chevalier-common configurator containers either errors hslogger
         hspec lens lens-properties marquise mtl multiset network
         network-uri pipes pipes-concurrency pipes-safe QuickCheck text time
         transformers unordered-containers vaultaire-common vector
         zeromq4-haskell
       ];
       jailbreak = true;
       homepage = "https://github.com/anchor/borel-core";
       description = "Metering System for OpenStack metrics provided by Vaultaire";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bot" = callPackage
    ({ mkDerivation, arrows, base, Stream }:
     mkDerivation {
       pname = "bot";
       version = "0.3";
       sha256 = "2c57b733057d4fe697f554aeb37bbafb09d15f64f1b5f9e5c41f25b10d0b3a33";
       libraryHaskellDepends = [ arrows base Stream ];
       homepage = "http://haskell.org/haskellwiki/Bot";
       description = "bots for functional reactive programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "both" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "both";
       version = "0.1.0.0";
       sha256 = "f30b3c55ade901bd6d15d4e359d7a58e5a44b44e4891d0c766731fd6879314fe";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/barrucadu/both";
       description = "Like Maybe, but with a different Monoid instance";
       license = stdenv.lib.licenses.mit;
     }) {};

  "botpp" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "botpp";
       version = "0.1";
       sha256 = "dc118d7cc2a08124a2981227360684774a31903e091ee75f50b600393f812647";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://haskell.org/haskellwiki/Lambdabot";
       description = "Build tool for Lambdabot";
       license = "GPL";
     }) {};

  "bound_1_0_4" = callPackage
    ({ mkDerivation, base, bifunctors, binary, bytes, cereal, comonad
     , directory, doctest, filepath, hashable, hashable-extras
     , prelude-extras, profunctors, transformers, vector
     }:
     mkDerivation {
       pname = "bound";
       version = "1.0.4";
       sha256 = "7ede186b3acd91574c336819da1d0d5d0ad2c4a5e487c6ff65077488abcc169f";
       libraryHaskellDepends = [
         base bifunctors binary bytes cereal comonad hashable
         hashable-extras prelude-extras profunctors transformers
       ];
       testHaskellDepends = [
         base directory doctest filepath prelude-extras transformers vector
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/bound/";
       description = "Making de Bruijn Succ Less";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bound_1_0_5" = callPackage
    ({ mkDerivation, base, bifunctors, binary, bytes, cereal, comonad
     , directory, doctest, filepath, hashable, hashable-extras
     , prelude-extras, profunctors, transformers, vector
     }:
     mkDerivation {
       pname = "bound";
       version = "1.0.5";
       sha256 = "0e21d99fa7a88f1bd8698b98abbb50902232bbdda6159a1412d36d0b186a62ee";
       libraryHaskellDepends = [
         base bifunctors binary bytes cereal comonad hashable
         hashable-extras prelude-extras profunctors transformers
       ];
       testHaskellDepends = [
         base directory doctest filepath prelude-extras transformers vector
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/bound/";
       description = "Making de Bruijn Succ Less";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bound_1_0_6" = callPackage
    ({ mkDerivation, base, bifunctors, binary, bytes, cereal, comonad
     , directory, doctest, filepath, hashable, hashable-extras
     , prelude-extras, profunctors, transformers, vector
     }:
     mkDerivation {
       pname = "bound";
       version = "1.0.6";
       sha256 = "db9cdd0f98073549dce4109fb039290161886205f27bb39e4a7e9f76f6353844";
       libraryHaskellDepends = [
         base bifunctors binary bytes cereal comonad hashable
         hashable-extras prelude-extras profunctors transformers
       ];
       testHaskellDepends = [
         base directory doctest filepath prelude-extras transformers vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/ekmett/bound/";
       description = "Making de Bruijn Succ Less";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bound" = callPackage
    ({ mkDerivation, base, bifunctors, binary, bytes, cereal, comonad
     , directory, doctest, filepath, hashable, hashable-extras
     , prelude-extras, profunctors, template-haskell, transformers
     , vector
     }:
     mkDerivation {
       pname = "bound";
       version = "1.0.7";
       sha256 = "ad0388ade83ca0b3cf02b182e663f553a83b3a8116ada8f39543318bf516340e";
       libraryHaskellDepends = [
         base bifunctors binary bytes cereal comonad hashable
         hashable-extras prelude-extras profunctors template-haskell
         transformers
       ];
       testHaskellDepends = [
         base directory doctest filepath prelude-extras transformers vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/ekmett/bound/";
       description = "Making de Bruijn Succ Less";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bound-gen" = callPackage
    ({ mkDerivation, base, bound, monad-gen, mtl }:
     mkDerivation {
       pname = "bound-gen";
       version = "0.1.0.2";
       sha256 = "97436491bc61df00f175ceb2da50fb6dd561a76c45e50d6b4901b493c8da84c6";
       libraryHaskellDepends = [ base bound monad-gen mtl ];
       description = "Unwrap Scope's with globally fresh values";
       license = stdenv.lib.licenses.mit;
     }) {};

  "bounded-tchan" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "bounded-tchan";
       version = "0.2.3";
       sha256 = "3ccd1447154c137d61f665793cd098765e47247037b5c960019e063f7e438789";
       libraryHaskellDepends = [ base stm ];
       description = "Bounded Transactional channels (queues)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "boundingboxes" = callPackage
    ({ mkDerivation, base, lens }:
     mkDerivation {
       pname = "boundingboxes";
       version = "0.2.3";
       sha256 = "e80947aa2c2c7f11e7eb2eb088a463d1cd1cdf03790e4c2746b629dcb1737564";
       libraryHaskellDepends = [ base lens ];
       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, mtl
     , scientific, tasty, tasty-hunit, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "bower-json";
       version = "0.7.0.0";
       sha256 = "1a9e6561983a3b61d9bdbbb88e10d623eb41f47eaee30a0ea447e42e78efe96f";
       libraryHaskellDepends = [
         aeson aeson-better-errors base bytestring mtl scientific text
         transformers unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bytestring tasty tasty-hunit text unordered-containers
       ];
       homepage = "https://github.com/hdgarrood/bower-json";
       description = "Read bower.json from Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "bowntz" = callPackage
    ({ mkDerivation, base, containers, GLUT, hosc, hsc3, random }:
     mkDerivation {
       pname = "bowntz";
       version = "0";
       sha256 = "771d0f4b4fccefd96e58d6c6ddf71d111aaa0c49180f1e0cab6ad61ec0d9b378";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers GLUT hosc hsc3 random
       ];
       homepage = "http://code.mathr.co.uk/bowntz";
       description = "audio-visual pseudo-physical simulation of colliding circles";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "boxes" = callPackage
    ({ mkDerivation, base, QuickCheck, split }:
     mkDerivation {
       pname = "boxes";
       version = "0.1.4";
       sha256 = "4e3ee9a88a28ed14a61b2c885b111922f201f56392ff68d350418ff6e98dfdd8";
       libraryHaskellDepends = [ base split ];
       testHaskellDepends = [ base QuickCheck split ];
       description = "2D text pretty-printing library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bpann" = callPackage
    ({ mkDerivation, base, random, split }:
     mkDerivation {
       pname = "bpann";
       version = "0.1.1";
       sha256 = "889fd9484e2e5a3fe3cc37e35adade0619d759c113118a4f67e94fa2bfef8809";
       libraryHaskellDepends = [ base random split ];
       description = "backpropagation neuronal network";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "braid" = callPackage
    ({ mkDerivation, base, containers, diagrams-contrib, diagrams-core
     , diagrams-lib, diagrams-svg, split
     }:
     mkDerivation {
       pname = "braid";
       version = "0.1.0.0";
       sha256 = "19a5f45ca45b30fcd09fe2909d3c07169a5c5216efbe4d2df7fcbc4f0b28ed99";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers diagrams-contrib diagrams-core diagrams-lib
         diagrams-svg split
       ];
       executableHaskellDepends = [
         base containers diagrams-contrib diagrams-core diagrams-lib
         diagrams-svg split
       ];
       homepage = "http://github.com/githubuser/braid#readme";
       description = "Types and functions to work with braids and Khovanov homology";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "brainfuck" = callPackage
    ({ mkDerivation, array, base, mtl, unix }:
     mkDerivation {
       pname = "brainfuck";
       version = "0.1.0.2";
       sha256 = "e9ff5626ceaca4913506a6b854f7d1375a5642e0fd33984d3fc30a58e906b7a3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base mtl ];
       executableHaskellDepends = [ array base mtl unix ];
       description = "Brainfuck interpreter";
       license = "GPL";
     }) {};

  "brainfuck-monad" = callPackage
    ({ mkDerivation, base, directory, process }:
     mkDerivation {
       pname = "brainfuck-monad";
       version = "0.5.0";
       sha256 = "4fdc46d934c22725840721310bdd225c859f585c4ec8b60761d0acc774382337";
       libraryHaskellDepends = [ base directory process ];
       description = "BrainFuck monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "brainfuck-tut" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "brainfuck-tut";
       version = "0.7.0.0";
       sha256 = "d2f4142ecc30ce39a83e58a144b650a44288e6cf62d47b83cc8ee95ac2aba8a7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base ];
       executableHaskellDepends = [ array base ];
       jailbreak = true;
       homepage = "https://gitlab.com/cpp.cabrera/brainfuck-tut";
       description = "A simple BF interpreter";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "break" = callPackage
    ({ mkDerivation, base, mtl, transformers }:
     mkDerivation {
       pname = "break";
       version = "1.0.0";
       sha256 = "55083f86c32ca20519605bd37e847e3c6e07aeab622395c18e9fc470146cd895";
       libraryHaskellDepends = [ base mtl transformers ];
       description = "Break from a loop";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "breakout" = callPackage
    ({ mkDerivation, base, haskgame, mtl, SDL }:
     mkDerivation {
       pname = "breakout";
       version = "0.0.2";
       sha256 = "990fd8a8640c396b700531cb12eecb56a988b6ca9be21642146b494252161a13";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskgame mtl SDL ];
       homepage = "http://github.com/Peaker/breakout/tree/master";
       description = "A simple Breakout game implementation";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "breve" = callPackage
    ({ mkDerivation, aeson, base, binary, blaze-html, bytestring
     , configurator, cryptohash, directory, hashtables, http-types, mtl
     , random, Spock, text, tls, transformers, wai, wai-extra
     , wai-middleware-static, warp, warp-tls, xdg-basedir
     }:
     mkDerivation {
       pname = "breve";
       version = "0.4.3.0";
       sha256 = "e4740b0cc882ada54bb7e89957349639ef2a3f171598818b7e678b9880d1f939";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base binary blaze-html bytestring configurator cryptohash
         directory hashtables http-types mtl random Spock text tls
         transformers wai wai-extra wai-middleware-static warp warp-tls
         xdg-basedir
       ];
       homepage = "https://github.com/rnhmjoj/breve";
       description = "a url shortener";
       license = stdenv.lib.licenses.mit;
     }) {};

  "brians-brain" = callPackage
    ({ mkDerivation, array, base, parallel, random, SDL }:
     mkDerivation {
       pname = "brians-brain";
       version = "0.0.1";
       sha256 = "56650c0cbe9d921a7509818dcf29bf406130fc8a310af74aad482c6c29fb2f29";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base parallel random SDL ];
       homepage = "http://github.com/willdonnelly/brians-brain";
       description = "A Haskell implementation of the Brian's Brain cellular automaton";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "brick_0_3_1" = callPackage
    ({ mkDerivation, base, containers, contravariant, data-default
     , deepseq, lens, template-haskell, text, text-zipper, transformers
     , vector, vty
     }:
     mkDerivation {
       pname = "brick";
       version = "0.3.1";
       sha256 = "0e97e82a8dc3b9eba8f11cdf69818b6a919dbe6e8c7710b55483c3908ecfc7a9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers contravariant data-default deepseq lens
         template-haskell text text-zipper transformers vector vty
       ];
       executableHaskellDepends = [
         base data-default lens text vector vty
       ];
       homepage = "https://github.com/jtdaugherty/brick/";
       description = "A declarative terminal user interface library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "brick" = callPackage
    ({ mkDerivation, base, containers, contravariant, data-default
     , deepseq, lens, template-haskell, text, text-zipper, transformers
     , vector, vty
     }:
     mkDerivation {
       pname = "brick";
       version = "0.4.1";
       sha256 = "bea0df7fdcb476fc955f7301e77bfb8845008ab0e36cab2c2dcc1cf679a4595d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers contravariant data-default deepseq lens
         template-haskell text text-zipper transformers vector vty
       ];
       executableHaskellDepends = [
         base data-default lens text vector vty
       ];
       homepage = "https://github.com/jtdaugherty/brick/";
       description = "A declarative terminal user interface library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "brillig" = callPackage
    ({ mkDerivation, base, binary, cmdargs, containers, directory
     , filepath, ListZipper, text
     }:
     mkDerivation {
       pname = "brillig";
       version = "0.3.1";
       sha256 = "163dcdf8f211792199324d7bca2a355be09d41399af188d76ba6a9d21c11f5a1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary containers directory filepath ListZipper text
       ];
       executableHaskellDepends = [
         base binary cmdargs containers directory filepath text
       ];
       jailbreak = true;
       description = "Simple part of speech tagger";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "broadcast-chan" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "broadcast-chan";
       version = "0.1.0";
       sha256 = "faa0bb66d2ceab2cbbd08a0c39e9142e0f54731257990e1a0c03f287f6bfd5b7";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/merijn/broadcast-chan";
       description = "Broadcast channel type that avoids 0 reader space leaks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "broccoli" = callPackage
    ({ mkDerivation, base, containers, stm, time }:
     mkDerivation {
       pname = "broccoli";
       version = "0.4.1.0";
       sha256 = "90c782cdb5693684da773bb6f34ea9922afd8ce3148f99c9bd7d6897138d9620";
       libraryHaskellDepends = [ base containers stm time ];
       jailbreak = true;
       description = "Small library for interactive functional programs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "broker-haskell" = callPackage
    ({ mkDerivation, base, broker, bytestring, hspec }:
     mkDerivation {
       pname = "broker-haskell";
       version = "0.1.0.0";
       sha256 = "6d0c74a52f20ba2dd33a5c396498045da877955e8b02ca67c2266abeeab1bf4b";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ broker ];
       testHaskellDepends = [ base bytestring hspec ];
       homepage = "https://github.com/capn-freako/broker-haskell";
       description = "Haskell bindings to Broker, Bro's messaging library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {broker = null;};

  "bsd-sysctl" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "bsd-sysctl";
       version = "1.0.7";
       sha256 = "de8c9e2b6d0fa64f7e33885392a05b450e30da35d80de10f37c918ac8d2e1aa3";
       libraryHaskellDepends = [ base ];
       description = "Access to the BSD sysctl(3) interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bson_0_3_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, cryptohash
     , data-binary-ieee754, mtl, network, QuickCheck, test-framework
     , test-framework-quickcheck2, text, time
     }:
     mkDerivation {
       pname = "bson";
       version = "0.3.1";
       sha256 = "3b4ec7ab27d99e85bb556b09dc1fa275098b73ff01d2b81f210b6ba4b9d430ce";
       libraryHaskellDepends = [
         base binary bytestring cryptohash data-binary-ieee754 mtl network
         text time
       ];
       testHaskellDepends = [
         base binary bytestring cryptohash data-binary-ieee754 mtl network
         QuickCheck test-framework test-framework-quickcheck2 text time
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/mongodb-haskell/bson";
       description = "BSON documents are JSON-like objects with a standard binary encoding";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bson_0_3_2" = callPackage
    ({ mkDerivation, base, binary, bytestring, cryptohash
     , data-binary-ieee754, mtl, network, QuickCheck, test-framework
     , test-framework-quickcheck2, text, time
     }:
     mkDerivation {
       pname = "bson";
       version = "0.3.2";
       sha256 = "6dd232ccda8ec13cf8b8c5da906ffce6b58ae65d72ff0f4e9bc747a7768beb90";
       libraryHaskellDepends = [
         base binary bytestring cryptohash data-binary-ieee754 mtl network
         text time
       ];
       testHaskellDepends = [
         base binary bytestring cryptohash data-binary-ieee754 mtl network
         QuickCheck test-framework test-framework-quickcheck2 text time
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/mongodb-haskell/bson";
       description = "BSON documents are JSON-like objects with a standard binary encoding";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bson" = callPackage
    ({ mkDerivation, base, binary, bytestring, cryptohash
     , data-binary-ieee754, mtl, network, QuickCheck, test-framework
     , test-framework-quickcheck2, text, time
     }:
     mkDerivation {
       pname = "bson";
       version = "0.3.2.1";
       sha256 = "054c24f90a713bedf6288df122db0ca17486c17595bdb45d3442da27d940991f";
       libraryHaskellDepends = [
         base binary bytestring cryptohash data-binary-ieee754 mtl network
         text time
       ];
       testHaskellDepends = [
         base binary bytestring cryptohash data-binary-ieee754 mtl network
         QuickCheck test-framework test-framework-quickcheck2 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 = "unknown";
     }) {};

  "bson-generic" = callPackage
    ({ mkDerivation, base, bson, ghc-prim, text }:
     mkDerivation {
       pname = "bson-generic";
       version = "0.0.8.1";
       sha256 = "9b9f8d160c7d813224946f194f82bf38a2299b6eb9d643f590ed7616a226877e";
       libraryHaskellDepends = [ base bson ghc-prim text ];
       jailbreak = true;
       description = "Generic functionality for BSON";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bson-generics" = callPackage
    ({ mkDerivation, base, bson, ghc-prim }:
     mkDerivation {
       pname = "bson-generics";
       version = "0.0.1";
       sha256 = "b7bf01e812043d15091baf5855f99e996a1bd8e81407cdbf33bd81e9627d2e0e";
       libraryHaskellDepends = [ base bson ghc-prim ];
       jailbreak = true;
       description = "Generics functionality for BSON";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bson-lens" = callPackage
    ({ mkDerivation, base, bson, lens, text }:
     mkDerivation {
       pname = "bson-lens";
       version = "0.1.1";
       sha256 = "d73bb417def2d8cb1efebfc22482a859e119bcc4005dd10106c82dff5ceeb160";
       libraryHaskellDepends = [ base bson lens text ];
       homepage = "https://github.com/jb55/bson-lens";
       description = "BSON lenses";
       license = stdenv.lib.licenses.mit;
     }) {};

  "bson-mapping" = callPackage
    ({ mkDerivation, base, bson, compact-string-fix, template-haskell
     , th-lift
     }:
     mkDerivation {
       pname = "bson-mapping";
       version = "0.1.4.1";
       sha256 = "eaa729942da079f4d4bce93ab1be378491fe171d74d6297814b8d203fdcc214d";
       libraryHaskellDepends = [
         base bson compact-string-fix template-haskell th-lift
       ];
       description = "Mapping between BSON and algebraic data types";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bspack" = callPackage
    ({ mkDerivation, base, bytestring, ghc-prim, mtl, tasty
     , tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "bspack";
       version = "0.0.4";
       sha256 = "eba20bf4322d3fedf703f47623663f75313f4d76aa783da42f65753b340bfc5b";
       libraryHaskellDepends = [ base bytestring ghc-prim ];
       testHaskellDepends = [
         base bytestring mtl tasty tasty-hunit tasty-quickcheck
       ];
       homepage = "https://github.com/NicolasDP/hs-bspack";
       description = "A simple and fast bytestring packer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bsparse" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "bsparse";
       version = "0.0.5";
       sha256 = "4a5041fcb820b87369776573825909d93e8690a883f1d5ee4e2dad89a944968b";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "https://github.com/vincenthz/hs-bsparse";
       description = "A simple unassuming parser for bytestring";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "btree-concurrent" = callPackage
    ({ mkDerivation, array, base, base64-bytestring, bytestring, cereal
     , containers, directory, filepath, hashable, mtl, QuickCheck
     , random, snappy, stm, time, unix
     }:
     mkDerivation {
       pname = "btree-concurrent";
       version = "0.1.5";
       sha256 = "a6e27939b020678ed7638590b483f55bfd1dba944abaef63effefa3de21cfcf5";
       libraryHaskellDepends = [
         array base base64-bytestring bytestring cereal containers directory
         filepath hashable mtl random snappy stm time
       ];
       testHaskellDepends = [
         array base base64-bytestring bytestring cereal containers directory
         filepath hashable mtl QuickCheck random snappy stm time unix
       ];
       jailbreak = true;
       homepage = "https://github.com/brinchj/btree-concurrent";
       description = "A backend agnostic, concurrent BTree";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "btrfs" = callPackage
    ({ mkDerivation, base, bytestring, time, unix }:
     mkDerivation {
       pname = "btrfs";
       version = "0.1.1.1";
       sha256 = "1f3d34897047c124f858b6097bf29ebf250d85aaad74c2c44183607041472bcc";
       revision = "1";
       editedCabalFile = "1ef2b2d9f4768be3250cf2f971639c1a0e410e6bb9b035e922305c62c5f00887";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring time unix ];
       homepage = "https://github.com/redneb/hs-btrfs";
       description = "Bindings to the btrfs API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "buffer-builder_0_2_4_0" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, criterion
     , deepseq, HUnit, mtl, quickcheck-instances, tasty, tasty-hunit
     , tasty-quickcheck, tasty-th, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "buffer-builder";
       version = "0.2.4.0";
       sha256 = "c2b2228b599b98e841423c2042299be157943fad3bff495916d171691afb30cf";
       libraryHaskellDepends = [
         base bytestring mtl text unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring criterion deepseq HUnit
         quickcheck-instances tasty tasty-hunit tasty-quickcheck tasty-th
         text vector
       ];
       homepage = "https://github.com/chadaustin/buffer-builder";
       description = "Library for efficiently building up buffers, one piece at a time";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "buffer-builder" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, criterion
     , deepseq, HTF, mtl, quickcheck-instances, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "buffer-builder";
       version = "0.2.4.1";
       sha256 = "f9ced75361df829a377fd3227ebb26ab9905b3c1eb6eef9b0234a9e14d519795";
       libraryHaskellDepends = [
         base bytestring mtl text unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring criterion deepseq HTF
         quickcheck-instances text vector
       ];
       homepage = "https://github.com/chadaustin/buffer-builder";
       description = "Library for efficiently building up buffers, one piece at a time";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "buffer-builder-aeson" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, buffer-builder
     , bytestring, hashable, HUnit, integer-gmp, QuickCheck, scientific
     , tasty, tasty-hunit, tasty-quickcheck, tasty-th, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "buffer-builder-aeson";
       version = "0.2.0.4";
       sha256 = "7aa47be52be4a264bbbabc38a1d51f24b3176e32263a6e795daa96d12f545c4e";
       revision = "1";
       editedCabalFile = "09657c97cf5ad79da78f230540398a9a99a8bb6cd99bba89a24d741372444b84";
       libraryHaskellDepends = [
         aeson base buffer-builder bytestring integer-gmp scientific
         unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base buffer-builder bytestring hashable HUnit
         QuickCheck scientific tasty tasty-hunit tasty-quickcheck tasty-th
         text unordered-containers vector
       ];
       description = "Serialize Aeson values with Data.BufferBuilder";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "buffer-pipe" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "buffer-pipe";
       version = "0.0";
       sha256 = "0875b6e41988f70e20d2e9d1a092ae03d545954732f93d65a3481b5c4b52dccf";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       description = "Read from stdin and write to stdout in large blocks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "buffon" = callPackage
    ({ mkDerivation, base, monad-primitive, mwc-random
     , mwc-random-monad, primitive, transformers
     }:
     mkDerivation {
       pname = "buffon";
       version = "0.1.0.0";
       sha256 = "2da56227ede11731a35f076629a3d8dbe3af4f5ab09713e2f418c6affe136a1c";
       libraryHaskellDepends = [
         base monad-primitive mwc-random mwc-random-monad primitive
         transformers
       ];
       homepage = "https://github.com/derekelkins/buffon";
       description = "An implementation of Buffon machines";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bugzilla" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, connection
     , containers, data-default, http-conduit, http-types, iso8601-time
     , resourcet, text, time, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "bugzilla";
       version = "0.2.1.1";
       sha256 = "ad30a9b8cbe7e9b994d6898ff68007e0c5a5a45b873e9a52dd51cf68d5945ea5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring connection containers
         data-default http-conduit http-types iso8601-time resourcet text
         time transformers unordered-containers vector
       ];
       executableHaskellDepends = [ base containers text time ];
       jailbreak = true;
       homepage = "https://github.com/sethfowler/hsbugzilla";
       description = "A Haskell interface to the Bugzilla native REST API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "buildable" = callPackage
    ({ mkDerivation, base, bytestring, containers, dlist, text }:
     mkDerivation {
       pname = "buildable";
       version = "0.1.0.3";
       sha256 = "fdbe2c5a274998a7d2f881361b30accdff5386bb471c78244c135533457d3bcb";
       libraryHaskellDepends = [ base bytestring containers dlist text ];
       jailbreak = true;
       description = "Typeclass for builders of linear data structures";
       license = stdenv.lib.licenses.mit;
     }) {};

  "buildbox" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, mtl
     , old-locale, pretty, process, random, stm, text, time
     }:
     mkDerivation {
       pname = "buildbox";
       version = "2.1.7.1";
       sha256 = "5193d8b22d0b576e972f85f032627a4ebbd6f2d6033aa4a789b312574baf8f58";
       libraryHaskellDepends = [
         base bytestring containers directory mtl old-locale pretty process
         random stm text time
       ];
       homepage = "http://code.ouroborus.net/buildbox";
       description = "Rehackable components for writing buildbots and test harnesses";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "buildbox-tools" = callPackage
    ({ mkDerivation, base, buildbox, parseargs }:
     mkDerivation {
       pname = "buildbox-tools";
       version = "1.5.3.1";
       sha256 = "8ef88a2fdc331547cca2145a6e64845729270bb79fc6be5fff81daae6ad32e48";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base buildbox parseargs ];
       jailbreak = true;
       homepage = "http://code.ouroborus.net/buildbox";
       description = "Tools for working with buildbox benchmark result files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "buildwrapper" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, bytestring, Cabal
     , cmdargs, conduit, conduit-extra, containers, cpphs, deepseq
     , directory, dynamic-cabal, filepath, ghc, ghc-paths, ghc-pkg-lib
     , haskell-src-exts, HTF, HUnit, mtl, old-time, process, regex-tdfa
     , syb, text, time, transformers, unordered-containers, utf8-string
     , vector
     }:
     mkDerivation {
       pname = "buildwrapper";
       version = "0.9.1";
       sha256 = "23239b1b5c18418648aba4efea6f33176c827b082d80ada8a646fd1af11695c5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async attoparsec base bytestring Cabal conduit conduit-extra
         containers cpphs deepseq directory dynamic-cabal filepath ghc
         ghc-paths ghc-pkg-lib haskell-src-exts mtl old-time process
         regex-tdfa syb text time transformers unordered-containers
         utf8-string vector
       ];
       executableHaskellDepends = [
         aeson async base bytestring Cabal cmdargs conduit conduit-extra
         containers cpphs directory dynamic-cabal filepath ghc ghc-paths
         ghc-pkg-lib haskell-src-exts mtl old-time process regex-tdfa syb
         text time transformers vector
       ];
       testHaskellDepends = [
         aeson async attoparsec base bytestring Cabal conduit conduit-extra
         containers directory dynamic-cabal filepath ghc-pkg-lib HTF HUnit
         mtl old-time process text time transformers unordered-containers
         vector
       ];
       jailbreak = true;
       homepage = "https://github.com/JPMoresmau/BuildWrapper";
       description = "A library and an executable that provide an easy API for a Haskell IDE";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bullet" = callPackage
    ({ mkDerivation, base, bullet, c2hs, vect }:
     mkDerivation {
       pname = "bullet";
       version = "0.2.4";
       sha256 = "f6ad58f558c911570894b2700054c8ff5ff3323e21ad201e4218e06eeeec7a3a";
       libraryHaskellDepends = [ base vect ];
       libraryPkgconfigDepends = [ bullet ];
       libraryToolDepends = [ c2hs ];
       homepage = "http://www.haskell.org/haskellwiki/Bullet";
       description = "A wrapper for the Bullet physics engine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) bullet;};

  "bumper_0_6_0_2" = callPackage
    ({ mkDerivation, base, Cabal, containers, fclabels, process
     , regex-compat, split, strict
     }:
     mkDerivation {
       pname = "bumper";
       version = "0.6.0.2";
       sha256 = "da62660d2d54972ffdc8121f6151a50935c630c28b6305ffa497ba316d030f49";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers fclabels process regex-compat split strict
       ];
       jailbreak = true;
       homepage = "http://github.com/silkapp/bumper";
       description = "Automatically bump package versions, also transitively";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bumper" = callPackage
    ({ mkDerivation, base, Cabal, containers, fclabels, process
     , regex-compat, split, strict
     }:
     mkDerivation {
       pname = "bumper";
       version = "0.6.0.3";
       sha256 = "7cfce3a38be30744a2eb322ad1e5271cd665fa62b4fe21bdf9aa00fcdbc4daa8";
       revision = "1";
       editedCabalFile = "d5083fd8bd41bdd8a9afb459891d3fbfd674b5279b30993928690410808a2af0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers fclabels process regex-compat split strict
       ];
       homepage = "http://github.com/silkapp/bumper";
       description = "Automatically bump package versions, also transitively";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "burst-detection" = callPackage
    ({ mkDerivation, base, deepseq }:
     mkDerivation {
       pname = "burst-detection";
       version = "1.0";
       sha256 = "953742286dddadd2bd54e13a72916044e1c1a7acada5a5e5d12759c29ac4f9dd";
       libraryHaskellDepends = [ base deepseq ];
       testHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://parsci.com/";
       description = "Burst detection algorithms";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "bus-pirate" = callPackage
    ({ mkDerivation, base, bytestring, either, errors, serialport
     , transformers
     }:
     mkDerivation {
       pname = "bus-pirate";
       version = "0.6.3";
       sha256 = "22db2acbd964175dce221dcff52e16ba346846c14e7772e20e320cde7798314a";
       libraryHaskellDepends = [
         base bytestring either errors serialport transformers
       ];
       homepage = "http://www.github.com/bgamari/bus-pirate";
       description = "Haskell interface to the Bus Pirate binary interface";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "buster" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, dataenc, mtl
     , old-locale, parsec, pretty, time
     }:
     mkDerivation {
       pname = "buster";
       version = "2.51";
       sha256 = "efffb20a6686c4430d008b85a66b83079f4b43796a960e85356a957f943e078a";
       libraryHaskellDepends = [
         base binary bytestring containers dataenc mtl old-locale parsec
         pretty time
       ];
       jailbreak = true;
       homepage = "http://vis.renci.org/jeff/buster";
       description = "Almost but not quite entirely unlike FRP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "buster-gtk" = callPackage
    ({ mkDerivation, base, binary, buster, bytestring, containers
     , dataenc, gtk, mtl, old-locale, parsec, pretty, time
     }:
     mkDerivation {
       pname = "buster-gtk";
       version = "2.0";
       sha256 = "a13dd06f6ecd1265e319cb87ae4048176805ed8d7103f90f6c05b3d373e355aa";
       libraryHaskellDepends = [
         base binary buster bytestring containers dataenc gtk mtl old-locale
         parsec pretty time
       ];
       homepage = "http://vis.renci.org/jeff/buster";
       description = "Almost but not quite entirely unlike FRP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "buster-network" = callPackage
    ({ mkDerivation, base, binary, buster, bytestring, containers
     , dataenc, haxr, HTTP, mtl, network, old-locale, pretty, time
     }:
     mkDerivation {
       pname = "buster-network";
       version = "1.2";
       sha256 = "71bc99106bf655f17a5d55cf432d1205a02903dce131fe587083e7c67ce1df9e";
       libraryHaskellDepends = [
         base binary buster bytestring containers dataenc haxr HTTP mtl
         network old-locale pretty time
       ];
       homepage = "http://vis.renci.org/jeff/buster";
       description = "Almost but not quite entirely unlike FRP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bustle_0_5_2" = callPackage
    ({ mkDerivation, base, bytestring, cairo, containers, dbus
     , directory, filepath, gio, glib, gtk3, hgettext, HUnit, mtl, pango
     , parsec, pcap, process, QuickCheck, setlocale, system-glib
     , test-framework, test-framework-hunit, text, time
     }:
     mkDerivation {
       pname = "bustle";
       version = "0.5.2";
       sha256 = "659d75f91d2d08447bce484a8176f6a2cc94cc10a2d732b7e733e4312a527e90";
       isLibrary = false;
       isExecutable = true;
       libraryPkgconfigDepends = [ system-glib ];
       executableHaskellDepends = [
         base bytestring cairo containers dbus directory filepath gio glib
         gtk3 hgettext mtl pango parsec pcap process setlocale text time
       ];
       testHaskellDepends = [
         base bytestring cairo containers dbus directory filepath gtk3
         hgettext HUnit mtl pango pcap QuickCheck setlocale test-framework
         test-framework-hunit text
       ];
       homepage = "http://www.freedesktop.org/wiki/Software/Bustle/";
       description = "Draw sequence diagrams of D-Bus traffic";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {system-glib = pkgs.glib;};

  "bustle_0_5_3" = callPackage
    ({ mkDerivation, base, bytestring, cairo, containers, dbus
     , directory, filepath, gio, glib, gtk3, hgettext, HUnit, mtl, pango
     , parsec, pcap, process, QuickCheck, setlocale, system-glib
     , test-framework, test-framework-hunit, text, time
     }:
     mkDerivation {
       pname = "bustle";
       version = "0.5.3";
       sha256 = "9e525611cfb0c0715969b0ea77c2f63aaf7bc6ad70c9cf889a1655b66c0c24fd";
       isLibrary = false;
       isExecutable = true;
       libraryPkgconfigDepends = [ system-glib ];
       executableHaskellDepends = [
         base bytestring cairo containers dbus directory filepath gio glib
         gtk3 hgettext mtl pango parsec pcap process setlocale text time
       ];
       testHaskellDepends = [
         base bytestring cairo containers dbus directory filepath gtk3
         hgettext HUnit mtl pango pcap QuickCheck setlocale test-framework
         test-framework-hunit text
       ];
       homepage = "http://www.freedesktop.org/wiki/Software/Bustle/";
       description = "Draw sequence diagrams of D-Bus traffic";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {system-glib = pkgs.glib;};

  "bustle" = callPackage
    ({ mkDerivation, base, bytestring, cairo, containers, dbus
     , directory, filepath, gio, glib, gtk3, hgettext, HUnit, mtl, pango
     , parsec, pcap, process, QuickCheck, setlocale, system-glib
     , test-framework, test-framework-hunit, text, time
     }:
     mkDerivation {
       pname = "bustle";
       version = "0.5.4";
       sha256 = "921c2cbbb957dcb02c3aa8fd1eeff3534cb437fa9eeca1c25206ad1e741a3f14";
       isLibrary = false;
       isExecutable = true;
       libraryPkgconfigDepends = [ system-glib ];
       executableHaskellDepends = [
         base bytestring cairo containers dbus directory filepath gio glib
         gtk3 hgettext mtl pango parsec pcap process setlocale text time
       ];
       testHaskellDepends = [
         base bytestring cairo containers dbus directory filepath gtk3
         hgettext HUnit mtl pango pcap QuickCheck setlocale test-framework
         test-framework-hunit text
       ];
       homepage = "http://www.freedesktop.org/wiki/Software/Bustle/";
       description = "Draw sequence diagrams of D-Bus traffic";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {system-glib = pkgs.glib;};

  "butterflies" = callPackage
    ({ mkDerivation, base, bytestring, gl-capture, GLUT, OpenGLRaw
     , OpenGLRaw21, repa, repa-devil
     }:
     mkDerivation {
       pname = "butterflies";
       version = "0.3.0.1";
       sha256 = "631cdc6b4e299c14f2687cb6ed7baab5b0ae353aa34fb6f09e46594a9a93f235";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [
         base bytestring gl-capture GLUT OpenGLRaw OpenGLRaw21 repa
         repa-devil
       ];
       jailbreak = true;
       homepage = "http://code.mathr.co.uk/butterflies";
       description = "butterfly tilings";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bv" = callPackage
    ({ mkDerivation, base, ghc-prim, integer-gmp }:
     mkDerivation {
       pname = "bv";
       version = "0.4.0";
       sha256 = "aaf6adc5aeccdf7bdaf7b5f832f339cbca45747745cd3bf52f30b496c70cb439";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ghc-prim integer-gmp ];
       homepage = "http://bitbucket.org/iago/bv-haskell";
       description = "Bit-vector arithmetic library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "byline" = callPackage
    ({ mkDerivation, ansi-terminal, base, colour, containers
     , exceptions, haskeline, mtl, terminfo-hs, text, transformers
     }:
     mkDerivation {
       pname = "byline";
       version = "0.2.1.0";
       sha256 = "dd464d3b9afb9e74fd2ed72e44f9fc74bcd59abf870184ee2a4ed2512e2b75c4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base colour containers exceptions haskeline mtl
         terminfo-hs text transformers
       ];
       executableHaskellDepends = [ base text ];
       homepage = "http://github.com/pjones/byline";
       description = "Library for creating command-line interfaces (colors, menus, etc.)";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "bytable" = callPackage
    ({ mkDerivation, base, bytestring, word24 }:
     mkDerivation {
       pname = "bytable";
       version = "0.1.0.0";
       sha256 = "b6a6cce6fcd3ec094211e7937cbe9a89c741820200c0286fca225e1069829e74";
       libraryHaskellDepends = [ base bytestring word24 ];
       description = "data from/to ByteString";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "byteable" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "byteable";
       version = "0.1.1";
       sha256 = "243b34a1b5b64b39e39fe58f75c18f6cad5b668b10cabcd86816cbde27783fe2";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://github.com/vincenthz/hs-byteable";
       description = "Type class for sequence of bytes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bytedump" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "bytedump";
       version = "1.0";
       sha256 = "ae17b5040f0423eec792505f14d1d3e53f5ff81ddf83524f1c5dc7a16c0dc0dd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://github.com/vincenthz/hs-bytedump";
       description = "Flexible byte dump helpers for human readers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "byteorder" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "byteorder";
       version = "1.0.4";
       sha256 = "bd20bbb586947f99c38a4c93d9d0266f49f6fc581767b51ba568f6d5d52d2919";
       libraryHaskellDepends = [ base ];
       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_0_14_1_2" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, containers
     , directory, doctest, filepath, mtl, text, time, transformers
     , transformers-compat, void
     }:
     mkDerivation {
       pname = "bytes";
       version = "0.14.1.2";
       sha256 = "ed34e778e1e499ad36dbe08e92d536d69b3d4cd07741ed40768bc452c3b536ec";
       revision = "1";
       editedCabalFile = "6d04c237986e2e9cc2e8066579a1668002f4a36227b4d5b739331ab74533630c";
       libraryHaskellDepends = [
         base binary bytestring cereal containers mtl text time transformers
         transformers-compat void
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/analytics/bytes";
       description = "Sharing code for serialization between binary and cereal";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytes_0_14_1_3" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, containers
     , directory, doctest, filepath, mtl, text, time, transformers
     , transformers-compat, void
     }:
     mkDerivation {
       pname = "bytes";
       version = "0.14.1.3";
       sha256 = "1dbae0203ff999809ab1fa81cf56d5214e1812aca2d1b6689b1c8ef4f1b1eba2";
       revision = "1";
       editedCabalFile = "320ebe39de8e091a9a043c59a0f7b44fdaf9b7306bbc299cc9552aa2a31093be";
       libraryHaskellDepends = [
         base binary bytestring cereal containers mtl text time transformers
         transformers-compat void
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/analytics/bytes";
       description = "Sharing code for serialization between binary and cereal";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytes_0_15" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, containers
     , directory, doctest, filepath, mtl, text, time, transformers
     , transformers-compat, void
     }:
     mkDerivation {
       pname = "bytes";
       version = "0.15";
       sha256 = "e6735d161ecba774db1bd217a68d988d66c96652744153e1185d91e32ec52821";
       revision = "1";
       editedCabalFile = "94dc3ad697fbfd70c7cf77a2e0c9bf4307a0f396012738537b931fc3b4e58386";
       libraryHaskellDepends = [
         base binary bytestring cereal containers mtl text time transformers
         transformers-compat void
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/analytics/bytes";
       description = "Sharing code for serialization between binary and cereal";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytes_0_15_0_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, containers
     , directory, doctest, filepath, mtl, text, time, transformers
     , transformers-compat, void
     }:
     mkDerivation {
       pname = "bytes";
       version = "0.15.0.1";
       sha256 = "0844677de1358ac66c0fd1c829cda66539963681cef1125e815bf435108c98e2";
       revision = "1";
       editedCabalFile = "a38761e7550c9ad5d2d6083c0ccc7c03f3ab77a58b294b157d5b3c9112318bbf";
       libraryHaskellDepends = [
         base binary bytestring cereal containers mtl text time transformers
         transformers-compat void
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "https://github.com/ekmett/bytes";
       description = "Sharing code for serialization between binary and cereal";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytes_0_15_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, containers
     , directory, doctest, filepath, hashable, mtl, scientific, text
     , time, transformers, transformers-compat, unordered-containers
     , void
     }:
     mkDerivation {
       pname = "bytes";
       version = "0.15.1";
       sha256 = "ce74d4e1dfbee76652964281a9a6a0f0ef922efe4b9612deda42bc65f5efc4bf";
       libraryHaskellDepends = [
         base binary bytestring cereal containers hashable mtl scientific
         text time transformers transformers-compat unordered-containers
         void
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "https://github.com/ekmett/bytes";
       description = "Sharing code for serialization between binary and cereal";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytes" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, containers
     , directory, doctest, filepath, hashable, mtl, scientific, text
     , time, transformers, transformers-compat, unordered-containers
     , void
     }:
     mkDerivation {
       pname = "bytes";
       version = "0.15.2";
       sha256 = "0bfaaf70154d3622be1ee620dd75e9c93cf4d4a21544d83f281d01439f261f34";
       libraryHaskellDepends = [
         base binary bytestring cereal containers hashable mtl scientific
         text time transformers transformers-compat unordered-containers
         void
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       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 }:
     mkDerivation {
       pname = "byteset";
       version = "0.1.1.0";
       sha256 = "13499c5b279f022097e9ae1d0aeef3fcea12b7f18f50157d4950aec58741afa1";
       libraryHaskellDepends = [ base binary ];
       description = "Set of bytes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bytestring_0_10_6_0" = callPackage
    ({ mkDerivation, base, byteorder, deepseq, directory, dlist
     , ghc-prim, HUnit, integer-gmp, mtl, QuickCheck, random
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "bytestring";
       version = "0.10.6.0";
       sha256 = "271b9a6b7b81bc259f8a947b12354951829580b0fe0bd8482e41af261b118977";
       libraryHaskellDepends = [ base deepseq ghc-prim integer-gmp ];
       testHaskellDepends = [
         base byteorder deepseq directory dlist ghc-prim HUnit mtl
         QuickCheck random test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/haskell/bytestring";
       description = "Fast, compact, strict and lazy byte strings with a list interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-arbitrary" = callPackage
    ({ mkDerivation, base, bytestring, cryptohash, QuickCheck }:
     mkDerivation {
       pname = "bytestring-arbitrary";
       version = "0.1.0";
       sha256 = "248378d6a7b75e8b9cbadcb3793ddcb17bd1ef7b36ffce02dc99ff11ef49c92b";
       libraryHaskellDepends = [ base bytestring cryptohash QuickCheck ];
       testHaskellDepends = [ base bytestring cryptohash QuickCheck ];
       homepage = "https://github.com/tsuraan/bytestring-arbitrary";
       description = "Arbitrary instances for ByteStrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-builder_0_10_4_0_1" = callPackage
    ({ mkDerivation, base, bytestring, deepseq }:
     mkDerivation {
       pname = "bytestring-builder";
       version = "0.10.4.0.1";
       sha256 = "2079e5f8b269b4b90095d69f864dcbddfac2499ef985086af8e5d0ddcc341047";
       revision = "1";
       editedCabalFile = "2184b845a3059f681324e4c71d041ec0ee5268208149877a06a5c93618c28e9b";
       libraryHaskellDepends = [ base bytestring deepseq ];
       doHaddock = false;
       jailbreak = true;
       description = "The new bytestring builder, packaged outside of GHC";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-builder_0_10_4_1_0" = callPackage
    ({ mkDerivation, base, bytestring, deepseq }:
     mkDerivation {
       pname = "bytestring-builder";
       version = "0.10.4.1.0";
       sha256 = "bf728099333a09ba28b8c48b28db52eac86d5e48421f7318e13e825a61ab197e";
       revision = "1";
       editedCabalFile = "44ec650d19703746349ce9f3b78ab2deb3f796836cd7120d796f2720e74fdb86";
       libraryHaskellDepends = [ base bytestring deepseq ];
       doHaddock = false;
       jailbreak = true;
       description = "The new bytestring builder, packaged outside of GHC";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-builder_0_10_4_1_1" = callPackage
    ({ mkDerivation, base, bytestring, deepseq }:
     mkDerivation {
       pname = "bytestring-builder";
       version = "0.10.4.1.1";
       sha256 = "36cb4cf34237104a79e4e34c4aa2bee0ff05bd5649d272100fb4e3eb9e97aa8d";
       revision = "1";
       editedCabalFile = "e2a69de6946e31a5966a6e660e6c1b512aaf68c1fbe9111837253a5517ff39f0";
       libraryHaskellDepends = [ base bytestring deepseq ];
       doHaddock = false;
       description = "The new bytestring builder, packaged outside of GHC";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-builder_0_10_4_1_2" = callPackage
    ({ mkDerivation, base, bytestring, deepseq }:
     mkDerivation {
       pname = "bytestring-builder";
       version = "0.10.4.1.2";
       sha256 = "9e04ab1360d6448c2648c60b7bb1689e71177286b2d36147ef1087527ef5e03e";
       libraryHaskellDepends = [ base bytestring deepseq ];
       doHaddock = false;
       description = "The new bytestring builder, packaged outside of GHC";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-builder" = callPackage
    ({ mkDerivation, base, bytestring, deepseq }:
     mkDerivation {
       pname = "bytestring-builder";
       version = "0.10.6.0.0";
       sha256 = "9c439987d11150ad3f73158ad3be1f9d1f70572cd2cf8fdf585765403f116fd6";
       libraryHaskellDepends = [ base bytestring deepseq ];
       doHaddock = false;
       description = "The new bytestring builder, packaged outside of GHC";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bytestring-class" = callPackage
    ({ mkDerivation, base, bytestring, utf8-string }:
     mkDerivation {
       pname = "bytestring-class";
       version = "0.0.0.1";
       sha256 = "7d80db8549d933273db4b058e61f532338de2fbce3b9c455b490de0c405ec5fc";
       revision = "1";
       editedCabalFile = "e3aa2813d237dcd0a12bfd27293d8bf592cdf13bfdc01a4b609f34df238d0417";
       libraryHaskellDepends = [ base bytestring utf8-string ];
       jailbreak = true;
       description = "Classes for automatic conversion to and from strict and lazy bytestrings. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-conversion_0_3_0" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, case-insensitive
     , double-conversion, QuickCheck, tasty, tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "bytestring-conversion";
       version = "0.3.0";
       sha256 = "153b42b6e9882d7bd130af4aefd5032cb995865cba1c846169130e1d19988571";
       libraryHaskellDepends = [
         attoparsec base bytestring case-insensitive double-conversion text
       ];
       testHaskellDepends = [
         base bytestring QuickCheck tasty tasty-quickcheck
       ];
       homepage = "https://github.com/twittner/bytestring-conversion/";
       description = "Type-classes to convert values to and from ByteString";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-conversion" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, case-insensitive
     , double-conversion, QuickCheck, tasty, tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "bytestring-conversion";
       version = "0.3.1";
       sha256 = "13b7ea48737dc7a7fd4c894ff1fb9344cf8d9ef8f4201e813d578b613e874ef8";
       revision = "2";
       editedCabalFile = "c3a83596c9955edb5558503dfd698d9a99e0da65bdf53edf6eceacef98200cf5";
       libraryHaskellDepends = [
         attoparsec base bytestring case-insensitive double-conversion text
       ];
       testHaskellDepends = [
         base bytestring QuickCheck tasty tasty-quickcheck
       ];
       homepage = "https://github.com/twittner/bytestring-conversion/";
       description = "Type-classes to convert values to and from ByteString";
       license = stdenv.lib.licenses.mpl20;
     }) {};

  "bytestring-csv" = callPackage
    ({ mkDerivation, array, base, bytestring, dlist }:
     mkDerivation {
       pname = "bytestring-csv";
       version = "0.1.2";
       sha256 = "19480f2f60c474b18ef507a657daa63b18a40f97a3171883cf9d4b33169df874";
       libraryHaskellDepends = [ array base bytestring dlist ];
       homepage = "http://code.haskell.org/~dons/code/bytestring-csv";
       description = "Parse CSV formatted data efficiently";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-delta" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "bytestring-delta";
       version = "0.1.0.1";
       sha256 = "38f0bfff325b9424678aeea05142c83e406fe0e6004da895d608d8385c4c0547";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://github.com/joeyadams/haskell-bytestring-delta";
       description = "Simple, fast binary diff/patch";
       license = stdenv.lib.licenses.mit;
     }) {};

  "bytestring-from" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, QuickCheck, tasty
     , tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "bytestring-from";
       version = "0.3";
       sha256 = "c4def9c8f930ed9c1717fd4547016062c3f7065df341853245bb6212f3cd120c";
       revision = "1";
       editedCabalFile = "b6efc5572f7f26aa1bcc4d930391cb9f0144f6e3df107838ee0adc28d73caa3a";
       libraryHaskellDepends = [ attoparsec base bytestring text ];
       testHaskellDepends = [
         base bytestring QuickCheck tasty tasty-quickcheck
       ];
       description = "A type-class to convert values from ByteString";
       license = "unknown";
     }) {};

  "bytestring-handle" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "bytestring-handle";
       version = "0.1.0.3";
       sha256 = "1f3c21fc4ccd36fc3d3915d10e3c447e7d260c4a005b8de1b342f6eaafe55335";
       libraryHaskellDepends = [ base bytestring ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://hub.darcs.net/ganesh/bytestring-handle";
       description = "ByteString-backed Handles";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bytestring-lexing_0_4_3_2" = callPackage
    ({ mkDerivation, alex, array, base, bytestring }:
     mkDerivation {
       pname = "bytestring-lexing";
       version = "0.4.3.2";
       sha256 = "05b0c59969e70b9e92bfcfaa0552fa0ea54f3103af670589e5c898206c78d527";
       libraryHaskellDepends = [ array base bytestring ];
       libraryToolDepends = [ alex ];
       homepage = "http://code.haskell.org/~wren/";
       description = "Parse and produce literals efficiently from strict or lazy bytestrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-lexing_0_4_3_3" = callPackage
    ({ mkDerivation, alex, array, base, bytestring }:
     mkDerivation {
       pname = "bytestring-lexing";
       version = "0.4.3.3";
       sha256 = "005f51e7711d933dded180e28ba8eaae5d55938cc39d4257ed9fbe9072afcbbd";
       libraryHaskellDepends = [ array base bytestring ];
       libraryToolDepends = [ alex ];
       homepage = "http://code.haskell.org/~wren/";
       description = "Parse and produce literals efficiently from strict or lazy bytestrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-lexing" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "bytestring-lexing";
       version = "0.5.0.2";
       sha256 = "01f9add3f25067a89c5ae9ab1f2fd8ab75ec9f386987ee0d83f73ec855b43f73";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://code.haskell.org/~wren/";
       description = "Parse and produce literals efficiently from strict or lazy bytestrings";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "bytestring-mmap" = callPackage
    ({ mkDerivation, base, bytestring, unix }:
     mkDerivation {
       pname = "bytestring-mmap";
       version = "0.2.2";
       sha256 = "7bbcaeeccec5cf448ba59c9ed4de95bcc47b11ae2b9bcddb6201decb88eb69af";
       libraryHaskellDepends = [ base bytestring unix ];
       homepage = "http://code.haskell.org/~dons/code/bytestring-mmap/";
       description = "mmap support for strict ByteStrings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bytestring-nums" = callPackage
    ({ mkDerivation, base, bytestring, containers }:
     mkDerivation {
       pname = "bytestring-nums";
       version = "0.3.6";
       sha256 = "bdca97600d91f00bb3c0f654784e3fbd2d62fcf4671820578105487cdf39e7cd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring containers ];
       homepage = "http://github.com/solidsnack/bytestring-nums";
       description = "Parse numeric literals from ByteStrings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bytestring-plain" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, ghc-prim, hashable }:
     mkDerivation {
       pname = "bytestring-plain";
       version = "0.1.0.2";
       sha256 = "9e2dfbba5b90c6b121953f8a18afbab4041c5a26b8af350360ec888a6ce6fddd";
       libraryHaskellDepends = [
         base bytestring deepseq ghc-prim hashable
       ];
       homepage = "https://github.com/hvr/bytestring-plain";
       description = "Plain byte strings ('ForeignPtr'-less 'ByteString's)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bytestring-progress_1_0_3" = callPackage
    ({ mkDerivation, base, bytestring, terminal-progress-bar, time }:
     mkDerivation {
       pname = "bytestring-progress";
       version = "1.0.3";
       sha256 = "ba7bb1670403cfa79b8b51c6bf031192a5f3682452be75735b903147daa12ced";
       libraryHaskellDepends = [
         base bytestring terminal-progress-bar time
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/acw/bytestring-progress";
       description = "A library for tracking the consumption of a lazy ByteString";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-progress_1_0_4" = callPackage
    ({ mkDerivation, base, bytestring, terminal-progress-bar, time }:
     mkDerivation {
       pname = "bytestring-progress";
       version = "1.0.4";
       sha256 = "e827487e3b6b2ca3063c1bca28a011bdd58f6cc394cc66712e0ecd502566fd9a";
       libraryHaskellDepends = [
         base bytestring terminal-progress-bar time
       ];
       doHaddock = false;
       homepage = "http://github.com/acw/bytestring-progress";
       description = "A library for tracking the consumption of a lazy ByteString";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-progress" = callPackage
    ({ mkDerivation, base, bytestring, terminal-progress-bar, time }:
     mkDerivation {
       pname = "bytestring-progress";
       version = "1.0.5";
       sha256 = "98b70b4ffcc67549e3544a174e2f829d383817411ac8baf7efe42a66777d490a";
       libraryHaskellDepends = [
         base bytestring terminal-progress-bar time
       ];
       doHaddock = false;
       homepage = "http://github.com/acw/bytestring-progress";
       description = "A library for tracking the consumption of a lazy ByteString";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bytestring-read" = callPackage
    ({ mkDerivation, base, bytestring, doctest, tasty, tasty-quickcheck
     , types-compat
     }:
     mkDerivation {
       pname = "bytestring-read";
       version = "0.3.1";
       sha256 = "0048cd84ec6c0c684fa8bb65bc20f280ee3e3dc164bf02d59ba139e8caaac635";
       revision = "2";
       editedCabalFile = "3746d301ac907af3750c2cd06d0e7f397e77a8bf33fbe7efd92b83ddef90752f";
       libraryHaskellDepends = [ base bytestring types-compat ];
       testHaskellDepends = [
         base bytestring doctest tasty tasty-quickcheck
       ];
       homepage = "https://github.com/philopon/bytestring-read";
       description = "fast ByteString to number converting library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "bytestring-rematch" = callPackage
    ({ mkDerivation, base, bytestring, hspec, HUnit, rematch }:
     mkDerivation {
       pname = "bytestring-rematch";
       version = "0.1.0.0";
       sha256 = "705df0968c0ddd9422b12f9837520b1f2f2cc93be31a47c94f8899abeb0dd307";
       libraryHaskellDepends = [ base bytestring ];
       testHaskellDepends = [ base bytestring hspec HUnit rematch ];
       doHaddock = false;
       jailbreak = true;
       homepage = "github.com/tcrayford/rematch";
       description = "Rematch support for ByteString";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-short" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "bytestring-short";
       version = "0.1.0.0";
       sha256 = "39b303951403758dcf626f48e4501b93865d3b4d52d90ae594bbe91a4fc9fca6";
       libraryHaskellDepends = [ base bytestring ];
       testHaskellDepends = [ base ];
       description = "Backport copy of ShortByteString";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-show" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , integer-gmp
     }:
     mkDerivation {
       pname = "bytestring-show";
       version = "0.3.5.6";
       sha256 = "29242efd16951ebba888218c469a99ff25b19ab74ee1e0d7b4db09b8800a0812";
       libraryHaskellDepends = [
         array base binary bytestring containers integer-gmp
       ];
       homepage = "http://code.haskell.org/~dolio/";
       description = "Efficient conversion of values into readable byte strings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bytestring-tree-builder" = callPackage
    ({ mkDerivation, base, base-prelude, bytestring, QuickCheck
     , quickcheck-instances, semigroups, tasty, tasty-hunit
     , tasty-quickcheck, tasty-smallcheck, text
     }:
     mkDerivation {
       pname = "bytestring-tree-builder";
       version = "0.2.5";
       sha256 = "05f819da3766b2521e4408497858c8fc538065375749d1dbc4d80de77e7ecf5a";
       libraryHaskellDepends = [
         base base-prelude bytestring semigroups text
       ];
       testHaskellDepends = [
         base-prelude bytestring QuickCheck quickcheck-instances tasty
         tasty-hunit tasty-quickcheck tasty-smallcheck
       ];
       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;
     }) {};

  "bytestring-trie_0_2_4" = callPackage
    ({ mkDerivation, base, binary, bytestring }:
     mkDerivation {
       pname = "bytestring-trie";
       version = "0.2.4";
       sha256 = "93f99b04a61f2114e22c9ca7cb976289b45dfacb743074f06a1f62280aec63bb";
       libraryHaskellDepends = [ base binary bytestring ];
       homepage = "http://code.haskell.org/~wren/";
       description = "An efficient finite map from (byte)strings to values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestring-trie" = callPackage
    ({ mkDerivation, base, binary, bytestring }:
     mkDerivation {
       pname = "bytestring-trie";
       version = "0.2.4.1";
       sha256 = "2fe4feb526a03d32aaf673506623b3af4ce3fee126f745a8852c5fd676a61363";
       libraryHaskellDepends = [ base binary bytestring ];
       homepage = "http://code.haskell.org/~wren/";
       description = "An efficient finite map from (byte)strings to values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bytestringparser" = callPackage
    ({ mkDerivation, base, bytestring, containers }:
     mkDerivation {
       pname = "bytestringparser";
       version = "0.3";
       sha256 = "0d0b686fcb68901a54045377e003aeb9b6fd6877c107b2e830254e12eeda29bd";
       libraryHaskellDepends = [ base bytestring containers ];
       description = "Combinator parsing with Data.ByteString.Lazy";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bytestringparser-temporary" = callPackage
    ({ mkDerivation, base, bytestring, containers }:
     mkDerivation {
       pname = "bytestringparser-temporary";
       version = "0.4.1";
       sha256 = "eda2b21f45cc42f057f8afdee0969cbdec9b91f7ded3c0e6d7f555580cee2a05";
       libraryHaskellDepends = [ base bytestring containers ];
       description = "Combinator parsing with Data.ByteString.Lazy";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "bytestringreadp" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "bytestringreadp";
       version = "0.2";
       sha256 = "ee9426929030f4cb020b817cf4492f21d8d11ca23e2568e41c3ebd2f0e181d1e";
       libraryHaskellDepends = [ base bytestring ];
       description = "A ReadP style parser library for ByteString";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "bzlib_0_5_0_4" = callPackage
    ({ mkDerivation, base, bytestring, bzip2 }:
     mkDerivation {
       pname = "bzlib";
       version = "0.5.0.4";
       sha256 = "8d31b58696eb7b517c2d622cf7d6d7fad83a61a4a6dd088f8331dbc98f3fc3ed";
       revision = "1";
       editedCabalFile = "96e2a6fa6a6a13bdf9d0fe95d7fa1ca3bae0d211b608b250548d90e89f1a1ce2";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ bzip2 ];
       jailbreak = true;
       description = "Compression and decompression in the bzip2 format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) bzip2;};

  "bzlib" = callPackage
    ({ mkDerivation, base, bytestring, bzip2 }:
     mkDerivation {
       pname = "bzlib";
       version = "0.5.0.5";
       sha256 = "9ee7d0ac7461b330820af928c13c6668bf4fe3601f171c42432a85c33718017e";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ bzip2 ];
       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
     , conduit-extra, data-default, hspec, mtl, QuickCheck, random
     , resourcet
     }:
     mkDerivation {
       pname = "bzlib-conduit";
       version = "0.2.1.3";
       sha256 = "153e5672cd16e42ff0fb9c597380e71fa14527aa1b7c45cebd0eb0be3f1a0f4b";
       libraryHaskellDepends = [
         base bindings-DSL bytestring conduit conduit-extra data-default mtl
         resourcet
       ];
       librarySystemDepends = [ bzip2 ];
       testHaskellDepends = [
         base bytestring conduit conduit-extra hspec QuickCheck random
         resourcet
       ];
       homepage = "https://github.com/snoyberg/bzlib-conduit";
       description = "Streaming compression/decompression via conduits";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) bzip2;};

  "c-dsl" = callPackage
    ({ mkDerivation, base, language-c }:
     mkDerivation {
       pname = "c-dsl";
       version = "0.3.1";
       sha256 = "fc9a30c237a4c0c077871a59dc0cb47634ea66271e115bc25ef1dc6c441b1212";
       libraryHaskellDepends = [ base language-c ];
       description = "A higher level DSL on top of language-c";
       license = stdenv.lib.licenses.mit;
     }) {};

  "c-io" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "c-io";
       version = "0.1.0";
       sha256 = "e2e203b1e95f95455f902d0cef3bdda0f78e78ffadade0b14713f72c33e344fd";
       libraryHaskellDepends = [ base ];
       description = "C IO";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "c-storable-deriving" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "c-storable-deriving";
       version = "0.1.3";
       sha256 = "68432da5e33d769c514402ad00bcd66c6a2742dd238825b4988476e5f4c9a67f";
       libraryHaskellDepends = [ base ghc-prim ];
       homepage = "https://github.com/maurer/c-storable-deriving";
       description = "Generate C-like storable instances from datatypes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "c0check" = callPackage
    ({ mkDerivation, base, c0parser }:
     mkDerivation {
       pname = "c0check";
       version = "0.2";
       sha256 = "350a80a434370c575da0832d5edfc211184284aef797fba08d0697dd18da9f2a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base c0parser ];
       description = "Simple C0 Syntax Check";
       license = "GPL";
     }) {};

  "c0parser" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "c0parser";
       version = "0.2";
       sha256 = "9c9df54d0044a203eef921aff79d5c7f1d90f1634fa44c0808e5cf0646d4cb44";
       libraryHaskellDepends = [ base parsec ];
       description = "Simple C0 Parser";
       license = "GPL";
     }) {};

  "c10k" = callPackage
    ({ mkDerivation, base, network, unix }:
     mkDerivation {
       pname = "c10k";
       version = "0.5.0";
       sha256 = "a981fcdf496ea9ebfc5a610febb41fd31bcce9d92ed077a6973bdc92268dc2c4";
       libraryHaskellDepends = [ base network unix ];
       homepage = "http://github.com/kazu-yamamoto/c10k";
       description = "C10k server library using prefork";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "c2hs_0_20_1" = callPackage
    ({ mkDerivation, array, base, containers, directory, dlist
     , filepath, HUnit, language-c, pretty, process, shelly
     , test-framework, test-framework-hunit, text, transformers
     }:
     mkDerivation {
       pname = "c2hs";
       version = "0.20.1";
       sha256 = "70d8d9a55bc0c68c1315bd98327825503ffa52c153611e2d2d4dfe1cfb4f5cf0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory dlist filepath language-c pretty
         process
       ];
       testHaskellDepends = [
         base filepath HUnit shelly test-framework test-framework-hunit text
         transformers
       ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "c2hs_0_25_2" = callPackage
    ({ mkDerivation, array, base, containers, directory, dlist
     , filepath, HUnit, language-c, pretty, process, shelly
     , test-framework, test-framework-hunit, text, transformers
     }:
     mkDerivation {
       pname = "c2hs";
       version = "0.25.2";
       sha256 = "153e28d4f8f7846fd0e09abc9b4ed0681b50cd8e2bb6100a1c3b91bf397b3934";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory dlist filepath language-c pretty
         process
       ];
       testHaskellDepends = [
         base filepath HUnit shelly test-framework test-framework-hunit text
         transformers
       ];
       homepage = "https://github.com/haskell/c2hs";
       description = "C->Haskell FFI tool that gives some cross-language type safety";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "c2hs" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , dlist, filepath, HUnit, language-c, pretty, process, shelly
     , test-framework, test-framework-hunit, text, transformers
     }:
     mkDerivation {
       pname = "c2hs";
       version = "0.27.1";
       sha256 = "668af07f261c7c6c2537921ba58870cfb1114b33670f2c182e6f9a8794ffe41f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring containers directory dlist filepath
         language-c pretty process
       ];
       testHaskellDepends = [
         base filepath HUnit shelly test-framework test-framework-hunit text
         transformers
       ];
       homepage = "https://github.com/haskell/c2hs";
       description = "C->Haskell FFI tool that gives some cross-language type safety";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "c2hsc" = callPackage
    ({ mkDerivation, base, cmdargs, containers, directory, filepath
     , HStringTemplate, language-c, mtl, pretty, split, transformers
     }:
     mkDerivation {
       pname = "c2hsc";
       version = "0.6.5";
       sha256 = "edfddd27e6329a620c8722a38f4ae2f1daea67f57c717d428ec3266e49fcb030";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs containers directory filepath HStringTemplate
         language-c mtl pretty split transformers
       ];
       homepage = "https://github.com/jwiegley/c2hsc";
       description = "Convert C API header files to .hsc and .hsc.helper.c files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cab" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, Cabal, conduit
     , conduit-extra, containers, directory, filepath, process
     , resourcet
     }:
     mkDerivation {
       pname = "cab";
       version = "0.2.16";
       sha256 = "f9f9f9c178ad486ff29186b519d6993a8429c3fa34a43d8ed42525c20df5585f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring Cabal conduit conduit-extra containers
         directory filepath process resourcet
       ];
       executableHaskellDepends = [
         attoparsec base bytestring Cabal conduit conduit-extra containers
         directory filepath process
       ];
       homepage = "http://www.mew.org/~kazu/proj/cab/";
       description = "A maintenance command of Haskell cabal packages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-audit" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, HTTP
     , optparse-applicative
     }:
     mkDerivation {
       pname = "cabal-audit";
       version = "0.3.0.0";
       sha256 = "3bc16b5a0a77c298caa147b91eb4d997babee0583d9b9d5b4aa3b944d4e48e09";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal directory filepath HTTP optparse-applicative
       ];
       jailbreak = true;
       homepage = "https://github.com/joelteon/cabal-audit.git";
       description = "Check how up-to-date your .cabal dependencies are.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cabal-bounds" = callPackage
    ({ mkDerivation, base, Cabal, cabal-lenses, cmdargs, directory
     , either, filepath, Glob, lens, process, strict, tasty
     , tasty-golden, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "cabal-bounds";
       version = "1.0.2";
       sha256 = "f5bc846128bea555c9f30e1a61007a5d8e45f30e162c19e98c23bfff6049d3b6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal cabal-lenses cmdargs directory either filepath lens
         strict transformers unordered-containers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base directory filepath Glob process tasty tasty-golden
       ];
       description = "A command line program for managing the bounds/versions of the dependencies in a cabal file";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-cargs" = callPackage
    ({ mkDerivation, base, Cabal, cabal-lenses, cmdargs, directory
     , either, filepath, lens, strict, system-fileio, system-filepath
     , tasty, tasty-golden, text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "cabal-cargs";
       version = "0.7.9";
       sha256 = "58de52a44a9e9895c2bca3d9689012ad3f525a8a5c3b0ebda7b1c5b461d6002d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal cabal-lenses cmdargs directory either lens strict
         system-fileio system-filepath text transformers
         unordered-containers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base filepath tasty tasty-golden ];
       description = "A command line program for extracting compiler arguments from a cabal file";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-constraints" = callPackage
    ({ mkDerivation, base, Cabal, optparse-applicative }:
     mkDerivation {
       pname = "cabal-constraints";
       version = "0.0.0.1";
       sha256 = "b05df399f159ef43eb633eb4bdabc6a821cc5b27864337ba918b478f681c641a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base Cabal optparse-applicative ];
       jailbreak = true;
       homepage = "https://github.com/benarmston/cabal-constraints";
       description = "Repeatable builds for cabalized Haskell projects";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-db" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, bytestring, Cabal
     , containers, directory, filepath, mtl, optparse-applicative
     , pretty, process, tar, utf8-string
     }:
     mkDerivation {
       pname = "cabal-db";
       version = "0.1.12";
       sha256 = "c788de6c8c2de1b89e117c3001ecdd3fc3bd717d93e9aedf6ae0411596d413de";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-wl-pprint base bytestring Cabal containers directory filepath
         mtl optparse-applicative pretty process tar utf8-string
       ];
       homepage = "http://github.com/vincenthz/cabal-db";
       description = "query tools for the local cabal database";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-debian_4_30_2" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, bifunctors, Cabal
     , containers, data-default, debian, deepseq, Diff, directory
     , exceptions, filepath, hsemail, HUnit, lens, memoize, mtl
     , network-uri, newtype-generics, optparse-applicative, parsec
     , pretty, process, pureMD5, regex-tdfa, set-extra, syb, text, unix
     , Unixutils, utf8-string
     }:
     mkDerivation {
       pname = "cabal-debian";
       version = "4.30.2";
       sha256 = "bca7aae4e601e8bd72cee931cd8081331a7298f07db2260fbb3a5a0103ee4eed";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-wl-pprint base bifunctors Cabal containers data-default debian
         deepseq Diff directory exceptions filepath hsemail HUnit lens
         memoize mtl network-uri newtype-generics optparse-applicative
         parsec pretty process pureMD5 regex-tdfa set-extra syb text unix
         Unixutils utf8-string
       ];
       executableHaskellDepends = [
         base Cabal debian lens mtl pretty Unixutils
       ];
       testHaskellDepends = [
         base Cabal containers debian Diff filepath hsemail HUnit lens
         pretty process text
       ];
       jailbreak = true;
       homepage = "https://github.com/ddssff/cabal-debian";
       description = "Create a Debianization for a Cabal package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-debian_4_31_9" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, bifunctors, Cabal
     , containers, data-default, debian, deepseq, Diff, directory
     , exceptions, filepath, hsemail, HUnit, lens, memoize, mtl
     , network-uri, newtype-generics, optparse-applicative, parsec
     , pretty, process, pureMD5, regex-tdfa, set-extra, syb, text, unix
     , Unixutils, utf8-string
     }:
     mkDerivation {
       pname = "cabal-debian";
       version = "4.31.9";
       sha256 = "e046eb64364023dc0e8c786c06b76e47f845c7be212403937d790ab1716f88e9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-wl-pprint base bifunctors Cabal containers data-default debian
         deepseq Diff directory exceptions filepath hsemail HUnit lens
         memoize mtl network-uri newtype-generics optparse-applicative
         parsec pretty process pureMD5 regex-tdfa set-extra syb text unix
         Unixutils utf8-string
       ];
       executableHaskellDepends = [
         base Cabal debian lens mtl pretty Unixutils
       ];
       testHaskellDepends = [
         base Cabal containers debian Diff directory filepath hsemail HUnit
         lens pretty process text
       ];
       doCheck = false;
       homepage = "https://github.com/ddssff/cabal-debian";
       description = "Create a Debianization for a Cabal package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-debian" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, bifunctors, Cabal
     , containers, data-default, debian, deepseq, Diff, directory
     , exceptions, filepath, hsemail, HUnit, lens, memoize, mtl
     , network-uri, newtype-generics, optparse-applicative, parsec
     , pretty, process, pureMD5, regex-tdfa, set-extra, syb, text, unix
     , Unixutils, utf8-string
     }:
     mkDerivation {
       pname = "cabal-debian";
       version = "4.32.2";
       sha256 = "63f80fc612511bc36857d05483fa67234b729e1847a8cf93985778bc0fb143ad";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-wl-pprint base bifunctors Cabal containers data-default debian
         deepseq Diff directory exceptions filepath hsemail HUnit lens
         memoize mtl network-uri newtype-generics optparse-applicative
         parsec pretty process pureMD5 regex-tdfa set-extra syb text unix
         Unixutils utf8-string
       ];
       executableHaskellDepends = [
         base Cabal debian lens mtl pretty Unixutils
       ];
       testHaskellDepends = [
         base Cabal containers debian Diff directory filepath hsemail HUnit
         lens pretty process text
       ];
       doCheck = false;
       homepage = "https://github.com/ddssff/cabal-debian";
       description = "Create a Debianization for a Cabal package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-dependency-licenses" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, filepath }:
     mkDerivation {
       pname = "cabal-dependency-licenses";
       version = "0.1.1.1";
       sha256 = "8dcedb4b61f137423acd48b857629fb3865d003f0d1bd1d62d1c4850eb2b7785";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers directory filepath
       ];
       homepage = "http://github.com/jaspervdj/cabal-dependency-licenses";
       description = "Compose a list of a project's transitive dependencies with their licenses";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-dev" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, cabal-install, containers
     , directory, filepath, HTTP, mtl, network, pretty, process, setenv
     , tar, template-haskell, transformers, zlib
     }:
     mkDerivation {
       pname = "cabal-dev";
       version = "0.9.2";
       sha256 = "081b3a32ef5b7b993d09774cc8568bd6e74651aae3be1740b5a71d8dec5de28c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal containers directory filepath HTTP mtl
         network pretty process setenv tar template-haskell transformers
         zlib
       ];
       executableToolDepends = [ cabal-install ];
       jailbreak = true;
       homepage = "http://github.com/creswick/cabal-dev";
       description = "Manage sandboxed Haskell build environments";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-dir" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath }:
     mkDerivation {
       pname = "cabal-dir";
       version = "0.1.0.4";
       sha256 = "8f175e700688ebd2cff0277763c6606fdbad9fb587132c1a0b0e05ba1229784d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base Cabal directory filepath ];
       description = "show dist dir of 'cabal copy/install'";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-file-th" = callPackage
    ({ mkDerivation, base, Cabal, directory, template-haskell }:
     mkDerivation {
       pname = "cabal-file-th";
       version = "0.2.3";
       sha256 = "2866e1bea82f5873423411bec9dbded2e4cc878ad7d05108c1339b62cbda5c4d";
       revision = "1";
       editedCabalFile = "50bc6cf5a335a2608ab1e5e59b73f184d3f48d91f49fec189701416ff3e1e37e";
       libraryHaskellDepends = [ base Cabal directory template-haskell ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/nkpart/cabal-file-th";
       description = "Template Haskell expressions for reading fields from a project's cabal file";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-ghc-dynflags" = callPackage
    ({ mkDerivation, base, Cabal, ghc, transformers }:
     mkDerivation {
       pname = "cabal-ghc-dynflags";
       version = "0.1.0.1";
       sha256 = "0e71145e966f450737f1598e20964e9453f64b69f6459a9dfa4a015e7ea57d8e";
       libraryHaskellDepends = [ base Cabal ghc transformers ];
       homepage = "http://github.com/bgamari/cabal-ghc-dynflags";
       description = "Conveniently configure GHC's dynamic flags for use with Cabal projects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-ghci" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, process }:
     mkDerivation {
       pname = "cabal-ghci";
       version = "0.3";
       sha256 = "86235def38b7303a73337f506be9c051b5eca18cfa7160123db88a5cf7beeef4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base Cabal directory filepath ];
       executableHaskellDepends = [
         base Cabal directory filepath process
       ];
       homepage = "http://github.com/atnnn/cabal-ghci";
       description = "Set up ghci with options taken from a .cabal file";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-graphdeps" = callPackage
    ({ mkDerivation, base, containers, directory, options, parsec
     , process, split, temporary
     }:
     mkDerivation {
       pname = "cabal-graphdeps";
       version = "0.1.3";
       sha256 = "2a419ca25fe5f8c346d520ccbce0b43701be976edf736bf3b046287ca6db75c8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory options parsec process split temporary
       ];
       homepage = "https://john-millikin.com/software/cabal-graphdeps/";
       description = "Generate graphs of install-time Cabal dependencies";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-helper_0_6_2_0" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, directory, extra
     , filepath, ghc-prim, mtl, process, template-haskell, temporary
     , transformers, unix, utf8-string
     }:
     mkDerivation {
       pname = "cabal-helper";
       version = "0.6.2.0";
       sha256 = "32adfd7deb1a227aa9b2fa5d9c6768ed395c1acaa9e5e0c5698ede52766daa2e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal directory filepath ghc-prim mtl process transformers
       ];
       executableHaskellDepends = [
         base bytestring Cabal directory filepath ghc-prim process
         template-haskell temporary transformers utf8-string
       ];
       testHaskellDepends = [
         base bytestring Cabal directory extra filepath ghc-prim mtl process
         template-haskell temporary transformers unix utf8-string
       ];
       doCheck = false;
       description = "Simple interface to some of Cabal's configuration state used by ghc-mod";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-helper_0_6_3_0" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, directory, extra
     , filepath, ghc-prim, mtl, process, template-haskell, temporary
     , transformers, unix, utf8-string
     }:
     mkDerivation {
       pname = "cabal-helper";
       version = "0.6.3.0";
       sha256 = "95d62411205c03f87737daaa790e885e73fea875194366a0b2168af494735f04";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal directory filepath ghc-prim mtl process transformers
       ];
       executableHaskellDepends = [
         base bytestring Cabal directory filepath ghc-prim process
         template-haskell temporary transformers utf8-string
       ];
       testHaskellDepends = [
         base bytestring Cabal directory extra filepath ghc-prim mtl process
         template-haskell temporary transformers unix utf8-string
       ];
       doCheck = false;
       description = "Simple interface to some of Cabal's configuration state used by ghc-mod";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-helper" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, cabal-install, directory
     , extra, filepath, ghc-prim, mtl, process, template-haskell
     , temporary, transformers, unix, utf8-string
     }:
     mkDerivation {
       pname = "cabal-helper";
       version = "0.6.3.1";
       sha256 = "c19a9a87c54f6649e0f8cbb3a070244bff9fcc5b9ae783c00c049867fb1a7afe";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal directory filepath ghc-prim mtl process transformers
       ];
       executableHaskellDepends = [
         base bytestring Cabal directory filepath ghc-prim process
         template-haskell temporary transformers utf8-string
       ];
       testHaskellDepends = [
         base bytestring Cabal directory extra filepath ghc-prim mtl process
         template-haskell temporary transformers unix utf8-string
       ];
       testToolDepends = [ cabal-install ];
       doCheck = false;
       description = "Simple interface to some of Cabal's configuration state used by ghc-mod";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "cabal-info" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath
     , optparse-applicative
     }:
     mkDerivation {
       pname = "cabal-info";
       version = "0.1.0.0";
       sha256 = "d7623ce69cdf180f3266cc14fcf4e53f4d5b2c4d9cb359f145a730878096fc6d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal directory filepath optparse-applicative
       ];
       executableHaskellDepends = [
         base Cabal filepath optparse-applicative
       ];
       homepage = "https://github.com/barrucadu/cabal-info";
       description = "Read information from cabal files";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cabal-install_1_18_0_5" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , directory, filepath, HTTP, HUnit, mtl, network, pretty, process
     , QuickCheck, random, stm, test-framework, test-framework-hunit
     , test-framework-quickcheck2, time, unix, zlib
     }:
     mkDerivation {
       pname = "cabal-install";
       version = "1.18.0.5";
       sha256 = "477df8ef73916e8bc23c727280a1700939131a3e2809a057668c883b0b521782";
       revision = "1";
       editedCabalFile = "a59e85ab1916d623dba54d4950b0c1ea60a3eda37a434cad340dd9ff8f640a97";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring Cabal containers directory filepath HTTP mtl
         network pretty process random stm time unix zlib
       ];
       testHaskellDepends = [
         array base bytestring Cabal containers directory filepath HTTP
         HUnit mtl network pretty process QuickCheck stm test-framework
         test-framework-hunit test-framework-quickcheck2 time unix zlib
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "cabal-install_1_18_0_6" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , directory, filepath, HTTP, HUnit, mtl, network, network-uri
     , pretty, process, QuickCheck, random, stm, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time, unix
     , zlib
     }:
     mkDerivation {
       pname = "cabal-install";
       version = "1.18.0.6";
       sha256 = "7bdb50a34264916ba252b8f93d6679878f8b98960f555be7ffe5f5aca5cded75";
       revision = "1";
       editedCabalFile = "6b4d18d5c5262c32bdb94da40c0a2c8c8a0326f3b95ab9f9941267877173bd58";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring Cabal containers directory filepath HTTP mtl
         network network-uri pretty process random stm time unix zlib
       ];
       testHaskellDepends = [
         array base bytestring Cabal containers directory filepath HTTP
         HUnit mtl network pretty process QuickCheck stm test-framework
         test-framework-hunit test-framework-quickcheck2 time unix zlib
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "cabal-install_1_18_0_7" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , directory, filepath, HTTP, HUnit, mtl, network, network-uri
     , pretty, process, QuickCheck, random, stm, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time, unix
     , zlib
     }:
     mkDerivation {
       pname = "cabal-install";
       version = "1.18.0.7";
       sha256 = "b0e0f68cf3116ed237958ee59e84fa84b4d73f3cf8b4ee63887981c07a95cc09";
       revision = "1";
       editedCabalFile = "ce721ec9734b14838faedafc3490d892e514f979224510dfed5d41dba8e649e1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring Cabal containers directory filepath HTTP mtl
         network network-uri pretty process random stm time unix zlib
       ];
       testHaskellDepends = [
         array base bytestring Cabal containers directory filepath HTTP
         HUnit mtl network network-uri pretty process QuickCheck stm
         test-framework test-framework-hunit test-framework-quickcheck2 time
         unix zlib
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "cabal-install_1_18_0_8" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , directory, filepath, HTTP, HUnit, mtl, network, network-uri
     , pretty, process, QuickCheck, random, stm, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time, unix
     , zlib
     }:
     mkDerivation {
       pname = "cabal-install";
       version = "1.18.0.8";
       sha256 = "914fbde460d5769868002b8652568b53e9ec4545ed584a3e19494311fddba7fb";
       revision = "1";
       editedCabalFile = "304c691360d6584972cc302672cb8854e634af0f1727e5f1e700c96ccb2f07e5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring Cabal containers directory filepath HTTP mtl
         network network-uri pretty process random stm time unix zlib
       ];
       testHaskellDepends = [
         array base bytestring Cabal containers directory filepath HTTP
         HUnit mtl network network-uri pretty process QuickCheck stm
         test-framework test-framework-hunit test-framework-quickcheck2 time
         unix zlib
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "cabal-install_1_18_1_0" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , directory, filepath, HTTP, HUnit, mtl, network, network-uri
     , pretty, process, QuickCheck, random, stm, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time, unix
     , zlib
     }:
     mkDerivation {
       pname = "cabal-install";
       version = "1.18.1.0";
       sha256 = "d6abb6fef8204780a41aff2e93dfa297883673507cec557348aebf6b37843ae4";
       revision = "1";
       editedCabalFile = "7f1c53bbf3a3906d0594e217d236e54acc015c67db88301dbadaf5008cb9ac4c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring Cabal containers directory filepath HTTP mtl
         network network-uri pretty process random stm time unix zlib
       ];
       testHaskellDepends = [
         array base bytestring Cabal containers directory filepath HTTP
         HUnit mtl network network-uri pretty process QuickCheck stm
         test-framework test-framework-hunit test-framework-quickcheck2 time
         unix zlib
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "cabal-install_1_22_6_0" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , directory, extensible-exceptions, filepath, HTTP, HUnit, mtl
     , network, network-uri, pretty, process, QuickCheck, random
     , regex-posix, stm, test-framework, test-framework-hunit
     , test-framework-quickcheck2, time, unix, zlib
     }:
     mkDerivation {
       pname = "cabal-install";
       version = "1.22.6.0";
       sha256 = "9d239e385696a7faa49f068aea451882baec6a7df26fbddbd08271c9053cb0b4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring Cabal containers directory filepath HTTP mtl
         network network-uri pretty process random stm time unix zlib
       ];
       testHaskellDepends = [
         array base bytestring Cabal containers directory
         extensible-exceptions filepath HTTP HUnit mtl network network-uri
         pretty process QuickCheck regex-posix stm test-framework
         test-framework-hunit test-framework-quickcheck2 time unix zlib
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "cabal-install_1_22_7_0" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , directory, extensible-exceptions, filepath, HTTP, HUnit, mtl
     , network, network-uri, pretty, process, QuickCheck, random
     , regex-posix, stm, test-framework, test-framework-hunit
     , test-framework-quickcheck2, time, unix, zlib
     }:
     mkDerivation {
       pname = "cabal-install";
       version = "1.22.7.0";
       sha256 = "b30fd14f20fdd11b028cba68fefeed7eeadcacf919e7c29bc4d7289a656d19f3";
       revision = "1";
       editedCabalFile = "9abc9a039f3abe8f7b3be29c11974d2371393df4069285caf7c4385956c30032";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring Cabal containers directory filepath HTTP mtl
         network network-uri pretty process random stm time unix zlib
       ];
       testHaskellDepends = [
         array base bytestring Cabal containers directory
         extensible-exceptions filepath HTTP HUnit mtl network network-uri
         pretty process QuickCheck regex-posix stm test-framework
         test-framework-hunit test-framework-quickcheck2 time unix zlib
       ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "cabal-install" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , directory, extensible-exceptions, filepath, HTTP, HUnit, mtl
     , network, network-uri, pretty, process, QuickCheck, random
     , regex-posix, stm, test-framework, test-framework-hunit
     , test-framework-quickcheck2, time, unix, zlib
     }:
     mkDerivation {
       pname = "cabal-install";
       version = "1.22.8.0";
       sha256 = "58cf197ca0751eac1e242202edc4b4a1dfe89e3b191a0eb57cb62b95d27b3b21";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring Cabal containers directory filepath HTTP mtl
         network network-uri pretty process random stm time unix zlib
       ];
       testHaskellDepends = [
         array base bytestring Cabal containers directory
         extensible-exceptions filepath HTTP HUnit mtl network network-uri
         pretty process QuickCheck regex-posix stm test-framework
         test-framework-hunit test-framework-quickcheck2 time unix zlib
       ];
       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;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "cabal-install-bundle" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , directory, filepath, old-time, pretty, process, time, unix, zlib
     }:
     mkDerivation {
       pname = "cabal-install-bundle";
       version = "1.18.0.2.1";
       sha256 = "584783f74c4cc703cf6b50f9263db4b0075fbca33a22b576c42da2616f854f3f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring Cabal containers directory filepath old-time
         pretty process time unix
       ];
       executableSystemDepends = [ zlib ];
       description = "The (bundled) command-line interface for Cabal and Hackage";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) zlib;};

  "cabal-install-ghc72" = callPackage
    ({ mkDerivation, array, base, Cabal, containers, directory
     , filepath, HTTP, network, old-time, pretty, process, random, time
     , unix, zlib
     }:
     mkDerivation {
       pname = "cabal-install-ghc72";
       version = "0.10.4";
       sha256 = "afd6439fc675f76c4a7922f3d5382f3d1a9e7494a9b9c7edc5f0ff55783afeb9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base Cabal containers directory filepath HTTP network
         old-time pretty process random time unix zlib
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/cabal/";
       description = "Temporary version of cabal-install for ghc-7.2";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-install-ghc74" = callPackage
    ({ mkDerivation, array, base, Cabal, containers, directory
     , filepath, HTTP, network, old-time, pretty, process, random, time
     , unix, zlib
     }:
     mkDerivation {
       pname = "cabal-install-ghc74";
       version = "0.10.4";
       sha256 = "adbeb4e70ed854c7e18ef41d766fc5130f641e483b82acff8e6a6c0a012c53eb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base Cabal containers directory filepath HTTP network
         old-time pretty process random time unix zlib
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/cabal/";
       description = "Temporary version of cabal-install for ghc-7.4";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-lenses" = callPackage
    ({ mkDerivation, base, Cabal, either, lens, strict, system-fileio
     , system-filepath, text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "cabal-lenses";
       version = "0.4.7";
       sha256 = "391c03e92137fde75bfc2fe7d6f3369c53a1a683e8da6d3cf14d901e7a1b58a2";
       libraryHaskellDepends = [
         base Cabal either lens strict system-fileio system-filepath text
         transformers unordered-containers
       ];
       description = "Lenses and traversals for the Cabal library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-macosx" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, fgl, filepath
     , hscolour, HUnit, parsec, process, temporary, test-framework
     , test-framework-hunit, text
     }:
     mkDerivation {
       pname = "cabal-macosx";
       version = "0.2.3.4";
       sha256 = "4c3ae50fdafa3283055624156016834f077bdf5b8237441497e7ccea69308570";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers directory fgl filepath hscolour parsec
         process text
       ];
       executableHaskellDepends = [
         base Cabal containers directory fgl filepath parsec process text
       ];
       testHaskellDepends = [
         base Cabal containers directory filepath HUnit process temporary
         test-framework test-framework-hunit text
       ];
       homepage = "http://github.com/danfran/cabal-macosx";
       description = "Cabal support for creating Mac OSX application bundles";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-meta" = callPackage
    ({ mkDerivation, base, hspec, shelly, system-fileio
     , system-filepath, text, unix
     }:
     mkDerivation {
       pname = "cabal-meta";
       version = "0.4.1.3";
       sha256 = "a6fdda58755c31683e88ffbc4eeed65f49698a8d7b4769bed6c9a237c5b66892";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base shelly system-filepath text ];
       executableHaskellDepends = [
         base shelly system-fileio system-filepath text
       ];
       testHaskellDepends = [
         base hspec shelly system-filepath text unix
       ];
       homepage = "http://www.yesodweb.com/";
       description = "build multiple packages at once";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-mon" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, process
     , simple-get-opt, vty
     }:
     mkDerivation {
       pname = "cabal-mon";
       version = "1.0.1";
       sha256 = "602376f6e45c41ea6d72935c0833ce62dcb5eb789edfe56c72dee3368eabcff2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath process simple-get-opt vty
       ];
       description = "A monitor for cabal builds";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cabal-nirvana" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, HTTP
     , process, tar
     }:
     mkDerivation {
       pname = "cabal-nirvana";
       version = "0.2.2.1";
       sha256 = "938e5e0269f61181be16b9c7ec9cbedad954b4174cac1493a833cd5031859cb2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory HTTP process tar
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/cabal-nirvana";
       description = "Avoid Cabal dependency hell by constraining to known good versions. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-progdeps" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath }:
     mkDerivation {
       pname = "cabal-progdeps";
       version = "1.0";
       sha256 = "2eee8fb8cba8e30ecfb1c85262f927669181dbfe9c25d63094893487ea85e23b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base Cabal directory filepath ];
       jailbreak = true;
       description = "Show dependencies of program being built in current directory";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-query" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, derive, ghc, MissingH
     , mtl, tar, template-haskell, uniplate
     }:
     mkDerivation {
       pname = "cabal-query";
       version = "0.1";
       sha256 = "8a9baadce9cfd1196462e7c47ac2bdd23fbe2affaa8e77e842da46fe2c229648";
       libraryHaskellDepends = [
         base bytestring Cabal derive ghc MissingH mtl tar template-haskell
         uniplate
       ];
       jailbreak = true;
       homepage = "http://github.com/explicitcall/cabal-query";
       description = "Helpers for quering .cabal files or hackageDB's 00-index.tar";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-rpm_0_9_4" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, old-locale
     , process, time, unix
     }:
     mkDerivation {
       pname = "cabal-rpm";
       version = "0.9.4";
       sha256 = "446935cc060dd3485d5bd0e07f3d720394b0a71d409a9ec79cbdf5ffb1320596";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal directory filepath old-locale process time unix
       ];
       homepage = "https://github.com/juhp/cabal-rpm";
       description = "RPM packaging tool for Haskell Cabal-based packages";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-rpm_0_9_5" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, old-locale
     , process, time, unix
     }:
     mkDerivation {
       pname = "cabal-rpm";
       version = "0.9.5";
       sha256 = "c3513a1ad816ae3c763619ad2f8c5a506d5268ffe07c9a34d3d3a916fc4d5228";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal directory filepath old-locale process time unix
       ];
       homepage = "https://github.com/juhp/cabal-rpm";
       description = "RPM packaging tool for Haskell Cabal-based packages";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-rpm_0_9_5_1" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, process, time
     , unix
     }:
     mkDerivation {
       pname = "cabal-rpm";
       version = "0.9.5.1";
       sha256 = "0202c75b238e139fce8089d677c9eda53e3d47e6ed486050f2b6b404443e1543";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal directory filepath process time unix
       ];
       homepage = "https://github.com/juhp/cabal-rpm";
       description = "RPM packaging tool for Haskell Cabal-based packages";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-rpm_0_9_6" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, process, time
     , unix
     }:
     mkDerivation {
       pname = "cabal-rpm";
       version = "0.9.6";
       sha256 = "e501a7b3a203be2e069e26337e6bbdd0993ffe6d9e75a626089b2637393d2f1e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal directory filepath process time unix
       ];
       homepage = "https://github.com/juhp/cabal-rpm";
       description = "RPM packaging tool for Haskell Cabal-based packages";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-rpm_0_9_7" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, process, time
     , unix
     }:
     mkDerivation {
       pname = "cabal-rpm";
       version = "0.9.7";
       sha256 = "b927e84b5a23edffa8053c3c5e5a5191c434dbcbbe7e4551f8dc840d3b17bc74";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal directory filepath process time unix
       ];
       homepage = "https://github.com/juhp/cabal-rpm";
       description = "RPM packaging tool for Haskell Cabal-based packages";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-rpm_0_9_8" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, process, time
     , unix
     }:
     mkDerivation {
       pname = "cabal-rpm";
       version = "0.9.8";
       sha256 = "dc004170b056dd899e2f4e5ebf725a6532aa21989e89465114e248674124a590";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal directory filepath process time unix
       ];
       homepage = "https://github.com/juhp/cabal-rpm";
       description = "RPM packaging tool for Haskell Cabal-based packages";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-rpm" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, process, time
     , unix
     }:
     mkDerivation {
       pname = "cabal-rpm";
       version = "0.9.9";
       sha256 = "2f5c487be9395fc34eba40efa73ee95d6419a84a62dc3dd02f4155778a953a6f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal directory filepath process time unix
       ];
       homepage = "https://github.com/juhp/cabal-rpm";
       description = "RPM packaging tool for Haskell Cabal-based packages";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "cabal-scripts" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "cabal-scripts";
       version = "0.1.1";
       sha256 = "445304a8f8efcd60bfe5ab4d60bfe833962a35f40d1dc6a9694db30d93e84faa";
       libraryHaskellDepends = [ base ];
       doHaddock = false;
       description = "Shell scripts for support of Cabal maintenance";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-setup" = callPackage
    ({ mkDerivation, base, Cabal }:
     mkDerivation {
       pname = "cabal-setup";
       version = "1.2.1";
       sha256 = "7589e307e85c1dac32ff9c33e089203aaf310230124e251ab2b2bd3a7bb4344c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base Cabal ];
       homepage = "http://www.haskell.org/cabal/";
       description = "The user interface for building and installing Cabal packages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-sign" = callPackage
    ({ mkDerivation, base, bytestring, cereal, directory, filepath
     , process, tar, zlib
     }:
     mkDerivation {
       pname = "cabal-sign";
       version = "0.4.1.0";
       sha256 = "13db5029af43356ea6046ab1ecd12ea6d9dfff5daa3793e0d3feaa0a26c91ead";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cereal directory filepath process tar zlib
       ];
       description = "Sign and verify Cabal packages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-sort" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, directory
     , explicit-exception, fgl, filepath, process, transformers
     , utility-ht
     }:
     mkDerivation {
       pname = "cabal-sort";
       version = "0.0.5.2";
       sha256 = "9a12f7db6ec6c34ba80aa903ab5dca4be52c76799c7b14ac8d18c181d194a60e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal containers directory explicit-exception fgl
         filepath process transformers utility-ht
       ];
       description = "Topologically sort cabal packages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-src_0_2_3" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , containers, directory, filepath, http-conduit, http-types
     , network, process, resourcet, shelly, system-fileio
     , system-filepath, tar, text, transformers
     }:
     mkDerivation {
       pname = "cabal-src";
       version = "0.2.3";
       sha256 = "40e9c32b9f93d547b6cac1f3cf1506de1eca14d97abf96b7e0294e5bb80c5061";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring conduit conduit-extra containers directory filepath
         http-conduit http-types network process resourcet shelly
         system-fileio system-filepath tar text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/yesodweb/cabal-src";
       description = "Alternative install procedure to avoid the diamond dependency issue";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-src_0_2_5" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, classy-prelude-conduit
     , conduit, conduit-extra, containers, directory, filepath
     , http-client, http-client-tls, http-conduit, http-types, network
     , process, resourcet, shelly, system-fileio, system-filepath, tar
     , temporary, text, transformers
     }:
     mkDerivation {
       pname = "cabal-src";
       version = "0.2.5";
       sha256 = "e70ff9b6acd1ca2cfccac40fb47badd2b43f42c0466ea8eaa5a0c41040b6dd1e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal classy-prelude-conduit conduit conduit-extra
         containers directory filepath http-client http-client-tls
         http-conduit http-types network process resourcet shelly
         system-fileio system-filepath tar temporary text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/yesodweb/cabal-src";
       description = "Alternative install procedure to avoid the diamond dependency issue";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-src_0_2_5_1" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, classy-prelude-conduit
     , conduit, conduit-extra, containers, directory, filepath
     , http-client, http-client-tls, http-conduit, http-types, network
     , process, resourcet, shelly, streaming-commons, system-fileio
     , system-filepath, tar, temporary, text, transformers
     }:
     mkDerivation {
       pname = "cabal-src";
       version = "0.2.5.1";
       sha256 = "3fcd304a651b8a499595a32b0c2eabbccb36055a8a1cf0ea195811a89ea6a57a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal classy-prelude-conduit conduit conduit-extra
         containers directory filepath http-client http-client-tls
         http-conduit http-types network process resourcet shelly
         streaming-commons system-fileio system-filepath tar temporary text
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/yesodweb/cabal-src";
       description = "Alternative install procedure to avoid the diamond dependency issue";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-src_0_3_0" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , containers, directory, filepath, http-conduit, http-types
     , network, process, resourcet, shelly, system-fileio
     , system-filepath, tar, text, transformers
     }:
     mkDerivation {
       pname = "cabal-src";
       version = "0.3.0";
       sha256 = "493c7037b94c382350412f6909dd6b671c53d50f5165ce94839d254fe1590ef5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring conduit conduit-extra containers directory filepath
         http-conduit http-types network process resourcet shelly
         system-fileio system-filepath tar text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/yesodweb/cabal-src";
       description = "Alternative install procedure to avoid the diamond dependency issue";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-src" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , containers, directory, filepath, http-conduit, http-types
     , network, process, resourcet, shelly, system-fileio
     , system-filepath, tar, text, transformers
     }:
     mkDerivation {
       pname = "cabal-src";
       version = "0.3.0.1";
       sha256 = "80effd26be00526fa876b6ab9c64e1b7f3e576f9064175d15ff689a7a0fa8a4c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring conduit conduit-extra containers directory filepath
         http-conduit http-types network process resourcet shelly
         system-fileio system-filepath tar text transformers
       ];
       homepage = "https://github.com/yesodweb/cabal-src";
       description = "Alternative install procedure to avoid the diamond dependency issue";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-test" = callPackage
    ({ mkDerivation, base, Cabal, filepath, ghc, pqc, QuickCheck }:
     mkDerivation {
       pname = "cabal-test";
       version = "0.1";
       sha256 = "5d19f8d90cf9c758f385c19e8effa66aa650a9ab6be7a2282e7478f90f1e0885";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal filepath ghc pqc QuickCheck
       ];
       description = "Automated test tool for cabal projects";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-test-bin" = callPackage
    ({ mkDerivation, base, directory, filepath, hspec, process
     , regex-posix, unix
     }:
     mkDerivation {
       pname = "cabal-test-bin";
       version = "0.1.5";
       sha256 = "07551e89dae1704a30144dda2f28dd4d0fcababe1a48cd2b31096e93d3835ae2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory filepath unix ];
       executableHaskellDepends = [ base directory filepath unix ];
       testHaskellDepends = [ base hspec process regex-posix ];
       description = "A program for finding temporary build file during cabal-test";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-test-compat" = callPackage
    ({ mkDerivation, base, Cabal, QuickCheck }:
     mkDerivation {
       pname = "cabal-test-compat";
       version = "0.2.0.0";
       sha256 = "b8654a0c916ef6340d6491380cb51e989ff804225d721598523ad9a07ef69d96";
       libraryHaskellDepends = [ base Cabal QuickCheck ];
       homepage = "http://twitter.com/khibino/";
       description = "Compatibility interface of cabal test-suite";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-test-quickcheck_0_1_4" = callPackage
    ({ mkDerivation, base, Cabal, QuickCheck }:
     mkDerivation {
       pname = "cabal-test-quickcheck";
       version = "0.1.4";
       sha256 = "319f6d7d453e956f98cc637bc6539e8fd1207f21a2749418f451cad20da05704";
       libraryHaskellDepends = [ base Cabal QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/zmthy/cabal-test-quickcheck";
       description = "QuickCheck for Cabal";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal-test-quickcheck" = callPackage
    ({ mkDerivation, base, Cabal, QuickCheck }:
     mkDerivation {
       pname = "cabal-test-quickcheck";
       version = "0.1.6";
       sha256 = "71c52f6439610ce48f67c86bd22a6f23808dfb21384c97135dae7538c7dfce65";
       libraryHaskellDepends = [ base Cabal QuickCheck ];
       homepage = "https://github.com/zmthy/cabal-test-quickcheck";
       description = "QuickCheck for Cabal";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cabal-uninstall" = callPackage
    ({ mkDerivation, base, directory, filepath, mtl, process }:
     mkDerivation {
       pname = "cabal-uninstall";
       version = "0.1.6";
       sha256 = "22c6ad9465150be1575877365d29f557e181013f44c7fadb615b10803e62417b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath mtl process ];
       description = "Uninstall cabal packages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal-upload" = callPackage
    ({ mkDerivation, base, filepath, HTTP, network }:
     mkDerivation {
       pname = "cabal-upload";
       version = "0.4";
       sha256 = "7f81f4779c99591251229d107dfcfa83e55a0fcb666d5288b56f69d01b3c6716";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base filepath HTTP network ];
       jailbreak = true;
       description = "Command-line tool for uploading packages to Hackage";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal2arch" = callPackage
    ({ mkDerivation, archlinux, base, bytestring, Cabal, cmdargs
     , containers, directory, filepath, mtl, pretty, process
     }:
     mkDerivation {
       pname = "cabal2arch";
       version = "1.1";
       sha256 = "1fb18ba9ed506788f1b6c2f977ee6aead0b7edb9cd2bdae2cd210949d307616a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         archlinux base bytestring Cabal cmdargs containers directory
         filepath mtl pretty process
       ];
       homepage = "http://github.com/archhaskell/";
       description = "Create Arch Linux packages from Cabal packages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal2doap" = callPackage
    ({ mkDerivation, base, Cabal, hsemail, hxt, parsec, process }:
     mkDerivation {
       pname = "cabal2doap";
       version = "0.2";
       sha256 = "542548fb6c5852bb8494d645352f54a31d4a3751dca9fd544a13e15f13860cdb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal hsemail hxt parsec process
       ];
       jailbreak = true;
       homepage = "http://gregheartsfield.com/cabal2doap/";
       description = "Cabal to Description-of-a-Project (DOAP)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabal2ebuild" = callPackage
    ({ mkDerivation, base, Cabal, curl, directory, filepath }:
     mkDerivation {
       pname = "cabal2ebuild";
       version = "0.0.15.9";
       sha256 = "54288f0813b2a83fffe7664574e00556f7bf96c195b2df67652fcf5fa128d785";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base Cabal directory filepath ];
       executableHaskellDepends = [ base curl directory ];
       homepage = "yet";
       description = "make gentoo's .ebuild file from .cabal file";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal2ghci" = callPackage
    ({ mkDerivation, base, Cabal, cmdargs, stylish-haskell
     , system-fileio, system-filepath, text, unordered-containers, yaml
     }:
     mkDerivation {
       pname = "cabal2ghci";
       version = "0.0.1.1";
       sha256 = "4fe78699cf2a022552a2b7ce6f22e96fbbf1499c7d776cd1320a1d5744bee3b9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal cmdargs stylish-haskell system-fileio system-filepath
         text unordered-containers yaml
       ];
       description = "A tool to generate .ghci file from .cabal";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabal2nix" = callPackage
    ({ mkDerivation, base, Cabal, containers, deepseq, directory
     , doctest, filepath, hackage-db, mtl, pretty, process, regex-posix
     , transformers
     }:
     mkDerivation {
       pname = "cabal2nix";
       version = "1.73";
       sha256 = "3bf693e683847ca4fc5326b842b015989cc2f90c0be85870aa1ca932516653db";
       revision = "5";
       editedCabalFile = "54866b8081ddfc72761c1f38cc96df6782682058cd09b465300562910f57e2ea";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers deepseq directory filepath hackage-db mtl
         pretty process regex-posix transformers
       ];
       testHaskellDepends = [ base doctest ];
       jailbreak = true;
       homepage = "http://github.com/NixOS/cabal2nix";
       description = "Convert Cabal files into Nix build instructions";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "cabal2spec" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, directory, filepath
     , haskell98, old-locale, process, tar, time, unix, Unixutils, zlib
     }:
     mkDerivation {
       pname = "cabal2spec";
       version = "1.0";
       sha256 = "52db417cd69007f01eead1fc78f517412b8c3aadb18bedf01aee588324cfc823";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal directory filepath haskell98 old-locale
         process tar time unix Unixutils zlib
       ];
       homepage = "https://fedorahosted.org/cabal2spec/";
       description = "Generates RPM Spec files from cabal files";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabalQuery" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, MissingH
     , pretty
     }:
     mkDerivation {
       pname = "cabalQuery";
       version = "0.1.0.1";
       sha256 = "6d81b9e7eaf8d75c167e4f63de0dc54c46ccdcebe2d3a156bde68f80a0d3bca4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base Cabal pretty ];
       executableHaskellDepends = [
         base Cabal containers directory MissingH
       ];
       jailbreak = true;
       homepage = "http://github.com/creswick/cabal-query";
       description = "A simple tool to query cabal files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabalg" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, process }:
     mkDerivation {
       pname = "cabalg";
       version = "0.2.9";
       sha256 = "7716a76cf1078e0435d00f5bf10cbb5faf390e80b182596de19e8d1756a27909";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory filepath process ];
       executableHaskellDepends = [ base directory filepath process ];
       testHaskellDepends = [ base directory doctest filepath process ];
       description = "alias for cabal install from given git repo";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cabalgraph" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, directory
     , filepath, pretty, process
     }:
     mkDerivation {
       pname = "cabalgraph";
       version = "0.1";
       sha256 = "7ecf056138a31a7cdc39198895dabd264f0e1a0ab0c2ef9ab92ac02f840dfccd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal containers directory filepath pretty process
       ];
       homepage = "http://code.haskell.org/~dons/code/cabalgraph";
       description = "Generate pretty graphs of module trees from cabal files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabalmdvrpm" = callPackage
    ({ mkDerivation, base, Cabal, cabalrpmdeps, haskell98 }:
     mkDerivation {
       pname = "cabalmdvrpm";
       version = "0.0.1";
       sha256 = "860125c65ae2ec7a1c07fc07d9488aa1f03cb05d3723d96282787217c956f35d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base Cabal cabalrpmdeps haskell98 ];
       executableHaskellDepends = [ base Cabal cabalrpmdeps haskell98 ];
       homepage = "http://nanardon.zarb.org/darcsweb/darcsweb.cgi?r=haskell-cabalmdvrpm;a=shortlog;topi=0";
       description = "Create mandriva rpm from cabal package";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabalrpmdeps" = callPackage
    ({ mkDerivation, base, Cabal, filepath, haskell98 }:
     mkDerivation {
       pname = "cabalrpmdeps";
       version = "0.0.4";
       sha256 = "21cfdb0d7e1c85d074eee5c59c5e2baacdb03c9a6cbb16be9d69bfb42e5f7fa6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base Cabal filepath haskell98 ];
       executableHaskellDepends = [ base Cabal filepath haskell98 ];
       homepage = "http://nanardon.zarb.org/darcsweb/darcsweb.cgi?r=haskell-CabalRpmDeps;a=summary";
       description = "Autogenerate rpm dependencies from cabal files";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cabalvchk" = callPackage
    ({ mkDerivation, base, Cabal }:
     mkDerivation {
       pname = "cabalvchk";
       version = "0.3";
       sha256 = "02478381b2a90078622cb7b9909bfbd64e7c7d9b587e7f1d4e532ec8c9f722aa";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base Cabal ];
       description = "Verify installed package version against user-specified constraints";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabin" = callPackage
    ({ mkDerivation, base, binary, bytestring, directory, filepath
     , optparse-applicative, process, unix
     }:
     mkDerivation {
       pname = "cabin";
       version = "0.1.0.3";
       sha256 = "b357aeb338c5d93fcee4fbf4bd8eb29d4a62bcf0fc754301b65496ac9fe94172";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring directory filepath optparse-applicative
         process unix
       ];
       description = "Cabal binary sandboxes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cabocha" = callPackage
    ({ mkDerivation, base, bytestring, cabocha, text, text-format }:
     mkDerivation {
       pname = "cabocha";
       version = "0.1.0.0";
       sha256 = "8e67cef4ae2c82a39ee13f424e1d2ca277cc980678f852dd0c2b194fdb80386a";
       libraryHaskellDepends = [ base bytestring text ];
       librarySystemDepends = [ cabocha ];
       testHaskellDepends = [ base text-format ];
       homepage = "http://github.com/pecorarista/hscabocha";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {cabocha = null;};

  "cached-io" = callPackage
    ({ mkDerivation, base, stm, time }:
     mkDerivation {
       pname = "cached-io";
       version = "0.1.1.0";
       sha256 = "b43e7b329aff4a1f96daff221b6e68b7124d35cef3331034b452d794c8b03546";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base stm time ];
       executableHaskellDepends = [ base stm time ];
       jailbreak = true;
       description = "A simple library to cache a single IO action with timeout";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "cached-traversable" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , filepath, mtl
     }:
     mkDerivation {
       pname = "cached-traversable";
       version = "0.1.0.1";
       sha256 = "663752f2d34c05643cc2c0ec91fdb31d3a1953760796f351f43802dfb0911416";
       libraryHaskellDepends = [
         base binary bytestring containers directory filepath mtl
       ];
       description = "Transparent, persistent caching of lazy, traversable structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cacophony" = callPackage
    ({ mkDerivation, base, bytestring, cryptonite, directory, doctest
     , filepath, hlint, lens, memory, mtl, QuickCheck, tasty
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "cacophony";
       version = "0.4.0";
       sha256 = "91f7e24e30baec41d88b6ddd25a594ec913cb6a034f4906c379e22b72697e608";
       libraryHaskellDepends = [
         base bytestring cryptonite lens memory mtl
       ];
       testHaskellDepends = [
         base bytestring directory doctest filepath hlint mtl QuickCheck
         tasty tasty-quickcheck
       ];
       doCheck = false;
       homepage = "https://github.com/centromere/cacophony";
       description = "A library implementing the Noise protocol";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "caf" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "caf";
       version = "0.0.3";
       sha256 = "481d0924cbb3674618391a0bbfe2d10781aa1a0df5942ee924fa71379d1b34fb";
       libraryHaskellDepends = [ base ];
       homepage = "http://sites.google.com/site/cafwiki/";
       description = "A library of Concurrency Abstractions using Futures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cafeteria-prelude" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "cafeteria-prelude";
       version = "0.1.0.0";
       sha256 = "345760ecd93d1e63939ef9fcd27214c01163b2f71d3a77fc46e9b18f5ad5cac7";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/Scott-Fleischman/cafeteria-prelude";
       description = "Prelude subsets—take only what you want!";
       license = stdenv.lib.licenses.mit;
     }) {};

  "caffegraph" = callPackage
    ({ mkDerivation, base, bytestring, containers, fgl, filepath
     , graphviz, language-lua, lens, mtl, optparse-applicative, process
     , protocol-buffers, protocol-buffers-descriptor, template-haskell
     , temporary, text
     }:
     mkDerivation {
       pname = "caffegraph";
       version = "0.1.0.2";
       sha256 = "e2d9c0593aef2ad38777a28be21d88dc9e40f5044570fcec667e2ef5fc11e4fb";
       libraryHaskellDepends = [
         base bytestring containers fgl filepath graphviz language-lua lens
         mtl optparse-applicative process protocol-buffers
         protocol-buffers-descriptor template-haskell temporary text
       ];
       jailbreak = true;
       homepage = "https://github.com/ajtulloch/caffegraph/";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cairo_0_13_0_5" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, gtk2hs-buildtools
     , mtl, text, utf8-string
     }:
     mkDerivation {
       pname = "cairo";
       version = "0.13.0.5";
       sha256 = "191cd974a99b7abb901219edddbf59982e235e69552f8f4f97aa7b96dd87662a";
       libraryHaskellDepends = [
         array base bytestring mtl text utf8-string
       ];
       libraryPkgconfigDepends = [ cairo ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Cairo library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) cairo;};

  "cairo_0_13_0_6" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, gtk2hs-buildtools
     , mtl, text, utf8-string
     }:
     mkDerivation {
       pname = "cairo";
       version = "0.13.0.6";
       sha256 = "5d353c734d1c60822e684a0a1610a59384a369ab41ba76f9dfaf8d9807999c73";
       libraryHaskellDepends = [
         array base bytestring mtl text utf8-string
       ];
       libraryPkgconfigDepends = [ cairo ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Cairo library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) cairo;};

  "cairo_0_13_1_0" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, gtk2hs-buildtools
     , mtl, text, utf8-string
     }:
     mkDerivation {
       pname = "cairo";
       version = "0.13.1.0";
       sha256 = "6b8e3fca37104022c53442c62bcb41c18d3e2fed4df372c1de56c41f3f7d276e";
       libraryHaskellDepends = [
         array base bytestring mtl text utf8-string
       ];
       libraryPkgconfigDepends = [ cairo ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Cairo library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) cairo;};

  "cairo" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, gtk2hs-buildtools
     , mtl, text, utf8-string
     }:
     mkDerivation {
       pname = "cairo";
       version = "0.13.1.1";
       sha256 = "58ae22451e7812a88531eaf91ae1250c277f48d0a88d1cae2438bd76f79e89f6";
       libraryHaskellDepends = [
         array base bytestring mtl text utf8-string
       ];
       libraryPkgconfigDepends = [ cairo ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Cairo library";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) cairo;};

  "cairo-appbase" = callPackage
    ({ mkDerivation, base, cairo, glib, gtk }:
     mkDerivation {
       pname = "cairo-appbase";
       version = "0.4";
       sha256 = "82ffb1ad2cbe61e5d95991b223f66d1800db8370ed946f1af13ab8838a902185";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base cairo glib gtk ];
       description = "A template for building new GUI applications using GTK and Cairo";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cake" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, cmdargs
     , containers, derive, directory, filepath, mtl, parsek, process
     , pureMD5, regex-tdfa, split
     }:
     mkDerivation {
       pname = "cake";
       version = "1.1.0.1";
       sha256 = "6a05ffe381b39db71efaba1b3e84c7483fdf74d5ec6b796f050fe087c6fb1a99";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers derive directory filepath mtl
         parsek process pureMD5 split
       ];
       executableHaskellDepends = [
         array base cmdargs directory filepath process regex-tdfa
       ];
       description = "A build-system library and driver";
       license = "GPL";
     }) {};

  "cake3" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, deepseq
     , directory, filepath, haskell-src-meta, language-javascript
     , mime-types, monadloc, mtl, optparse-applicative, parsec, process
     , syb, system-filepath, template-haskell, text, text-format
     }:
     mkDerivation {
       pname = "cake3";
       version = "0.6.0";
       sha256 = "b8419752bc8fe97ae83193137d423261cd87d3adf403adfad615ee68312e044c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring containers deepseq directory filepath
         haskell-src-meta language-javascript mime-types monadloc mtl parsec
         process syb system-filepath template-haskell text text-format
       ];
       executableHaskellDepends = [
         attoparsec base bytestring containers directory filepath
         haskell-src-meta language-javascript mime-types monadloc mtl
         optparse-applicative parsec process syb template-haskell text
       ];
       jailbreak = true;
       homepage = "https://github.com/grwlf/cake3";
       description = "Third cake the Makefile EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cakyrespa" = callPackage
    ({ mkDerivation, base, GLUT, gluturtle, lojbanParser, yjsvg
     , yjtools
     }:
     mkDerivation {
       pname = "cakyrespa";
       version = "0.0.29";
       sha256 = "ddbb90b43b56057a6f12bc51588f0ee84c7081daaa8c4e8285e2fe7fe7bb5ea8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base GLUT gluturtle lojbanParser yjsvg yjtools
       ];
       homepage = "http://homepage3.nifty.com/salamander/myblog/cakyrespa.html";
       description = "run turtle like LOGO with lojban";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cal3d" = callPackage
    ({ mkDerivation, base, cal3d }:
     mkDerivation {
       pname = "cal3d";
       version = "0.1";
       sha256 = "060f26197f1969ba7d2e7b0a3c72767ae932fdc3d3b929b4dde92077bf5497ac";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ cal3d ];
       homepage = "http://haskell.org/haskellwiki/Cal3d_animation";
       description = "Haskell binding to the Cal3D animation library";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {cal3d = null;};

  "cal3d-examples" = callPackage
    ({ mkDerivation, base, cal3d, cal3d-opengl, OpenGL, SDL }:
     mkDerivation {
       pname = "cal3d-examples";
       version = "0.1";
       sha256 = "8057aeafe7279d4740cdc3964149de4822d7a18a3f6a4d7a33debfc05bd846ba";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base cal3d cal3d-opengl OpenGL SDL ];
       jailbreak = true;
       homepage = "http://haskell.org/haskellwiki/Cal3d_animation";
       description = "Examples for the Cal3d animation library";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cal3d-opengl" = callPackage
    ({ mkDerivation, base, cal3d, OpenGL }:
     mkDerivation {
       pname = "cal3d-opengl";
       version = "0.1";
       sha256 = "c269646464707fe10e53722053588cf703fe777b738b7dbcb008f056380fca0a";
       libraryHaskellDepends = [ base cal3d OpenGL ];
       jailbreak = true;
       homepage = "http://haskell.org/haskellwiki/Cal3d_animation";
       description = "OpenGL rendering for the Cal3D animation library";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "calc" = callPackage
    ({ mkDerivation, array, base, harpy, haskell98, mtl }:
     mkDerivation {
       pname = "calc";
       version = "0.1";
       sha256 = "bc63933d2a8208986422e7caa3b49d098bc472391766b1b29dc8b82664c779c0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base harpy haskell98 mtl ];
       description = "A small compiler for arithmetic expressions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "calculator" = callPackage
    ({ mkDerivation, base, containers, gtk, haskeline, hmatrix, parsec
     , plot-gtk-ui, QuickCheck, transformers
     }:
     mkDerivation {
       pname = "calculator";
       version = "0.4.1.1";
       sha256 = "9601f78d63c42c7382990d33ca475a947f8d8317d6dbf47819345693fdb4442d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers gtk haskeline hmatrix parsec plot-gtk-ui
         transformers
       ];
       testHaskellDepends = [
         base containers gtk parsec plot-gtk-ui QuickCheck
       ];
       homepage = "https://github.com/sumitsahrawat/calculator";
       description = "A calculator repl, with variables, functions & Mathematica like dynamic plots";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "caldims" = callPackage
    ({ mkDerivation, base, containers, directory, haskell98, mtl
     , parsec, readline
     }:
     mkDerivation {
       pname = "caldims";
       version = "0.1.0";
       sha256 = "005e2f1be21fb7eede9defca7aa59284d50952908efb7cc206bc22a8e0eb8f56";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory haskell98 mtl parsec readline
       ];
       executableHaskellDepends = [
         base containers directory haskell98 mtl parsec readline
       ];
       description = "Calculation tool and library supporting units";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "caledon" = callPackage
    ({ mkDerivation, base, containers, cpphs, lens, mtl, parsec
     , transformers
     }:
     mkDerivation {
       pname = "caledon";
       version = "3.2.1.0";
       sha256 = "e9375150e95a7d02fe927a1d27209e925622bcdef28772ddbee569f789c5e355";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers cpphs lens mtl parsec transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/mmirman/caledon";
       description = "a logic programming language based on the calculus of constructions";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "call" = callPackage
    ({ mkDerivation, base, bindings-portaudio, boundingboxes, colors
     , containers, control-bool, deepseq, directory, filepath, free
     , freetype2, GLFW-b, hashable, JuicyPixels, JuicyPixels-util, lens
     , linear, mtl, objective, OpenGL, OpenGLRaw, random
     , template-haskell, text, transformers, vector, WAVE
     }:
     mkDerivation {
       pname = "call";
       version = "0.1.4.2";
       sha256 = "2fe8f1ade21ea24c67ab2447189f756b75a60cbb4d2221a0058bc62050c00461";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bindings-portaudio boundingboxes colors containers
         control-bool deepseq directory filepath free freetype2 GLFW-b
         hashable JuicyPixels JuicyPixels-util lens linear mtl objective
         OpenGL OpenGLRaw random template-haskell text transformers vector
         WAVE
       ];
       executableHaskellDepends = [ base lens ];
       jailbreak = true;
       homepage = "https://github.com/fumieval/call";
       description = "The call game engine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "call-haskell-from-anything" = callPackage
    ({ mkDerivation, base, bytestring, msgpack, mtl, template-haskell
     , vector
     }:
     mkDerivation {
       pname = "call-haskell-from-anything";
       version = "1.0.1.0";
       sha256 = "1a33bc1a6f4f91f434a57bab242c9d46244bf73702432cbd8de6019595f7bffc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring msgpack mtl template-haskell vector
       ];
       executableHaskellDepends = [ base bytestring msgpack mtl ];
       homepage = "https://github.com/nh2/call-haskell-from-anything";
       description = "Call Haskell functions from other languages via serialization and dynamic libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "camh" = callPackage
    ({ mkDerivation, base, bytestring, Imlib, terminfo }:
     mkDerivation {
       pname = "camh";
       version = "0.0.2";
       sha256 = "577045c8c3b819a1e815864c67cbacfcd18ae26b5c92c792e48e33db7ccf6176";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bytestring Imlib terminfo ];
       homepage = "not yet available";
       description = "Image converter to 256-colored text";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "campfire" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , filepath, http-enumerator, http-types, mtl, old-locale, process
     , text, time, transformers, unordered-containers, url
     }:
     mkDerivation {
       pname = "campfire";
       version = "0.2.1";
       sha256 = "6485a3fe48c088459bb76ec34550df2f40d97358d18695401fb7e266d669a51a";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers filepath
         http-enumerator http-types mtl old-locale process text time
         transformers unordered-containers url
       ];
       jailbreak = true;
       homepage = "http://github.com/michaelxavier/Campfire";
       description = "Haskell implementation of the Campfire API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "canonical-filepath" = callPackage
    ({ mkDerivation, base, deepseq, directory, filepath }:
     mkDerivation {
       pname = "canonical-filepath";
       version = "1.0.0.3";
       sha256 = "8e43893518f47e86cc859546534b2bb886c2f89bea3af5ab5cd33f043669e935";
       libraryHaskellDepends = [ base deepseq directory filepath ];
       jailbreak = true;
       homepage = "http://github.com/nominolo/canonical-filepath";
       description = "Abstract data type for canonical file paths";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "canteven-config" = callPackage
    ({ mkDerivation, base, unix, yaml }:
     mkDerivation {
       pname = "canteven-config";
       version = "1.0.0.0";
       sha256 = "a994222fbc6957be65eb555b9acba14ca73d52a6ac42743fbb4f4a3508077cb6";
       libraryHaskellDepends = [ base unix yaml ];
       description = "A pattern for configuring programs";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "canteven-listen-http" = callPackage
    ({ mkDerivation, aeson, base }:
     mkDerivation {
       pname = "canteven-listen-http";
       version = "0.1.0.0";
       sha256 = "b7a750e3cf9c1aa7bac89c631714546aea477f3b5a5672dd3df7bb1e2513e168";
       libraryHaskellDepends = [ aeson base ];
       jailbreak = true;
       description = "data types to describe HTTP services";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "canteven-log" = callPackage
    ({ mkDerivation, aeson, base, bytestring, canteven-config
     , directory, fast-logger, filepath, hslogger, monad-logger
     , template-haskell, text, time, transformers, yaml
     }:
     mkDerivation {
       pname = "canteven-log";
       version = "0.3.0.2";
       sha256 = "296cc4329510c766b973d98c2e6f1186404df46eaf0f10f53fec432a3a5a3379";
       libraryHaskellDepends = [
         aeson base bytestring canteven-config directory fast-logger
         filepath hslogger monad-logger template-haskell text time
         transformers yaml
       ];
       homepage = "https://github.com/SumAll/haskell-canteven-log";
       description = "A canteven way of setting up logging for your program";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "canteven-template" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, data-default
     , markdown, template-haskell, text
     }:
     mkDerivation {
       pname = "canteven-template";
       version = "0.1.0.0";
       sha256 = "c9c1e542c81288537211ed6d80c0cdc53bd1ec8967146337a2a2364286acc586";
       libraryHaskellDepends = [
         base blaze-html bytestring data-default markdown template-haskell
         text
       ];
       homepage = "https://github.com/SumAll/haskell-canteven-template/";
       description = "A few utilites and helpers for using Template Haskell in your projects";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "cantor" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, directory
     , filepath, hspec, hxt, hxt-xpath, parsec, QuickCheck, split
     }:
     mkDerivation {
       pname = "cantor";
       version = "0.4";
       sha256 = "e36330c9cf27759773099057d66e93c6a2bb16a772722a96cb99bb97c446bd99";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory filepath hxt hxt-xpath parsec
         split
       ];
       testHaskellDepends = [
         base bytestring Cabal containers directory filepath hspec hxt
         hxt-xpath parsec QuickCheck split
       ];
       jailbreak = true;
       homepage = "https://github.com/klangner/cantor";
       description = "Application for analysis of java source code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cao" = callPackage
    ({ mkDerivation, alex, array, base, cmdargs, ConfigFile, containers
     , directory, dlist, filepath, happy, language-c, mtl, pretty
     , process, yices
     }:
     mkDerivation {
       pname = "cao";
       version = "0.1.1";
       sha256 = "6d2abd0b0aadcc201887a9676fe38d32644de22bb3c835d9d7b729159d10b866";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base cmdargs ConfigFile containers directory dlist filepath
         language-c mtl pretty process yices
       ];
       executableToolDepends = [ alex happy ];
       homepage = "http://haslab.uminho.pt/mbb/software/cao-domain-specific-language-cryptography";
       description = "CAO Compiler";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cap" = callPackage
    ({ mkDerivation, array, base, containers, haskell98 }:
     mkDerivation {
       pname = "cap";
       version = "1.0.1";
       sha256 = "253c8267ea9570db869acc3e7a3197c719c1479385000608044ed2e261e92291";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base containers haskell98 ];
       description = "Interprets and debug the cap language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "capped-list" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "capped-list";
       version = "1.2";
       sha256 = "29f664c033a6bbca03ae2fd196b57e9947c5650c97ac4da13355293bb73e336a";
       libraryHaskellDepends = [ base ];
       description = "A list-like type for lazy sequences, with a user-defined termination value";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "capri" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, process }:
     mkDerivation {
       pname = "capri";
       version = "0.1";
       sha256 = "27da85e58be530a1f9e03544e8ca3d105f56ff0ca994c32e162bd8fdbcfd5943";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal directory filepath process
       ];
       description = "A simple wrapper over cabal-install to operate in project-private mode";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "car-pool" = callPackage
    ({ mkDerivation, base, blaze-html, containers, digestive-functors
     , digestive-functors-blaze, digestive-functors-happstack
     , explicit-exception, happstack-server, non-empty, spreadsheet
     , text, transformers, utility-ht
     }:
     mkDerivation {
       pname = "car-pool";
       version = "0.0.1";
       sha256 = "30aaf499ee387edfc52256638077f190b9fbbbdee3efb53da166d61e2d26c7f8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-html containers digestive-functors
         digestive-functors-blaze digestive-functors-happstack
         explicit-exception happstack-server non-empty spreadsheet text
         transformers utility-ht
       ];
       homepage = "http://hub.darcs.net/thielema/car-pool/";
       description = "Simple web-server for organizing car-pooling for an event";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "caramia" = callPackage
    ({ mkDerivation, base, bytestring, containers, exceptions, gl
     , HUnit, lens, linear, mtl, sdl2, semigroups, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     , transformers, vector
     }:
     mkDerivation {
       pname = "caramia";
       version = "0.7.2.2";
       sha256 = "fa3129d63816e1ccb47a57808ece432a2b6ab652eeba15ac6a76d6799af277b3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers exceptions gl lens linear mtl semigroups
         text transformers vector
       ];
       testHaskellDepends = [
         base containers HUnit linear sdl2 test-framework
         test-framework-hunit test-framework-quickcheck2 transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/Noeda/caramia/";
       description = "High-level OpenGL bindings";
       license = stdenv.lib.licenses.mit;
     }) {};

  "carboncopy" = callPackage
    ({ mkDerivation, base, bytestring, filepath, haskell98, IfElse
     , MissingH
     }:
     mkDerivation {
       pname = "carboncopy";
       version = "0.1.2";
       sha256 = "71a8862ee790bf6e996c23fe3cf564182760a5b727ca9431f67be2c6803520f2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring filepath haskell98 IfElse MissingH
       ];
       homepage = "http://github.com/jdevelop/carboncopy";
       description = "Drop emails from threads being watched into special CC folder";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "carettah" = callPackage
    ({ mkDerivation, base, cairo, directory, filepath, gtk, hcwiid
     , highlighting-kate, mtl, pandoc, pango, process, text, time
     }:
     mkDerivation {
       pname = "carettah";
       version = "0.4.2";
       sha256 = "e698dc362f8f6c3fb62bfaecbd56484faa4d2ff84e5fabe8747312970d91f35b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cairo directory filepath gtk hcwiid highlighting-kate mtl
         pandoc pango process text time
       ];
       homepage = "https://github.com/master-q/carettah";
       description = "A presentation tool written with Haskell";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "carray_0_1_6_2" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, ix-shapable
     , QuickCheck, syb
     }:
     mkDerivation {
       pname = "carray";
       version = "0.1.6.2";
       sha256 = "7e71c800472376631cf6933243a0a0190376afab77593ac86825cc2d52b21588";
       libraryHaskellDepends = [
         array base binary bytestring ix-shapable QuickCheck syb
       ];
       testHaskellDepends = [ array base ix-shapable QuickCheck ];
       description = "A C-compatible array library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "carray" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, ix-shapable
     , QuickCheck, syb
     }:
     mkDerivation {
       pname = "carray";
       version = "0.1.6.3";
       sha256 = "92f78eaf7c88d9652edb452fdeb4292deb896b667e44fb2f99aeab324bdd7bff";
       libraryHaskellDepends = [
         array base binary bytestring ix-shapable QuickCheck syb
       ];
       testHaskellDepends = [ array base ix-shapable QuickCheck ];
       description = "A C-compatible array library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cartel_0_14_2_6" = callPackage
    ({ mkDerivation, base, directory, filepath, multiarg, QuickCheck
     , random, tasty, tasty-quickcheck, tasty-th, time, transformers
     }:
     mkDerivation {
       pname = "cartel";
       version = "0.14.2.6";
       sha256 = "8c4540ece37f0a708032d06bde61a4d6a198ba3b8242fafd385dfb121f5aa416";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory filepath time transformers
       ];
       testHaskellDepends = [
         base directory filepath multiarg QuickCheck random tasty
         tasty-quickcheck tasty-th time transformers
       ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/cartel";
       description = "Specify Cabal files in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cartel_0_14_2_8" = callPackage
    ({ mkDerivation, base, directory, filepath, multiarg, QuickCheck
     , random, tasty, tasty-quickcheck, tasty-th, time, transformers
     }:
     mkDerivation {
       pname = "cartel";
       version = "0.14.2.8";
       sha256 = "c8d36712a4504f3a22d6290d8952535f32c533b33d4e54fa461a0867c7e09989";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory filepath time transformers
       ];
       testHaskellDepends = [
         base directory filepath multiarg QuickCheck random tasty
         tasty-quickcheck tasty-th time transformers
       ];
       homepage = "http://www.github.com/massysett/cartel";
       description = "Specify Cabal files in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cartel" = callPackage
    ({ mkDerivation, base, directory, filepath, multiarg, QuickCheck
     , random, tasty, tasty-quickcheck, tasty-th, time, transformers
     }:
     mkDerivation {
       pname = "cartel";
       version = "0.16.0.0";
       sha256 = "67594fa408d74553038b677b650863f457309d69d968b01f4dda3bdf46a8b6b3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory filepath time transformers
       ];
       testHaskellDepends = [
         base directory filepath multiarg QuickCheck random tasty
         tasty-quickcheck tasty-th time transformers
       ];
       homepage = "http://www.github.com/massysett/cartel";
       description = "Specify Cabal files in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "casadi-bindings" = callPackage
    ({ mkDerivation, base, binary, casadi, casadi-bindings-core
     , casadi-bindings-internal, cereal, containers, doctest, linear
     , spatial-math, vector, vector-binary-instances
     }:
     mkDerivation {
       pname = "casadi-bindings";
       version = "2.4.1.8";
       sha256 = "982f4bd1b6e8f4939795daaadf456faa6ea9ffa96723e5081fbbd13a0d28bd95";
       libraryHaskellDepends = [
         base binary casadi-bindings-core casadi-bindings-internal cereal
         containers linear spatial-math vector vector-binary-instances
       ];
       libraryPkgconfigDepends = [ casadi ];
       testHaskellDepends = [ base doctest ];
       homepage = "http://github.com/ghorn/casadi-bindings";
       description = "mid-level bindings to CasADi";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {casadi = null;};

  "casadi-bindings-control" = callPackage
    ({ mkDerivation, base, casadi-bindings-core
     , casadi-bindings-internal, casadi_control, vector
     }:
     mkDerivation {
       pname = "casadi-bindings-control";
       version = "2.0.0.1";
       sha256 = "5c940b6d73306f5454629827b103b3c399f4037452294e1847ab1d72777a970e";
       libraryHaskellDepends = [
         base casadi-bindings-core casadi-bindings-internal vector
       ];
       libraryPkgconfigDepends = [ casadi_control ];
       jailbreak = true;
       description = "low level bindings to casadi-control";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {casadi_control = null;};

  "casadi-bindings-core" = callPackage
    ({ mkDerivation, base, casadi, casadi-bindings-internal, containers
     , vector
     }:
     mkDerivation {
       pname = "casadi-bindings-core";
       version = "2.4.1.0";
       sha256 = "f35fdfc2d8d33c5455d3e7dccce341332c0620db0445f99386f1e7920e053b6c";
       libraryHaskellDepends = [
         base casadi-bindings-internal containers vector
       ];
       libraryPkgconfigDepends = [ casadi ];
       description = "autogenerated low level bindings to casadi";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {casadi = null;};

  "casadi-bindings-internal" = callPackage
    ({ mkDerivation, base, casadi, containers, vector }:
     mkDerivation {
       pname = "casadi-bindings-internal";
       version = "0.1.3.1";
       sha256 = "7170eebb779a1e0dc18dc26edd55e7136978a1e24624c9953ddc5aee60f1e3a0";
       libraryHaskellDepends = [ base containers vector ];
       libraryPkgconfigDepends = [ casadi ];
       homepage = "http://github.com/ghorn/casadi-bindings";
       description = "low level bindings to CasADi";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {casadi = null;};

  "casadi-bindings-ipopt-interface" = callPackage
    ({ mkDerivation, base, casadi-bindings-core
     , casadi-bindings-internal, casadi_ipopt_interface, vector
     }:
     mkDerivation {
       pname = "casadi-bindings-ipopt-interface";
       version = "1.9.0.3";
       sha256 = "4a54d5348287bf8d9d955c2a29d3887f0f592ecd516b4782f93123c810bd38c0";
       libraryHaskellDepends = [
         base casadi-bindings-core casadi-bindings-internal vector
       ];
       libraryPkgconfigDepends = [ casadi_ipopt_interface ];
       description = "low level bindings to casadi-ipopt_interface";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {casadi_ipopt_interface = null;};

  "casadi-bindings-snopt-interface" = callPackage
    ({ mkDerivation, base, casadi-bindings-core
     , casadi-bindings-internal, casadi_snopt_interface, vector
     }:
     mkDerivation {
       pname = "casadi-bindings-snopt-interface";
       version = "1.9.0.3";
       sha256 = "5c2bb4286c559e031bf0dab80f1fa43522d25cc71e389fa6513fb4dcf65acf6b";
       libraryHaskellDepends = [
         base casadi-bindings-core casadi-bindings-internal vector
       ];
       libraryPkgconfigDepends = [ casadi_snopt_interface ];
       description = "low level bindings to casadi-snopt_interface";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {casadi_snopt_interface = null;};

  "cascading" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, colour
     , containers, lens, mtl, text, utf8-string, web-routes
     }:
     mkDerivation {
       pname = "cascading";
       version = "0.1.0";
       sha256 = "bec8cf0bc910b0a58f23132934fca720b00fdca3d4391dd6a03601459c823f71";
       libraryHaskellDepends = [
         base blaze-builder bytestring colour containers lens mtl text
         utf8-string web-routes
       ];
       jailbreak = true;
       description = "DSL for HTML CSS (Cascading Style Sheets)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "case-conversion" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "case-conversion";
       version = "0.1";
       sha256 = "24061f58765007efdff7024b2c9986c311734281f8acb941ee1fb020f18256da";
       libraryHaskellDepends = [ base ];
       homepage = "www.xy30.com";
       description = "Convert between different cases";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "case-insensitive_1_2_0_1" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, hashable, HUnit
     , test-framework, test-framework-hunit, text
     }:
     mkDerivation {
       pname = "case-insensitive";
       version = "1.2.0.1";
       sha256 = "d5d0ae6d8242365a6ff086ab4b7332dddca43805242cd29d1863606fe29fccc2";
       revision = "1";
       editedCabalFile = "e05afc901d0abd6e59044982737a4dfe88c2763b2ebe8463b0d7f9212732ffd3";
       libraryHaskellDepends = [ base bytestring deepseq hashable text ];
       testHaskellDepends = [
         base bytestring HUnit test-framework test-framework-hunit text
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/case-insensitive";
       description = "Case insensitive string comparison";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "case-insensitive_1_2_0_3" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, hashable, HUnit
     , test-framework, test-framework-hunit, text
     }:
     mkDerivation {
       pname = "case-insensitive";
       version = "1.2.0.3";
       sha256 = "0d1aaa1b3af81c09733a771bdbbc5d54e3dbaec62a7e195c534b001a6f4476c9";
       libraryHaskellDepends = [ base bytestring deepseq hashable text ];
       testHaskellDepends = [
         base bytestring HUnit test-framework test-framework-hunit text
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/case-insensitive";
       description = "Case insensitive string comparison";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "case-insensitive_1_2_0_4" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, hashable, HUnit
     , test-framework, test-framework-hunit, text
     }:
     mkDerivation {
       pname = "case-insensitive";
       version = "1.2.0.4";
       sha256 = "63830d4b6b8cd51f4e40e492c17b5eaa11ebab5ef28eeb344e57709f3220d51e";
       libraryHaskellDepends = [ base bytestring deepseq hashable text ];
       testHaskellDepends = [
         base bytestring HUnit test-framework test-framework-hunit text
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/case-insensitive";
       description = "Case insensitive string comparison";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "case-insensitive" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, hashable, HUnit
     , test-framework, test-framework-hunit, text
     }:
     mkDerivation {
       pname = "case-insensitive";
       version = "1.2.0.5";
       sha256 = "c450d04e018a027747592482d7b4d8725e334bde38e903d4f2c03f99583d3700";
       revision = "1";
       editedCabalFile = "4935ae0d0f5866052676c346aa5efc84f0a0a10570eaa44b6221b6db00f90aa6";
       libraryHaskellDepends = [ base bytestring deepseq hashable text ];
       testHaskellDepends = [
         base bytestring HUnit test-framework test-framework-hunit text
       ];
       homepage = "https://github.com/basvandijk/case-insensitive";
       description = "Case insensitive string comparison";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cased" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "cased";
       version = "0.1.0.0";
       sha256 = "8394e6705ed83152875e1de1c51c54c26b04a2359919d8958d66997b2b60ad23";
       libraryHaskellDepends = [ base text ];
       homepage = "https://github.com/jb55/cased";
       description = "Track string casing in its type";
       license = stdenv.lib.licenses.mit;
       maintainers = with stdenv.lib.maintainers; [ jb55 ];
     }) {};

  "cases_0_1_2" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, HTF, HUnit
     , loch-th, placeholders, QuickCheck, text
     }:
     mkDerivation {
       pname = "cases";
       version = "0.1.2";
       sha256 = "f05a0cd257cc5872fa3e90198416393518a9fb8409c71fe4284d120a2e6da40a";
       libraryHaskellDepends = [ attoparsec base-prelude loch-th text ];
       testHaskellDepends = [
         base HTF HUnit loch-th placeholders QuickCheck text
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/cases";
       description = "A converter for spinal, snake and camel cases";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cases_0_1_2_1" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, HTF, HUnit
     , loch-th, placeholders, QuickCheck, text
     }:
     mkDerivation {
       pname = "cases";
       version = "0.1.2.1";
       sha256 = "6d726f55ec5ac0c8f6b50287fc3675757962e3ac4b5f12c8b5eb2024bd754d5c";
       libraryHaskellDepends = [ attoparsec base-prelude loch-th text ];
       testHaskellDepends = [
         base HTF HUnit loch-th placeholders QuickCheck text
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/cases";
       description = "A converter for spinal, snake and camel cases";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cases" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, HTF, HUnit
     , loch-th, placeholders, QuickCheck, text
     }:
     mkDerivation {
       pname = "cases";
       version = "0.1.3";
       sha256 = "67263b179ba8687f04f76de41f8dc69833baa5dd34c7089907ff7c4cef95a928";
       libraryHaskellDepends = [ attoparsec base-prelude loch-th text ];
       testHaskellDepends = [
         base HTF HUnit loch-th placeholders QuickCheck text
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/cases";
       description = "A converter for spinal, snake and camel cases";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cash" = callPackage
    ({ mkDerivation, base, deepseq, haskell98, HaXml, network, parallel
     , pretty
     }:
     mkDerivation {
       pname = "cash";
       version = "0.1.0.1";
       sha256 = "074697c7d286fa263d8f5242de917912d0a5e121d87414c9d16f957ddb18965f";
       libraryHaskellDepends = [
         base deepseq haskell98 HaXml network parallel pretty
       ];
       jailbreak = true;
       homepage = "http://www.cs.st-andrews.ac.uk/~hwloidl/SCIEnce/SymGrid-Par/CASH/";
       description = "the Computer Algebra SHell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "casing" = callPackage
    ({ mkDerivation, base, split }:
     mkDerivation {
       pname = "casing";
       version = "0.1.0.1";
       sha256 = "9039e45dc21851b7b6e5e58c79603beb27a03a79588c3176150d5c83d6e077ac";
       libraryHaskellDepends = [ base split ];
       description = "Convert between various source code casing conventions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cassandra-cql" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, cryptohash
     , Decimal, hslogger, MonadCatchIO-transformers, mtl, network
     , resource-pool, stm, text, time, uuid
     }:
     mkDerivation {
       pname = "cassandra-cql";
       version = "0.5.0.2";
       sha256 = "a4a8b6f6cdd6f0fb54bcbd2d04a0a7c64a8c6aa68b5c0089a67dc35fb7be60da";
       libraryHaskellDepends = [
         base bytestring cereal containers cryptohash Decimal hslogger
         MonadCatchIO-transformers mtl network resource-pool stm text time
         uuid
       ];
       description = "Haskell client for Cassandra's CQL protocol";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cassandra-thrift" = callPackage
    ({ mkDerivation, base, bytestring, containers, Thrift }:
     mkDerivation {
       pname = "cassandra-thrift";
       version = "0.8.5.1";
       sha256 = "8c77b9c1f82a41e496201b42217984e7ca610897646953bc65dc59311e88b542";
       libraryHaskellDepends = [ base bytestring containers Thrift ];
       homepage = "http://cassandra.apache.org/";
       description = "thrift bindings to the cassandra database";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cassava_0_4_2_0" = callPackage
    ({ mkDerivation, array, attoparsec, base, blaze-builder, bytestring
     , containers, deepseq, ghc-prim, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "cassava";
       version = "0.4.2.0";
       sha256 = "a38b5352368a3790f0af4787b7490c57dec9d4edc231522fcd5855d264fb31ec";
       libraryHaskellDepends = [
         array attoparsec base blaze-builder bytestring containers deepseq
         ghc-prim text unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 text
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/tibbe/cassava";
       description = "A CSV parsing and encoding library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cassava_0_4_2_1" = callPackage
    ({ mkDerivation, array, attoparsec, base, blaze-builder, bytestring
     , containers, deepseq, ghc-prim, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "cassava";
       version = "0.4.2.1";
       sha256 = "9a9435650ba3cbcfef29b76b9a30a64cfe5091905d3828a0cf3d0e392311eaef";
       libraryHaskellDepends = [
         array attoparsec base blaze-builder bytestring containers deepseq
         ghc-prim text unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 text
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/tibbe/cassava";
       description = "A CSV parsing and encoding library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cassava_0_4_2_2" = callPackage
    ({ mkDerivation, array, attoparsec, base, blaze-builder, bytestring
     , containers, deepseq, ghc-prim, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "cassava";
       version = "0.4.2.2";
       sha256 = "2eefcf322a336f40f9c848d49e197a4c09057a8a1ad6efe89d1c768c87ccf72a";
       libraryHaskellDepends = [
         array attoparsec base blaze-builder bytestring containers deepseq
         ghc-prim text unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 text
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/tibbe/cassava";
       description = "A CSV parsing and encoding library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cassava_0_4_2_3" = callPackage
    ({ mkDerivation, array, attoparsec, base, blaze-builder, bytestring
     , containers, deepseq, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "cassava";
       version = "0.4.2.3";
       sha256 = "4eb0cfc9ddd351e643d4787d3b778614b331431d5ab7e2f9c91376ea478dd08d";
       revision = "1";
       editedCabalFile = "2b71712f064f50be8f752c9f6f433f5df985091de4a01a7d0be3a520e1652807";
       libraryHaskellDepends = [
         array attoparsec base blaze-builder bytestring containers deepseq
         text unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 text
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/tibbe/cassava";
       description = "A CSV parsing and encoding library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cassava_0_4_2_4" = callPackage
    ({ mkDerivation, array, attoparsec, base, blaze-builder, bytestring
     , containers, deepseq, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "cassava";
       version = "0.4.2.4";
       sha256 = "0a81bd1cb4c78158ffce0feec4d3f55f020a7e9abfc656e64f239662c916c4ed";
       revision = "1";
       editedCabalFile = "b04f4bc6b14e22b08f335f02e5c0dfe8adf04006bd5e55fefba07d33767265c0";
       libraryHaskellDepends = [
         array attoparsec base blaze-builder bytestring containers deepseq
         text unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 text
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/tibbe/cassava";
       description = "A CSV parsing and encoding library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cassava_0_4_3_0" = callPackage
    ({ mkDerivation, array, attoparsec, base, blaze-builder, bytestring
     , containers, deepseq, hashable, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "cassava";
       version = "0.4.3.0";
       sha256 = "a38bdbb85e00b5650797c2c8ff2cbcddd67238e1d1152e383417d856c3ee8c5f";
       revision = "2";
       editedCabalFile = "201c58372b964b372dffcafb6774bee04329640d4bedf0c98d9a1b5cf34cc565";
       libraryHaskellDepends = [
         array attoparsec base blaze-builder bytestring containers deepseq
         hashable text unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring hashable HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 text
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/tibbe/cassava";
       description = "A CSV parsing and encoding library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cassava_0_4_3_1" = callPackage
    ({ mkDerivation, array, attoparsec, base, blaze-builder, bytestring
     , containers, deepseq, hashable, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "cassava";
       version = "0.4.3.1";
       sha256 = "e389ea01f6f346246e7002d5eb925518d134185f260cbdf1e81628eb4cffc2ac";
       revision = "2";
       editedCabalFile = "698c3f8bf72c561280944d2ace8be7c0b271c83557426a9474699930644b3828";
       libraryHaskellDepends = [
         array attoparsec base blaze-builder bytestring containers deepseq
         hashable text unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring hashable HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 text
         unordered-containers vector
       ];
       homepage = "https://github.com/tibbe/cassava";
       description = "A CSV parsing and encoding library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cassava_0_4_4_0" = callPackage
    ({ mkDerivation, array, attoparsec, base, blaze-builder, bytestring
     , containers, deepseq, hashable, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "cassava";
       version = "0.4.4.0";
       sha256 = "0733ede68d2670fd3e676f5a19b6d31233b266a8dc42387316e6ec7ed5e5df3f";
       revision = "1";
       editedCabalFile = "0293422ddf8cc18edba220088560c5d5a6bdba54cd784a5d7cb2eb8cd430166b";
       libraryHaskellDepends = [
         array attoparsec base blaze-builder bytestring containers deepseq
         hashable text unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring hashable HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 text
         unordered-containers vector
       ];
       homepage = "https://github.com/tibbe/cassava";
       description = "A CSV parsing and encoding library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cassava" = callPackage
    ({ mkDerivation, array, attoparsec, base, blaze-builder, bytestring
     , containers, deepseq, hashable, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "cassava";
       version = "0.4.5.0";
       sha256 = "7320a1c764efd3baae6944b31f7fdb438ae307876dce283a242e8f1deeb371c9";
       libraryHaskellDepends = [
         array attoparsec base blaze-builder bytestring containers deepseq
         hashable text unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring hashable HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 text
         unordered-containers vector
       ];
       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, conduit-extra, containers, mtl, QuickCheck, text
     }:
     mkDerivation {
       pname = "cassava-conduit";
       version = "0.3.1";
       sha256 = "3f712d0128a0fa02ad66378f6eddb6be3c846ba666cfbb3fff138c516e6cede6";
       libraryHaskellDepends = [
         array base bifunctors bytestring cassava conduit conduit-extra
         containers mtl text
       ];
       testHaskellDepends = [ base QuickCheck ];
       homepage = "https://github.com/domdere/cassava-conduit";
       description = "Conduit interface for cassava package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cassava-streams" = callPackage
    ({ mkDerivation, base, bytestring, cassava, io-streams, QuickCheck
     , tasty, tasty-quickcheck, vector
     }:
     mkDerivation {
       pname = "cassava-streams";
       version = "0.2.0.0";
       sha256 = "b4e825309533f9bd33728de92950eea33f362ea5bfd4e04689777b3760f69d6d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cassava io-streams vector
       ];
       testHaskellDepends = [
         base bytestring cassava io-streams QuickCheck tasty
         tasty-quickcheck vector
       ];
       homepage = "https://github.com/pjones/cassava-streams";
       description = "io-streams interface for the cassava CSV library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cassette" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "cassette";
       version = "0.1.0";
       sha256 = "fd40b3fd44eebce549216f3a4c1852f5b109edddfff3d6d7e243b64574981613";
       libraryHaskellDepends = [ base ];
       description = "A combinator library for simultaneously defining parsers and pretty printers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cassy" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , cassandra-thrift, cereal, conduit, containers, data-default
     , derive, errors, exceptions, HUnit, mtl, network, QuickCheck
     , resource-pool, retry, safecopy, stm, syb, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, Thrift
     , time, transformers-base
     }:
     mkDerivation {
       pname = "cassy";
       version = "0.7.1";
       sha256 = "0ef87e18a5e8faf5c353a36375bd2b56aa73651294d131c1550df7998feda15a";
       libraryHaskellDepends = [
         aeson async attoparsec base binary bytestring cassandra-thrift
         cereal conduit containers data-default errors exceptions mtl
         network resource-pool retry safecopy stm syb text Thrift time
         transformers-base
       ];
       testHaskellDepends = [
         base bytestring cassandra-thrift containers derive HUnit network
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 text Thrift time
       ];
       jailbreak = true;
       homepage = "http://github.com/ozataman/cassy";
       description = "A high level driver for the Cassandra datastore";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "castle" = callPackage
    ({ mkDerivation, base, containers, optparse-applicative, shelly
     , system-fileio, system-filepath, text
     }:
     mkDerivation {
       pname = "castle";
       version = "0.1.0.1";
       sha256 = "6a16bfd1c29d94789af6e61eae1d7949685e9becfc0f39f17cb3d34f11dbcd40";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers optparse-applicative shelly system-fileio
         system-filepath text
       ];
       jailbreak = true;
       homepage = "https://github.com/erochest/castle";
       description = "A tool to manage shared cabal-install sandboxes";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "casui" = callPackage
    ({ mkDerivation, base, gtk, haskell98, mtl, parsec }:
     mkDerivation {
       pname = "casui";
       version = "0.3";
       sha256 = "fc15678e54cf70db356163c9d3d0c8a90e28d2cbeb1d9071037888d75b7a50ee";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base gtk haskell98 mtl parsec ];
       homepage = "http://code.atnnn.com/projects/casui";
       description = "Equation Manipulator";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "catamorphism" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "catamorphism";
       version = "0.5.1.0";
       sha256 = "782ea7852cbc3f092cb00ac48b5aeec4121fcde5b58718744d85f141416e18d2";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "https://github.com/frerich/catamorphism";
       description = "A package exposing a helper function for generating catamorphisms";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "catch-fd" = callPackage
    ({ mkDerivation, base, mtl, transformers }:
     mkDerivation {
       pname = "catch-fd";
       version = "0.2.0.2";
       sha256 = "3dbb21228ea97426b266ffd3930f75e9e553fd7290b7bd8d6dfd488ff7ccdb15";
       libraryHaskellDepends = [ base mtl transformers ];
       jailbreak = true;
       homepage = "http://github.com/sonyandy/catch-fd";
       description = "MonadThrow and MonadCatch, using functional dependencies";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "categorical-algebra" = callPackage
    ({ mkDerivation, base, newtype, pointless-haskell, void }:
     mkDerivation {
       pname = "categorical-algebra";
       version = "0.0.0.1";
       sha256 = "f46e7787eca3f60a54ba00d8980cfc48075a3ed2a486c62a56845b574b0aa6cf";
       libraryHaskellDepends = [ base newtype pointless-haskell void ];
       description = "Categorical Monoids and Semirings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "categories" = callPackage
    ({ mkDerivation, base, void }:
     mkDerivation {
       pname = "categories";
       version = "1.0.7";
       sha256 = "c29dcec070073f3fdb13f0265e2efc4f2f88522292189690351a70f24cd830a2";
       libraryHaskellDepends = [ base void ];
       homepage = "http://github.com/ekmett/categories";
       description = "Categories";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "category-extras" = callPackage
    ({ mkDerivation, adjunctions, bifunctors, categories, comonad
     , comonad-extras, comonad-transformers, comonads-fd, contravariant
     , distributive, either, free, groupoids, indexed, indexed-extras
     , invariant, kan-extensions, keys, monad-products, pointed
     , profunctor-extras, profunctors, recursion-schemes, reducers
     , representable-functors, representable-profunctors
     , semigroupoid-extras, semigroupoids, semigroups, void
     }:
     mkDerivation {
       pname = "category-extras";
       version = "1.0.2";
       sha256 = "984d06bdc6604133b1ccecd927e86a51a604714aa49094161a08a086c3d51799";
       libraryHaskellDepends = [
         adjunctions bifunctors categories comonad comonad-extras
         comonad-transformers comonads-fd contravariant distributive either
         free groupoids indexed indexed-extras invariant kan-extensions keys
         monad-products pointed profunctor-extras profunctors
         recursion-schemes reducers representable-functors
         representable-profunctors semigroupoid-extras semigroupoids
         semigroups void
       ];
       doHaddock = false;
       homepage = "http://comonad.com/reader/";
       description = "A meta-package documenting various packages inspired by category theory";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cautious-file" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, unix }:
     mkDerivation {
       pname = "cautious-file";
       version = "1.0.2";
       sha256 = "38fa615f6b2154c65016662d7fa7c173c2f56ae3621b469aa6016795f9b385eb";
       revision = "1";
       editedCabalFile = "c6183204fc6d4767c8b8c4b954f6908fd376054c28904866a90a66497970d893";
       libraryHaskellDepends = [
         base bytestring directory filepath unix
       ];
       doHaddock = false;
       doCheck = false;
       description = "Ways to write a file cautiously, to reduce the chances of problems such as data loss due to crashes or power failures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cayley-client_0_1_3_0" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, exceptions
     , http-client, http-conduit, lens, lens-aeson, mtl, text
     , transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "cayley-client";
       version = "0.1.3.0";
       sha256 = "d455191e53e66049912ebf89034a59390a4d4658843c2cada2a07bfaa9b7f773";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring exceptions http-client
         http-conduit lens lens-aeson mtl text transformers
         unordered-containers vector
       ];
       homepage = "https://github.com/MichelBoucey/cayley-client";
       description = "A Haskell client for the Cayley graph database";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cayley-client_0_1_4_0" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, exceptions
     , http-client, http-conduit, lens, lens-aeson, mtl, text
     , transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "cayley-client";
       version = "0.1.4.0";
       sha256 = "dd7135dc1f0970784d594a45781570b222c487c5ed64cdd51becca6029447b1a";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring exceptions http-client
         http-conduit lens lens-aeson mtl text transformers
         unordered-containers vector
       ];
       homepage = "https://github.com/MichelBoucey/cayley-client";
       description = "A Haskell client for the Cayley graph database";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cayley-client" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, exceptions
     , http-client, http-conduit, lens, lens-aeson, mtl, text
     , transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "cayley-client";
       version = "0.1.5.0";
       sha256 = "9ad3361bda007e98dfc9977c81881d2ccfcb7a8bcded8996d6543c3b95b288b5";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring exceptions http-client
         http-conduit lens lens-aeson mtl text transformers
         unordered-containers vector
       ];
       homepage = "https://github.com/MichelBoucey/cayley-client";
       description = "A Haskell client for the Cayley graph database";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cayley-dickson" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "cayley-dickson";
       version = "0.3.1.0";
       sha256 = "bcba575db8a9ed81d1c9d8e048642577bfb28b9e3b761334a187ad2fabb404c3";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base random ];
       homepage = "https://github.com/lmj/cayley-dickson";
       description = "Complex numbers, quaternions, octonions, sedenions, etc";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cblrepo" = callPackage
    ({ mkDerivation, aeson, ansi-wl-pprint, base, bytestring, Cabal
     , containers, directory, filepath, mtl, optparse-applicative
     , process, safe, stringsearch, tar, transformers, unix, Unixutils
     , utf8-string, zlib
     }:
     mkDerivation {
       pname = "cblrepo";
       version = "0.19.1";
       sha256 = "e06276a14157bf82b86f3a534bc51620134253b1e9472e676616cec58ab8b436";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson ansi-wl-pprint base bytestring Cabal containers directory
         filepath mtl optparse-applicative process safe stringsearch tar
         transformers unix Unixutils utf8-string zlib
       ];
       jailbreak = true;
       description = "Tool to maintain a database of CABAL packages and their dependencies";
       license = "unknown";
     }) {};

  "cci" = callPackage
    ({ mkDerivation, base, binary, bytestring, cci, cmdargs, containers
     , filepath, mtl, pretty, process, random, time
     }:
     mkDerivation {
       pname = "cci";
       version = "0.3.1";
       sha256 = "87390d636e6877bfb982ce60b3accef9d73153ea03632cec967526eb8eb96a5f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ cci ];
       testHaskellDepends = [
         base binary bytestring cmdargs containers filepath mtl pretty
         process random time
       ];
       description = "Bindings for the CCI networking library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {cci = null;};

  "ccnx" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "ccnx";
       version = "0.0.0";
       sha256 = "0776e3c546363b07b579dc5bc37334f68f804a1bfbd0a32333d0b63fb5a9f6a1";
       libraryHaskellDepends = [ base bytestring ];
       jailbreak = true;
       homepage = "http://tomahawkins.org";
       description = "A Haskell implementation of the CCNx network protocol";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cctools-workqueue" = callPackage
    ({ mkDerivation, bindings-cctools, bytestring, dttools, lens
     , monad-loops, unix
     }:
     mkDerivation {
       pname = "cctools-workqueue";
       version = "3.6.1.0.1.0.0.1";
       sha256 = "c3f2c6eeef5ea217a1be3eb9641cc92390af18a6d462d8f401612fe244fe0cdb";
       libraryHaskellDepends = [
         bindings-cctools bytestring lens monad-loops unix
       ];
       librarySystemDepends = [ dttools ];
       homepage = "http://bitbucket.org/badi/hs-cctools-workqueue";
       description = "High-level interface to CCTools' WorkQueue library";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {dttools = null;};

  "cedict" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, parsec
     , utf8-string
     }:
     mkDerivation {
       pname = "cedict";
       version = "0.2.5";
       sha256 = "7e8b51af665a499902021faa5530f84cb5281813d9b9a9d6bb57787a40e3d08e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers mtl parsec utf8-string
       ];
       jailbreak = true;
       description = "Convenient Chinese phrase & character lookup";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cef" = callPackage
    ({ mkDerivation, base, bytestring, directory, doctest, filepath
     , text, time
     }:
     mkDerivation {
       pname = "cef";
       version = "0.1.3";
       sha256 = "9918fb0b19e23aefe90ed914e30498011f1fa6ea0c8ffdc9e8f8a90337ac41d4";
       libraryHaskellDepends = [ base bytestring text time ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/picussecurity/haskell-cef.git";
       description = "CEF log format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ceilometer-common" = callPackage
    ({ mkDerivation, base, bimap, binary, bytestring, containers
     , data-ordlist, foldl, hspec, lens, lens-properties, mtl, pipes
     , QuickCheck, siphash, template-haskell, text, transformers
     , vaultaire-common
     }:
     mkDerivation {
       pname = "ceilometer-common";
       version = "0.2.3";
       sha256 = "fad2955f09f526c66afd6a2021fb4b744088f81314c6c6dc36dc1f61e68118ff";
       libraryHaskellDepends = [
         base bimap binary bytestring containers foldl lens pipes siphash
         template-haskell text vaultaire-common
       ];
       testHaskellDepends = [
         base bimap binary bytestring containers data-ordlist foldl hspec
         lens lens-properties mtl pipes QuickCheck siphash template-haskell
         text transformers vaultaire-common
       ];
       homepage = "https://github.com/anchor/ceilometer-common";
       description = "Common Haskell types and encoding for OpenStack Ceilometer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cellrenderer-cairo" = callPackage
    ({ mkDerivation, base, c2hs, cairo, glib, gtk, gtk2, mtl }:
     mkDerivation {
       pname = "cellrenderer-cairo";
       version = "1.0.0.0";
       sha256 = "fca3c3c7012a29f72f7bf8912c524d1058e5152eaf051ea65e0ee65c03ce8d15";
       libraryHaskellDepends = [ base cairo glib gtk mtl ];
       libraryPkgconfigDepends = [ gtk2 ];
       libraryToolDepends = [ c2hs ];
       jailbreak = true;
       description = "Cairo-based CellRenderer";
       license = stdenv.lib.licenses.bsd3;
     }) {gtk2 = pkgs.gnome2.gtk;};

  "cerberus" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, cmdargs
     , conduit-extra, ekg, ekg-core, hslogger, http-client
     , http-client-tls, http-reverse-proxy, http-types, pretty-show
     , text, wai, wai-middleware-caching, wai-middleware-caching-lru
     , wai-middleware-caching-redis, wai-middleware-throttle, warp
     }:
     mkDerivation {
       pname = "cerberus";
       version = "0.1.0.0";
       sha256 = "11c9b5aa94939e289869a1a98cf60b6081b1be8ba5d75a66cf4ed8be0faa5c8e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring conduit-extra ekg ekg-core hslogger
         http-client http-client-tls http-reverse-proxy http-types text wai
         wai-middleware-caching wai-middleware-caching-lru
         wai-middleware-caching-redis wai-middleware-throttle warp
       ];
       executableHaskellDepends = [
         base cmdargs ekg ekg-core hslogger pretty-show
       ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/yogsototh/cerberus#readme";
       description = "Protect and control API access with cerberus";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cereal_0_4_1_0" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, ghc-prim }:
     mkDerivation {
       pname = "cereal";
       version = "0.4.1.0";
       sha256 = "8ba24540c8c9209f6ca0a1cc332cb393c42c774e21bf1c26b744b7959ce41154";
       libraryHaskellDepends = [
         array base bytestring containers ghc-prim
       ];
       description = "A binary serialization library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cereal_0_4_1_1" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, ghc-prim }:
     mkDerivation {
       pname = "cereal";
       version = "0.4.1.1";
       sha256 = "df047216179ba3817134e32c73ef9e3b5dddbd4efff604f50ca0ca0c93753097";
       libraryHaskellDepends = [
         array base bytestring containers ghc-prim
       ];
       description = "A binary serialization library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cereal" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, ghc-prim
     , QuickCheck, test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "cereal";
       version = "0.5.1.0";
       sha256 = "30f95a5c30b402e2d9020daef8297e338941f1bbe2084259d92f6bb4015904cb";
       libraryHaskellDepends = [
         array base bytestring containers ghc-prim
       ];
       testHaskellDepends = [
         base bytestring QuickCheck test-framework
         test-framework-quickcheck2
       ];
       homepage = "https://github.com/GaloisInc/cereal";
       description = "A binary serialization library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cereal-conduit_0_7_2_3" = callPackage
    ({ mkDerivation, base, bytestring, cereal, conduit, HUnit, mtl
     , resourcet, transformers
     }:
     mkDerivation {
       pname = "cereal-conduit";
       version = "0.7.2.3";
       sha256 = "3a49a7c4a8eaaf8062e119b9f395f4932e5cfe245f6e423a21b2f322aa443a68";
       libraryHaskellDepends = [
         base bytestring cereal conduit resourcet transformers
       ];
       testHaskellDepends = [
         base bytestring cereal conduit HUnit mtl resourcet transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/conduit";
       description = "Turn Data.Serialize Gets and Puts into Sources, Sinks, and Conduits";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cereal-conduit" = callPackage
    ({ mkDerivation, base, bytestring, cereal, conduit, HUnit, mtl
     , resourcet, transformers
     }:
     mkDerivation {
       pname = "cereal-conduit";
       version = "0.7.2.5";
       sha256 = "414407daafbe39e4a49623f32e7a96f3c844dec93d890ba6420b0554ba9a0491";
       libraryHaskellDepends = [
         base bytestring cereal conduit resourcet transformers
       ];
       testHaskellDepends = [
         base bytestring cereal conduit HUnit mtl resourcet transformers
       ];
       homepage = "https://github.com/snoyberg/conduit";
       description = "Turn Data.Serialize Gets and Puts into Sources, Sinks, and Conduits";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cereal-derive" = callPackage
    ({ mkDerivation, base, cereal, ghc-prim }:
     mkDerivation {
       pname = "cereal-derive";
       version = "0.1.1";
       sha256 = "8b3ba3942d518a46e172e36cce0e7bc226b788c62ab8e5d86f3c6f2c7278b412";
       libraryHaskellDepends = [ base cereal ghc-prim ];
       jailbreak = true;
       description = "Automatic deriving of Serialize using GHC.Generics";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "cereal-enumerator" = callPackage
    ({ mkDerivation, base, bytestring, cereal, enumerator }:
     mkDerivation {
       pname = "cereal-enumerator";
       version = "0.3.1";
       sha256 = "d35ac7fb71e14cae6b045a0d21f9884322c9fb015422474dce4f937d1c91fa52";
       libraryHaskellDepends = [ base bytestring cereal enumerator ];
       description = "Deserialize things with cereal and enumerator";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cereal-ieee754" = callPackage
    ({ mkDerivation, array, base, cereal }:
     mkDerivation {
       pname = "cereal-ieee754";
       version = "0.1";
       sha256 = "5af05b446448b04ecc457a3627d5daf82362aa216f0789fcc044aef4e31722bf";
       libraryHaskellDepends = [ array base cereal ];
       jailbreak = true;
       homepage = "http://github.com/jystic/cereal-ieee754";
       description = "Floating point support for the 'cereal' serialization library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cereal-plus" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, containers
     , errors, hashable, hashtables, HTF, HUnit, mmorph, mtl, QuickCheck
     , quickcheck-instances, stm, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "cereal-plus";
       version = "0.4.1";
       sha256 = "696f8a279e6c38c70c1b821565398b850c602464fba909ab3ce7c30b4b14e492";
       libraryHaskellDepends = [
         array base bytestring cereal containers errors hashable hashtables
         mmorph mtl stm text time unordered-containers vector
       ];
       testHaskellDepends = [
         array base bytestring cereal containers errors hashable hashtables
         HTF HUnit mmorph mtl QuickCheck quickcheck-instances stm text time
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/cereal-plus";
       description = "An extended serialization library on top of \"cereal\"";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cereal-text" = callPackage
    ({ mkDerivation, base, cereal, text }:
     mkDerivation {
       pname = "cereal-text";
       version = "0.1.0.1";
       sha256 = "f86a00086d5f2cdfc652912a6e7e95946a414fedd1603549f50ead68d62757f3";
       libraryHaskellDepends = [ base cereal text ];
       homepage = "https://github.com/ulikoehler/cereal-text";
       description = "Data.Text instances for the cereal serialization library";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "cereal-vector" = callPackage
    ({ mkDerivation, base, bytestring, cereal, QuickCheck, vector }:
     mkDerivation {
       pname = "cereal-vector";
       version = "0.2.0.1";
       sha256 = "ff0685a6c39e7aae32f8b4165e2ae06f284c867298ad4f7b776c1c1b2859f933";
       libraryHaskellDepends = [ base bytestring cereal vector ];
       testHaskellDepends = [ base cereal QuickCheck vector ];
       homepage = "https://github.com/acfoltzer/cereal-vector";
       description = "Serialize instances for Data.Vector types.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "certificate" = callPackage
    ({ mkDerivation, asn1-data, base, bytestring, containers
     , crypto-pubkey-types, cryptohash, directory, filepath, mtl, pem
     , process, time
     }:
     mkDerivation {
       pname = "certificate";
       version = "1.3.9";
       sha256 = "e6257b4b0e884db8a817d265d9a7f9a6c76af8190504f32dadbbf64b0fcee5a1";
       revision = "1";
       editedCabalFile = "6b4b703a1c34a9fa3e0223f3ff2796183c7b9b7351da1ad34478225637e837ba";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         asn1-data base bytestring containers crypto-pubkey-types cryptohash
         directory filepath mtl pem process time
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "Certificates and Key Reader/Writer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cf" = callPackage
    ({ mkDerivation, base, QuickCheck, test-framework
     , test-framework-quickcheck2, test-framework-th
     }:
     mkDerivation {
       pname = "cf";
       version = "0.4.2";
       sha256 = "f2852d1f13c434f5e49ed319afc8f1a79cbb5e06d4235e5b342dc44cba6c2519";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
         test-framework-th
       ];
       homepage = "http://github.com/mvr/cf";
       description = "Exact real arithmetic using continued fractions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cfipu" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default
     , dequeue, mtl
     }:
     mkDerivation {
       pname = "cfipu";
       version = "1.1.0.4";
       sha256 = "327e57024225f24baa82e88b8c9a2cbfea1fa982e1f90b3f1b16e9dc57c48fd3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers data-default dequeue mtl
       ];
       homepage = "https://github.com/bairyn/cfipu";
       description = "cfipu processor for toy brainfuck-like language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cflp" = callPackage
    ({ mkDerivation, base, containers, control-monad-omega, HUnit
     , incremental-sat-solver, level-monad, logict, MonadRandom, mtl
     , random, stream-monad, syb, value-supply
     }:
     mkDerivation {
       pname = "cflp";
       version = "2009.2.1";
       sha256 = "7e83e7f9871040f856ef4b8bbb286dc6a4d7c60b78684c5de5e223e508484406";
       libraryHaskellDepends = [
         base containers control-monad-omega HUnit incremental-sat-solver
         level-monad logict MonadRandom mtl random stream-monad syb
         value-supply
       ];
       homepage = "http://www-ps.informatik.uni-kiel.de/~sebf/projects/cflp.html";
       description = "Constraint Functional-Logic Programming in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cfopu" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default
     , dequeue, mtl
     }:
     mkDerivation {
       pname = "cfopu";
       version = "1.0.0";
       sha256 = "7fac407bbab277e0dc28e4b3ffcf5f2e35ddbefa615af256406086d6188da1ed";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers data-default dequeue mtl
       ];
       description = "cfopu processor";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cg" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, deepseq
     , directory, filepath, hashable, mtl, parallel, parsec, process
     , split, text, unordered-containers, utf8-string, void
     }:
     mkDerivation {
       pname = "cg";
       version = "0.0.9.0";
       sha256 = "f4ee74928f521b0cbc76b0bc64e76a2c658863130d76b1f658c1fa1ef2649a6a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cereal containers deepseq directory filepath
         hashable mtl parallel parsec process split text
         unordered-containers utf8-string void
       ];
       jailbreak = true;
       description = "Parser for categorial grammars";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "cgen" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, mtl, parsec
     , regex-posix, safe, template-haskell
     }:
     mkDerivation {
       pname = "cgen";
       version = "0.0.5";
       sha256 = "0807822d8eaec236d895d2b6c77a22fc2c16088838d8d85eb1d556fe8eb269a2";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath mtl parsec regex-posix safe
         template-haskell
       ];
       doHaddock = false;
       homepage = "http://anttisalonen.github.com/cgen";
       description = "generates Haskell bindings and C wrappers for C++ libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cgi_3001_2_2_2" = callPackage
    ({ mkDerivation, base, bytestring, containers, exceptions, mtl
     , multipart, network, network-uri, old-locale, old-time, parsec
     , xhtml
     }:
     mkDerivation {
       pname = "cgi";
       version = "3001.2.2.2";
       sha256 = "23850f29cd80a5ac671c5663b8b3b3aae45e269c8db5a8216082c487d4ed3760";
       libraryHaskellDepends = [
         base bytestring containers exceptions mtl multipart network
         network-uri old-locale old-time parsec xhtml
       ];
       homepage = "https://github.com/cheecheeo/haskell-cgi";
       description = "A library for writing CGI programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cgi" = callPackage
    ({ mkDerivation, base, bytestring, containers, exceptions, mtl
     , multipart, network, network-uri, old-locale, old-time, parsec
     , xhtml
     }:
     mkDerivation {
       pname = "cgi";
       version = "3001.2.2.3";
       sha256 = "db57fe55805e3d639f18c594a07106926dd7d86345cf4889f8c512a09d3cfca4";
       libraryHaskellDepends = [
         base bytestring containers exceptions mtl multipart network
         network-uri old-locale old-time parsec xhtml
       ];
       homepage = "https://github.com/cheecheeo/haskell-cgi";
       description = "A library for writing CGI programs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cgi-undecidable" = callPackage
    ({ mkDerivation, base, cgi, mtl }:
     mkDerivation {
       pname = "cgi-undecidable";
       version = "3000.0.0";
       sha256 = "4bddf6f79aa990a55b2ae4acd526b0325520edf59df911ca680fa57134c003f6";
       libraryHaskellDepends = [ base cgi mtl ];
       description = "Undecidable instances for the cgi package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cgi-utils" = callPackage
    ({ mkDerivation, base, cgi, containers, mtl, random }:
     mkDerivation {
       pname = "cgi-utils";
       version = "0.2.1";
       sha256 = "f7b0d806ab13edb839f16cfa41c5c098b6fa7287386108b38680fc1506965457";
       revision = "1";
       editedCabalFile = "df1cb1e658d9b79adde373fc31a1d7553a4803f8967c760abf233e75913ddd52";
       libraryHaskellDepends = [ base cgi containers mtl random ];
       homepage = "http://github.com/chrisdone/haskell-cgi-utils";
       description = "Simple modular utilities for CGI/FastCGI (sessions, etc.)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cgrep" = callPackage
    ({ mkDerivation, ansi-terminal, array, async, base, bytestring
     , cmdargs, containers, directory, dlist, either, filepath, ghc-prim
     , mtl, process, regex-base, regex-pcre, regex-posix, safe, split
     , stm, stringsearch, transformers, unix-compat
     , unordered-containers
     }:
     mkDerivation {
       pname = "cgrep";
       version = "6.6.1";
       sha256 = "49cfd5695a20c7cdad917704e81ae6cb50e77d7db6a18f7792237bb6c4dbfc38";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal array async base bytestring cmdargs containers
         directory dlist either filepath ghc-prim mtl process regex-base
         regex-pcre regex-posix safe split stm stringsearch transformers
         unix-compat unordered-containers
       ];
       homepage = "http://awgn.github.io/cgrep/";
       description = "Command line tool";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "chain-codes" = callPackage
    ({ mkDerivation, base, containers, hspec, JuicyPixels }:
     mkDerivation {
       pname = "chain-codes";
       version = "0.3.0.0";
       sha256 = "66a2a9b72210ddf2fc2c9030c0b45d71f76b316ef3cea7b3ccaf4bca1ec7866f";
       libraryHaskellDepends = [ base containers JuicyPixels ];
       testHaskellDepends = [ base containers hspec JuicyPixels ];
       homepage = "http://github.com/Fuuzetsu/chain-codes";
       description = "Library decoding chain codes from images";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "chalk" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "chalk";
       version = "0.1.0.1";
       sha256 = "be7bc5016333d20771b30fb8375af438f92eb1d2c4af7bf6beac702e42b93835";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://github.com/joom/chalk";
       description = "Terminal string styling";
       license = stdenv.lib.licenses.mit;
     }) {};

  "chalkboard" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, Codec-Image-DevIL
     , containers, data-reify, directory, GLUT, OpenGLRaw, process, time
     }:
     mkDerivation {
       pname = "chalkboard";
       version = "1.9.0.16";
       sha256 = "696963d4c4e43cf84e5e00af6c1d812e9f095df9d778efd79be3fc4f7d77061d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring Codec-Image-DevIL containers
         data-reify directory GLUT OpenGLRaw process time
       ];
       executableHaskellDepends = [ base ];
       homepage = "http://www.ittc.ku.edu/csdl/fpg/ChalkBoard";
       description = "Combinators for building and processing 2D images";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "chalkboard-viewer" = callPackage
    ({ mkDerivation, array, base, chalkboard, GLUT, OpenGL, time }:
     mkDerivation {
       pname = "chalkboard-viewer";
       version = "0.1";
       sha256 = "023e840acca9f6c7d171c3f29b92aa7cd889e3fd20e0cf8d06ed21694eb876bf";
       libraryHaskellDepends = [ array base chalkboard GLUT OpenGL time ];
       jailbreak = true;
       homepage = "http://ittc.ku.edu/~andygill/chalkboard.php";
       description = "OpenGL based viewer for chalkboard rendered images";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "chalmers-lava2000" = callPackage
    ({ mkDerivation, array, base, process, random }:
     mkDerivation {
       pname = "chalmers-lava2000";
       version = "1.6";
       sha256 = "243d3b25635eb16700723a1250f8db52c5493d56bb16144537dedb0e776e01f8";
       libraryHaskellDepends = [ array base process random ];
       homepage = "http://projects.haskell.org/chalmers-lava2000/Doc/tutorial.pdf";
       description = "Hardware description EDSL";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "chan-split" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "chan-split";
       version = "0.5.0";
       sha256 = "2c2f2f9e90d5ee0e283eeae7e3ff727763165476ea1d0983d16f18e158cffbd7";
       libraryHaskellDepends = [ base stm ];
       homepage = "http://brandon.si/code/module-chan-split-released/";
       description = "Concurrent Chans as read/write pairs. Also provides generic Chan pair class.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "change-monger" = callPackage
    ({ mkDerivation, base, directory, process }:
     mkDerivation {
       pname = "change-monger";
       version = "0.0";
       sha256 = "4225ef32f9bc7ab40b7e1a68c2646872051edd1010932f060b8390072d60381c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base process ];
       executableHaskellDepends = [ directory ];
       description = "Parse VCS changelogs into ChangeLogs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "charade" = callPackage
    ({ mkDerivation, base, configurator, containers, filepath, heist
     , lens, mtl, QuickCheck, random, snap, snap-core, snap-extras
     , snap-server, text, xmlhtml
     }:
     mkDerivation {
       pname = "charade";
       version = "0.1.1.2";
       sha256 = "c4d02c8bf96b82a2ccd081aefde69e966136fc018bf3313dd4a5cec1c417286e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base configurator containers heist mtl QuickCheck random snap text
         xmlhtml
       ];
       executableHaskellDepends = [
         base configurator containers filepath heist lens mtl QuickCheck
         random snap snap-core snap-extras snap-server text xmlhtml
       ];
       jailbreak = true;
       homepage = "https://github.com/soostone/charade";
       description = "Rapid prototyping websites with Snap and Heist";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "charset_0_3_7" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, semigroups
     , unordered-containers
     }:
     mkDerivation {
       pname = "charset";
       version = "0.3.7";
       sha256 = "a6f51b321e2fd02d29d2636605df3f7b9ad62b8f17ee3828461d14537a1321f5";
       libraryHaskellDepends = [
         array base bytestring containers semigroups unordered-containers
       ];
       homepage = "http://github.com/ekmett/charset";
       description = "Fast unicode character sets based on complemented PATRICIA tries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "charset" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, semigroups
     , unordered-containers
     }:
     mkDerivation {
       pname = "charset";
       version = "0.3.7.1";
       sha256 = "3d415d2883bd7bf0cc9f038e8323f19c71e07dd12a3c712f449ccb8b4daac0be";
       libraryHaskellDepends = [
         array base bytestring containers semigroups unordered-containers
       ];
       homepage = "http://github.com/ekmett/charset";
       description = "Fast unicode character sets based on complemented PATRICIA tries";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "charsetdetect" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "charsetdetect";
       version = "1.0";
       sha256 = "f7d8e6a38572ed4e0789279ff9726a7a2b192e3f8c099cc54484c47acd1660f0";
       libraryHaskellDepends = [ base bytestring ];
       jailbreak = true;
       homepage = "http://www.github.com/batterseapower/charsetdetect";
       description = "Character set detection using Mozilla's Universal Character Set Detector";
       license = "LGPL";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "charsetdetect-ae" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "charsetdetect-ae";
       version = "1.1.0.1";
       sha256 = "1da16c91136cfe357e40522cdabcb4afc7a9f8a36a29492812e224563b1dcbf8";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://github.com/aelve/charsetdetect-ae";
       description = "Character set detection using Mozilla's Universal Character Set Detector";
       license = "LGPL";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "chart-histogram" = callPackage
    ({ mkDerivation, base, Chart }:
     mkDerivation {
       pname = "chart-histogram";
       version = "1.0.0";
       sha256 = "85136b3ba2b6f3f2a84a45d4d00760065f0d325e40fb7e155ef3eab0d65a128c";
       libraryHaskellDepends = [ base Chart ];
       jailbreak = true;
       description = "Easily render histograms with Chart";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "chaselev-deque" = callPackage
    ({ mkDerivation, abstract-deque, abstract-deque-tests, array
     , atomic-primops, base, containers, ghc-prim, HUnit, test-framework
     , test-framework-hunit, transformers, vector
     }:
     mkDerivation {
       pname = "chaselev-deque";
       version = "0.5.0.5";
       sha256 = "4d58f8d56228e9f5bea2a65717dea65106323cb5ead9b5f39f904dac5c0043f4";
       libraryHaskellDepends = [
         abstract-deque array atomic-primops base ghc-prim transformers
         vector
       ];
       testHaskellDepends = [
         abstract-deque abstract-deque-tests array atomic-primops base
         containers ghc-prim HUnit test-framework test-framework-hunit
         vector
       ];
       homepage = "https://github.com/rrnewton/haskell-lockfree/wiki";
       description = "Chase & Lev work-stealing lock-free double-ended queues (deques)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "chatter" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, cereal-text
     , containers, deepseq, directory, filepath, fullstop, hashable
     , HUnit, mbox, MonadRandom, parsec, QuickCheck
     , quickcheck-instances, random-shuffle, regex-tdfa, regex-tdfa-text
     , tasty, tasty-ant-xml, tasty-hunit, tasty-quickcheck, text
     , tokenize, transformers, unordered-containers, zlib
     }:
     mkDerivation {
       pname = "chatter";
       version = "0.8.0.2";
       sha256 = "d298cc5ce3d95df664e050e17395d56b0b4206b6557af14345eee90768c9ecc0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cereal cereal-text containers deepseq
         directory filepath fullstop hashable mbox MonadRandom parsec
         QuickCheck quickcheck-instances random-shuffle regex-tdfa
         regex-tdfa-text text tokenize transformers unordered-containers
         zlib
       ];
       executableHaskellDepends = [
         base bytestring cereal containers filepath text
       ];
       testHaskellDepends = [
         base cereal containers filepath HUnit parsec QuickCheck
         quickcheck-instances tasty tasty-ant-xml tasty-hunit
         tasty-quickcheck text tokenize unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/creswick/chatter";
       description = "A library of simple NLP algorithms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "chatty" = callPackage
    ({ mkDerivation, ansi-terminal, base, chatty-utils, directory, mtl
     , process, random, setenv, template-haskell, text, time
     , transformers, unix
     }:
     mkDerivation {
       pname = "chatty";
       version = "0.6.4.1";
       sha256 = "9f3ecc2335277144a86e9299f9775d2c655862e028b49e1070623cc8dbcaea09";
       libraryHaskellDepends = [
         ansi-terminal base chatty-utils directory mtl process random setenv
         template-haskell text time transformers unix
       ];
       jailbreak = true;
       homepage = "http://doomanddarkness.eu/pub/chatty";
       description = "Some monad transformers and typeclasses for abstraction of global dependencies";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "chatty-text" = callPackage
    ({ mkDerivation, base, chatty, transformers }:
     mkDerivation {
       pname = "chatty-text";
       version = "0.6.2.0";
       sha256 = "830a7503347bdcba3c6778ab8e4d7843d574c3a8d64f387e6b4349d92efecf3d";
       libraryHaskellDepends = [ base chatty transformers ];
       homepage = "http://doomanddarkness.eu/pub/chatty";
       description = "Provides some classes and types for dealing with text, using the fundaments of Chatty";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "chatty-utils" = callPackage
    ({ mkDerivation, base, mtl, text, transformers }:
     mkDerivation {
       pname = "chatty-utils";
       version = "0.7.3.2";
       sha256 = "12c9510397cdbf45fd90aac93ebf353df8aac0ad3e24b353ca3549fc934f22b5";
       libraryHaskellDepends = [ base mtl text transformers ];
       homepage = "http://doomanddarkness.eu/pub/chatty";
       description = "Some utilities every serious chatty-based application may need";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "cheapskate" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, bytestring, containers
     , data-default, http-types, mtl, syb, text, uniplate, wai
     , wai-extra, xss-sanitize
     }:
     mkDerivation {
       pname = "cheapskate";
       version = "0.1.0.4";
       sha256 = "023243726dd26a381ae43c6cace5381533b7605f069f04888c99b58d290c3d37";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html containers data-default mtl syb text uniplate
         xss-sanitize
       ];
       executableHaskellDepends = [
         aeson base blaze-html bytestring http-types text wai wai-extra
       ];
       homepage = "http://github.com/jgm/cheapskate";
       description = "Experimental markdown processor";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cheapskate-terminal" = callPackage
    ({ mkDerivation, ansi-terminal, base, cheapskate, data-default
     , directory, hpygments, hscolour, terminal-size, text
     }:
     mkDerivation {
       pname = "cheapskate-terminal";
       version = "0.1.0.0";
       sha256 = "8601c50c9979b463bf695d41d4111bdb0d7824f9600306b08b874bacea1fe9b9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base cheapskate data-default directory hpygments
         hscolour terminal-size text
       ];
       executableHaskellDepends = [
         ansi-terminal base cheapskate data-default directory hpygments
         hscolour terminal-size text
       ];
       testHaskellDepends = [
         ansi-terminal base cheapskate data-default directory hpygments
         hscolour terminal-size text
       ];
       homepage = "http://github.com/yamadapc/cheapskate-terminal#readme";
       description = "Initial project template from stack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "check-email" = callPackage
    ({ mkDerivation, base, bytestring, email-validate, resolv }:
     mkDerivation {
       pname = "check-email";
       version = "1.0";
       sha256 = "dfbba577c18ca1180d8d4b38cd0a54a6f0ca5a886e502cb83c8ab07675463cb7";
       libraryHaskellDepends = [ base bytestring email-validate ];
       librarySystemDepends = [ resolv ];
       description = "Confirm whether an email is valid and probably existant";
       license = stdenv.lib.licenses.bsd3;
     }) {resolv = null;};

  "check-pvp" = callPackage
    ({ mkDerivation, base, Cabal, containers, explicit-exception
     , filepath, haskell-src-exts, non-empty, transformers, utility-ht
     }:
     mkDerivation {
       pname = "check-pvp";
       version = "0.0.1";
       sha256 = "2e158e7826ade55941c90d72fa240965f547241db5b544c267c96fde43a8b0a3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers explicit-exception filepath haskell-src-exts
         non-empty transformers utility-ht
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Import_modules_properly";
       description = "Check whether module and package imports conform to the PVP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "checked" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "checked";
       version = "0.1.0.1";
       sha256 = "adea2330a33548439be112ac9ecbacfa45bd4282def658108a57b4d83a268002";
       libraryHaskellDepends = [ base ];
       description = "Bounds-checking integer types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "checkers_0_4_1" = callPackage
    ({ mkDerivation, array, base, QuickCheck, random }:
     mkDerivation {
       pname = "checkers";
       version = "0.4.1";
       sha256 = "b9ed807d4f8da9cc5462786a020f5e8d4a41258ee91b8d3564fb80b6e37acda6";
       libraryHaskellDepends = [ array base QuickCheck random ];
       jailbreak = true;
       description = "Check properties on standard classes and data structures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "checkers_0_4_2" = callPackage
    ({ mkDerivation, array, base, QuickCheck, random }:
     mkDerivation {
       pname = "checkers";
       version = "0.4.2";
       sha256 = "52419c7a22c0642293810f87468737d8ce3cb7607c0070001c524cf040db586c";
       libraryHaskellDepends = [ array base QuickCheck random ];
       description = "Check properties on standard classes and data structures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "checkers_0_4_3" = callPackage
    ({ mkDerivation, array, base, QuickCheck, random }:
     mkDerivation {
       pname = "checkers";
       version = "0.4.3";
       sha256 = "c0589321485225b7f37f108d232eb4caa42ba52afe0d28dccbe932185862c567";
       libraryHaskellDepends = [ array base QuickCheck random ];
       description = "Check properties on standard classes and data structures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "checkers" = callPackage
    ({ mkDerivation, array, base, QuickCheck, random }:
     mkDerivation {
       pname = "checkers";
       version = "0.4.4";
       sha256 = "11ad84ddb449ef97188c32b1a1324cc611a6d75033020890699ae8dba9fd8e9d";
       libraryHaskellDepends = [ array base QuickCheck random ];
       description = "Check properties on standard classes and data structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "chell_0_4" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, options, patience
     , random, template-haskell, text, transformers
     }:
     mkDerivation {
       pname = "chell";
       version = "0.4";
       sha256 = "cf824e5ada55b18aa1e3fca93996fb04521cafcb7db0fccd1fec757eecc9d6c3";
       revision = "1";
       editedCabalFile = "14853f792d3fab75efc50a9bc4e1493bf5afc8eaee06137f37adad8855ada3be";
       libraryHaskellDepends = [
         ansi-terminal base bytestring options patience random
         template-haskell text transformers
       ];
       jailbreak = true;
       homepage = "https://john-millikin.com/software/chell/";
       description = "A simple and intuitive library for automated testing";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "chell" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, options, patience
     , random, template-haskell, text, transformers
     }:
     mkDerivation {
       pname = "chell";
       version = "0.4.0.1";
       sha256 = "5f0abd31f4b00483e4667090c89828eda6a1c6ba5d77ecec418ad0fe972a6951";
       libraryHaskellDepends = [
         ansi-terminal base bytestring options patience random
         template-haskell text transformers
       ];
       homepage = "https://john-millikin.com/software/chell/";
       description = "A simple and intuitive library for automated testing";
       license = stdenv.lib.licenses.mit;
     }) {};

  "chell-hunit" = callPackage
    ({ mkDerivation, base, chell, HUnit }:
     mkDerivation {
       pname = "chell-hunit";
       version = "0.2.1";
       sha256 = "00f423ea3ef78f24ba2d9077db267fa9d30e47fa1b80ebafcaf2d5879214d400";
       libraryHaskellDepends = [ base chell HUnit ];
       jailbreak = true;
       homepage = "https://john-millikin.com/software/chell/";
       description = "HUnit support for the Chell testing library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "chell-quickcheck_0_2_4" = callPackage
    ({ mkDerivation, base, chell, QuickCheck, random }:
     mkDerivation {
       pname = "chell-quickcheck";
       version = "0.2.4";
       sha256 = "8d930248329e18938ad0c9d8932d958b449525eabc36649105b0f893f454467b";
       libraryHaskellDepends = [ base chell QuickCheck random ];
       jailbreak = true;
       homepage = "https://john-millikin.com/software/chell/";
       description = "QuickCheck support for the Chell testing library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "chell-quickcheck" = callPackage
    ({ mkDerivation, base, chell, QuickCheck, random }:
     mkDerivation {
       pname = "chell-quickcheck";
       version = "0.2.5";
       sha256 = "9a119daa3ff6046efd3024c48356b76650d01c27734f6b9b66259b59ba657309";
       libraryHaskellDepends = [ base chell QuickCheck random ];
       homepage = "https://john-millikin.com/software/chell/";
       description = "QuickCheck support for the Chell testing library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "chesshs" = callPackage
    ({ mkDerivation, array, attoparsec, base, bytestring, containers }:
     mkDerivation {
       pname = "chesshs";
       version = "0.2.1";
       sha256 = "db31b42771c43c6811389a17f5e276dd83d807784246ec25e5651c97c78acd37";
       libraryHaskellDepends = [
         array attoparsec base bytestring containers
       ];
       homepage = "http://arnovanlumig.com/chesshs.html";
       description = "Simple library for validating chess moves and parsing PGN files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "chevalier-common" = callPackage
    ({ mkDerivation, base, bifunctors, bytestring, cereal, locators
     , mtl, network, network-uri, protobuf, text, unordered-containers
     , vaultaire-common, zeromq4-haskell
     }:
     mkDerivation {
       pname = "chevalier-common";
       version = "0.6.0";
       sha256 = "3aff57938dcdc844cf0d8b29ed28eeeaaba3a8e2e6eb6808983d0addca62e739";
       libraryHaskellDepends = [
         base bifunctors bytestring cereal locators mtl network network-uri
         protobuf text unordered-containers vaultaire-common zeromq4-haskell
       ];
       jailbreak = true;
       description = "Query interface for Chevalier";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "chp" = callPackage
    ({ mkDerivation, base, containers, deepseq, extensible-exceptions
     , pretty, stm
     }:
     mkDerivation {
       pname = "chp";
       version = "2.2.0.1";
       sha256 = "822476732bae22b90174fdee21036be1681201597777d9eae991e80ecd40e0a3";
       libraryHaskellDepends = [
         base containers deepseq extensible-exceptions pretty stm
       ];
       homepage = "http://www.cs.kent.ac.uk/projects/ofa/chp/";
       description = "An implementation of concurrency ideas from Communicating Sequential Processes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "chp-mtl" = callPackage
    ({ mkDerivation, base, chp, chp-plus, mtl }:
     mkDerivation {
       pname = "chp-mtl";
       version = "1.0.0";
       sha256 = "9fac30f3d042fe29f0848ea438822a3801a6ee760e76233ffbc3a60a13ed24f4";
       libraryHaskellDepends = [ base chp chp-plus mtl ];
       jailbreak = true;
       homepage = "http://www.cs.kent.ac.uk/projects/ofa/chp/";
       description = "MTL class instances for the CHP library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "chp-plus" = callPackage
    ({ mkDerivation, base, chp, containers, deepseq
     , extensible-exceptions, HUnit, pretty, QuickCheck, stm
     }:
     mkDerivation {
       pname = "chp-plus";
       version = "1.3.1.2";
       sha256 = "1f70ae988d9fe5d5830f044472de1d8581090ef3477b26dc2e944b221c76e5a0";
       libraryHaskellDepends = [
         base chp containers deepseq extensible-exceptions HUnit pretty
         QuickCheck stm
       ];
       homepage = "http://www.cs.kent.ac.uk/projects/ofa/chp/";
       description = "A set of high-level concurrency utilities built on Communicating Haskell Processes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "chp-spec" = callPackage
    ({ mkDerivation, base, containers, deepseq, mtl, pretty
     , TypeCompose
     }:
     mkDerivation {
       pname = "chp-spec";
       version = "1.0.0";
       sha256 = "b13da7269e2189c3dc3addb0837d07772ddb24ed34b909d6bf6b21cec035344a";
       libraryHaskellDepends = [
         base containers deepseq mtl pretty TypeCompose
       ];
       jailbreak = true;
       homepage = "http://www.cs.kent.ac.uk/projects/ofa/chp/";
       description = "A mirror implementation of chp that generates a specification of the program";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "chp-transformers" = callPackage
    ({ mkDerivation, base, chp, chp-plus, transformers }:
     mkDerivation {
       pname = "chp-transformers";
       version = "1.0.0";
       sha256 = "43603e90ffb74b8eefec05ff3ea95cb42fe2d2371a8584a10bdad62e2f669034";
       libraryHaskellDepends = [ base chp chp-plus transformers ];
       jailbreak = true;
       homepage = "http://www.cs.kent.ac.uk/projects/ofa/chp/";
       description = "Transformers instances for the CHP library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "chronograph" = callPackage
    ({ mkDerivation, base, deepseq, ghc-prim, thyme, vector-space }:
     mkDerivation {
       pname = "chronograph";
       version = "0.2.0.1";
       sha256 = "e229751fc8b687d79033549b97d784a18b3c98254a73bc3c809288712d54c263";
       libraryHaskellDepends = [
         base deepseq ghc-prim thyme vector-space
       ];
       jailbreak = true;
       description = "measure timings of data evaluation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "chu2" = callPackage
    ({ mkDerivation, base, bytestring, data-default, hack2
     , hack2-handler-snap-server, utf8-string
     }:
     mkDerivation {
       pname = "chu2";
       version = "2012.11.20";
       sha256 = "3f364deec95014e56d5d15410b1ede411ed5a392ae9539a25568e908ff240307";
       libraryHaskellDepends = [
         base bytestring data-default hack2 hack2-handler-snap-server
         utf8-string
       ];
       homepage = "https://github.com/nfjinjing/chu2";
       description = "FFI for Chu2 Agda Web Server Interface";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "chuchu" = callPackage
    ({ mkDerivation, abacate, ansi-wl-pprint, base, cmdargs, HUnit
     , lifted-base, monad-control, parsec, text, transformers, unix
     }:
     mkDerivation {
       pname = "chuchu";
       version = "0.4.5";
       sha256 = "0cdb5b369c9e1876bd031281cbfaf3081c7132b2b88f72f4bd3cd2572ef5be13";
       libraryHaskellDepends = [
         abacate ansi-wl-pprint base cmdargs lifted-base monad-control
         parsec text transformers
       ];
       testHaskellDepends = [ base HUnit text transformers unix ];
       jailbreak = true;
       homepage = "http://github.com/marcotmarcot/chuchu";
       description = "Behaviour Driven Development like Cucumber for Haskell";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "chunked-data_0_1_0_1" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers
     , mono-traversable, semigroups, system-filepath, text, transformers
     , vector
     }:
     mkDerivation {
       pname = "chunked-data";
       version = "0.1.0.1";
       sha256 = "f9702c5ec695178a0de18e25dcb2e33d93ee5c7103098edbf0d0a6d86b3ab84d";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers mono-traversable
         semigroups system-filepath text transformers vector
       ];
       homepage = "https://github.com/fpco/chunked-data";
       description = "Typeclasses for dealing with various chunked data representations";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "chunked-data" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers
     , mono-traversable, semigroups, text, transformers, vector
     }:
     mkDerivation {
       pname = "chunked-data";
       version = "0.2.0";
       sha256 = "9aa0f3c81f9b0d7c1dde206501415f01638f20eebfbe1386dfd802bcc1bab272";
       revision = "2";
       editedCabalFile = "8e667f090de9d53e254c511c8658c15f3c097b7652611b4f65bfabd5151319d0";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers mono-traversable
         semigroups text transformers vector
       ];
       homepage = "https://github.com/fpco/chunked-data";
       description = "Typeclasses for dealing with various chunked data representations";
       license = stdenv.lib.licenses.mit;
     }) {};

  "chunks" = callPackage
    ({ mkDerivation, base, haskell98, parsec, template-haskell }:
     mkDerivation {
       pname = "chunks";
       version = "2007.4.18";
       sha256 = "7f3a9042423f7ed4484cdc2d8fe25e7af33f4de38c16a3defba5db053f8dbc61";
       libraryHaskellDepends = [ base haskell98 parsec template-haskell ];
       homepage = "http://www.wellquite.org/chunks/";
       description = "Simple template library with static safety";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "chunky" = callPackage
    ({ mkDerivation, base, binary, bytestring, HUnit, text }:
     mkDerivation {
       pname = "chunky";
       version = "0.1.0.0";
       sha256 = "6746c6d0f4ce1721a4b1f711f1760a1713369d3e9227348275755d5cd686e589";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base binary bytestring text ];
       executableHaskellDepends = [ base binary bytestring text ];
       testHaskellDepends = [ base binary bytestring HUnit text ];
       jailbreak = true;
       description = "Human-readable storage of text/binary objects";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "church-list" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "church-list";
       version = "0.0.2";
       sha256 = "bc87a1a726027f6184756ae2155fbaf9d27ef098b8031b927997a9742ce32d76";
       libraryHaskellDepends = [ base ];
       doHaddock = false;
       description = "Removed; please see fmlist";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cil" = callPackage
    ({ mkDerivation, base, bytestring, language-c }:
     mkDerivation {
       pname = "cil";
       version = "0.1.1";
       sha256 = "5f11907c80d6c83a8851d0e156ca3439a375a8696e368c41956370837d935939";
       libraryHaskellDepends = [ base bytestring language-c ];
       jailbreak = true;
       homepage = "http://tomahawkins.org";
       description = "An interface to CIL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cinvoke" = callPackage
    ({ mkDerivation, base, bytestring, cinvoke }:
     mkDerivation {
       pname = "cinvoke";
       version = "0.1";
       sha256 = "82ead108765cbdfe4bdc8a5aeaab112cfcbc82e7af70735de36c6668d53a3f5a";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ cinvoke ];
       homepage = "http://haskell.org/haskellwiki/Library/cinvoke";
       description = "A binding to cinvoke";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {cinvoke = null;};

  "cio" = callPackage
    ({ mkDerivation, base, monad-stm, mtl, parallel-io, stm }:
     mkDerivation {
       pname = "cio";
       version = "0.1.0";
       sha256 = "8bdebb177fb1c24b5d6eeb10503866c000c2295cbbdb0d237c2340e9dd622814";
       libraryHaskellDepends = [ base monad-stm mtl parallel-io stm ];
       homepage = "https://github.com/nikita-volkov/cio";
       description = "A monad for concurrent IO on a thread pool";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cipher-aes_0_2_9" = callPackage
    ({ mkDerivation, base, byteable, bytestring, crypto-cipher-tests
     , crypto-cipher-types, QuickCheck, securemem, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "cipher-aes";
       version = "0.2.9";
       sha256 = "985aadac75ef93b0762682a7ab20382c7108788b8e822fa1fb24c09c2b8279da";
       libraryHaskellDepends = [
         base byteable bytestring crypto-cipher-types securemem
       ];
       testHaskellDepends = [
         base byteable bytestring crypto-cipher-tests crypto-cipher-types
         QuickCheck test-framework test-framework-quickcheck2
       ];
       homepage = "http://github.com/vincenthz/hs-cipher-aes";
       description = "Fast AES cipher implementation with advanced mode of operations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cipher-aes_0_2_10" = callPackage
    ({ mkDerivation, base, byteable, bytestring, crypto-cipher-tests
     , crypto-cipher-types, QuickCheck, securemem, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "cipher-aes";
       version = "0.2.10";
       sha256 = "bf33e8226049f1bb21509d0adfb7001fd2472a718c46c8d9122bfa65cceef4e9";
       libraryHaskellDepends = [
         base byteable bytestring crypto-cipher-types securemem
       ];
       testHaskellDepends = [
         base byteable bytestring crypto-cipher-tests crypto-cipher-types
         QuickCheck test-framework test-framework-quickcheck2
       ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cipher-aes" = callPackage
    ({ mkDerivation, base, byteable, bytestring, crypto-cipher-tests
     , crypto-cipher-types, QuickCheck, securemem, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "cipher-aes";
       version = "0.2.11";
       sha256 = "d3b171895698c73da24d7ce97543f725d26637f038de670c0fd4012ca7f95015";
       libraryHaskellDepends = [
         base byteable bytestring crypto-cipher-types securemem
       ];
       testHaskellDepends = [
         base byteable bytestring crypto-cipher-tests crypto-cipher-types
         QuickCheck test-framework test-framework-quickcheck2
       ];
       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_0_6_4" = callPackage
    ({ mkDerivation, base, bytestring, cereal, crypto-api, tagged }:
     mkDerivation {
       pname = "cipher-aes128";
       version = "0.6.4";
       sha256 = "4a95c3f572aacbe3b0d68c593f45c16014ef96b5e38dd32a8fb6466e10bf7f24";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal crypto-api tagged
       ];
       homepage = "https://github.com/TomMD/cipher-aes128";
       description = "AES and common modes using AES-NI when available";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cipher-aes128" = callPackage
    ({ mkDerivation, base, bytestring, cereal, crypto-api, tagged }:
     mkDerivation {
       pname = "cipher-aes128";
       version = "0.7.0.1";
       sha256 = "18aecff826ca46e188062b972dfbda7360f6f73e2ffe45aa15bdc676debb7662";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal crypto-api tagged
       ];
       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-tests
     , crypto-cipher-types, QuickCheck, securemem, test-framework
     , test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "cipher-blowfish";
       version = "0.0.3";
       sha256 = "8f41170a851dba6d0b6f07298af3213baca09ab2a8aaf2adb733631feb3b6641";
       libraryHaskellDepends = [
         base byteable bytestring crypto-cipher-types securemem vector
       ];
       testHaskellDepends = [
         base byteable bytestring crypto-cipher-tests crypto-cipher-types
         QuickCheck test-framework test-framework-quickcheck2
       ];
       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-tests
     , crypto-cipher-types, QuickCheck, securemem, test-framework
     , test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "cipher-camellia";
       version = "0.0.2";
       sha256 = "8d0cd137cdb890646bb5d3bb52b20fa6d74e1b0c35d7d524d60edd9d43ace2a7";
       libraryHaskellDepends = [
         base byteable bytestring crypto-cipher-types securemem vector
       ];
       testHaskellDepends = [
         base byteable bytestring crypto-cipher-tests crypto-cipher-types
         QuickCheck test-framework test-framework-quickcheck2
       ];
       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-tests
     , crypto-cipher-types, QuickCheck, securemem, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "cipher-des";
       version = "0.0.6";
       sha256 = "85f1bccdec625a120ecf83b861afcb6478f8f899ceaa06fc083e642b54ff4ac7";
       libraryHaskellDepends = [
         base byteable bytestring crypto-cipher-types securemem
       ];
       testHaskellDepends = [
         base byteable bytestring crypto-cipher-tests crypto-cipher-types
         QuickCheck test-framework test-framework-quickcheck2
       ];
       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-tests
     , crypto-cipher-types, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "cipher-rc4";
       version = "0.1.4";
       sha256 = "c67e731bc9e7f3882e33609c3d9ec97b4e9bbd2f95cd882926acfb621970384d";
       libraryHaskellDepends = [
         base byteable bytestring crypto-cipher-types
       ];
       testHaskellDepends = [
         base bytestring crypto-cipher-tests crypto-cipher-types QuickCheck
         test-framework test-framework-quickcheck2
       ];
       homepage = "http://github.com/vincenthz/hs-cipher-rc4";
       description = "Fast RC4 cipher implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cipher-rc5" = callPackage
    ({ mkDerivation, base, split }:
     mkDerivation {
       pname = "cipher-rc5";
       version = "0.1.0.1";
       sha256 = "2e66cd9a8e8b7fe73ba7f88470781d6d0e1ec170cdd0850851f3b4056c9ba4d1";
       libraryHaskellDepends = [ base split ];
       jailbreak = true;
       homepage = "http://github.com/fegu/cipher-rc5";
       description = "Pure RC5 implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ciphersaber2" = callPackage
    ({ mkDerivation, array, base, bytestring, parseargs }:
     mkDerivation {
       pname = "ciphersaber2";
       version = "0.1.1.2";
       sha256 = "d64c809fff4312d71cf93b462c76a4f23b763d95b70d305b1091f3d5d240efb3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base bytestring ];
       executableHaskellDepends = [ array base bytestring parseargs ];
       homepage = "http://github.com/BartMassey/ciphersaber";
       description = "Implementation of CipherSaber2 RC4 cryptography";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "circ" = callPackage
    ({ mkDerivation, base, directory, mtl }:
     mkDerivation {
       pname = "circ";
       version = "0.0.4";
       sha256 = "ccce2238cb77669521e3a1252b917361f9b0242e2c7e0368038145ece53c7558";
       libraryHaskellDepends = [ base directory mtl ];
       description = "A Compiler IR Compiler";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "circle-packing_0_1_0_3" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "circle-packing";
       version = "0.1.0.3";
       sha256 = "e29d51825a0f1758978fc89bff3f0184f7fc4a371274a94e1cde06142c41c2b5";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Simple heuristic for packing discs of varying radii in a circle";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "circle-packing_0_1_0_4" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "circle-packing";
       version = "0.1.0.4";
       sha256 = "fbf504b60e14397bb3e45a087e741e579d66018eb83f986c25ff2c39e1f7daeb";
       libraryHaskellDepends = [ base ];
       description = "Simple heuristic for packing discs of varying radii in a circle";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "circle-packing" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "circle-packing";
       version = "0.1.0.5";
       sha256 = "041ad1ce696a66f747bb4c65102387cd15b7b026a4b1462d19b341733c2f5c9f";
       libraryHaskellDepends = [ base ];
       description = "Simple heuristic for packing discs of varying radii in a circle";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cirru-parser" = callPackage
    ({ mkDerivation, aeson, base, text, vector }:
     mkDerivation {
       pname = "cirru-parser";
       version = "0.0.2";
       sha256 = "3ff792385f4b0362b3454186f5ae891b649b67e5a527a294cefd27be32621687";
       libraryHaskellDepends = [ aeson base text vector ];
       homepage = "https://github.com/Cirru/parser.hs";
       description = "Cirru Parser in Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "citation-resolve" = callPackage
    ({ mkDerivation, aeson, base, bytestring, citeproc-hs, containers
     , curl, data-default, directory, doctest, download-curl, either
     , filepath, hspec, lens, MissingH, mtl, process, QuickCheck, safe
     , text, transformers, yaml
     }:
     mkDerivation {
       pname = "citation-resolve";
       version = "0.4.3";
       sha256 = "34c01af0f429736013c520721da0ca038575079256c03e08b4e14fa80f0da6f4";
       libraryHaskellDepends = [
         aeson base bytestring citeproc-hs containers curl data-default
         directory download-curl either lens mtl process safe text
         transformers yaml
       ];
       testHaskellDepends = [
         base directory doctest filepath hspec MissingH QuickCheck
       ];
       homepage = "https://github.com/nushio3/citation-resolve";
       description = "convert document IDs such as DOI, ISBN, arXiv ID to bibliographic reference";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "citeproc-hs" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , hexpat, hs-bibutils, HTTP, json, mtl, network, network-uri
     , old-locale, pandoc-types, parsec, syb, time, utf8-string
     }:
     mkDerivation {
       pname = "citeproc-hs";
       version = "0.3.10";
       sha256 = "1928db4f4c00f6722281f25171fc58412ec74c5e42adfc901a33a20dd10e65b9";
       libraryHaskellDepends = [
         base bytestring containers directory filepath hexpat hs-bibutils
         HTTP json mtl network network-uri old-locale pandoc-types parsec
         syb time utf8-string
       ];
       jailbreak = true;
       homepage = "http://istitutocolli.org/repos/citeproc-hs/";
       description = "A Citation Style Language implementation in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "citeproc-hs-pandoc-filter" = callPackage
    ({ mkDerivation, aeson, base, bytestring, citeproc-hs, containers
     , directory, filepath, mtl, pandoc, pandoc-types, parsec, tagsoup
     , texmath, utf8-string, yaml
     }:
     mkDerivation {
       pname = "citeproc-hs-pandoc-filter";
       version = "0.1";
       sha256 = "d276c62b696b8d70dd5e7c3a5de94d0a554b708523f4937b6f78770f2aaf9acf";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring citeproc-hs containers directory filepath mtl
         pandoc pandoc-types parsec tagsoup texmath utf8-string yaml
       ];
       homepage = "http://istitutocolli.org/repos/citeproc-hs-pandoc-filter/";
       description = "A Pandoc filter for processing bibliographic references with citeproc-hs";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cityhash" = callPackage
    ({ mkDerivation, base, bytestring, largeword, QuickCheck
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "cityhash";
       version = "0.3.0.1";
       sha256 = "26f6b94f21f530fce2e4772de0d2ecad159d4cb6b5144ea17f536abb33d620db";
       libraryHaskellDepends = [ base bytestring largeword ];
       testHaskellDepends = [
         base bytestring largeword QuickCheck test-framework
         test-framework-quickcheck2
       ];
       homepage = "http://github.com/thoughtpolice/hs-cityhash";
       description = "Bindings to CityHash";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "cjk" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, text
     , text-icu
     }:
     mkDerivation {
       pname = "cjk";
       version = "0.1.0.1";
       sha256 = "742732f475e8842168cf8d4ad69e292e1c9538bd297cec2a980c4ebcc7e019e4";
       libraryHaskellDepends = [
         attoparsec base bytestring containers text text-icu
       ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/batterseapower/cjk";
       description = "Data about Chinese, Japanese and Korean characters and languages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clac" = callPackage
    ({ mkDerivation, base, containers, dsp, optparse-applicative
     , plailude, pretty-tree, safe, split
     }:
     mkDerivation {
       pname = "clac";
       version = "0.5.0";
       sha256 = "48f9a94ed851f59143a5a143662c12e763cdbcd46a72f2a6f04257a2ea804aaa";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers dsp optparse-applicative plailude pretty-tree safe
         split
       ];
       jailbreak = true;
       description = "Simple CLI RPN calculator";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "clafer" = callPackage
    ({ mkDerivation, aeson, alex, array, base, bytestring, cmdargs
     , containers, data-stringmap, directory, doctest, executable-path
     , file-embed, filepath, happy, HTTP, HUnit, json-builder, lens
     , lens-aeson, mtl, mtl-compat, network, network-uri, parsec
     , process, QuickCheck, split, string-conversions, tasty
     , tasty-hunit, tasty-th, text, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "clafer";
       version = "0.4.3";
       sha256 = "0be4dd9ab5551e247e69bf9b8863de4f6615a38e26e4c51d3f0bf214478585e4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array base bytestring cmdargs containers data-stringmap
         directory executable-path file-embed filepath HTTP json-builder
         lens lens-aeson mtl mtl-compat network network-uri parsec process
         split string-conversions text transformers transformers-compat
       ];
       libraryToolDepends = [ alex happy ];
       executableHaskellDepends = [
         base cmdargs containers filepath mtl process split
       ];
       testHaskellDepends = [
         base containers data-stringmap directory doctest filepath HUnit
         lens lens-aeson mtl mtl-compat QuickCheck tasty tasty-hunit
         tasty-th transformers-compat
       ];
       jailbreak = true;
       homepage = "http://clafer.org";
       description = "Compiles Clafer models to other formats: Alloy, JavaScript, JSON, HTML, Dot";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "claferIG" = callPackage
    ({ mkDerivation, array, base, clafer, cmdargs, containers
     , data-stringmap, directory, executable-path, filepath, haskeline
     , HaXml, HUnit, json-builder, mtl, mtl-compat, parsec, process
     , string-conversions, tasty, tasty-hunit, tasty-th, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "claferIG";
       version = "0.4.3";
       sha256 = "e3afbf8d5a057a54bf0e41a0ad19259f284ab2b7c33f208b08426f1436c52fc3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base clafer containers data-stringmap directory
         executable-path filepath haskeline HaXml json-builder mtl
         mtl-compat parsec process string-conversions transformers
         transformers-compat
       ];
       executableHaskellDepends = [
         base clafer cmdargs containers directory executable-path filepath
         haskeline mtl mtl-compat transformers transformers-compat
       ];
       testHaskellDepends = [
         array base clafer cmdargs directory filepath HUnit tasty
         tasty-hunit tasty-th transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://clafer.org";
       description = "claferIG is an interactive tool that generates instances of Clafer models";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "claferwiki" = callPackage
    ({ mkDerivation, base, clafer, containers, directory, gitit
     , MissingH, mtl, network, network-uri, process, SHA, split, time
     , transformers, transformers-compat, utf8-string
     }:
     mkDerivation {
       pname = "claferwiki";
       version = "0.4.3";
       sha256 = "7a582f4e59757ea00346f01ced2ef917ea8640941c45c3a407fe7760a5aa483c";
       libraryHaskellDepends = [
         base clafer containers directory gitit MissingH mtl network
         network-uri process SHA split time transformers transformers-compat
         utf8-string
       ];
       jailbreak = true;
       homepage = "http://github.com/gsdlab/claferwiki";
       description = "A wiki-based IDE for literate modeling with Clafer";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clang-pure" = callPackage
    ({ mkDerivation, base, bytestring, clang, containers, contravariant
     , inline-c, stm, template-haskell, vector
     }:
     mkDerivation {
       pname = "clang-pure";
       version = "0.1.0.0";
       sha256 = "7c5cfef49732236bc6d6da95b89087c07447d9bf235c032c16c7e6850a747b08";
       libraryHaskellDepends = [
         base bytestring containers contravariant inline-c stm
         template-haskell vector
       ];
       librarySystemDepends = [ clang ];
       description = "Pure C++ code analysis with libclang";
       license = stdenv.lib.licenses.asl20;
     }) {inherit (self.llvmPackages) clang;};

  "clanki" = callPackage
    ({ mkDerivation, base, bytestring, directory, safe, strict, time }:
     mkDerivation {
       pname = "clanki";
       version = "1.2.6";
       sha256 = "97cbfea975eb7a49f86ca5cbad2ece1818fd8dee47740f934c9a0d33ffdfb3a0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory safe strict time
       ];
       description = "Command-line spaced-repetition software";
       license = stdenv.lib.licenses.mit;
     }) {};

  "clarifai" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, easy-file
     , HTTP, http-client, lens, lens-aeson, scientific, text
     , unordered-containers, vector, wreq
     }:
     mkDerivation {
       pname = "clarifai";
       version = "0.2.0.0";
       sha256 = "4a382f92c21d1571861ddb557f721edce63c9b356960ea74a779175e13c41d2d";
       libraryHaskellDepends = [
         aeson base bytestring containers easy-file HTTP http-client lens
         lens-aeson scientific text unordered-containers vector wreq
       ];
       description = "API Client for the Clarifai API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "clash" = callPackage
    ({ mkDerivation, base, containers, data-accessor
     , data-accessor-template, directory, filepath, ghc, haskell98
     , pretty, prettyclass, template-haskell, tfp, th-lift, time
     , transformers, utility-ht, vhdl
     }:
     mkDerivation {
       pname = "clash";
       version = "0.1.3.11";
       sha256 = "1dfa7702639d1261a49934cad944272a094a30f099faacda2e77fbe3cd83ed10";
       libraryHaskellDepends = [
         base containers data-accessor data-accessor-template directory
         filepath ghc haskell98 pretty prettyclass template-haskell tfp
         th-lift time transformers utility-ht vhdl
       ];
       jailbreak = true;
       homepage = "http://clash.ewi.utwente.nl/";
       description = "CAES Language for Synchronous Hardware (CLaSH)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-ghc_0_5_11" = callPackage
    ({ mkDerivation, array, base, bifunctors, bytestring, clash-lib
     , clash-prelude, clash-systemverilog, clash-verilog, clash-vhdl
     , containers, directory, filepath, ghc, ghc-typelits-natnormalise
     , hashable, haskeline, lens, mtl, process, text, transformers
     , unbound-generics, unix, unordered-containers
     }:
     mkDerivation {
       pname = "clash-ghc";
       version = "0.5.11";
       sha256 = "efbdf2e6ef43b8dc59f8dd918d997f68cdd83ab92f04f5643b54f028d6218cd3";
       revision = "1";
       editedCabalFile = "3044314296cb2fd9414ffc5ef600e051b88e3c1c920b7dd5f67da472998e0b32";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bifunctors bytestring clash-lib clash-prelude
         clash-systemverilog clash-verilog clash-vhdl containers directory
         filepath ghc ghc-typelits-natnormalise hashable haskeline lens mtl
         process text transformers unbound-generics unix
         unordered-containers
       ];
       jailbreak = true;
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-ghc_0_5_13" = callPackage
    ({ mkDerivation, array, base, bifunctors, bytestring, clash-lib
     , clash-prelude, clash-systemverilog, clash-verilog, clash-vhdl
     , containers, directory, filepath, ghc, ghc-typelits-natnormalise
     , hashable, haskeline, lens, mtl, process, text, transformers
     , unbound-generics, unix, unordered-containers
     }:
     mkDerivation {
       pname = "clash-ghc";
       version = "0.5.13";
       sha256 = "135104a2d23bb86a686c0043d9b95307d766431e3beb98d06d41676ec4bdbcb2";
       revision = "1";
       editedCabalFile = "396817fac16ea3e29675c3a6e13e02c2eed7155c5c6361bb291e77307fbc7851";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bifunctors bytestring clash-lib clash-prelude
         clash-systemverilog clash-verilog clash-vhdl containers directory
         filepath ghc ghc-typelits-natnormalise hashable haskeline lens mtl
         process text transformers unbound-generics unix
         unordered-containers
       ];
       jailbreak = true;
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-ghc_0_5_14" = callPackage
    ({ mkDerivation, array, base, bifunctors, bytestring, clash-lib
     , clash-prelude, clash-systemverilog, clash-verilog, clash-vhdl
     , containers, directory, filepath, ghc, ghc-typelits-natnormalise
     , hashable, haskeline, lens, mtl, process, text, transformers
     , unbound-generics, unix, unordered-containers
     }:
     mkDerivation {
       pname = "clash-ghc";
       version = "0.5.14";
       sha256 = "84b931a8b22c253eb324d3e0e5afe92f49a09870c6e06fb9e37efc0c2c8ca8d5";
       revision = "1";
       editedCabalFile = "2dfee368e718de9199b29cb091a33d2fec7b6006fa8053756b24bb3cbb44528f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bifunctors bytestring clash-lib clash-prelude
         clash-systemverilog clash-verilog clash-vhdl containers directory
         filepath ghc ghc-typelits-natnormalise hashable haskeline lens mtl
         process text transformers unbound-generics unix
         unordered-containers
       ];
       jailbreak = true;
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-ghc_0_5_15" = callPackage
    ({ mkDerivation, array, base, bifunctors, bytestring, clash-lib
     , clash-prelude, clash-systemverilog, clash-verilog, clash-vhdl
     , containers, directory, filepath, ghc, ghc-typelits-natnormalise
     , hashable, haskeline, lens, mtl, process, text, transformers
     , unbound-generics, unix, unordered-containers
     }:
     mkDerivation {
       pname = "clash-ghc";
       version = "0.5.15";
       sha256 = "54799a12bd0a01e0a1814caef51504301c843c4f745b7110a3542cc6043215e3";
       revision = "1";
       editedCabalFile = "2e620f3c94f1bd3039f7e8cbdd5f3f547182b4a657fcb2a5d05554d378b2ae6b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bifunctors bytestring clash-lib clash-prelude
         clash-systemverilog clash-verilog clash-vhdl containers directory
         filepath ghc ghc-typelits-natnormalise hashable haskeline lens mtl
         process text transformers unbound-generics unix
         unordered-containers
       ];
       jailbreak = true;
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-ghc_0_6_7" = callPackage
    ({ mkDerivation, array, base, bifunctors, bytestring, clash-lib
     , clash-prelude, clash-systemverilog, clash-verilog, clash-vhdl
     , containers, directory, filepath, ghc, ghc-typelits-extra
     , ghc-typelits-natnormalise, hashable, haskeline, lens, mtl
     , process, text, transformers, unbound-generics, unix
     , unordered-containers
     }:
     mkDerivation {
       pname = "clash-ghc";
       version = "0.6.7";
       sha256 = "08eb23a3986af41ede3dca432e3f4ac0d80d0ae5cfc6af6115e8943447264a52";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bifunctors bytestring clash-lib clash-prelude
         clash-systemverilog clash-verilog clash-vhdl containers directory
         filepath ghc ghc-typelits-extra ghc-typelits-natnormalise hashable
         haskeline lens mtl process text transformers unbound-generics unix
         unordered-containers
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-ghc_0_6_8" = callPackage
    ({ mkDerivation, array, base, bifunctors, bytestring, clash-lib
     , clash-prelude, clash-systemverilog, clash-verilog, clash-vhdl
     , containers, directory, filepath, ghc, ghc-typelits-extra
     , ghc-typelits-natnormalise, hashable, haskeline, lens, mtl
     , process, text, transformers, unbound-generics, unix
     , unordered-containers
     }:
     mkDerivation {
       pname = "clash-ghc";
       version = "0.6.8";
       sha256 = "3d7adf1cb5a895a2240fdd74f94540719cf804a0aa3eb3bfc89ef5b0a8644059";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bifunctors bytestring clash-lib clash-prelude
         clash-systemverilog clash-verilog clash-vhdl containers directory
         filepath ghc ghc-typelits-extra ghc-typelits-natnormalise hashable
         haskeline lens mtl process text transformers unbound-generics unix
         unordered-containers
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-ghc_0_6_9" = callPackage
    ({ mkDerivation, array, base, bifunctors, bytestring, clash-lib
     , clash-prelude, clash-systemverilog, clash-verilog, clash-vhdl
     , containers, directory, filepath, ghc, ghc-typelits-extra
     , ghc-typelits-natnormalise, hashable, haskeline, lens, mtl
     , process, text, transformers, unbound-generics, unix
     , unordered-containers
     }:
     mkDerivation {
       pname = "clash-ghc";
       version = "0.6.9";
       sha256 = "c6f87e8c87fa30cdf58320ea1950e24b7413115febfbf26c64912863df1ebbfb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bifunctors bytestring clash-lib clash-prelude
         clash-systemverilog clash-verilog clash-vhdl containers directory
         filepath ghc ghc-typelits-extra ghc-typelits-natnormalise hashable
         haskeline lens mtl process text transformers unbound-generics unix
         unordered-containers
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-ghc" = callPackage
    ({ mkDerivation, array, base, bifunctors, bytestring, clash-lib
     , clash-prelude, clash-systemverilog, clash-verilog, clash-vhdl
     , containers, directory, filepath, ghc, ghc-typelits-extra
     , ghc-typelits-natnormalise, hashable, haskeline, lens, mtl
     , process, text, transformers, unbound-generics, unix
     , unordered-containers
     }:
     mkDerivation {
       pname = "clash-ghc";
       version = "0.6.10";
       sha256 = "5f8280cd4e71313c0b54942d34bcb698c1792e10d87da56f673b23ef7792ebcb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bifunctors bytestring clash-lib clash-prelude
         clash-systemverilog clash-verilog clash-vhdl containers directory
         filepath ghc ghc-typelits-extra ghc-typelits-natnormalise hashable
         haskeline lens mtl process text transformers unbound-generics unix
         unordered-containers
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "clash-lib_0_5_10" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, clash-prelude
     , concurrent-supply, containers, deepseq, directory, errors, fgl
     , filepath, hashable, lens, mtl, pretty, process, template-haskell
     , text, time, transformers, unbound-generics, unordered-containers
     , uu-parsinglib, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-lib";
       version = "0.5.10";
       sha256 = "b42daab696bbde48f4fd0af8e04bf4a5f268e5ebaa947f5669f9cd938329320d";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring clash-prelude concurrent-supply
         containers deepseq directory errors fgl filepath hashable lens mtl
         pretty process template-haskell text time transformers
         unbound-generics unordered-containers uu-parsinglib wl-pprint-text
       ];
       jailbreak = true;
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - As a Library";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-lib_0_5_11" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, clash-prelude
     , concurrent-supply, containers, deepseq, directory, errors, fgl
     , filepath, hashable, lens, mtl, pretty, process, template-haskell
     , text, time, transformers, unbound-generics, unordered-containers
     , uu-parsinglib, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-lib";
       version = "0.5.11";
       sha256 = "9b7b6b96d2a64fc24bc5379083ef023d7cc7e23d7cc2fe8a926682742ce59b6b";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring clash-prelude concurrent-supply
         containers deepseq directory errors fgl filepath hashable lens mtl
         pretty process template-haskell text time transformers
         unbound-generics unordered-containers uu-parsinglib wl-pprint-text
       ];
       jailbreak = true;
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - As a Library";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-lib_0_5_12" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, clash-prelude
     , concurrent-supply, containers, deepseq, directory, errors, fgl
     , filepath, hashable, lens, mtl, pretty, process, template-haskell
     , text, time, transformers, unbound-generics, unordered-containers
     , uu-parsinglib, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-lib";
       version = "0.5.12";
       sha256 = "13af8f85ea2375dbc603048089e4a374cc0f93b00fa16f1d2b53a72ec30580e5";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring clash-prelude concurrent-supply
         containers deepseq directory errors fgl filepath hashable lens mtl
         pretty process template-haskell text time transformers
         unbound-generics unordered-containers uu-parsinglib wl-pprint-text
       ];
       jailbreak = true;
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - As a Library";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-lib_0_5_13" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, clash-prelude
     , concurrent-supply, containers, deepseq, directory, errors, fgl
     , filepath, hashable, lens, mtl, pretty, process, template-haskell
     , text, time, transformers, unbound-generics, unordered-containers
     , uu-parsinglib, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-lib";
       version = "0.5.13";
       sha256 = "d2440a3f0ff9df8b4b2b374b8c934da1c90cd9e57ed74aea3b682a99c84fd579";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring clash-prelude concurrent-supply
         containers deepseq directory errors fgl filepath hashable lens mtl
         pretty process template-haskell text time transformers
         unbound-generics unordered-containers uu-parsinglib wl-pprint-text
       ];
       jailbreak = true;
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - As a Library";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-lib_0_6_7" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, clash-prelude
     , concurrent-supply, containers, deepseq, directory, errors, fgl
     , filepath, hashable, lens, mtl, pretty, process, template-haskell
     , text, time, transformers, unbound-generics, unordered-containers
     , uu-parsinglib, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-lib";
       version = "0.6.7";
       sha256 = "26dd3e636ac6ea644d30d7bd583c57e80ed5c99f2a7d145852b3234df25a2ccf";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring clash-prelude concurrent-supply
         containers deepseq directory errors fgl filepath hashable lens mtl
         pretty process template-haskell text time transformers
         unbound-generics unordered-containers uu-parsinglib wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - As a Library";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-lib_0_6_8" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, clash-prelude
     , concurrent-supply, containers, deepseq, directory, errors, fgl
     , filepath, hashable, lens, mtl, pretty, process, template-haskell
     , text, time, transformers, unbound-generics, unordered-containers
     , uu-parsinglib, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-lib";
       version = "0.6.8";
       sha256 = "7582ce8364d2e3d2793555d7a80aa0ab90489cabbe9d8640272f9d95d7abec7d";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring clash-prelude concurrent-supply
         containers deepseq directory errors fgl filepath hashable lens mtl
         pretty process template-haskell text time transformers
         unbound-generics unordered-containers uu-parsinglib wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - As a Library";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-lib_0_6_9" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, clash-prelude
     , concurrent-supply, containers, deepseq, directory, errors, fgl
     , filepath, hashable, lens, mtl, pretty, process, template-haskell
     , text, time, transformers, unbound-generics, unordered-containers
     , uu-parsinglib, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-lib";
       version = "0.6.9";
       sha256 = "b5de3d8e2b87d7b0b9e24721cadf4fff4c5de1bbc3338556269e0978d5cceded";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring clash-prelude concurrent-supply
         containers deepseq directory errors fgl filepath hashable lens mtl
         pretty process template-haskell text time transformers
         unbound-generics unordered-containers uu-parsinglib wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - As a Library";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-lib" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, clash-prelude
     , concurrent-supply, containers, deepseq, directory, errors, fgl
     , filepath, hashable, lens, mtl, pretty, process, template-haskell
     , text, time, transformers, unbound-generics, unordered-containers
     , uu-parsinglib, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-lib";
       version = "0.6.10";
       sha256 = "93cb93dac0201f23a9821b02f4e908ef0b47f71f7da7f83f71c0a8bfa125a8e2";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring clash-prelude concurrent-supply
         containers deepseq directory errors fgl filepath hashable lens mtl
         pretty process template-haskell text time transformers
         unbound-generics unordered-containers uu-parsinglib wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - As a Library";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "clash-prelude_0_9_2" = callPackage
    ({ mkDerivation, array, base, data-default, doctest, ghc-prim
     , ghc-typelits-natnormalise, Glob, integer-gmp, lens, QuickCheck
     , singletons, template-haskell, th-lift
     }:
     mkDerivation {
       pname = "clash-prelude";
       version = "0.9.2";
       sha256 = "11f8997503a00452e543d1bcb3d984bc79332cde5b30f1782bafec8b572d87be";
       revision = "1";
       editedCabalFile = "c2165cbe11e6b0e0acadbe0a6e822c1df9a4b12bf2825831badbc5dae9bba65a";
       libraryHaskellDepends = [
         array base data-default ghc-prim ghc-typelits-natnormalise
         integer-gmp lens QuickCheck singletons template-haskell th-lift
       ];
       testHaskellDepends = [ base doctest Glob ];
       jailbreak = true;
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - Prelude library";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-prelude_0_9_3" = callPackage
    ({ mkDerivation, array, base, data-default, doctest, ghc-prim
     , ghc-typelits-natnormalise, Glob, integer-gmp, lens, QuickCheck
     , singletons, template-haskell, th-lift
     }:
     mkDerivation {
       pname = "clash-prelude";
       version = "0.9.3";
       sha256 = "3cfcc4aa822a251dc2ea2e31e2bf3c15a37fe63ec859ea16aaa0fe3f31913315";
       libraryHaskellDepends = [
         array base data-default ghc-prim ghc-typelits-natnormalise
         integer-gmp lens QuickCheck singletons template-haskell th-lift
       ];
       testHaskellDepends = [ base doctest Glob ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - Prelude library";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-prelude_0_10_4" = callPackage
    ({ mkDerivation, array, base, data-default, doctest, ghc-prim
     , ghc-typelits-extra, ghc-typelits-natnormalise, Glob, integer-gmp
     , lens, QuickCheck, reflection, singletons, template-haskell
     , th-lift
     }:
     mkDerivation {
       pname = "clash-prelude";
       version = "0.10.4";
       sha256 = "0e61217e0cb01a88daae477ce3dffb22c347cfa7165a09718bf8d51d6329e180";
       libraryHaskellDepends = [
         array base data-default ghc-prim ghc-typelits-extra
         ghc-typelits-natnormalise integer-gmp lens QuickCheck reflection
         singletons template-haskell th-lift
       ];
       testHaskellDepends = [ base doctest Glob ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - Prelude library";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-prelude_0_10_5" = callPackage
    ({ mkDerivation, array, base, data-default, doctest, ghc-prim
     , ghc-typelits-extra, ghc-typelits-natnormalise, integer-gmp, lens
     , QuickCheck, reflection, singletons, template-haskell, th-lift
     }:
     mkDerivation {
       pname = "clash-prelude";
       version = "0.10.5";
       sha256 = "5a840a84f1ec02f1c2537b4ee9de0a1d98b71c401e4726e298b108a5ccad39fb";
       libraryHaskellDepends = [
         array base data-default ghc-prim ghc-typelits-extra
         ghc-typelits-natnormalise integer-gmp lens QuickCheck reflection
         singletons template-haskell th-lift
       ];
       testHaskellDepends = [ base doctest ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - Prelude library";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-prelude" = callPackage
    ({ mkDerivation, array, base, data-default, doctest, ghc-prim
     , ghc-typelits-extra, ghc-typelits-natnormalise, integer-gmp, lens
     , QuickCheck, reflection, singletons, template-haskell, th-lift
     }:
     mkDerivation {
       pname = "clash-prelude";
       version = "0.10.6";
       sha256 = "7056c0ac7b2fecbb9cabb3e8ac029e0a269265fa40b361089d4a3af53e6e9237";
       libraryHaskellDepends = [
         array base data-default ghc-prim ghc-typelits-extra
         ghc-typelits-natnormalise integer-gmp lens QuickCheck reflection
         singletons template-haskell th-lift
       ];
       testHaskellDepends = [ base doctest ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - Prelude library";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "clash-prelude-quickcheck" = callPackage
    ({ mkDerivation, base, clash-prelude, QuickCheck }:
     mkDerivation {
       pname = "clash-prelude-quickcheck";
       version = "0.1.2.1";
       sha256 = "1c1c0e373578e15b04b92bdf2b857192bd855005ce3e2f7436b4572a1ee5c5ba";
       libraryHaskellDepends = [ base clash-prelude QuickCheck ];
       jailbreak = true;
       description = "QuickCheck instances for various types in the CλaSH Prelude";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-systemverilog_0_5_7" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-systemverilog";
       version = "0.5.7";
       sha256 = "a5aae9795f3ecf3dad39197b7e518a164170132e893baeb2ab6aa90289c61e69";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - SystemVerilog backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-systemverilog_0_5_8" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-systemverilog";
       version = "0.5.8";
       sha256 = "cf7a6589a7d67960bac4533ea0a31d13d081b781b4598b07d04a6a895ab03036";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - SystemVerilog backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-systemverilog_0_5_9" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-systemverilog";
       version = "0.5.9";
       sha256 = "740b51f023cea8d640f6fb1d736957ba90fe2ad43b47d98d063f35e604c27a4e";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - SystemVerilog backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-systemverilog_0_5_10" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-systemverilog";
       version = "0.5.10";
       sha256 = "511310bdf943ecd2b1aeb87e22474e4a1bd9a4c6e881c8ba0733c6a097ae3e35";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - SystemVerilog backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-systemverilog_0_6_3" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-systemverilog";
       version = "0.6.3";
       sha256 = "09eb0b12b909646a9502bbea399496b0f837683d4515effd2ce735decbd90b78";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - SystemVerilog backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-systemverilog_0_6_4" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-systemverilog";
       version = "0.6.4";
       sha256 = "18172fec133b0971b216997e6421ddbb5575431634f5543b17674d7fab2855e5";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - SystemVerilog backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-systemverilog" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-systemverilog";
       version = "0.6.5";
       sha256 = "687ee5931b035fdd8e1cbd45b7c1f99a7020103834afcf4fa819b6d8026e0536";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - SystemVerilog backend";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "clash-verilog_0_5_7" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-verilog";
       version = "0.5.7";
       sha256 = "72904082f2d03fd075c7b7ed0811e97daf707ac899b751885d624204823f8a13";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - Verilog backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-verilog_0_5_8" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-verilog";
       version = "0.5.8";
       sha256 = "1b90d23a2d81e8c0962c22c8ae4b9ceb16ce1e64768f684476a4b50eec0c296e";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - Verilog backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-verilog_0_5_9" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-verilog";
       version = "0.5.9";
       sha256 = "9e4718b93d07b00b311f55aef1623a7aa35dacce2e0be4e293caa05eb8d1c0a9";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - Verilog backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-verilog_0_5_10" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-verilog";
       version = "0.5.10";
       sha256 = "1a6ad070087a464a4eed05f8bc30cd92d000d8c02be33cbef08f973e9624bb03";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - Verilog backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-verilog_0_6_3" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-verilog";
       version = "0.6.3";
       sha256 = "10148bb672fdd62866b6f9c2f1aa0144e366331c2091210d52b3a321537197f8";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - Verilog backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-verilog_0_6_4" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-verilog";
       version = "0.6.4";
       sha256 = "178fa48768fbdf99f121ee34701431c788451bcb2411cca2156cdf4bedc1b4da";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - Verilog backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-verilog" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-verilog";
       version = "0.6.5";
       sha256 = "6ddf7f1a16a9308632a5e47d7f7cbf7164f1efee1733c0ca59e6edf175d7d840";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - Verilog backend";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "clash-vhdl_0_5_8" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-vhdl";
       version = "0.5.8";
       sha256 = "1cb035f474c64fd3afef98ea268698ff626447b16fc79991c75222aaeca61723";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - VHDL backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-vhdl_0_5_10" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-vhdl";
       version = "0.5.10";
       sha256 = "a971c2bd050dc76c04b769952df63364a60abf868d5de5a47a892e649daf330a";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - VHDL backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-vhdl_0_5_11" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-vhdl";
       version = "0.5.11";
       sha256 = "36ac0973b14928b38b1a8cf404aeeaa9e26958f2eebe624d3370551bb39467ad";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - VHDL backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-vhdl_0_5_12" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-vhdl";
       version = "0.5.12";
       sha256 = "fe91d7635fb1278ee99c757ac0dc1965b04ec37a91db115d85692cf5a166d511";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - VHDL backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-vhdl_0_6_4" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-vhdl";
       version = "0.6.4";
       sha256 = "6584b069730f25e3c8a6aec8ca1836a10a13d16102accbe5072aea2c5f3a592c";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - VHDL backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-vhdl_0_6_5" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-vhdl";
       version = "0.6.5";
       sha256 = "a613685f811411452739bd13d6616be1314ec110e0f7b9a2f42e8d07d8c652f5";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - VHDL backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-vhdl_0_6_6" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-vhdl";
       version = "0.6.6";
       sha256 = "14023afa8445712f4bb40a3a5bf02b44c84bb87643366b50e615cea54baff293";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - VHDL backend";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clash-vhdl" = callPackage
    ({ mkDerivation, base, clash-lib, clash-prelude, fgl, lens, mtl
     , text, unordered-containers, wl-pprint-text
     }:
     mkDerivation {
       pname = "clash-vhdl";
       version = "0.6.7";
       sha256 = "bbf5d4f3261dcf2f0ff570cce475045cf7f32001f6ef62980f522c64eafc5a51";
       libraryHaskellDepends = [
         base clash-lib clash-prelude fgl lens mtl text unordered-containers
         wl-pprint-text
       ];
       homepage = "http://www.clash-lang.org/";
       description = "CAES Language for Synchronous Hardware - VHDL backend";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "classify" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "classify";
       version = "2013.11.6.1";
       sha256 = "997fcd7b96a5148657219106f6af0bee4d07bc6785a12bdd66e42d0cf1f3a40d";
       libraryHaskellDepends = [ base containers mtl ];
       description = "Library for classification of media files";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "classy-parallel" = callPackage
    ({ mkDerivation, base, lifted-base, monad-control, parallel
     , resourcet, transformers
     }:
     mkDerivation {
       pname = "classy-parallel";
       version = "0.1.0.0";
       sha256 = "3b0887ff82ea1d20426f0eba6dd23827ee1655790a0e322e619f3bf1ce98d16d";
       libraryHaskellDepends = [
         base lifted-base monad-control parallel resourcet transformers
       ];
       jailbreak = true;
       description = "Fork of the monad-parallel package using monad-control";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "classy-prelude_0_10_2" = callPackage
    ({ mkDerivation, base, basic-prelude, bifunctors, bytestring
     , chunked-data, containers, enclosed-exceptions, exceptions
     , ghc-prim, hashable, hspec, lifted-base, mono-traversable, mtl
     , old-locale, primitive, QuickCheck, semigroups, stm
     , system-filepath, text, time, transformers, unordered-containers
     , vector, vector-instances
     }:
     mkDerivation {
       pname = "classy-prelude";
       version = "0.10.2";
       sha256 = "f3341ddb9a469f612263d94274144510209f16ed4d9ec709ad622f3d5f36015f";
       libraryHaskellDepends = [
         base basic-prelude bifunctors bytestring chunked-data containers
         enclosed-exceptions exceptions ghc-prim hashable lifted-base
         mono-traversable mtl old-locale primitive semigroups stm
         system-filepath text time transformers unordered-containers vector
         vector-instances
       ];
       testHaskellDepends = [
         base containers hspec QuickCheck transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "A typeclass-based Prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude_0_10_4" = callPackage
    ({ mkDerivation, base, basic-prelude, bifunctors, bytestring
     , chunked-data, containers, enclosed-exceptions, exceptions
     , ghc-prim, hashable, hspec, lifted-base, mono-traversable, mtl
     , old-locale, primitive, QuickCheck, semigroups, stm
     , system-filepath, text, time, transformers, unordered-containers
     , vector, vector-instances
     }:
     mkDerivation {
       pname = "classy-prelude";
       version = "0.10.4";
       sha256 = "e6fb56bfe0b38b9d084f5f398492a2cbc8093771f32ca561d24c5df8c5f1049c";
       libraryHaskellDepends = [
         base basic-prelude bifunctors bytestring chunked-data containers
         enclosed-exceptions exceptions ghc-prim hashable lifted-base
         mono-traversable mtl old-locale primitive semigroups stm
         system-filepath text time transformers unordered-containers vector
         vector-instances
       ];
       testHaskellDepends = [
         base containers hspec QuickCheck transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "A typeclass-based Prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude_0_10_5" = callPackage
    ({ mkDerivation, base, basic-prelude, bifunctors, bytestring
     , chunked-data, containers, enclosed-exceptions, exceptions
     , ghc-prim, hashable, hspec, lifted-base, mono-traversable, mtl
     , mutable-containers, old-locale, primitive, QuickCheck, semigroups
     , stm, system-filepath, text, time, transformers
     , unordered-containers, vector, vector-instances
     }:
     mkDerivation {
       pname = "classy-prelude";
       version = "0.10.5";
       sha256 = "c3ebf83dd83fd6d370dbc403121e40397ed142ffb2e7071317a2f4a365f330e9";
       libraryHaskellDepends = [
         base basic-prelude bifunctors bytestring chunked-data containers
         enclosed-exceptions exceptions ghc-prim hashable lifted-base
         mono-traversable mtl mutable-containers old-locale primitive
         semigroups stm system-filepath text time transformers
         unordered-containers vector vector-instances
       ];
       testHaskellDepends = [
         base containers hspec QuickCheck transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "A typeclass-based Prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude_0_11_0" = callPackage
    ({ mkDerivation, base, basic-prelude, bifunctors, bytestring
     , chunked-data, containers, dlist, enclosed-exceptions, exceptions
     , ghc-prim, hashable, hspec, lifted-base, mono-traversable, mtl
     , mutable-containers, old-locale, primitive, QuickCheck, semigroups
     , stm, system-filepath, text, time, transformers
     , unordered-containers, vector, vector-instances
     }:
     mkDerivation {
       pname = "classy-prelude";
       version = "0.11.0";
       sha256 = "ce36f9cfa3d5c2652a308e5caa476f8b1d82e95472b01ad6ec03b91c75add81d";
       revision = "1";
       editedCabalFile = "c81bf68ba89e8e7959a28ef72534c68754a25751b835cb1f8b8319a57e870a49";
       libraryHaskellDepends = [
         base basic-prelude bifunctors bytestring chunked-data containers
         dlist enclosed-exceptions exceptions ghc-prim hashable lifted-base
         mono-traversable mtl mutable-containers old-locale primitive
         semigroups stm system-filepath text time transformers
         unordered-containers vector vector-instances
       ];
       testHaskellDepends = [
         base containers hspec QuickCheck transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "A typeclass-based Prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude_0_11_1" = callPackage
    ({ mkDerivation, base, basic-prelude, bifunctors, bytestring
     , chunked-data, containers, dlist, enclosed-exceptions, exceptions
     , ghc-prim, hashable, hspec, lifted-base, mono-traversable, mtl
     , mutable-containers, old-locale, primitive, QuickCheck, semigroups
     , stm, system-filepath, text, time, transformers
     , unordered-containers, vector, vector-instances
     }:
     mkDerivation {
       pname = "classy-prelude";
       version = "0.11.1";
       sha256 = "31a6e0d46efa1c1df694becb8be1eeb9bae4b65d81fa3f3b0170e823aeb22a00";
       revision = "1";
       editedCabalFile = "efba11a13e994d395e10c529bebbce36190a5187b867f7267f256e53fa655255";
       libraryHaskellDepends = [
         base basic-prelude bifunctors bytestring chunked-data containers
         dlist enclosed-exceptions exceptions ghc-prim hashable lifted-base
         mono-traversable mtl mutable-containers old-locale primitive
         semigroups stm system-filepath text time transformers
         unordered-containers vector vector-instances
       ];
       testHaskellDepends = [
         base containers hspec QuickCheck transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "A typeclass-based Prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude_0_11_1_1" = callPackage
    ({ mkDerivation, base, basic-prelude, bifunctors, bytestring
     , chunked-data, containers, dlist, enclosed-exceptions, exceptions
     , ghc-prim, hashable, hspec, lifted-base, mono-traversable, mtl
     , mutable-containers, primitive, QuickCheck, semigroups, stm
     , system-filepath, text, time, time-locale-compat, transformers
     , unordered-containers, vector, vector-instances
     }:
     mkDerivation {
       pname = "classy-prelude";
       version = "0.11.1.1";
       sha256 = "ea38048052a392b5080476160042e68402df18ec4ba3e9ed61abdf2c566436aa";
       revision = "1";
       editedCabalFile = "7b3c53842e0544b865ddd2be370b1541810f24b764056f507e23c8d26f1f716d";
       libraryHaskellDepends = [
         base basic-prelude bifunctors bytestring chunked-data containers
         dlist enclosed-exceptions exceptions ghc-prim hashable lifted-base
         mono-traversable mtl mutable-containers primitive semigroups stm
         system-filepath text time time-locale-compat transformers
         unordered-containers vector vector-instances
       ];
       testHaskellDepends = [
         base containers hspec QuickCheck transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "A typeclass-based Prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude_0_12_1_1" = callPackage
    ({ mkDerivation, base, basic-prelude, bifunctors, bytestring
     , chunked-data, containers, dlist, enclosed-exceptions, exceptions
     , ghc-prim, hashable, hspec, lifted-base, mono-traversable, mtl
     , mutable-containers, primitive, QuickCheck, semigroups, stm, text
     , time, time-locale-compat, transformers, unordered-containers
     , vector, vector-instances
     }:
     mkDerivation {
       pname = "classy-prelude";
       version = "0.12.1.1";
       sha256 = "670a85ffd10ff467e5eec1164462932c00bb6282cda2987a2b92c82f09ac3d13";
       libraryHaskellDepends = [
         base basic-prelude bifunctors bytestring chunked-data containers
         dlist enclosed-exceptions exceptions ghc-prim hashable lifted-base
         mono-traversable mtl mutable-containers primitive semigroups stm
         text time time-locale-compat transformers unordered-containers
         vector vector-instances
       ];
       testHaskellDepends = [
         base containers hspec QuickCheck transformers unordered-containers
       ];
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "A typeclass-based Prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude_0_12_3" = callPackage
    ({ mkDerivation, base, basic-prelude, bifunctors, bytestring
     , chunked-data, containers, dlist, enclosed-exceptions, exceptions
     , ghc-prim, hashable, hspec, lifted-base, mono-traversable, mtl
     , mutable-containers, primitive, QuickCheck, semigroups, stm, text
     , time, time-locale-compat, transformers, unordered-containers
     , vector, vector-instances
     }:
     mkDerivation {
       pname = "classy-prelude";
       version = "0.12.3";
       sha256 = "fd7b6e97c8e462844598f76f9aef4c4f445cd833e3b72eebcc94e8c20a7d3a24";
       libraryHaskellDepends = [
         base basic-prelude bifunctors bytestring chunked-data containers
         dlist enclosed-exceptions exceptions ghc-prim hashable lifted-base
         mono-traversable mtl mutable-containers primitive semigroups stm
         text time time-locale-compat transformers unordered-containers
         vector vector-instances
       ];
       testHaskellDepends = [
         base containers hspec QuickCheck transformers unordered-containers
       ];
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "A typeclass-based Prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude_0_12_4" = callPackage
    ({ mkDerivation, base, basic-prelude, bifunctors, bytestring
     , chunked-data, containers, dlist, enclosed-exceptions, exceptions
     , ghc-prim, hashable, hspec, lifted-base, mono-traversable, mtl
     , mutable-containers, primitive, QuickCheck, semigroups, stm, text
     , time, time-locale-compat, transformers, unordered-containers
     , vector, vector-instances
     }:
     mkDerivation {
       pname = "classy-prelude";
       version = "0.12.4";
       sha256 = "503064f5574a7786c860395d4c22676e2339021d311daeb327795e35a98fa43b";
       libraryHaskellDepends = [
         base basic-prelude bifunctors bytestring chunked-data containers
         dlist enclosed-exceptions exceptions ghc-prim hashable lifted-base
         mono-traversable mtl mutable-containers primitive semigroups stm
         text time time-locale-compat transformers unordered-containers
         vector vector-instances
       ];
       testHaskellDepends = [
         base containers hspec QuickCheck transformers unordered-containers
       ];
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "A typeclass-based Prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude_0_12_5" = callPackage
    ({ mkDerivation, base, basic-prelude, bifunctors, bytestring
     , chunked-data, containers, dlist, enclosed-exceptions, exceptions
     , ghc-prim, hashable, hspec, lifted-base, mono-traversable, mtl
     , mutable-containers, primitive, QuickCheck, semigroups, stm, text
     , time, time-locale-compat, transformers, unordered-containers
     , vector, vector-instances
     }:
     mkDerivation {
       pname = "classy-prelude";
       version = "0.12.5";
       sha256 = "40b56fae07d001e262cdcb9567774a3c6a2a39c2210e49333d33992595c54ca1";
       libraryHaskellDepends = [
         base basic-prelude bifunctors bytestring chunked-data containers
         dlist enclosed-exceptions exceptions ghc-prim hashable lifted-base
         mono-traversable mtl mutable-containers primitive semigroups stm
         text time time-locale-compat transformers unordered-containers
         vector vector-instances
       ];
       testHaskellDepends = [
         base containers hspec QuickCheck transformers unordered-containers
       ];
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "A typeclass-based Prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude" = callPackage
    ({ mkDerivation, base, basic-prelude, bifunctors, bytestring
     , chunked-data, containers, dlist, enclosed-exceptions, exceptions
     , ghc-prim, hashable, hspec, lifted-base, mono-traversable, mtl
     , mutable-containers, primitive, QuickCheck, semigroups, stm, text
     , time, time-locale-compat, transformers, unordered-containers
     , vector, vector-instances
     }:
     mkDerivation {
       pname = "classy-prelude";
       version = "0.12.5.1";
       sha256 = "30da07b4577005fbd41f807fddef5aee34aee7593a5d1b1eab23c7f059ef18b4";
       libraryHaskellDepends = [
         base basic-prelude bifunctors bytestring chunked-data containers
         dlist enclosed-exceptions exceptions ghc-prim hashable lifted-base
         mono-traversable mtl mutable-containers primitive semigroups stm
         text time time-locale-compat transformers unordered-containers
         vector vector-instances
       ];
       testHaskellDepends = [
         base containers hspec QuickCheck transformers unordered-containers
       ];
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "A typeclass-based Prelude";
       license = stdenv.lib.licenses.mit;
     }) {};

  "classy-prelude-conduit_0_10_2" = callPackage
    ({ mkDerivation, base, bytestring, classy-prelude, conduit
     , conduit-combinators, hspec, monad-control, QuickCheck, resourcet
     , system-fileio, transformers, void
     }:
     mkDerivation {
       pname = "classy-prelude-conduit";
       version = "0.10.2";
       sha256 = "1431ded0d7ad89dff51ee07a0b406d8b112cf4e729855895b61716708361f12d";
       libraryHaskellDepends = [
         base bytestring classy-prelude conduit conduit-combinators
         monad-control resourcet system-fileio transformers void
       ];
       testHaskellDepends = [
         base bytestring conduit hspec QuickCheck transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "conduit instances for classy-prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-conduit_0_10_4" = callPackage
    ({ mkDerivation, base, bytestring, classy-prelude, conduit
     , conduit-combinators, hspec, monad-control, QuickCheck, resourcet
     , system-fileio, transformers, void
     }:
     mkDerivation {
       pname = "classy-prelude-conduit";
       version = "0.10.4";
       sha256 = "e974f135138e83bbfe3fa204f0f2af15465298b21bf97e4f15fcf27311a09428";
       libraryHaskellDepends = [
         base bytestring classy-prelude conduit conduit-combinators
         monad-control resourcet system-fileio transformers void
       ];
       testHaskellDepends = [
         base bytestring conduit hspec QuickCheck transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "conduit instances for classy-prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-conduit_0_10_5" = callPackage
    ({ mkDerivation, base, bytestring, classy-prelude, conduit
     , conduit-combinators, hspec, monad-control, QuickCheck, resourcet
     , system-fileio, transformers, void
     }:
     mkDerivation {
       pname = "classy-prelude-conduit";
       version = "0.10.5";
       sha256 = "a2eab8e435309015488195b294647c9caa777fd9a0361e7e38c542608494c9b7";
       libraryHaskellDepends = [
         base bytestring classy-prelude conduit conduit-combinators
         monad-control resourcet system-fileio transformers void
       ];
       testHaskellDepends = [
         base bytestring conduit hspec QuickCheck transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "conduit instances for classy-prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-conduit_0_11_0" = callPackage
    ({ mkDerivation, base, bytestring, classy-prelude, conduit
     , conduit-combinators, hspec, monad-control, QuickCheck, resourcet
     , system-fileio, transformers, void
     }:
     mkDerivation {
       pname = "classy-prelude-conduit";
       version = "0.11.0";
       sha256 = "014166feb8cfa6c129071e2f718e83ef5e2bdf6948d482ba5aea305cb0001faa";
       revision = "1";
       editedCabalFile = "fd59787f97e0267d654aa88b7474200bcb9a183836806e82b17640785c6e44ba";
       libraryHaskellDepends = [
         base bytestring classy-prelude conduit conduit-combinators
         monad-control resourcet system-fileio transformers void
       ];
       testHaskellDepends = [
         base bytestring conduit hspec QuickCheck transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "conduit instances for classy-prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-conduit_0_11_1" = callPackage
    ({ mkDerivation, base, bytestring, classy-prelude, conduit
     , conduit-combinators, hspec, monad-control, QuickCheck, resourcet
     , system-fileio, transformers, void
     }:
     mkDerivation {
       pname = "classy-prelude-conduit";
       version = "0.11.1";
       sha256 = "2ce2c9ba1fb4ea8b6c28362ca55e6b8e26be971731d566fde8a192d1ff445566";
       revision = "1";
       editedCabalFile = "9a73ecb1f50eb59efffb612511189c9398be480c743dd139a88d419506da52f4";
       libraryHaskellDepends = [
         base bytestring classy-prelude conduit conduit-combinators
         monad-control resourcet system-fileio transformers void
       ];
       testHaskellDepends = [
         base bytestring conduit hspec QuickCheck transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "conduit instances for classy-prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-conduit_0_12_0_1" = callPackage
    ({ mkDerivation, base, bytestring, classy-prelude, conduit
     , conduit-combinators, hspec, monad-control, QuickCheck, resourcet
     , transformers, void
     }:
     mkDerivation {
       pname = "classy-prelude-conduit";
       version = "0.12.0.1";
       sha256 = "b12758b3ebe429268ca5a0f18a61ffc9429d6cdc00b4362742ea0717460462f7";
       libraryHaskellDepends = [
         base bytestring classy-prelude conduit conduit-combinators
         monad-control resourcet transformers void
       ];
       testHaskellDepends = [
         base bytestring conduit hspec QuickCheck transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "conduit instances for classy-prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-conduit_0_12_3" = callPackage
    ({ mkDerivation, base, bytestring, classy-prelude, conduit
     , conduit-combinators, hspec, monad-control, QuickCheck, resourcet
     , transformers, void
     }:
     mkDerivation {
       pname = "classy-prelude-conduit";
       version = "0.12.3";
       sha256 = "d86127153f9a69a2ed87777a0a93d8174c7ff136cbefb470879982b3b4875970";
       libraryHaskellDepends = [
         base bytestring classy-prelude conduit conduit-combinators
         monad-control resourcet transformers void
       ];
       testHaskellDepends = [
         base bytestring conduit hspec QuickCheck transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "conduit instances for classy-prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-conduit_0_12_4" = callPackage
    ({ mkDerivation, base, bytestring, classy-prelude, conduit
     , conduit-combinators, hspec, monad-control, QuickCheck, resourcet
     , transformers, void
     }:
     mkDerivation {
       pname = "classy-prelude-conduit";
       version = "0.12.4";
       sha256 = "71878fa293f8276c9989f889b73de24777e147183279c733351d32e9a784da61";
       libraryHaskellDepends = [
         base bytestring classy-prelude conduit conduit-combinators
         monad-control resourcet transformers void
       ];
       testHaskellDepends = [
         base bytestring conduit hspec QuickCheck transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "conduit instances for classy-prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-conduit" = callPackage
    ({ mkDerivation, base, bytestring, classy-prelude, conduit
     , conduit-combinators, hspec, monad-control, QuickCheck, resourcet
     , transformers, void
     }:
     mkDerivation {
       pname = "classy-prelude-conduit";
       version = "0.12.5";
       sha256 = "9df2403cd5dd3cc65facfc569b6a3883ca4da159bf601ac1993cb99caf9c206e";
       libraryHaskellDepends = [
         base bytestring classy-prelude conduit conduit-combinators
         monad-control resourcet transformers void
       ];
       testHaskellDepends = [
         base bytestring conduit hspec QuickCheck transformers
       ];
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "conduit instances for classy-prelude";
       license = stdenv.lib.licenses.mit;
     }) {};

  "classy-prelude-yesod_0_10_2" = callPackage
    ({ mkDerivation, aeson, base, classy-prelude
     , classy-prelude-conduit, data-default, http-conduit, http-types
     , persistent, yesod, yesod-newsfeed, yesod-static
     }:
     mkDerivation {
       pname = "classy-prelude-yesod";
       version = "0.10.2";
       sha256 = "6704037c924d04a82a7c01072b8773878504d72fd098a7206c15d524b311eecb";
       libraryHaskellDepends = [
         aeson base classy-prelude classy-prelude-conduit data-default
         http-conduit http-types persistent yesod yesod-newsfeed
         yesod-static
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "Provide a classy prelude including common Yesod functionality";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-yesod_0_10_4" = callPackage
    ({ mkDerivation, aeson, base, classy-prelude
     , classy-prelude-conduit, data-default, http-conduit, http-types
     , persistent, yesod, yesod-newsfeed, yesod-static
     }:
     mkDerivation {
       pname = "classy-prelude-yesod";
       version = "0.10.4";
       sha256 = "745b2051df9d705a9d47776063cd510d926b033187ad9e919f3d46ba3a077c35";
       libraryHaskellDepends = [
         aeson base classy-prelude classy-prelude-conduit data-default
         http-conduit http-types persistent yesod yesod-newsfeed
         yesod-static
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "Provide a classy prelude including common Yesod functionality";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-yesod_0_10_5" = callPackage
    ({ mkDerivation, aeson, base, classy-prelude
     , classy-prelude-conduit, data-default, http-conduit, http-types
     , persistent, yesod, yesod-newsfeed, yesod-static
     }:
     mkDerivation {
       pname = "classy-prelude-yesod";
       version = "0.10.5";
       sha256 = "9d15a5739c890da44c24708a1c6a3c34f3d420c79633e38762740dabe5670a5e";
       libraryHaskellDepends = [
         aeson base classy-prelude classy-prelude-conduit data-default
         http-conduit http-types persistent yesod yesod-newsfeed
         yesod-static
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "Provide a classy prelude including common Yesod functionality";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-yesod_0_11_0" = callPackage
    ({ mkDerivation, aeson, base, classy-prelude
     , classy-prelude-conduit, data-default, http-conduit, http-types
     , persistent, yesod, yesod-newsfeed, yesod-static
     }:
     mkDerivation {
       pname = "classy-prelude-yesod";
       version = "0.11.0";
       sha256 = "0c677978c31f22a859bf5c22ae0da4af36ad4942ee045df8fab19dc21e041ac4";
       libraryHaskellDepends = [
         aeson base classy-prelude classy-prelude-conduit data-default
         http-conduit http-types persistent yesod yesod-newsfeed
         yesod-static
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "Provide a classy prelude including common Yesod functionality";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-yesod_0_11_1" = callPackage
    ({ mkDerivation, aeson, base, classy-prelude
     , classy-prelude-conduit, data-default, http-conduit, http-types
     , persistent, yesod, yesod-newsfeed, yesod-static
     }:
     mkDerivation {
       pname = "classy-prelude-yesod";
       version = "0.11.1";
       sha256 = "63b3ddc3e362c96305a542b079a485edbb0bb82ae365819397c42d408f660191";
       libraryHaskellDepends = [
         aeson base classy-prelude classy-prelude-conduit data-default
         http-conduit http-types persistent yesod yesod-newsfeed
         yesod-static
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "Provide a classy prelude including common Yesod functionality";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-yesod_0_12_0_1" = callPackage
    ({ mkDerivation, aeson, base, classy-prelude
     , classy-prelude-conduit, data-default, http-conduit, http-types
     , persistent, yesod, yesod-newsfeed, yesod-static
     }:
     mkDerivation {
       pname = "classy-prelude-yesod";
       version = "0.12.0.1";
       sha256 = "220f42a881672837513de5a425fa060fa545436b99baa02c6d5faaa697a6ff02";
       libraryHaskellDepends = [
         aeson base classy-prelude classy-prelude-conduit data-default
         http-conduit http-types persistent yesod yesod-newsfeed
         yesod-static
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "Provide a classy prelude including common Yesod functionality";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-yesod_0_12_3" = callPackage
    ({ mkDerivation, aeson, base, classy-prelude
     , classy-prelude-conduit, data-default, http-conduit, http-types
     , persistent, yesod, yesod-newsfeed, yesod-static
     }:
     mkDerivation {
       pname = "classy-prelude-yesod";
       version = "0.12.3";
       sha256 = "ddc03c6e473e3355f5c5efa3cd1eecf15605ef3a109038d0350eb5890b6a3c9d";
       libraryHaskellDepends = [
         aeson base classy-prelude classy-prelude-conduit data-default
         http-conduit http-types persistent yesod yesod-newsfeed
         yesod-static
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "Provide a classy prelude including common Yesod functionality";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-yesod_0_12_4" = callPackage
    ({ mkDerivation, aeson, base, classy-prelude
     , classy-prelude-conduit, data-default, http-conduit, http-types
     , persistent, yesod, yesod-newsfeed, yesod-static
     }:
     mkDerivation {
       pname = "classy-prelude-yesod";
       version = "0.12.4";
       sha256 = "6c434a6524206849ee11657b14d0350961c63be1b8260d50abec09e2a8da675f";
       libraryHaskellDepends = [
         aeson base classy-prelude classy-prelude-conduit data-default
         http-conduit http-types persistent yesod yesod-newsfeed
         yesod-static
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "Provide a classy prelude including common Yesod functionality";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "classy-prelude-yesod" = callPackage
    ({ mkDerivation, aeson, base, classy-prelude
     , classy-prelude-conduit, data-default, http-conduit, http-types
     , persistent, yesod, yesod-newsfeed, yesod-static
     }:
     mkDerivation {
       pname = "classy-prelude-yesod";
       version = "0.12.5";
       sha256 = "8f63ff332861d8a72627e4e402fe717750e86f89bdfb518e7db2aec52095b676";
       libraryHaskellDepends = [
         aeson base classy-prelude classy-prelude-conduit data-default
         http-conduit http-types persistent yesod yesod-newsfeed
         yesod-static
       ];
       homepage = "https://github.com/snoyberg/classy-prelude";
       description = "Provide a classy prelude including common Yesod functionality";
       license = stdenv.lib.licenses.mit;
     }) {};

  "clay" = callPackage
    ({ mkDerivation, base, HUnit, mtl, test-framework
     , test-framework-hunit, text
     }:
     mkDerivation {
       pname = "clay";
       version = "0.10.1";
       sha256 = "3bb820281b8824055f5a087273f6578ccd5b6f6575891ec88933d9ebdf920a54";
       revision = "1";
       editedCabalFile = "8ecb3c320c9470f2bf250552d7fac738520d90d28e8e90b11922d1c4940a0263";
       libraryHaskellDepends = [ base mtl text ];
       testHaskellDepends = [
         base HUnit mtl test-framework test-framework-hunit text
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://fvisser.nl/clay";
       description = "CSS preprocessor as embedded Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "clckwrks" = callPackage
    ({ mkDerivation, acid-state, aeson, aeson-qq, attoparsec, base
     , blaze-html, bytestring, cereal, containers, directory, filepath
     , happstack-authenticate, happstack-hsp, happstack-jmacro
     , happstack-server, happstack-server-tls, hsp, hsx-jmacro, hsx2hs
     , ixset, jmacro, lens, mtl, network, network-uri, old-locale
     , openssl, process, random, reform, reform-happstack, reform-hsp
     , safecopy, stm, tagsoup, text, time, time-locale-compat
     , unordered-containers, userid, utf8-string, uuid-orphans
     , uuid-types, vector, web-plugins, web-routes, web-routes-happstack
     , web-routes-hsp, web-routes-th, xss-sanitize
     }:
     mkDerivation {
       pname = "clckwrks";
       version = "0.23.13";
       sha256 = "b663a9495d434e62b02965009fefdd8cef6ec64fbccb3894efb662a58779e3a2";
       libraryHaskellDepends = [
         acid-state aeson aeson-qq attoparsec base blaze-html bytestring
         cereal containers directory filepath happstack-authenticate
         happstack-hsp happstack-jmacro happstack-server
         happstack-server-tls hsp hsx-jmacro hsx2hs ixset jmacro lens mtl
         network network-uri old-locale process random reform
         reform-happstack reform-hsp safecopy stm tagsoup text time
         time-locale-compat unordered-containers userid utf8-string
         uuid-orphans uuid-types vector web-plugins web-routes
         web-routes-happstack web-routes-hsp web-routes-th xss-sanitize
       ];
       librarySystemDepends = [ openssl ];
       homepage = "http://www.clckwrks.com/";
       description = "A secure, reliable content management system (CMS) and blogging platform";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) openssl;};

  "clckwrks-cli" = callPackage
    ({ mkDerivation, acid-state, base, clckwrks, haskeline, mtl
     , network, parsec
     }:
     mkDerivation {
       pname = "clckwrks-cli";
       version = "0.2.16";
       sha256 = "424fcaa1f1b6b39be1d727073b9b9ab37c9a201f6c2eca5a8c30d469919c12e7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         acid-state base clckwrks haskeline mtl network parsec
       ];
       homepage = "http://www.clckwrks.com/";
       description = "a command-line interface for adminstrating some aspects of clckwrks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "clckwrks-dot-com" = callPackage
    ({ mkDerivation, base, clckwrks, clckwrks-plugin-media
     , clckwrks-plugin-page, clckwrks-theme-clckwrks, containers
     , happstack-server, hsp, hsx2hs, mtl, network, text, web-plugins
     }:
     mkDerivation {
       pname = "clckwrks-dot-com";
       version = "0.3.11";
       sha256 = "009c6533f3aea2d73d07ce2b9e0f6e94cd86de9802000a1200c0e31492e66938";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base clckwrks clckwrks-plugin-media clckwrks-plugin-page
         clckwrks-theme-clckwrks containers happstack-server hsp mtl network
         text web-plugins
       ];
       executableToolDepends = [ hsx2hs ];
       jailbreak = true;
       homepage = "http://www.clckwrks.com/";
       description = "clckwrks.com";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "clckwrks-plugin-bugs" = callPackage
    ({ mkDerivation, acid-state, attoparsec, base, cereal, clckwrks
     , clckwrks-plugin-page, containers, directory, filepath
     , happstack-authenticate, happstack-hsp, happstack-server, hsp
     , hsx2hs, ixset, mtl, network, network-uri, reform
     , reform-happstack, reform-hsp, safecopy, text, time, web-plugins
     , web-routes, web-routes-th
     }:
     mkDerivation {
       pname = "clckwrks-plugin-bugs";
       version = "0.7.5";
       sha256 = "db1da270750e2327e15b28a0f29d6b51e42844e91d5af102e6082e8de68e4451";
       libraryHaskellDepends = [
         acid-state attoparsec base cereal clckwrks clckwrks-plugin-page
         containers directory filepath happstack-authenticate happstack-hsp
         happstack-server hsp ixset mtl network network-uri reform
         reform-happstack reform-hsp safecopy text time web-plugins
         web-routes web-routes-th
       ];
       libraryToolDepends = [ hsx2hs ];
       jailbreak = true;
       homepage = "http://clckwrks.com/";
       description = "bug tracking plugin for clckwrks";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clckwrks-plugin-ircbot" = callPackage
    ({ mkDerivation, acid-state, attoparsec, base, blaze-html
     , bytestring, clckwrks, containers, directory, filepath
     , happstack-hsp, happstack-server, hsp, hsx2hs, ircbot, ixset, mtl
     , network, reform, reform-happstack, reform-hsp, safecopy, text
     , web-plugins, web-routes, web-routes-th
     }:
     mkDerivation {
       pname = "clckwrks-plugin-ircbot";
       version = "0.6.15";
       sha256 = "1e6e9747a27e24258448b98d82217f9f69317beea18e4607accab1aa3df0ee88";
       libraryHaskellDepends = [
         acid-state attoparsec base blaze-html bytestring clckwrks
         containers directory filepath happstack-hsp happstack-server hsp
         ircbot ixset mtl network reform reform-happstack reform-hsp
         safecopy text web-plugins web-routes web-routes-th
       ];
       libraryToolDepends = [ hsx2hs ];
       jailbreak = true;
       homepage = "http://clckwrks.com/";
       description = "ircbot plugin for clckwrks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "clckwrks-plugin-media" = callPackage
    ({ mkDerivation, acid-state, attoparsec, base, blaze-html, cereal
     , clckwrks, containers, directory, filepath, gd, happstack-server
     , hsp, hsx2hs, ixset, magic, mtl, reform, reform-happstack
     , reform-hsp, safecopy, text, web-plugins, web-routes
     , web-routes-th
     }:
     mkDerivation {
       pname = "clckwrks-plugin-media";
       version = "0.6.15";
       sha256 = "8718187ddc8017bb875645eb2032dbbb71cd72ee7541e30c0e7281dc49ca5b85";
       libraryHaskellDepends = [
         acid-state attoparsec base blaze-html cereal clckwrks containers
         directory filepath gd happstack-server hsp ixset magic mtl reform
         reform-happstack reform-hsp safecopy text web-plugins web-routes
         web-routes-th
       ];
       libraryToolDepends = [ hsx2hs ];
       homepage = "http://clckwrks.com/";
       description = "media plugin for clckwrks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "clckwrks-plugin-page" = callPackage
    ({ mkDerivation, acid-state, aeson, attoparsec, base, clckwrks
     , containers, directory, filepath, happstack-hsp, happstack-server
     , hsp, hsx2hs, ixset, mtl, old-locale, random, reform
     , reform-happstack, reform-hsp, safecopy, tagsoup, template-haskell
     , text, time, time-locale-compat, uuid, web-plugins, web-routes
     , web-routes-happstack, web-routes-th
     }:
     mkDerivation {
       pname = "clckwrks-plugin-page";
       version = "0.4.3";
       sha256 = "6c3ccbdbcdd5034223577e29a8e0791d8e3c262ed1a117f8f865ca2cbdbf9fea";
       libraryHaskellDepends = [
         acid-state aeson attoparsec base clckwrks containers directory
         filepath happstack-hsp happstack-server hsp hsx2hs ixset mtl
         old-locale random reform reform-happstack reform-hsp safecopy
         tagsoup template-haskell text time time-locale-compat uuid
         web-plugins web-routes web-routes-happstack web-routes-th
       ];
       homepage = "http://www.clckwrks.com/";
       description = "support for CMS/Blogging in clckwrks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "clckwrks-theme-bootstrap" = callPackage
    ({ mkDerivation, base, clckwrks, happstack-authenticate, hsp
     , hsx-jmacro, hsx2hs, jmacro, mtl, text, web-plugins
     }:
     mkDerivation {
       pname = "clckwrks-theme-bootstrap";
       version = "0.4.1";
       sha256 = "59399a42c5d928e9aa332e0901d023e00f6add27c03b95cddf405e392885f852";
       libraryHaskellDepends = [
         base clckwrks happstack-authenticate hsp hsx-jmacro hsx2hs jmacro
         mtl text web-plugins
       ];
       homepage = "http://www.clckwrks.com/";
       description = "simple bootstrap based template for clckwrks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "clckwrks-theme-clckwrks" = callPackage
    ({ mkDerivation, base, clckwrks, containers, happstack-authenticate
     , hsp, hsx2hs, mtl, text, web-plugins
     }:
     mkDerivation {
       pname = "clckwrks-theme-clckwrks";
       version = "0.5.2";
       sha256 = "53182128e49924132191d6d607e7088f92367a10ab31d38b5e4a1d8a2471ed1c";
       libraryHaskellDepends = [
         base clckwrks containers happstack-authenticate hsp hsx2hs mtl text
         web-plugins
       ];
       homepage = "http://www.clckwrks.com/";
       description = "simple bootstrap based template for clckwrks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "clckwrks-theme-geo-bootstrap" = callPackage
    ({ mkDerivation, base, clckwrks, hsp, text }:
     mkDerivation {
       pname = "clckwrks-theme-geo-bootstrap";
       version = "0.1.1";
       sha256 = "f3a816c8ef4259d1931789814c39ef6411d2aa80bf97e568b1008cdfe099b1e3";
       libraryHaskellDepends = [ base clckwrks hsp text ];
       jailbreak = true;
       homepage = "http://divshot.github.com/geo-bootstrap/";
       description = "geo bootstrap based template for clckwrks";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cld2" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "cld2";
       version = "0.1.0.1";
       sha256 = "0d8e9a77b80fc40e160fcfb04c55265444c34f7f7ded41e6d8ef04573cb8523b";
       revision = "1";
       editedCabalFile = "60506ceb359329f803a733a06f9a6060a31cab7e86dd4a8e3fd843953cb4cfbd";
       libraryHaskellDepends = [ base bytestring text ];
       homepage = "https://github.com/dfoxfranke/haskell-cld2";
       description = "Haskell bindings to Google's Compact Language Detector 2";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "clean-home" = callPackage
    ({ mkDerivation, base, cmdargs, containers, directory, HSH, IfElse
     }:
     mkDerivation {
       pname = "clean-home";
       version = "0.0.4";
       sha256 = "42307b2fdcf750a64cae131845e39964a47adb1e1b16ba19497f4ab907250969";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs containers directory HSH IfElse
       ];
       homepage = "https://github.com/ivanperez-keera/clean-home";
       description = "Keep your home dir clean by finding old conf files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "clean-unions" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "clean-unions";
       version = "0.1.1";
       sha256 = "4144d228eac2d94e6079c441b619ce901d8d05f3cc4730f9574c3ea34b908cf8";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/fumieval/clean-unions";
       description = "Open unions without need for Typeable";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cless" = callPackage
    ({ mkDerivation, base, highlighting-kate, optparse-applicative
     , process, terminfo, wl-pprint-extras, wl-pprint-terminfo
     }:
     mkDerivation {
       pname = "cless";
       version = "0.3.0.0";
       sha256 = "0f06437973de1c36c1ac2472091a69c2684db40ba12f881592f1f08e8584629b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base highlighting-kate optparse-applicative process terminfo
         wl-pprint-extras wl-pprint-terminfo
       ];
       jailbreak = true;
       homepage = "https://github.com/tanakh/cless";
       description = "Colorized LESS";
       license = stdenv.lib.licenses.mit;
     }) {};

  "clevercss" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec }:
     mkDerivation {
       pname = "clevercss";
       version = "0.2.4";
       sha256 = "d47eaabad3d4bf7a1ef7d852c4171ae905a49b013f04d60e39c0043952fbcc5a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers mtl parsec ];
       executableHaskellDepends = [ parsec ];
       homepage = "http://sandbox.pocoo.org/clevercss-hs/";
       description = "A CSS preprocessor";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cli" = callPackage
    ({ mkDerivation, base, directory, mtl, QuickCheck, tasty
     , tasty-quickcheck, terminfo, transformers
     }:
     mkDerivation {
       pname = "cli";
       version = "0.1.2";
       sha256 = "580a31fc25eb988dbb5ad3aebfb72d49f089cbee9693edf78dae722b2fde4acb";
       libraryHaskellDepends = [ base mtl terminfo transformers ];
       testHaskellDepends = [
         base directory QuickCheck tasty tasty-quickcheck transformers
       ];
       homepage = "https://github.com/vincenthz/hs-cli";
       description = "Command Line Interface";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "click-clack" = callPackage
    ({ mkDerivation, base, containers, GLFW, Hipmunk, MonadRandom, mtl
     , OpenGL, random, StateVar, transformers
     }:
     mkDerivation {
       pname = "click-clack";
       version = "1.0.1";
       sha256 = "a8359ffc25bb582b231eccc5c1fa0cdb5ba6dd50f89685b9e21d0b14016efb59";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers GLFW Hipmunk MonadRandom mtl OpenGL random StateVar
         transformers
       ];
       jailbreak = true;
       description = "Toy game (tetris on billiard board). Hipmunk in action.";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clientsession" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, cereal
     , cipher-aes, containers, cprng-aes, crypto-api, crypto-random
     , directory, entropy, hspec, HUnit, QuickCheck, setenv, skein
     , tagged, transformers
     }:
     mkDerivation {
       pname = "clientsession";
       version = "0.9.1.1";
       sha256 = "c9563c0bcda1a02cfea2fd39aecec5b9f419901587287f05afdec1e683210022";
       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 ];
       testHaskellDepends = [
         base bytestring cereal containers hspec HUnit QuickCheck
         transformers
       ];
       homepage = "http://github.com/yesodweb/clientsession/tree/master";
       description = "Securely store session data in a client-side cookie";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "clifford" = callPackage
    ({ mkDerivation, base, cereal, Chart, Chart-cairo, colour, converge
     , criterion, data-default-class, data-ordlist, deepseq, derive
     , gnuplot, hspec, lens, MemoTrie, monoid-extras, nats
     , numeric-prelude, permutation, QuickCheck, reflection
     , semigroupoids, stream-fusion, tagged, vector
     }:
     mkDerivation {
       pname = "clifford";
       version = "0.1.0.14";
       sha256 = "99e4e4e2cfb64d47ea4b90e23422cdd654a975d11f1e23886819466014dfbd03";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cereal converge criterion data-ordlist deepseq derive hspec
         lens MemoTrie monoid-extras nats numeric-prelude permutation
         QuickCheck reflection semigroupoids stream-fusion tagged vector
       ];
       executableHaskellDepends = [
         base Chart Chart-cairo colour data-default-class gnuplot lens
         numeric-prelude stream-fusion
       ];
       testHaskellDepends = [
         base hspec nats numeric-prelude QuickCheck
       ];
       jailbreak = true;
       homepage = "http://github.com/spacekitteh/haskell-clifford";
       description = "A Clifford algebra library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clippard" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "clippard";
       version = "0.1.1";
       sha256 = "6814350ec951b207741ab17a8a5011e2ff1fa0691b97fe3c897bd21c8f381162";
       libraryHaskellDepends = [ base process ];
       jailbreak = true;
       homepage = "https://github.com/Raynes/clippard";
       description = "A simple Haskell library for copying text to the clipboard in a cross-platform way";
       license = stdenv.lib.licenses.mit;
     }) {};

  "clipper" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "clipper";
       version = "0.0.1";
       sha256 = "20dbc176eeacd3514d1f3d32fe24159c9a3ae19553a8db67561ea47040439668";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/chetant/clipper";
       description = "Haskell API to clipper (2d polygon union/intersection/xor/clipping API)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clippings" = callPackage
    ({ mkDerivation, assertions, base, bifunctors, bytestring, cassava
     , data-default, filepath, functor-infix, old-locale, parsec
     , safecopy, strptime, time
     }:
     mkDerivation {
       pname = "clippings";
       version = "0.2.0";
       sha256 = "8562481c8ba001b6c401d6ebfacd458fe44b19676ce8bd2e8694cd45cf825bdb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base data-default functor-infix old-locale parsec strptime time
       ];
       executableHaskellDepends = [
         base bifunctors bytestring cassava functor-infix parsec safecopy
       ];
       testHaskellDepends = [
         assertions base data-default filepath old-locale parsec time
       ];
       description = "A parser/generator for Kindle-format clipping files (`My Clippings.txt`),";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clist" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, peano }:
     mkDerivation {
       pname = "clist";
       version = "0.1.0.0";
       sha256 = "eddf07964751b51550c5197f39cc772418b0fa7d2ad6cf762af589ce9bd973cb";
       libraryHaskellDepends = [ base base-unicode-symbols peano ];
       homepage = "https://github.com/strake/clist.hs";
       description = "Counted list";
       license = "unknown";
     }) {};

  "clock_0_4_1_3" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "clock";
       version = "0.4.1.3";
       sha256 = "0d38b2ecd60328b9b4ede572ff238d840e713da18e6ce002f08b82b01e7a1073";
       revision = "1";
       editedCabalFile = "653fd69fcb84f23fb93241604f83f686921593f7ded7c3bf61ce7cecf1f00440";
       libraryHaskellDepends = [ base ];
       homepage = "http://corsis.github.com/clock/";
       description = "High-resolution clock functions: monotonic, realtime, cputime";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clock_0_4_5_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "clock";
       version = "0.4.5.0";
       sha256 = "3caee3e7e3dcd2047ff8edb563ea8116dc10ca96d5495a035430654ca44f4561";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/corsis/clock";
       description = "High-resolution clock functions: monotonic, realtime, cputime";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clock_0_4_6_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "clock";
       version = "0.4.6.0";
       sha256 = "b9c79ed3de358afea75f3083f1e6a2b7ce503ea00b049acebe45f6d846e03377";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/corsis/clock";
       description = "High-resolution clock functions: monotonic, realtime, cputime";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clock_0_5_1" = callPackage
    ({ mkDerivation, base, tasty, tasty-quickcheck }:
     mkDerivation {
       pname = "clock";
       version = "0.5.1";
       sha256 = "7c7a1f89bc4fa2f995d31a214bb7e3ad44c3570cb46b8f18e7de6011f78197d9";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base tasty tasty-quickcheck ];
       homepage = "https://github.com/corsis/clock";
       description = "High-resolution clock functions: monotonic, realtime, cputime";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clock" = callPackage
    ({ mkDerivation, base, tasty, tasty-quickcheck }:
     mkDerivation {
       pname = "clock";
       version = "0.6.0.1";
       sha256 = "88a2c7cfe3edacb8775fa8e8e6fa6ff8ceceb45554c5d2d7fabefc8df52b5f74";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base tasty tasty-quickcheck ];
       doCheck = false;
       homepage = "https://github.com/corsis/clock";
       description = "High-resolution clock functions: monotonic, realtime, cputime";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "clocked" = callPackage
    ({ mkDerivation, base, clock, containers, MonadCatchIO-transformers
     , QtCore, transformers
     }:
     mkDerivation {
       pname = "clocked";
       version = "0.4.1.3";
       sha256 = "287272104ea5944b9c3c89178e5995838f61cceb31ab0319a77f1ca5a32536fd";
       libraryHaskellDepends = [
         base clock containers MonadCatchIO-transformers transformers
       ];
       libraryPkgconfigDepends = [ QtCore ];
       homepage = "http://patch-tag.com/r/shahn/clocked/home";
       description = "timer functionality to clock IO commands";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {QtCore = null;};

  "clogparse" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, filepath, text, time
     , timezone-olson, timezone-series
     }:
     mkDerivation {
       pname = "clogparse";
       version = "0.2";
       sha256 = "7d65bfde034f16b9064d997fe9cecbeedafab85a06d5cebad85e726222cfc59e";
       libraryHaskellDepends = [
         attoparsec base bytestring filepath text time timezone-olson
         timezone-series
       ];
       description = "Parse IRC logs such as the #haskell logs on tunes.org";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clone-all" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, github
     , optparse-applicative, process, system-fileio, system-filepath
     , text, transformers
     }:
     mkDerivation {
       pname = "clone-all";
       version = "0.1.0.0";
       sha256 = "09dc42cceff97d531fffaab5b223a06d4655f6ce985e7a74e4e1becb310b2ed6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring directory github optparse-applicative process
         system-fileio system-filepath text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/silky/clone-all";
       description = "Clone all github repositories from a given user";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "closure" = callPackage
    ({ mkDerivation, base, hashable, unordered-containers }:
     mkDerivation {
       pname = "closure";
       version = "0.1.0.0";
       sha256 = "8ecb1fa2557e86907512f65e4fdbd37ca772186d7421888a7801c82bf9a42cfd";
       libraryHaskellDepends = [ base hashable unordered-containers ];
       jailbreak = true;
       homepage = "http://github.com/tel/closure";
       description = "Depth- and breadth-first set closures";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cloud-haskell" = callPackage
    ({ mkDerivation, distributed-process, distributed-process-async
     , distributed-process-client-server, distributed-process-execution
     , distributed-process-extras, distributed-process-supervisor
     , distributed-process-task, distributed-static, network-transport
     , rank1dynamic
     }:
     mkDerivation {
       pname = "cloud-haskell";
       version = "0.2.0.0";
       sha256 = "0698fe456337b7ebe084d5e980d8e322392ca0dd4f336a9de67eefe1fec92286";
       libraryHaskellDepends = [
         distributed-process distributed-process-async
         distributed-process-client-server distributed-process-execution
         distributed-process-extras distributed-process-supervisor
         distributed-process-task distributed-static network-transport
         rank1dynamic
       ];
       doHaddock = false;
       jailbreak = true;
       homepage = "http://github.com/haskell-distributed/cloud-haskell";
       description = "The Cloud Haskell Application Platform";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cloudfront-signer" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, base64-bytestring
     , bytestring, crypto-pubkey-types, old-locale, RSA, time
     }:
     mkDerivation {
       pname = "cloudfront-signer";
       version = "0.0.0.1";
       sha256 = "9f7b834f9b4bace4c3bbaa12fbdf209acea1106f84b6c388d43d074116cd72c6";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base base64-bytestring bytestring
         crypto-pubkey-types old-locale RSA time
       ];
       homepage = "http://github.com/cdornan/cloudfront-signer";
       description = "CloudFront URL signer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cloudyfs" = callPackage
    ({ mkDerivation, base, bytestring, containers, convertible
     , datetime, filepath, HFuse, HTTP, regex-base, regex-tdfa, tagsoup
     , timerep, unix
     }:
     mkDerivation {
       pname = "cloudyfs";
       version = "0.0.2";
       sha256 = "8fd3c25a498606ae5739051ba43cf26453c7635de5688c77b87ebc09061adb49";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers convertible datetime filepath HFuse HTTP
         regex-base regex-tdfa tagsoup timerep unix
       ];
       homepage = "https://github.com/bhickey/cloudyfs";
       description = "A cloud in the file system";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cltw" = callPackage
    ({ mkDerivation, base, curl, mtl, random, tagsoup }:
     mkDerivation {
       pname = "cltw";
       version = "1.1.4";
       sha256 = "09936f4cb9fc0a309ae1e3fb28477d6d236a14fac4ead92ee8bb3e8b18d4d122";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base curl mtl random tagsoup ];
       homepage = "http://ui3.info/d/proj/cltw.html";
       description = "Command line Twitter utility";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "clua" = callPackage
    ({ mkDerivation, base, bytestring, containers, haskell98
     , language-c, pretty, pretty-show
     }:
     mkDerivation {
       pname = "clua";
       version = "0.3";
       sha256 = "7b0fbab3f4ff823243e6a2f9a88ef9cf90385fb12104e50eefc8d9b4b4bcf077";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers haskell98 language-c pretty pretty-show
       ];
       homepage = "http://zwizwa.be/-/meta";
       description = "C to Lua data wrapper generator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clumpiness" = callPackage
    ({ mkDerivation, base, containers, tree-fun }:
     mkDerivation {
       pname = "clumpiness";
       version = "0.17.0.0";
       sha256 = "fd4b303d206eaf242c779bb65c42256e42220c8497a6bcf3bc59589b9396c495";
       libraryHaskellDepends = [ base containers tree-fun ];
       description = "Calculate the clumpiness of leaf properties in a tree";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "cluss" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "cluss";
       version = "0.3";
       sha256 = "effd03b754a93b2b3e973e83fb47e961e5a7bfb67002f92d67dff28f9ca8b3e0";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "https://github.com/Kinokkory/cluss";
       description = "simple alternative to type classes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clustering" = callPackage
    ({ mkDerivation, base, binary, containers, hierarchical-clustering
     , matrices, mwc-random, parallel, primitive, Rlang-QQ, split, tasty
     , tasty-hunit, tasty-quickcheck, vector
     }:
     mkDerivation {
       pname = "clustering";
       version = "0.2.1";
       sha256 = "5078c28e185fd26770726cb2632ff043d99b6918d7a5d135c30bd53fc27ab9cb";
       libraryHaskellDepends = [
         base binary containers matrices mwc-random parallel primitive
         vector
       ];
       testHaskellDepends = [
         base binary hierarchical-clustering matrices mwc-random Rlang-QQ
         split tasty tasty-hunit tasty-quickcheck vector
       ];
       doCheck = false;
       description = "High performance clustering algorithms";
       license = stdenv.lib.licenses.mit;
     }) {};

  "clustertools" = callPackage
    ({ mkDerivation, base, bio, bytestring, containers, QuickCheck
     , regex-compat, simpleargs
     }:
     mkDerivation {
       pname = "clustertools";
       version = "0.1.5";
       sha256 = "78eec3a52f3d6e32e955ba9a97462d8aee1378a57becb9601371aa903f76c646";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bio bytestring containers QuickCheck regex-compat simpleargs
       ];
       homepage = "http://malde.org/~ketil/";
       description = "Tools for manipulating sequence clusters";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "clutterhs" = callPackage
    ({ mkDerivation, array, base, c2hs, cairo, clutter, glib, gtk
     , haskell98, mtl, pango, X11
     }:
     mkDerivation {
       pname = "clutterhs";
       version = "0.1";
       sha256 = "b423463110ae35991f5612f86ef60cc73e44ca803c388ab197d14b0cd8359455";
       libraryHaskellDepends = [
         array base cairo glib gtk haskell98 mtl X11
       ];
       libraryPkgconfigDepends = [ clutter pango ];
       libraryToolDepends = [ c2hs ];
       description = "Bindings to the Clutter animation library";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) clutter; inherit (pkgs.gnome) pango;};

  "cmaes" = callPackage
    ({ mkDerivation, base, doctest, doctest-prop, mtl, process, random
     , safe, strict, syb, vector
     }:
     mkDerivation {
       pname = "cmaes";
       version = "0.2.2.1";
       sha256 = "f5606c1eb628b6c67dd47856bdfea31c5fa70170c7b7070b4a4da730632e1f64";
       libraryHaskellDepends = [ base mtl process safe strict syb ];
       testHaskellDepends = [
         base doctest doctest-prop mtl process random syb vector
       ];
       description = "CMA-ES wrapper in Haskell";
       license = "unknown";
     }) {};

  "cmark_0_4_0_1" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, text }:
     mkDerivation {
       pname = "cmark";
       version = "0.4.0.1";
       sha256 = "638328b59c2bb8bdcd0f3042c4554f2b2b7c6deac7770dbc8bc2813c865a35ce";
       libraryHaskellDepends = [ base bytestring text ];
       testHaskellDepends = [ base HUnit text ];
       jailbreak = true;
       homepage = "https://github.com/jgm/commonmark-hs";
       description = "Fast, accurate CommonMark (Markdown) parser and renderer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cmark_0_4_1" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, text }:
     mkDerivation {
       pname = "cmark";
       version = "0.4.1";
       sha256 = "22f006ba36620476916c605b92de8e1f325eb2b5ebec6b30c12aee6220262330";
       libraryHaskellDepends = [ base bytestring text ];
       testHaskellDepends = [ base HUnit text ];
       homepage = "https://github.com/jgm/commonmark-hs";
       description = "Fast, accurate CommonMark (Markdown) parser and renderer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cmark" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, text }:
     mkDerivation {
       pname = "cmark";
       version = "0.5.1";
       sha256 = "e13a2889a74d6c9dd27bbd506b89f4ee8841c98aac36dd22f30a68863efa5446";
       libraryHaskellDepends = [ base bytestring text ];
       testHaskellDepends = [ base HUnit text ];
       homepage = "https://github.com/jgm/commonmark-hs";
       description = "Fast, accurate CommonMark (Markdown) parser and renderer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cmath" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "cmath";
       version = "0.3";
       sha256 = "d5b6919c88b1d1726ab4309ed5cc94b09e521e5a1174b069229757ba1e1369c1";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.haskell.org/~dons/code/cmath";
       description = "A binding to the standard C math library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cmathml3" = callPackage
    ({ mkDerivation, array, arrowapply-utils, base, Cabal, containers
     , filepath, hxt, monads-tf, parsec, syb, transformers, url
     }:
     mkDerivation {
       pname = "cmathml3";
       version = "0.1";
       sha256 = "cd244f14fc45845d351bdc5a6ba9ece748a11c16779471baa381b945dbc70656";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array arrowapply-utils base containers hxt monads-tf parsec syb
         transformers url
       ];
       executableHaskellDepends = [ base Cabal filepath ];
       description = "Data model, parser, serialiser and transformations for Content MathML 3";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cmd-item" = callPackage
    ({ mkDerivation, base, containers, hspec, hspec-laws, HUnit
     , QuickCheck, quickcheck-instances, templater, text
     }:
     mkDerivation {
       pname = "cmd-item";
       version = "0.0.1.0";
       sha256 = "c2e0d3628136527fcd418efe51085e94a6a4e703e72b395c47c3363136b05cd1";
       libraryHaskellDepends = [ base containers templater text ];
       testHaskellDepends = [
         base hspec hspec-laws HUnit QuickCheck quickcheck-instances text
       ];
       homepage = "https://github.com/geraud/cmd-item";
       description = "Library to compose and reuse command line fragments";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cmdargs_0_10_12" = callPackage
    ({ mkDerivation, base, filepath, process, template-haskell
     , transformers
     }:
     mkDerivation {
       pname = "cmdargs";
       version = "0.10.12";
       sha256 = "5e66581205cb76a2621a7bf5cb42411a8cc1d37fe3b8a266803266c2991fb62b";
       revision = "1";
       editedCabalFile = "e37c92e6337ccbacd95f77938a1d0459f52cdb1a51c920a96610793cf2b5e4dc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base filepath process template-haskell transformers
       ];
       homepage = "http://community.haskell.org/~ndm/cmdargs/";
       description = "Command line argument processing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cmdargs_0_10_13" = callPackage
    ({ mkDerivation, base, filepath, process, template-haskell
     , transformers
     }:
     mkDerivation {
       pname = "cmdargs";
       version = "0.10.13";
       sha256 = "66117c1fadaa2a79be07998287ca7cee334c249615b0fab9b91467ad813bbf6e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base filepath process template-haskell transformers
       ];
       homepage = "http://community.haskell.org/~ndm/cmdargs/";
       description = "Command line argument processing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cmdargs" = callPackage
    ({ mkDerivation, base, filepath, process, template-haskell
     , transformers
     }:
     mkDerivation {
       pname = "cmdargs";
       version = "0.10.14";
       sha256 = "38b60053c11394a1876d2744950eece66ca9e4364298c1383f247894044bce58";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base filepath process template-haskell transformers
       ];
       homepage = "https://github.com/ndmitchell/cmdargs#readme";
       description = "Command line argument processing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cmdargs-browser" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, directory, filepath
     , http-types, process, text, transformers, wai, wai-handler-launch
     }:
     mkDerivation {
       pname = "cmdargs-browser";
       version = "0.1.3";
       sha256 = "a0fd5a45d98723938525f44d1022e09333177c74d06fa7e5a76b627de0160fcc";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs directory filepath http-types process text
         transformers wai wai-handler-launch
       ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~ndm/cmdargs/";
       description = "Helper to enter cmdargs command lines using a web browser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cmdlib" = callPackage
    ({ mkDerivation, base, mtl, split, syb, transformers }:
     mkDerivation {
       pname = "cmdlib";
       version = "0.3.6";
       sha256 = "5643d219c371f903c3f877b5955de4ca99a723bc96165f4f629d3e3dbc3fb357";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl split syb transformers ];
       description = "a library for command line parsing & online help";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cmdtheline" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, HUnit
     , parsec, pretty, process, test-framework, test-framework-hunit
     , transformers
     }:
     mkDerivation {
       pname = "cmdtheline";
       version = "0.2.3";
       sha256 = "042c4f995a8e6e336451d11702f341dbe31d9e6e0b956acd5f92b1d7c9c88bcb";
       libraryHaskellDepends = [
         base containers directory filepath parsec pretty process
         transformers
       ];
       testHaskellDepends = [
         base containers directory filepath HUnit parsec pretty process
         test-framework test-framework-hunit transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/eli-frey/cmdtheline";
       description = "Declarative command-line option parsing and documentation library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cml" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "cml";
       version = "0.1.3";
       sha256 = "f096f829721334f460d71d43051eb1ef16deea673e2c93d8787f2aa4c801d5c3";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.haskell.org/cml/";
       description = "Events and Channels as in Concurrent ML";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cmonad" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "cmonad";
       version = "0.1.1.1";
       sha256 = "530bb4369dcfac4157d59aee898145a006dfc496ed4a17a12578bcaa2fe44d1d";
       libraryHaskellDepends = [ array base ];
       description = "A library for C-like programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cmu" = callPackage
    ({ mkDerivation, array, base, containers }:
     mkDerivation {
       pname = "cmu";
       version = "1.10";
       sha256 = "fe15496a9c3026924eb54252c93948b5a32925beba265d0a994287b2ae368c7e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base containers ];
       executableHaskellDepends = [ array base containers ];
       description = "Unification in a Commutative Monoid";
       license = "GPL";
     }) {};

  "cnc-spec-compiler" = callPackage
    ({ mkDerivation, ansi-terminal, array, base, binary, bytestring
     , containers, directory, fgl, filepath, HUnit, mtl, parsec, pretty
     , prettyclass, process, split, stringtable-atom, unix, zlib
     }:
     mkDerivation {
       pname = "cnc-spec-compiler";
       version = "0.2.0.1";
       sha256 = "6009a1d320b1ace68bcea267ef30430c1ea66c3e2816d7911e717d6d3e7dd859";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal array base binary bytestring containers directory fgl
         filepath HUnit mtl parsec pretty prettyclass process split
         stringtable-atom unix zlib
       ];
       homepage = "http://software.intel.com/en-us/articles/intel-concurrent-collections-for-cc/";
       description = "Compiler/Translator for CnC Specification Files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cndict" = callPackage
    ({ mkDerivation, base, binary, bytestring, cassava, containers
     , text, vector
     }:
     mkDerivation {
       pname = "cndict";
       version = "0.6.4";
       sha256 = "087b98003461144617d8d932ff5d6e853e44d599f5b2df1f378f1bb07ddb91da";
       libraryHaskellDepends = [
         base binary bytestring cassava containers text vector
       ];
       homepage = "https://github.com/Lemmih/cndict";
       description = "Chinese/Mandarin <-> English dictionary, Chinese lexer";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "code-builder" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "code-builder";
       version = "0.1.3";
       sha256 = "559e47a44cec85a8e95df92e5d2693cacc9761503c30be3b83eaebd95360a4ab";
       libraryHaskellDepends = [ base containers ];
       description = "Simple system for generating code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "codec" = callPackage
    ({ mkDerivation, aeson, base, binary, binary-bits, bytestring
     , data-default-class, mtl, template-haskell, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "codec";
       version = "0.1.1";
       sha256 = "3351aa3747ae92db463706c527d1723c22c34dc280ccd14e530f1ca1555b6c3a";
       libraryHaskellDepends = [
         aeson base binary binary-bits bytestring data-default-class mtl
         template-haskell text transformers unordered-containers
       ];
       testHaskellDepends = [
         aeson base binary binary-bits bytestring data-default-class mtl
         template-haskell text transformers unordered-containers
       ];
       homepage = "https://github.com/chpatrick/codec";
       description = "First-class record construction and bidirectional serialization";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "codec-libevent" = callPackage
    ({ mkDerivation, array, base, binary, binary-strict, bytestring
     , containers, parsec, QuickCheck, regex-compat
     }:
     mkDerivation {
       pname = "codec-libevent";
       version = "0.1.2";
       sha256 = "14983b281a62947824c7f6d774852cf8963b1ef711b4f82c395816a37b53679f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary binary-strict bytestring containers parsec
         QuickCheck regex-compat
       ];
       executableHaskellDepends = [
         array base binary binary-strict bytestring containers parsec
         QuickCheck regex-compat
       ];
       description = "Cross-platform structure serialisation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "codec-mbox" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "codec-mbox";
       version = "0.2.0.0";
       sha256 = "94094b42a472016be310aba00f25a8f442231c9820be08539337786a9e39764d";
       libraryHaskellDepends = [ base bytestring ];
       description = "A library to read and write mailboxes in mbox format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "codecov-haskell" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, cmdargs
     , containers, curl, hpc, HUnit, process, regex-posix, safe, split
     }:
     mkDerivation {
       pname = "codecov-haskell";
       version = "0.4.0.2";
       sha256 = "5c375baf7257ae6d490964df8169687df9eb1fa98178729d9c714baf62da3b78";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring cmdargs containers curl hpc safe split
       ];
       executableHaskellDepends = [
         aeson async base bytestring cmdargs containers curl hpc process
         regex-posix safe split
       ];
       testHaskellDepends = [ base HUnit ];
       homepage = "https://github.com/guillaume-nargeot/codecov-haskell";
       description = "Codecov.io support for Haskell.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "codemonitor" = callPackage
    ({ mkDerivation, base, cairo, containers, directory, filepath, gtk
     , haskell98, hinotify, MissingH, process, regex-posix, time
     }:
     mkDerivation {
       pname = "codemonitor";
       version = "0.2";
       sha256 = "ac86edc30a979d975ab16416ce916b0d4015f48b44f6ac032e72f50a4ce35e92";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cairo containers directory filepath gtk haskell98 hinotify
         MissingH process regex-posix time
       ];
       homepage = "http://github.com/rickardlindberg/codemonitor";
       description = "Tool that automatically runs arbitrary commands when files change on disk";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "codepad" = callPackage
    ({ mkDerivation, base, curl, mtl, network, tagsoup }:
     mkDerivation {
       pname = "codepad";
       version = "0.1";
       sha256 = "215704a914c2006369c63cf6000385b2ece643839a8c0f2398353f46f65a5b0e";
       revision = "3";
       editedCabalFile = "6f9d1a534fa6ff720347aa10521a99456aa4b9e2a95b45f71cadb06074277c86";
       libraryHaskellDepends = [ base curl mtl network tagsoup ];
       jailbreak = true;
       homepage = "http://github.com/chrisdone/codepad";
       description = "Submit and retrieve paste output from CodePad.org.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "codex_0_3_0_8" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, cryptohash
     , directory, either, filepath, hackage-db, http-client, lens
     , machines, machines-directory, MissingH, monad-loops, network
     , process, tar, text, transformers, wreq, yaml, zlib
     }:
     mkDerivation {
       pname = "codex";
       version = "0.3.0.8";
       sha256 = "02c49e36d82351706816587c72cd958acab586836259706b7bda3e88c75599ca";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring Cabal containers cryptohash directory either
         filepath hackage-db http-client lens machines machines-directory
         process tar text transformers wreq yaml zlib
       ];
       executableHaskellDepends = [
         base bytestring Cabal directory either filepath hackage-db MissingH
         monad-loops network wreq yaml
       ];
       jailbreak = true;
       homepage = "http://github.com/aloiscochard/codex";
       description = "A ctags file generator for cabal project dependencies";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "codex_0_3_0_10" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, cryptohash
     , directory, either, filepath, hackage-db, http-client, lens
     , machines, machines-directory, MissingH, monad-loops, network
     , process, tar, text, transformers, wreq, yaml, zlib
     }:
     mkDerivation {
       pname = "codex";
       version = "0.3.0.10";
       sha256 = "ae2ace3744de09abb7cf8d8d8e36905ea08698c47f1b0677433f4649196f4e76";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring Cabal containers cryptohash directory either
         filepath hackage-db http-client lens machines machines-directory
         process tar text transformers wreq yaml zlib
       ];
       executableHaskellDepends = [
         base bytestring Cabal directory either filepath hackage-db MissingH
         monad-loops network wreq yaml
       ];
       jailbreak = true;
       homepage = "http://github.com/aloiscochard/codex";
       description = "A ctags file generator for cabal project dependencies";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "codex_0_4_0_6" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, cryptohash
     , directory, either, filepath, hackage-db, http-client, lens
     , machines, machines-directory, MissingH, monad-loops, network
     , process, tar, text, transformers, wreq, yaml, zlib
     }:
     mkDerivation {
       pname = "codex";
       version = "0.4.0.6";
       sha256 = "b39508eaa0f2239e18070a358b7a9a83f7e7aba326e27061bdaf47b9498eacb1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring Cabal containers cryptohash directory either
         filepath hackage-db http-client lens machines machines-directory
         process tar text transformers wreq yaml zlib
       ];
       executableHaskellDepends = [
         base bytestring Cabal directory either filepath hackage-db MissingH
         monad-loops network process transformers wreq yaml
       ];
       jailbreak = true;
       homepage = "http://github.com/aloiscochard/codex";
       description = "A ctags file generator for cabal project dependencies";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "codex" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, cryptohash
     , directory, either, filepath, hackage-db, http-client, lens
     , machines, machines-directory, MissingH, monad-loops, network
     , process, tar, text, transformers, wreq, yaml, zlib
     }:
     mkDerivation {
       pname = "codex";
       version = "0.4.0.8";
       sha256 = "b648e6b2a90e5e032caeaaf013f4d97318fa8396d20de0a54980ccdf16b5117f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring Cabal containers cryptohash directory either
         filepath hackage-db http-client lens machines machines-directory
         process tar text transformers wreq yaml zlib
       ];
       executableHaskellDepends = [
         base bytestring Cabal directory either filepath hackage-db MissingH
         monad-loops network process transformers wreq yaml
       ];
       homepage = "http://github.com/aloiscochard/codex";
       description = "A ctags file generator for cabal project dependencies";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "codo-notation" = callPackage
    ({ mkDerivation, base, comonad, haskell-src-meta, parsec
     , template-haskell, uniplate
     }:
     mkDerivation {
       pname = "codo-notation";
       version = "0.5.2";
       sha256 = "78eb57004541ed29eb4c54196b91ac2dd1028a3315f51cd4dc00debfc0938eaf";
       libraryHaskellDepends = [
         base comonad haskell-src-meta parsec template-haskell uniplate
       ];
       description = "A notation for comonads, analogous to the do-notation for monads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cofunctor" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "cofunctor";
       version = "0.1.0.1";
       sha256 = "379110f43cfbabf3f13023390ce69208bb3bd37374f3453578e3277a5898c476";
       libraryHaskellDepends = [ base ];
       description = "DEPRECATED: use the \"contravariant\" package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cognimeta-utils" = callPackage
    ({ mkDerivation, array, base, bytestring, collections-api
     , comonad-transformers, containers, data-lens, data-lens-fd
     , data-lens-template, deepseq, ghc-prim, mtl, primitive, QuickCheck
     , stm, tagged, template-haskell, transformers
     }:
     mkDerivation {
       pname = "cognimeta-utils";
       version = "0.1.2";
       sha256 = "b4782dabe5db7b382d792bd9332df597d47f125668bdc094031df5d3142e7801";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring collections-api comonad-transformers
         containers data-lens data-lens-fd data-lens-template deepseq
         ghc-prim mtl primitive QuickCheck stm tagged template-haskell
         transformers
       ];
       executableHaskellDepends = [
         base bytestring containers mtl QuickCheck template-haskell
         transformers
       ];
       homepage = "https://github.com/Cognimeta/cognimeta-utils";
       description = "Utilities for Cognimeta products (such as perdure). API may change often.";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "coinbase-exchange" = callPackage
    ({ mkDerivation, aeson, aeson-casing, async, base
     , base64-bytestring, byteable, bytestring, conduit, conduit-extra
     , cryptohash, deepseq, exceptions, hashable, http-client
     , http-client-tls, http-conduit, http-types, mtl, network
     , old-locale, random, resourcet, scientific, tasty, tasty-hunit
     , tasty-quickcheck, tasty-th, text, time, transformers
     , transformers-base, unordered-containers, uuid, uuid-aeson, vector
     , websockets, wuss
     }:
     mkDerivation {
       pname = "coinbase-exchange";
       version = "0.3.0.0";
       sha256 = "930a8971e2e558f1acfcf7ff545a6ca919ec7e11eb9c9b3fa4c50b94c6c5930b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-casing base base64-bytestring byteable bytestring
         conduit conduit-extra cryptohash deepseq exceptions hashable
         http-conduit http-types mtl network old-locale resourcet scientific
         text time transformers-base unordered-containers uuid uuid-aeson
         vector websockets wuss
       ];
       executableHaskellDepends = [
         aeson base bytestring conduit conduit-extra http-client
         http-client-tls http-conduit network old-locale resourcet
         scientific text time transformers unordered-containers uuid
         websockets wuss
       ];
       testHaskellDepends = [
         aeson async base bytestring http-client-tls http-conduit old-locale
         random scientific tasty tasty-hunit tasty-quickcheck tasty-th time
         transformers unordered-containers uuid websockets
       ];
       jailbreak = true;
       description = "Connector library for the coinbase exchange";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "colada" = callPackage
    ({ mkDerivation, base, bytestring, cereal, cmdargs, containers
     , fclabels, ghc-prim, ListZipper, monad-atom, mtl, nlp-scores
     , split, swift-lda, text, vector
     }:
     mkDerivation {
       pname = "colada";
       version = "0.8.4.0";
       sha256 = "e34f1a7ce3b421d6a31544f07319948f875b48e3376756d0632a8b0b45ae369a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal cmdargs containers fclabels ghc-prim
         ListZipper monad-atom mtl nlp-scores split swift-lda text vector
       ];
       executableHaskellDepends = [
         base bytestring cereal cmdargs containers fclabels ghc-prim
         ListZipper monad-atom mtl nlp-scores split swift-lda text vector
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/gchrupala/colada";
       description = "Colada implements incremental word class class induction using online LDA";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "colchis" = callPackage
    ({ mkDerivation, aeson, base, conceit, network, network-simple
     , pipes, pipes-aeson, pipes-attoparsec, pipes-network, text
     , transformers
     }:
     mkDerivation {
       pname = "colchis";
       version = "0.2.0.3";
       sha256 = "6be5248e49359254c7818aac0561236743b4c2b5427fa5014e2503726aaf0aba";
       libraryHaskellDepends = [
         aeson base conceit network network-simple pipes pipes-aeson
         pipes-attoparsec pipes-network text transformers
       ];
       jailbreak = true;
       description = "Rudimentary JSON-RPC 2.0 client over raw TCP.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "collada-output" = callPackage
    ({ mkDerivation, base, collada-types, containers, SVGPath, time
     , vector, xml
     }:
     mkDerivation {
       pname = "collada-output";
       version = "0.6";
       sha256 = "fdf013f5ef6f765015d55e9afcd870557535da6377ad9b2d9006f4f42515d3cc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base collada-types containers SVGPath time vector xml
       ];
       jailbreak = true;
       description = "Generate animated 3d objects in COLLADA";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "collada-types" = callPackage
    ({ mkDerivation, base, containers, enumerable, OpenGL, tuple
     , tuple-gen, vector
     }:
     mkDerivation {
       pname = "collada-types";
       version = "0.3";
       sha256 = "88f59074a3d2ed819d809e6bb3955771d64a1432017103391ff25a46fdf0812b";
       libraryHaskellDepends = [
         base containers enumerable OpenGL tuple tuple-gen vector
       ];
       jailbreak = true;
       description = "Data exchange between graphic applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "collapse-util" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "collapse-util";
       version = "0.1.0.1";
       sha256 = "47ce281530a3003933483c9e4eeee2320e5ee396c549042383a34a2ed267240b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://github.com/mwotton/collapse";
       description = "utility for collapsing adjacent writes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "collection-json" = callPackage
    ({ mkDerivation, aeson, base, bytestring, text }:
     mkDerivation {
       pname = "collection-json";
       version = "0.1.0.0";
       sha256 = "8ca99eb2c0a6cb48d7982ba1316d4ef411a38ec9490c3b231e99001dd251f7db";
       libraryHaskellDepends = [ aeson base bytestring text ];
       jailbreak = true;
       homepage = "https://github.com/danchoi/collection-json.hs";
       description = "Collection+JSON hypermedia type tools";
       license = stdenv.lib.licenses.mit;
     }) {};

  "collections" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, QuickCheck }:
     mkDerivation {
       pname = "collections";
       version = "0.3.1.1";
       sha256 = "ef3075c5034bf45bafa6c3a1ffda219c25377094c06dd1dc235b722926aab328";
       libraryHaskellDepends = [
         array base bytestring containers QuickCheck
       ];
       jailbreak = true;
       description = "Useful standard collections types and related functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "collections-api" = callPackage
    ({ mkDerivation, array, base, QuickCheck }:
     mkDerivation {
       pname = "collections-api";
       version = "1.0.0.0";
       sha256 = "b4dc47ec1552b66e69a465e9f974c8afab914b6a85f8214398969b1daf0efc6d";
       libraryHaskellDepends = [ array base QuickCheck ];
       homepage = "http://code.haskell.org/collections/";
       description = "API for collection data structures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "collections-base-instances" = callPackage
    ({ mkDerivation, array, base, bytestring, collections-api
     , containers
     }:
     mkDerivation {
       pname = "collections-base-instances";
       version = "1.0.0.0";
       sha256 = "f3df97932f34c33d6a26f675dbbe9dd474266f348c3aed9cbd63488dffe5865b";
       libraryHaskellDepends = [
         array base bytestring collections-api containers
       ];
       homepage = "http://code.haskell.org/collections/";
       description = "Useful standard collections types and related functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "colock" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "colock";
       version = "0.2.2";
       sha256 = "6175f073e27b7ff981db88b115e338cea54f7360cddb4a9f98219cc1062b7e40";
       libraryHaskellDepends = [ base unix ];
       description = "thread-friendly file locks that don't block the entire program";
       license = "LGPL";
     }) {};

  "colorize-haskell" = callPackage
    ({ mkDerivation, ansi-terminal, base, haskell-lexer }:
     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 ];
       homepage = "http://github.com/yav/colorize-haskell";
       description = "Highligt Haskell source";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "colors" = callPackage
    ({ mkDerivation, base, lens, linear, profunctors }:
     mkDerivation {
       pname = "colors";
       version = "0.3.0.2";
       sha256 = "155ea3ac3cb65482236e4a997706ac431d3edababe6858640827c1cc8bc56d3d";
       revision = "1";
       editedCabalFile = "b49946d81e0089d4d80191523839f934802975ede3b9fd9521ead9e591142560";
       libraryHaskellDepends = [ base lens linear profunctors ];
       homepage = "https://github.com/fumieval/colors";
       description = "A type for colors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "colour" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "colour";
       version = "2.3.3";
       sha256 = "8d15a63494f8e2a06fe6dc38baee8e948adfae0e93749b9e3ce0fd8ece09b6e2";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.haskell.org/haskellwiki/Colour";
       description = "A model for human colour/color perception";
       license = stdenv.lib.licenses.mit;
     }) {};

  "coltrane" = callPackage
    ({ mkDerivation, base, bytestring, HTTP, http-types, HUnit, mtl
     , regex-compat, text, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "coltrane";
       version = "0.1.0.0";
       sha256 = "ca95b5b07c9b17f57798275458234a2fbef341a246b7c4b6bc2a5affa3cb2a8c";
       libraryHaskellDepends = [
         base bytestring HTTP http-types HUnit mtl regex-compat text wai
         wai-extra warp
       ];
       jailbreak = true;
       homepage = "https://github.com/wellecks/coltrane";
       description = "A jazzy, minimal web framework for Haskell, inspired by Sinatra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "com" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "com";
       version = "1.2.3.1";
       sha256 = "f5085572cd0b0c8f8fdf115fad5c842657e803c70b2ce1c230ee452f87a9dff8";
       doHaddock = false;
       description = "Haskell COM support library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "combinat" = callPackage
    ({ mkDerivation, array, base, containers, QuickCheck, random
     , test-framework, test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "combinat";
       version = "0.2.8.1";
       sha256 = "5a6c09490085056f2b042c814df6f7333b394581dba1c5c7b788bcad81861937";
       libraryHaskellDepends = [
         array base containers random transformers
       ];
       testHaskellDepends = [
         array base containers QuickCheck random test-framework
         test-framework-quickcheck2 transformers
       ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "Generate and manipulate various combinatorial objects";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "combinat-diagrams" = callPackage
    ({ mkDerivation, array, base, colour, combinat, containers
     , diagrams-core, diagrams-lib, linear, transformers
     }:
     mkDerivation {
       pname = "combinat-diagrams";
       version = "0.2";
       sha256 = "70c8f0126c8c92588a45136f928398e08fc4f4e03f8e8573679328db0d41a94a";
       libraryHaskellDepends = [
         array base colour combinat containers diagrams-core diagrams-lib
         linear transformers
       ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "Graphical representations for various combinatorial objects";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "combinator-interactive" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, directory
     , lens, mtl, template-haskell, th-lift, trifecta, void
     }:
     mkDerivation {
       pname = "combinator-interactive";
       version = "0.1.2";
       sha256 = "84494a9d77282847954e3de8d71fb8023c07ef92ea325c1a81cac83b02f1ad7b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base lens template-haskell th-lift trifecta void
       ];
       executableHaskellDepends = [
         base bytestring cereal containers directory lens mtl
         template-haskell th-lift trifecta void
       ];
       jailbreak = true;
       homepage = "https://github.com/fumieval/combinator-interactive";
       description = "SKI Combinator interpreter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "combinatorial-problems" = callPackage
    ({ mkDerivation, array, base, bytestring, bytestring-lexing
     , containers, parsec, random
     }:
     mkDerivation {
       pname = "combinatorial-problems";
       version = "0.0.5";
       sha256 = "a0a0e700307362308a62c4b8f02ce7d03177380a602162755cdd98284cd471cc";
       libraryHaskellDepends = [
         array base bytestring bytestring-lexing containers parsec random
       ];
       homepage = "http://www.comp.leeds.ac.uk/sc06r2s/Projects/HaskellCombinatorialProblems";
       description = "A number of data structures to represent and allow the manipulation of standard combinatorial problems, used as test problems in computer science";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "combinatorics" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "combinatorics";
       version = "0.1.0";
       sha256 = "2af52830c0548d0e6eacd1f762dd1d8ff8b747da4043891be6662bc73c1d2b80";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.haskell.org/~wren/";
       description = "Efficient computation of common combinatoric functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "combobuffer" = callPackage
    ({ mkDerivation, base, containers, template-haskell, vector
     , vector-space
     }:
     mkDerivation {
       pname = "combobuffer";
       version = "0.2";
       sha256 = "5066b4be6b4b47eec38baefa3c1945ef93cb3541c56b8c6fcfd6f89a588a4dff";
       libraryHaskellDepends = [
         base containers template-haskell vector vector-space
       ];
       jailbreak = true;
       homepage = "https://github.com/JohnLato/combobuffer";
       description = "Various buffer implementations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "comfort-graph" = callPackage
    ({ mkDerivation, base, containers, QuickCheck, transformers
     , utility-ht
     }:
     mkDerivation {
       pname = "comfort-graph";
       version = "0.0.1";
       sha256 = "81487e3610993d2939bf1777823357095645f710d1bee94dd4dd0fa052b428a0";
       libraryHaskellDepends = [
         base containers QuickCheck transformers utility-ht
       ];
       testHaskellDepends = [
         base containers QuickCheck transformers utility-ht
       ];
       homepage = "http://hub.darcs.net/thielema/comfort-graph";
       description = "Graph structure with type parameters for nodes and edges";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "command" = callPackage
    ({ mkDerivation, base, deepseq, process }:
     mkDerivation {
       pname = "command";
       version = "0.1.1";
       sha256 = "1c0a9bddc3518e08eedb61197389fe7dc53c7927a75dace3466dfc1872894662";
       libraryHaskellDepends = [ base deepseq process ];
       homepage = "https://github.com/nh2/command";
       description = "Conveniently run shell commands";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "command-qq" = callPackage
    ({ mkDerivation, base, doctest, hspec, process, template-haskell
     , text
     }:
     mkDerivation {
       pname = "command-qq";
       version = "0.3.0.0";
       sha256 = "c5cb03a4123f38620b3bfb6e6d3b737591008cbb58c6e7656a49c9c21e590eaf";
       libraryHaskellDepends = [ base process template-haskell text ];
       testHaskellDepends = [ base doctest hspec template-haskell text ];
       homepage = "http://biegunka.github.io/command-qq/";
       description = "Quasiquoters for external commands";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "commodities" = callPackage
    ({ mkDerivation, base, comonad, containers, directory, distributive
     , doctest, filepath, hspec, hspec-expectations, keys, lens, linear
     , mtl, numbers, PSQueue, QuickCheck, semigroupoids, semigroups
     , text, thyme, transformers
     }:
     mkDerivation {
       pname = "commodities";
       version = "0.2.0";
       sha256 = "093df899954134b657ac338384342f64a4f71dbe9841cef2ec138fc5cfddc275";
       libraryHaskellDepends = [
         base comonad containers distributive keys lens linear mtl numbers
         PSQueue semigroupoids semigroups text thyme transformers
       ];
       testHaskellDepends = [
         base containers directory doctest filepath hspec hspec-expectations
         lens QuickCheck semigroups thyme transformers
       ];
       jailbreak = true;
       description = "Library for working with commoditized amounts and price histories";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "commsec" = callPackage
    ({ mkDerivation, base, bytestring, cipher-aes128, crypto-api
     , network
     }:
     mkDerivation {
       pname = "commsec";
       version = "0.3.5";
       sha256 = "f5d93bd74020fcdfa3541bf9e0f4096333191f806ba85bc11949546c0eba50d3";
       libraryHaskellDepends = [
         base bytestring cipher-aes128 crypto-api network
       ];
       description = "Provide communications security using symmetric ephemeral keys";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "commsec-keyexchange" = callPackage
    ({ mkDerivation, base, bytestring, cereal, cipher-aes128, commsec
     , crypto-api, crypto-pubkey-types, cryptohash-cryptoapi, DRBG
     , monadcryptorandom, network, RSA
     }:
     mkDerivation {
       pname = "commsec-keyexchange";
       version = "0.3.3";
       sha256 = "365fd0db7498d350659e8eaecea6e574cf097ec8c00a72969fd92541b63b40b0";
       libraryHaskellDepends = [
         base bytestring cereal cipher-aes128 commsec crypto-api
         crypto-pubkey-types cryptohash-cryptoapi DRBG monadcryptorandom
         network RSA
       ];
       homepage = "https://github.com/TomMD/commsec-keyExchange";
       description = "Key agreement for commsec";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "commutative" = callPackage
    ({ mkDerivation, base, QuickCheck, quickcheck-instances, random
     , semigroups, tasty, tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "commutative";
       version = "0.0.1.4";
       sha256 = "0de746012c73543b5dcf649434046e36d5e158e0967e8e2ae122e85d5457c9cf";
       libraryHaskellDepends = [ base random semigroups ];
       testHaskellDepends = [
         base QuickCheck quickcheck-instances random semigroups tasty
         tasty-hunit tasty-quickcheck
       ];
       description = "Commutative binary operations";
       license = stdenv.lib.licenses.mit;
     }) {};

  "comonad_4_2_2" = callPackage
    ({ mkDerivation, base, containers, contravariant, directory
     , distributive, doctest, filepath, semigroups, tagged, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "comonad";
       version = "4.2.2";
       sha256 = "4822281f025267480e03da26f9dcfeebffeb85e759861596b44d731981674e08";
       libraryHaskellDepends = [
         base containers contravariant distributive semigroups tagged
         transformers transformers-compat
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/ekmett/comonad/";
       description = "Comonads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "comonad_4_2_3" = callPackage
    ({ mkDerivation, base, containers, contravariant, directory
     , distributive, doctest, filepath, semigroups, tagged, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "comonad";
       version = "4.2.3";
       sha256 = "527b0cd3183dd4326dee4bf0382b10edf88e05f1eee889051a67e3d0fd3149ff";
       libraryHaskellDepends = [
         base containers contravariant distributive semigroups tagged
         transformers transformers-compat
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/ekmett/comonad/";
       description = "Comonads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "comonad_4_2_4" = callPackage
    ({ mkDerivation, base, containers, contravariant, directory
     , distributive, doctest, filepath, semigroups, tagged, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "comonad";
       version = "4.2.4";
       sha256 = "68290d0a06872db420a7457cf45c4a3a4d9a0095014117667259ae91e369cc73";
       libraryHaskellDepends = [
         base containers contravariant distributive semigroups tagged
         transformers transformers-compat
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/ekmett/comonad/";
       description = "Comonads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "comonad_4_2_5" = callPackage
    ({ mkDerivation, base, containers, contravariant, directory
     , distributive, doctest, filepath, semigroups, tagged, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "comonad";
       version = "4.2.5";
       sha256 = "0ef3a31140df072b077bf92db79c8807f5fa1fb30d3c17eb2679dafdb0cf341e";
       revision = "1";
       editedCabalFile = "e94b577455438ce49d931cfcac104ac6d6503541190538cae41b6419ac85fbd7";
       libraryHaskellDepends = [
         base containers contravariant distributive semigroups tagged
         transformers transformers-compat
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/ekmett/comonad/";
       description = "Comonads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "comonad_4_2_6" = callPackage
    ({ mkDerivation, base, containers, contravariant, directory
     , distributive, doctest, filepath, semigroups, tagged, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "comonad";
       version = "4.2.6";
       sha256 = "11982a4458189e8aa01ef1152aadd79829913292fdeccd456ce44ce99df657b7";
       revision = "3";
       editedCabalFile = "9783b032c5ea8a64282096775eeaaa112b71ebe980b47e5cad4260f9d51eb647";
       libraryHaskellDepends = [
         base containers contravariant distributive semigroups tagged
         transformers transformers-compat
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/ekmett/comonad/";
       description = "Comonads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "comonad" = callPackage
    ({ mkDerivation, base, containers, contravariant, directory
     , distributive, doctest, filepath, semigroups, tagged, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "comonad";
       version = "4.2.7.2";
       sha256 = "b762261ef545a16881b66409398752e249a8e654a34088c66d9fabf9ba5a3b2b";
       libraryHaskellDepends = [
         base containers contravariant distributive semigroups tagged
         transformers transformers-compat
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/ekmett/comonad/";
       description = "Comonads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "comonad_5" = callPackage
    ({ mkDerivation, base, containers, contravariant, directory
     , distributive, doctest, filepath, semigroups, tagged, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "comonad";
       version = "5";
       sha256 = "78e5b19da5b701d14ceb2ca19191cc6205b2024ff2f71b754f5e949faa19cb2a";
       libraryHaskellDepends = [
         base containers contravariant distributive semigroups tagged
         transformers transformers-compat
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/ekmett/comonad/";
       description = "Comonads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "comonad-extras" = callPackage
    ({ mkDerivation, array, base, comonad, containers, distributive
     , semigroupoids, transformers
     }:
     mkDerivation {
       pname = "comonad-extras";
       version = "4.0";
       sha256 = "c264dd957f2ee50f133cf63ac818f3659f5d8350a56adda52d9881bbb2e93447";
       libraryHaskellDepends = [
         array base comonad containers distributive semigroupoids
         transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/comonad-extras/";
       description = "Exotic comonad transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "comonad-random" = callPackage
    ({ mkDerivation, base, category-extras, random }:
     mkDerivation {
       pname = "comonad-random";
       version = "0.1.2";
       sha256 = "5ebdd4677d4b1de6246c4c6045c39fdf24b043b28f0b4733d7cada9b91984a86";
       libraryHaskellDepends = [ base category-extras random ];
       jailbreak = true;
       description = "Comonadic interface for random values";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "comonad-transformers" = callPackage
    ({ mkDerivation, base, comonad }:
     mkDerivation {
       pname = "comonad-transformers";
       version = "4.0";
       sha256 = "dfec0c4ce1eccd34c228951454a8f2ebab0bfbdf1cde68a70688196db2b9ff8f";
       libraryHaskellDepends = [ base comonad ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://github.com/ekmett/comonad-transformers/";
       description = "This package has been merged into comonad 4.0";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "comonads-fd" = callPackage
    ({ mkDerivation, base, comonad }:
     mkDerivation {
       pname = "comonads-fd";
       version = "4.0";
       sha256 = "3a70386e2ef3d6f444585f082de42e842a47dfe7bdbd807550839faf1bd8b7a7";
       libraryHaskellDepends = [ base comonad ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://github.com/ekmett/comonads-fd/";
       description = "This package has been merged into comonad 4.0";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "compact-map" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers }:
     mkDerivation {
       pname = "compact-map";
       version = "2008.11.9";
       sha256 = "7ea5d68219aca29f43cd37910db9c7921d65ee57652fc573546bd1c575796266";
       libraryHaskellDepends = [
         array base binary bytestring containers
       ];
       description = "Compact Data.Map implementation using Data.Binary";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "compact-socket" = callPackage
    ({ mkDerivation, base, binary, bytestring, compact, deepseq
     , directory, filepath, network, unix
     }:
     mkDerivation {
       pname = "compact-socket";
       version = "0.1.0.0";
       sha256 = "e758ee08d3013aebc013fe2d5eb1f529db56ea0f926bd2ba7bc1266cc1c9ee3b";
       libraryHaskellDepends = [
         base binary bytestring compact deepseq directory filepath network
         unix
       ];
       jailbreak = true;
       description = "Socket functions for compact normal form";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {compact = null;};

  "compact-string" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "compact-string";
       version = "0.3.1";
       sha256 = "48da37dc629ee3bfe55d05d5284c2c6b067deb034cf3feab3982572910ed980a";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://twan.home.fmf.nl/compact-string/";
       description = "Fast, packed and strict strings with Unicode support, based on bytestrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "compact-string-fix" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "compact-string-fix";
       version = "0.3.2";
       sha256 = "f620377ff715dfc740cf48f5af82afb4b2afaca9e7bf76ef397ee39c2b053f98";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://twan.home.fmf.nl/compact-string/";
       description = "Same as compact-string except with a small fix so it builds on ghc-6.12";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "compactmap" = callPackage
    ({ mkDerivation, base, containers, hspec, QuickCheck, vector }:
     mkDerivation {
       pname = "compactmap";
       version = "0.1.3.1";
       sha256 = "14a6e2da9d41c4499a3d1e29c4259847062ec19ff5e3abc3f84861218d6195c3";
       libraryHaskellDepends = [ base vector ];
       testHaskellDepends = [ base containers hspec QuickCheck ];
       description = "A read-only memory-efficient key-value store";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "compare-type" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "compare-type";
       version = "0.1.1";
       sha256 = "4bb3e899e63e63d6787ed191f1800606666e88f18693c810b8abe38ba21dd7e8";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/Kinokkory/compare-type";
       description = "compare types of any kinds in haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "compdata_0_9" = callPackage
    ({ mkDerivation, base, containers, deepseq, derive, HUnit, mtl
     , QuickCheck, template-haskell, test-framework
     , test-framework-hunit, test-framework-quickcheck2, th-expand-syns
     , transformers, tree-view
     }:
     mkDerivation {
       pname = "compdata";
       version = "0.9";
       sha256 = "0cfb5e49ef51bbd968d81469180c395fb8f261622f6be688616e503290dc69f2";
       libraryHaskellDepends = [
         base containers deepseq derive mtl QuickCheck template-haskell
         th-expand-syns transformers tree-view
       ];
       testHaskellDepends = [
         base containers deepseq derive HUnit mtl QuickCheck
         template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2 th-expand-syns transformers
       ];
       doCheck = false;
       description = "Compositional Data Types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "compdata" = callPackage
    ({ mkDerivation, base, containers, deepseq, derive, HUnit, mtl
     , QuickCheck, template-haskell, test-framework
     , test-framework-hunit, test-framework-quickcheck2, th-expand-syns
     , transformers, tree-view
     }:
     mkDerivation {
       pname = "compdata";
       version = "0.10";
       sha256 = "10d14424338033c66f3ca0fa27ef6793474747d0a66d28068dfb14ce55936894";
       revision = "1";
       editedCabalFile = "09ef1d8f84ae93c4f212661d411542155b0da1c8202e8bf10bfc18d69001a82e";
       libraryHaskellDepends = [
         base containers deepseq derive mtl QuickCheck template-haskell
         th-expand-syns transformers tree-view
       ];
       testHaskellDepends = [
         base containers deepseq derive HUnit mtl QuickCheck
         template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2 th-expand-syns transformers
       ];
       doCheck = false;
       description = "Compositional Data Types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "compdata-automata" = callPackage
    ({ mkDerivation, base, compdata, containers, projection }:
     mkDerivation {
       pname = "compdata-automata";
       version = "0.9";
       sha256 = "6eba64e2cbb12d2494c9d10bdbe7ccd3d552dec2ced1fcaf41d952ee89329bc2";
       revision = "1";
       editedCabalFile = "f8bda15b8d1d1e56f64c37f39ac8ba1c7bf860c291adad3698041eee68146130";
       libraryHaskellDepends = [ base compdata containers projection ];
       jailbreak = true;
       description = "Tree automata on Compositional Data Types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "compdata-dags" = callPackage
    ({ mkDerivation, base, compdata, containers, HUnit, mtl, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "compdata-dags";
       version = "0.2";
       sha256 = "ec8806f65eb818bbaef9156da0191df49c6400fb3594046d8f6c1106aa93bb7c";
       libraryHaskellDepends = [
         base compdata containers mtl unordered-containers vector
       ];
       testHaskellDepends = [
         base compdata containers HUnit mtl QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
         unordered-containers vector
       ];
       jailbreak = true;
       description = "Compositional Data Types on DAGs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "compdata-param" = callPackage
    ({ mkDerivation, base, compdata, containers, HUnit, mtl
     , template-haskell, test-framework, test-framework-hunit
     , transformers
     }:
     mkDerivation {
       pname = "compdata-param";
       version = "0.9";
       sha256 = "2492ab983e8f2d9cd41265ad99ef75953bb92a48b5370e82ff17d7f0c86bf3ac";
       libraryHaskellDepends = [
         base compdata mtl template-haskell transformers
       ];
       testHaskellDepends = [
         base compdata containers HUnit mtl template-haskell test-framework
         test-framework-hunit transformers
       ];
       description = "Parametric Compositional Data Types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "compensated_0_6_1" = callPackage
    ({ mkDerivation, base, bifunctors, binary, bytes, cereal, comonad
     , deepseq, directory, distributive, doctest, filepath
     , generic-deriving, hashable, lens, log-domain, safecopy
     , semigroupoids, semigroups, simple-reflect, vector
     }:
     mkDerivation {
       pname = "compensated";
       version = "0.6.1";
       sha256 = "d0765ac142238cc03288e64172517b24d025a979ed0e3bf7222d8e79efc0cf08";
       libraryHaskellDepends = [
         base bifunctors binary bytes cereal comonad deepseq distributive
         generic-deriving hashable lens log-domain safecopy semigroupoids
         semigroups vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       jailbreak = true;
       homepage = "http://github.com/analytics/compensated/";
       description = "Compensated floating-point arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "compensated" = callPackage
    ({ mkDerivation, base, bifunctors, binary, bytes, cereal, comonad
     , deepseq, directory, distributive, doctest, filepath
     , generic-deriving, hashable, lens, log-domain, safecopy
     , semigroupoids, semigroups, simple-reflect, vector
     }:
     mkDerivation {
       pname = "compensated";
       version = "0.7";
       sha256 = "af6a245921b80c5384d64e217fdf2122ea069e8733bd57e9c0135bfd94b5e9b2";
       libraryHaskellDepends = [
         base bifunctors binary bytes cereal comonad deepseq distributive
         generic-deriving hashable lens log-domain safecopy semigroupoids
         semigroups vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       jailbreak = true;
       homepage = "http://github.com/analytics/compensated/";
       description = "Compensated floating-point arithmetic";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "competition" = callPackage
    ({ mkDerivation, base, filepath, parsec }:
     mkDerivation {
       pname = "competition";
       version = "0.2.0.0";
       sha256 = "f68f78e6d4f68912ec01e24da4e3641cfe55aeafbfc666318aa9a3a8bc59861d";
       libraryHaskellDepends = [ base filepath parsec ];
       jailbreak = true;
       homepage = "github.com/yanatan16/haskell-competition";
       description = "Helpers and runners for code competitions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "compilation" = callPackage
    ({ mkDerivation, base, MissingH }:
     mkDerivation {
       pname = "compilation";
       version = "0.0.0.3";
       sha256 = "34e6ecf09fe1f0c2fd258a4069b800ef3b35c66a3f4ad1f5534165a764b83728";
       libraryHaskellDepends = [ base MissingH ];
       description = "Haskell functionality for quickly assembling simple compilers";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "complex-generic" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "complex-generic";
       version = "0.1.1";
       sha256 = "9422670fd08f3daaae823466398a9d4b9b2d8b4b9d568380833c5c391e679896";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "https://gitorious.org/complex-generic";
       description = "complex numbers with non-mandatory RealFloat";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "complex-integrate" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "complex-integrate";
       version = "1.0.0";
       sha256 = "d23130086dffc463153a2fa7e0fa79edd871d6eb4edcd30e64c2911cf1750e60";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/hijarian/complex-integrate";
       description = "A simple integration function to integrate a complex-valued complex functions";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "complexity" = callPackage
    ({ mkDerivation, base, Chart, colour, data-accessor, hstats
     , parallel, pretty, time, transformers
     }:
     mkDerivation {
       pname = "complexity";
       version = "0.1.3";
       sha256 = "929ac3292c1ea9aa9536b9718e2af4022a164c047d098c1fcb0a408f479a9999";
       libraryHaskellDepends = [
         base Chart colour data-accessor hstats parallel pretty time
         transformers
       ];
       jailbreak = true;
       description = "Empirical algorithmic complexity";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "compose-ltr" = callPackage
    ({ mkDerivation, base, hspec, QuickCheck }:
     mkDerivation {
       pname = "compose-ltr";
       version = "0.1.3";
       sha256 = "ebd267fc0ff418bd58d337830cf9cabab5d2d01eec59e3a1bdf82786cc8ab750";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec QuickCheck ];
       jailbreak = true;
       description = "More intuitive, left-to-right function composition";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "compose-trans" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "compose-trans";
       version = "0.1";
       sha256 = "3f612fc9ad34e8b7a6f23d5f55a7cfcef5fbb3ce9f2a053499d22d6727684e5c";
       libraryHaskellDepends = [ base mtl ];
       description = "Composable monad transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "composition_1_0_1_0" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "composition";
       version = "1.0.1.0";
       sha256 = "0c168845189fd678e5a833edb208029a5ac96395cf2bc99ee731ca26fe3ea2bf";
       homepage = "http://patch-tag.com/r/DanBurton/composition/home";
       description = "Combinators for unorthodox function composition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "composition_1_0_1_1" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "composition";
       version = "1.0.1.1";
       sha256 = "3728762c3d433f3194f433eb75c5b7780a3982126e6120a716314ffd75bf5e84";
       description = "Combinators for unorthodox function composition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "composition_1_0_2" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "composition";
       version = "1.0.2";
       sha256 = "0db6b7579db9a96dc47cfcb30e7835d4742bfab9b46518f00244e168b32405cd";
       description = "Combinators for unorthodox function composition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "composition" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "composition";
       version = "1.0.2.1";
       sha256 = "7123300f5eca5a7cec4eb731dc0e9c2c44aabe26b37e6579582a7267d9f7ad6a";
       description = "Combinators for unorthodox function composition";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "composition-extra_1_1_0" = callPackage
    ({ mkDerivation, base, contravariant }:
     mkDerivation {
       pname = "composition-extra";
       version = "1.1.0";
       sha256 = "e12fafa670548f4bb22a9948abeba4dc3ef06991738cef366a06a787400575d6";
       libraryHaskellDepends = [ base contravariant ];
       description = "Combinators for unorthodox structure composition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "composition-extra" = callPackage
    ({ mkDerivation, base, composition, contravariant }:
     mkDerivation {
       pname = "composition-extra";
       version = "2.0.0";
       sha256 = "c998244a8fd160af3dd7ee93c417f665af51a46a04ce6b7d4623f46596ba7129";
       libraryHaskellDepends = [ base composition contravariant ];
       description = "Combinators for unorthodox structure composition";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "composition-tree" = callPackage
    ({ mkDerivation, base, doctest, QuickCheck }:
     mkDerivation {
       pname = "composition-tree";
       version = "0.2.0.1";
       sha256 = "6452868a10df2e5ac564a2c3ae53eafa746a3c8f8791e064b49b9b54d4746502";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base doctest QuickCheck ];
       homepage = "https://github.com/liamoc/composition-tree";
       description = "Composition trees for arbitrary monoids";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "compressed" = callPackage
    ({ mkDerivation, base, comonad, containers, fingertree, hashable
     , keys, pointed, reducers, semigroupoids, semigroups
     , unordered-containers
     }:
     mkDerivation {
       pname = "compressed";
       version = "3.10";
       sha256 = "9cd5724f8ad297b00924bdcf9b641f614122385c8aad8f2682cece20880549f8";
       revision = "1";
       editedCabalFile = "0ab968cb9d6a6da40cb91befc6051d91b77039f8f64442eecf7a61bd508f61bb";
       libraryHaskellDepends = [
         base comonad containers fingertree hashable keys pointed reducers
         semigroupoids semigroups unordered-containers
       ];
       homepage = "http://github.com/ekmett/compressed/";
       description = "Compressed containers and reducers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "compression" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "compression";
       version = "0.1";
       sha256 = "f932b25c4a9fef0a363eb3a924f4293df1ca4796899807af2a76b7134341c733";
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://urchin.earth.li/~ian/cabal/compression/";
       description = "Common compression algorithms";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "compstrat" = callPackage
    ({ mkDerivation, base, compdata, mtl, template-haskell
     , th-expand-syns, transformers
     }:
     mkDerivation {
       pname = "compstrat";
       version = "0.1.0.2";
       sha256 = "6f4246375cd943bb340defc347b8bb2c850210b4c578ba87cf937f3db1dfbdc9";
       libraryHaskellDepends = [
         base compdata mtl template-haskell th-expand-syns transformers
       ];
       jailbreak = true;
       description = "Strategy combinators for compositional data types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "comptrans" = callPackage
    ({ mkDerivation, base, compdata, containers, deepseq
     , deepseq-generics, ghc-prim, lens, template-haskell
     , th-expand-syns
     }:
     mkDerivation {
       pname = "comptrans";
       version = "0.1.0.5";
       sha256 = "753e4c630f36e077205c05a191081c431ef088e443befdd50b3eda05403a2017";
       libraryHaskellDepends = [
         base compdata containers deepseq deepseq-generics ghc-prim lens
         template-haskell th-expand-syns
       ];
       homepage = "https://github.com/jkoppel/comptrans";
       description = "Automatically converting ASTs into compositional data types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "computational-algebra" = callPackage
    ({ mkDerivation, algebra, base, containers, equational-reasoning
     , heaps, lens, monad-loops, monomorphic, peggy, singletons
     , sized-vector, tagged, type-natural
     }:
     mkDerivation {
       pname = "computational-algebra";
       version = "0.3.0.0";
       sha256 = "9dd0b12afcdf642cfed686820d2523291cb62a064122c51c78e45dfeae5e9226";
       libraryHaskellDepends = [
         algebra base containers equational-reasoning heaps lens monad-loops
         monomorphic peggy singletons sized-vector tagged type-natural
       ];
       jailbreak = true;
       homepage = "https://github.com/konn/computational-algebra";
       description = "Well-kinded computational algebra library, currently supporting Groebner basis";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "computations" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "computations";
       version = "0.0.0.0";
       sha256 = "c0880c60e06b1248fc14122be16963bb8f7efad092be9e4f10e017fc6a1bcfcf";
       libraryHaskellDepends = [ base ];
       homepage = "http://darcs.wolfgang.jeltsch.info/haskell/computations";
       description = "Advanced notions of computation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "concatenative" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "concatenative";
       version = "1.0.1";
       sha256 = "ed5997924518f0ca6b8afcd4e1ee10d30675bb4c4ba164a4d70b4ddbd8c6bc17";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "https://patch-tag.com/r/salazar/concatenative/snapshot/current/content/pretty";
       description = "A library for postfix control flow";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "conceit" = callPackage
    ({ mkDerivation, base, bifunctors, semigroupoids, semigroups, void
     }:
     mkDerivation {
       pname = "conceit";
       version = "0.4.0.0";
       sha256 = "8972aafc4143cf2f6039d99747a9f1d191762636fd4453e7fc5bdb7c604a980b";
       libraryHaskellDepends = [
         base bifunctors semigroupoids semigroups void
       ];
       description = "Concurrent actions that may fail with a value";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "concorde" = callPackage
    ({ mkDerivation, base, containers, process, safe, temporary }:
     mkDerivation {
       pname = "concorde";
       version = "0.1";
       sha256 = "40b0e947ae41e7fc2699181264b556c76d53656874c100729352fd6564a60324";
       libraryHaskellDepends = [ base containers process safe temporary ];
       description = "Simple interface to the Concorde solver for the Traveling Salesperson Problem";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "concraft" = callPackage
    ({ mkDerivation, aeson, array, base, binary, bytestring, cmdargs
     , comonad, containers, crf-chain1-constrained, crf-chain2-tiers
     , data-lens, lazy-io, monad-codec, monad-ox, sgd, tagset-positional
     , temporary, text, text-binary, transformers, vector, vector-binary
     , zlib
     }:
     mkDerivation {
       pname = "concraft";
       version = "0.9.4";
       sha256 = "030f63c8c08dba11ac85b08746a145df45276930de8fc937ecf6260b1cac079f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array base binary bytestring cmdargs comonad containers
         crf-chain1-constrained crf-chain2-tiers data-lens lazy-io
         monad-codec monad-ox sgd tagset-positional temporary text
         text-binary transformers vector vector-binary zlib
       ];
       jailbreak = true;
       homepage = "http://zil.ipipan.waw.pl/Concraft";
       description = "Morphological disambiguation based on constrained CRFs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "concraft-hr" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, cmdargs, concraft
     , containers, double-conversion, lazy-io, moan, network, sgd, split
     , tagset-positional, text
     }:
     mkDerivation {
       pname = "concraft-hr";
       version = "0.1.0.2";
       sha256 = "81fc81a15bd38916dab18a83a5d303c6097a7ad297511538f32088d9b1175460";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base binary bytestring concraft containers double-conversion
         lazy-io moan network sgd split tagset-positional text
       ];
       executableHaskellDepends = [ cmdargs ];
       jailbreak = true;
       homepage = "https://github.com/vjeranc/concraft-hr";
       description = "Part-of-speech tagger for Croatian";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "concraft-pl" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, cmdargs, concraft
     , containers, lazy-io, mtl, network, process, sgd, split
     , tagset-positional, text, transformers
     }:
     mkDerivation {
       pname = "concraft-pl";
       version = "0.7.4";
       sha256 = "83bfddfb8099d468ae3237b40ee698d2655aaa0447f60b365c11d0f3da1e187a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base binary bytestring concraft containers lazy-io mtl
         network process sgd split tagset-positional text transformers
       ];
       executableHaskellDepends = [ cmdargs ];
       jailbreak = true;
       homepage = "http://zil.ipipan.waw.pl/Concraft";
       description = "Morphological tagger for Polish";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "concrete-relaxng-parser" = callPackage
    ({ mkDerivation, base, cmdargs, containers, hxt, hxt-charproperties
     , hxt-curl, hxt-relaxng, hxt-tagsoup
     }:
     mkDerivation {
       pname = "concrete-relaxng-parser";
       version = "0.1.1";
       sha256 = "aac9e15b435ccf26a45b2167facdc9fd6700356a2781f37c09cd324790788bf0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs containers hxt hxt-charproperties hxt-curl hxt-relaxng
         hxt-tagsoup
       ];
       description = "A parser driven by a standard RELAX NG schema with concrete syntax extensions";
       license = "GPL";
     }) {};

  "concrete-typerep" = callPackage
    ({ mkDerivation, base, binary, hashable, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "concrete-typerep";
       version = "0.1.0.2";
       sha256 = "f72a41d9d8315528c7b0e13bf61e6122c7d236cb529c207cfb431cf272439e1f";
       revision = "1";
       editedCabalFile = "cdcd034ff6ff0e8cf9313f312294e12494f3f021c4bf562b9c1365b91715ff4e";
       libraryHaskellDepends = [ base binary hashable ];
       testHaskellDepends = [
         base binary hashable QuickCheck test-framework
         test-framework-quickcheck2
       ];
       jailbreak = true;
       description = "Binary and Hashable instances for TypeRep";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "concurrent-barrier" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "concurrent-barrier";
       version = "0.1.2";
       sha256 = "bb8e1e37c1a49735fb1eca9bb1b0ee2684c9714fd60f4d311e33a359f8e92d8e";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/jsgf/concurrent-barrier";
       description = "Simple thread barriers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "concurrent-dns-cache" = callPackage
    ({ mkDerivation, array, async, base, bytestring, containers, dns
     , hashable, hspec, iproute, network, stm, time
     }:
     mkDerivation {
       pname = "concurrent-dns-cache";
       version = "0.0.1";
       sha256 = "62c316082f91b0183355741aba5b2b4796663521ad607d43107e4692d5518b2b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array async base bytestring containers dns hashable iproute network
         stm time
       ];
       executableHaskellDepends = [
         array async base bytestring containers dns hashable iproute network
         stm time
       ];
       testHaskellDepends = [ async base dns hspec ];
       description = "Concurrent DNS cache";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "concurrent-extra_0_7_0_8" = callPackage
    ({ mkDerivation, async, base, base-unicode-symbols, HUnit, random
     , stm, test-framework, test-framework-hunit, unbounded-delays
     }:
     mkDerivation {
       pname = "concurrent-extra";
       version = "0.7.0.8";
       sha256 = "78203bfb522583ebdc2ea6c8708049b83710935dbdfe916576dbeea9283fd660";
       libraryHaskellDepends = [
         base base-unicode-symbols stm unbounded-delays
       ];
       testHaskellDepends = [
         async base base-unicode-symbols HUnit random stm test-framework
         test-framework-hunit unbounded-delays
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/basvandijk/concurrent-extra";
       description = "Extra concurrency primitives";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "concurrent-extra_0_7_0_9" = callPackage
    ({ mkDerivation, async, base, HUnit, random, stm, test-framework
     , test-framework-hunit, unbounded-delays
     }:
     mkDerivation {
       pname = "concurrent-extra";
       version = "0.7.0.9";
       sha256 = "5c8535c5155c747fdc04fcf731da3ccad6236e49295e6fcbad102e9b17a878a5";
       libraryHaskellDepends = [ base stm unbounded-delays ];
       testHaskellDepends = [
         async base HUnit random stm test-framework test-framework-hunit
         unbounded-delays
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/basvandijk/concurrent-extra";
       description = "Extra concurrency primitives";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "concurrent-extra" = callPackage
    ({ mkDerivation, async, base, HUnit, random, stm, test-framework
     , test-framework-hunit, unbounded-delays
     }:
     mkDerivation {
       pname = "concurrent-extra";
       version = "0.7.0.10";
       sha256 = "6f27cc0a90f5f25b3c0a1e9e3c0e3b407538908c061c5b7da34461b76e1adc12";
       libraryHaskellDepends = [ base stm unbounded-delays ];
       testHaskellDepends = [
         async base HUnit random stm test-framework test-framework-hunit
         unbounded-delays
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/basvandijk/concurrent-extra";
       description = "Extra concurrency primitives";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "concurrent-machines" = callPackage
    ({ mkDerivation, async, base, containers, lifted-async, machines
     , monad-control, semigroups, tasty, tasty-hunit, time, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "concurrent-machines";
       version = "0.2.1";
       sha256 = "8c22ce94dfbc20214a1a5ced0cfcb7de0c2eae509a250d144c8af51a8f27507f";
       libraryHaskellDepends = [
         async base containers lifted-async machines monad-control
         semigroups time transformers transformers-base
       ];
       testHaskellDepends = [
         base machines tasty tasty-hunit time transformers
       ];
       description = "Concurrent networked stream transducers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "concurrent-output" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, directory, exceptions
     , process, stm, terminal-size, text, transformers, unix
     }:
     mkDerivation {
       pname = "concurrent-output";
       version = "1.7.3";
       sha256 = "9a510e7378ba9c6c637027074fa127fad832f9321144fdbe9ae3b1955cf40620";
       libraryHaskellDepends = [
         ansi-terminal async base directory exceptions process stm
         terminal-size text transformers unix
       ];
       description = "Ungarble output from several threads or commands";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "concurrent-sa" = callPackage
    ({ mkDerivation, base, MonadRandom }:
     mkDerivation {
       pname = "concurrent-sa";
       version = "1.0.1";
       sha256 = "a6997893de2546e223d4edc0830cbfa3c60220ae078ef536145d161837e0fbeb";
       libraryHaskellDepends = [ base MonadRandom ];
       description = "Concurrent simulated annealing system";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "concurrent-split" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "concurrent-split";
       version = "0.0.0.1";
       sha256 = "4b7f4a40bc8dbbd3437f460a2eabe78fed84c900ca2912e523b281c311e03177";
       libraryHaskellDepends = [ base ];
       description = "MVars and Channels with distinguished input and output side";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "concurrent-state" = callPackage
    ({ mkDerivation, base, exceptions, mtl, stm, transformers }:
     mkDerivation {
       pname = "concurrent-state";
       version = "0.6.0.0";
       sha256 = "e6071814c277106cb13b458a7161dd42269e9a7c2419b17992a1908a7fb3342d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base exceptions mtl stm transformers ];
       jailbreak = true;
       homepage = "https://github.com/joelteon/concurrent-state";
       description = "MTL-like library using TVars";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "concurrent-supply_0_1_7" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, hashable }:
     mkDerivation {
       pname = "concurrent-supply";
       version = "0.1.7";
       sha256 = "0c19eb3de807771b894e19bfd553eee17580441b24ea4a0d4c7c455e6a262f33";
       libraryHaskellDepends = [ base ghc-prim hashable ];
       testHaskellDepends = [ base containers ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/concurrent-supply/";
       description = "A fast concurrent unique identifier supply with a pure API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "concurrent-supply_0_1_7_1" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, hashable }:
     mkDerivation {
       pname = "concurrent-supply";
       version = "0.1.7.1";
       sha256 = "be5092519735b1dbac7e4b8611fe39d03e454fe9ec6ac4c7555eca0dc90c0d14";
       libraryHaskellDepends = [ base ghc-prim hashable ];
       testHaskellDepends = [ base containers ];
       homepage = "http://github.com/ekmett/concurrent-supply/";
       description = "A fast concurrent unique identifier supply with a pure API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "concurrent-supply" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, hashable }:
     mkDerivation {
       pname = "concurrent-supply";
       version = "0.1.8";
       sha256 = "ccf827dcd221298ae93fad6021c63a06707456de0671706b44f1f2fed867f21f";
       libraryHaskellDepends = [ base ghc-prim hashable ];
       testHaskellDepends = [ base containers ];
       homepage = "http://github.com/ekmett/concurrent-supply/";
       description = "A fast concurrent unique identifier supply with a pure API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "concurrent-utilities" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "concurrent-utilities";
       version = "0.2.0.0";
       sha256 = "d108b831e0631c1d3d9b5e2dbfb335b63997206384b7a069978c95a2a1af918a";
       libraryHaskellDepends = [ base ];
       homepage = "-";
       description = "More utilities and broad-used datastructures for concurrency";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "concurrentoutput" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "concurrentoutput";
       version = "0.2.0.2";
       sha256 = "481dd3e34600d55ad8a956c2368f1842a6af86ff1e5eb1d87a36f7ca9538a339";
       libraryHaskellDepends = [ base ];
       description = "Ungarble output from several threads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cond" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "cond";
       version = "0.4.1.1";
       sha256 = "039c76e43b5484bdc78627f50740106ae2844b3c877d92b5228de9106997ac8b";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/kallisti-dev/cond";
       description = "Basic conditional and boolean operators with monadic variants";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "condor" = callPackage
    ({ mkDerivation, base, binary, Cabal, containers, directory
     , filepath, glider-nlp, HUnit, text
     }:
     mkDerivation {
       pname = "condor";
       version = "0.3";
       sha256 = "a79b44fb76db86e6ed54de6f94aa121bca34ae7f479978479f940968969b112a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base binary containers glider-nlp text ];
       executableHaskellDepends = [
         base binary containers directory filepath glider-nlp text
       ];
       testHaskellDepends = [
         base binary Cabal containers glider-nlp HUnit text
       ];
       jailbreak = true;
       homepage = "https://github.com/klangner/Condor";
       description = "Information retrieval library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "condorcet" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "condorcet";
       version = "0.0.1";
       sha256 = "cd9a8323491635b9a25495e281a676b7a6f56770187acbaa07c95a6773454ee5";
       libraryHaskellDepends = [ array base ];
       homepage = "http://neugierig.org/software/darcs/condorcet";
       description = "Library for Condorcet voting";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conductive-base" = callPackage
    ({ mkDerivation, array, base, containers, random, stm, time }:
     mkDerivation {
       pname = "conductive-base";
       version = "0.3";
       sha256 = "97a3a733949176c3eeeba581d37407dc6270471220a6093b08f440cfada3bac9";
       libraryHaskellDepends = [ array base containers random stm time ];
       homepage = "http://www.renickbell.net/doku.php?id=conductive-base";
       description = "a library for live coding and real-time musical applications";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "conductive-clock" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "conductive-clock";
       version = "0.2";
       sha256 = "b790a02835ba51b95f61e92fcbb9c35d6bdc58574fcabd469661b40249a095de";
       doHaddock = false;
       homepage = "http://www.renickbell.net/doku.php?id=conductive-clock";
       description = "a library for displaying musical time in a terminal-based clock";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "conductive-hsc3" = callPackage
    ({ mkDerivation, base, conductive-base, conductive-song, containers
     , directory, filepath, hosc, hsc3, random
     }:
     mkDerivation {
       pname = "conductive-hsc3";
       version = "0.3.1";
       sha256 = "eaced5f31e79f4b5aaa6d72d13a4bc4ea56f547977d28cf1c26ef63aca3903fc";
       libraryHaskellDepends = [
         base conductive-base conductive-song containers directory filepath
         hosc hsc3 random
       ];
       jailbreak = true;
       homepage = "http://www.renickbell.net/doku.php?id=conductive-hsc3";
       description = "a library with examples of using Conductive with hsc3";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conductive-song" = callPackage
    ({ mkDerivation, base, conductive-base, random }:
     mkDerivation {
       pname = "conductive-song";
       version = "0.2";
       sha256 = "71e71a09990c2a1f979203d6d436c9f4e39c705132832176f3833962b6d46d99";
       libraryHaskellDepends = [ base conductive-base random ];
       homepage = "http://www.renickbell.net/doku.php?id=conductive-song";
       description = "a library of functions which are useful for composing music";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "conduit_1_2_3" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, monad-control, mtl, QuickCheck, resourcet, safe
     , transformers, transformers-base, void
     }:
     mkDerivation {
       pname = "conduit";
       version = "1.2.3";
       sha256 = "d6386a4a802e504ddc68e54dc152b676eda366138aa4516de60527196b618cd8";
       libraryHaskellDepends = [
         base containers exceptions lifted-base mmorph monad-control mtl
         resourcet transformers transformers-base void
       ];
       testHaskellDepends = [
         base containers exceptions hspec mtl QuickCheck resourcet safe
         transformers void
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Streaming data processing library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit_1_2_3_1" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, mtl, QuickCheck, resourcet, safe, transformers
     , transformers-base, void
     }:
     mkDerivation {
       pname = "conduit";
       version = "1.2.3.1";
       sha256 = "786d4b29f9478c7aad63fb9a264c5a077a7ed6c62a209fab56a6a9981c18c312";
       libraryHaskellDepends = [
         base exceptions lifted-base mmorph mtl resourcet transformers
         transformers-base void
       ];
       testHaskellDepends = [
         base containers exceptions hspec mtl QuickCheck resourcet safe
         transformers void
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Streaming data processing library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit_1_2_4" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, mtl, QuickCheck, resourcet, safe, transformers
     , transformers-base, void
     }:
     mkDerivation {
       pname = "conduit";
       version = "1.2.4";
       sha256 = "70e363f7b3c682fc5700274ba2a3919247f2e54048dec224c3765a5e8b940aef";
       libraryHaskellDepends = [
         base exceptions lifted-base mmorph mtl resourcet transformers
         transformers-base void
       ];
       testHaskellDepends = [
         base containers exceptions hspec mtl QuickCheck resourcet safe
         transformers void
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Streaming data processing library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit_1_2_4_2" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, mtl, QuickCheck, resourcet, safe, transformers
     , transformers-base, void
     }:
     mkDerivation {
       pname = "conduit";
       version = "1.2.4.2";
       sha256 = "f487957698c87d343b2c2748f39e569f763102dc5a545064030e53f23a2a1dea";
       libraryHaskellDepends = [
         base exceptions lifted-base mmorph mtl resourcet transformers
         transformers-base
       ];
       testHaskellDepends = [
         base containers exceptions hspec mtl QuickCheck resourcet safe
         transformers void
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Streaming data processing library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit_1_2_5" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, mtl, QuickCheck, resourcet, safe, transformers
     , transformers-base, void
     }:
     mkDerivation {
       pname = "conduit";
       version = "1.2.5";
       sha256 = "b100cdb428731923205372dded60b6529d33728f69a0eb951a01f53c182c2a46";
       libraryHaskellDepends = [
         base exceptions lifted-base mmorph mtl resourcet transformers
         transformers-base
       ];
       testHaskellDepends = [
         base containers exceptions hspec mtl QuickCheck resourcet safe
         transformers void
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Streaming data processing library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit_1_2_5_1" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, mtl, QuickCheck, resourcet, safe, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "conduit";
       version = "1.2.5.1";
       sha256 = "651fddf1641b2a92eae5acad77711b03df466b4a0d4a7d7c6d70b6d2b8e6062b";
       revision = "1";
       editedCabalFile = "3f33cf6347a248ba71ee278ca5caf55d7f7c22ab59dcf0c141a1977cd099344d";
       libraryHaskellDepends = [
         base exceptions lifted-base mmorph mtl resourcet transformers
         transformers-base
       ];
       testHaskellDepends = [
         base containers exceptions hspec mtl QuickCheck resourcet safe
         transformers
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Streaming data processing library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit_1_2_6" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, mtl, QuickCheck, resourcet, safe, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "conduit";
       version = "1.2.6";
       sha256 = "6533d47843209659ea0158f7a091eb9fae466bfe3af818e404a17c0e3bcb83bb";
       libraryHaskellDepends = [
         base exceptions lifted-base mmorph mtl resourcet transformers
         transformers-base
       ];
       testHaskellDepends = [
         base containers exceptions hspec mtl QuickCheck resourcet safe
         transformers
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Streaming data processing library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit_1_2_6_1" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, mtl, QuickCheck, resourcet, safe, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "conduit";
       version = "1.2.6.1";
       sha256 = "ae38875a01312070cc1f59aba6687b7b8619416f426299ab126e08023c22309c";
       libraryHaskellDepends = [
         base exceptions lifted-base mmorph mtl resourcet transformers
         transformers-base
       ];
       testHaskellDepends = [
         base containers exceptions hspec mtl QuickCheck resourcet safe
         transformers
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Streaming data processing library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, mtl, QuickCheck, resourcet, safe, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "conduit";
       version = "1.2.6.2";
       sha256 = "f9a6322b9150e85c7cc33e2eafafecc0b35ed991781a2952c274d82627c9f41e";
       libraryHaskellDepends = [
         base exceptions lifted-base mmorph mtl resourcet transformers
         transformers-base
       ];
       testHaskellDepends = [
         base containers exceptions hspec mtl QuickCheck resourcet safe
         transformers
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Streaming data processing library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "conduit-audio" = callPackage
    ({ mkDerivation, base, conduit, vector }:
     mkDerivation {
       pname = "conduit-audio";
       version = "0.2.0.1";
       sha256 = "7feb6d81fcafd3853cff73d63f86c68cd4fb67baa97c37410a607b79d8dfc02b";
       libraryHaskellDepends = [ base conduit vector ];
       homepage = "http://github.com/mtolly/conduit-audio";
       description = "Combinators to efficiently slice and dice audio streams";
       license = "LGPL";
     }) {};

  "conduit-audio-lame" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, conduit, conduit-audio
     , mp3lame, resourcet, transformers, vector
     }:
     mkDerivation {
       pname = "conduit-audio-lame";
       version = "0.1.1";
       sha256 = "aac3760ea6325219903e0726b4a8e0b9662699ed34a77a0d2a09a5bef67c8d7f";
       libraryHaskellDepends = [
         base bytestring conduit conduit-audio resourcet transformers vector
       ];
       librarySystemDepends = [ mp3lame ];
       libraryToolDepends = [ c2hs ];
       homepage = "http://github.com/mtolly/conduit-audio";
       description = "conduit-audio interface to the LAME MP3 library";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {mp3lame = null;};

  "conduit-audio-samplerate" = callPackage
    ({ mkDerivation, base, c2hs, conduit, conduit-audio, resourcet
     , samplerate, transformers, vector
     }:
     mkDerivation {
       pname = "conduit-audio-samplerate";
       version = "0.1.0.1";
       sha256 = "03b2ce7a89b0ae9a6db7464d1066596d7784bb5d7e45458a6b9fc6600e6726cf";
       libraryHaskellDepends = [
         base conduit conduit-audio resourcet transformers vector
       ];
       librarySystemDepends = [ samplerate ];
       libraryToolDepends = [ c2hs ];
       homepage = "http://github.com/mtolly/conduit-audio";
       description = "conduit-audio interface to the libsamplerate resampling library";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {samplerate = null;};

  "conduit-audio-sndfile" = callPackage
    ({ mkDerivation, base, conduit, conduit-audio, hsndfile
     , hsndfile-vector, resourcet, transformers
     }:
     mkDerivation {
       pname = "conduit-audio-sndfile";
       version = "0.1.1";
       sha256 = "2c4288d60fa0ea8a629ab3e3e77ee813e849f4454b006ab75ebc33bf707be4cc";
       libraryHaskellDepends = [
         base conduit conduit-audio hsndfile hsndfile-vector resourcet
         transformers
       ];
       homepage = "http://github.com/mtolly/conduit-audio";
       description = "conduit-audio interface to the libsndfile audio file library";
       license = "LGPL";
     }) {};

  "conduit-combinators_0_3_0_4" = callPackage
    ({ mkDerivation, base, base16-bytestring, base64-bytestring
     , bytestring, chunked-data, conduit, conduit-extra, containers
     , directory, hspec, monad-control, mono-traversable, mtl
     , mwc-random, primitive, QuickCheck, resourcet, safe, silently
     , system-fileio, system-filepath, text, transformers
     , transformers-base, unix, unix-compat, vector, void
     }:
     mkDerivation {
       pname = "conduit-combinators";
       version = "0.3.0.4";
       sha256 = "f523877e5dcd8245efdb04920f25226e9eab6329dfb6e95f5a77c591d399f0aa";
       libraryHaskellDepends = [
         base base16-bytestring base64-bytestring bytestring chunked-data
         conduit conduit-extra monad-control mono-traversable mwc-random
         primitive resourcet system-fileio system-filepath text transformers
         transformers-base unix unix-compat vector void
       ];
       testHaskellDepends = [
         base base16-bytestring base64-bytestring bytestring chunked-data
         conduit containers directory hspec mono-traversable mtl mwc-random
         QuickCheck safe silently system-filepath text transformers vector
       ];
       homepage = "https://github.com/fpco/conduit-combinators";
       description = "Commonly used conduit functions, for both chunked and unchunked data";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-combinators_0_3_0_5" = callPackage
    ({ mkDerivation, base, base16-bytestring, base64-bytestring
     , bytestring, chunked-data, conduit, conduit-extra, containers
     , directory, hspec, monad-control, mono-traversable, mtl
     , mwc-random, primitive, QuickCheck, resourcet, safe, silently
     , system-fileio, system-filepath, text, transformers
     , transformers-base, unix, unix-compat, vector, void
     }:
     mkDerivation {
       pname = "conduit-combinators";
       version = "0.3.0.5";
       sha256 = "a39ef2479fe7d20ac49ef46451b7ea5cd77c7656d890311d0ae023f58e010547";
       libraryHaskellDepends = [
         base base16-bytestring base64-bytestring bytestring chunked-data
         conduit conduit-extra monad-control mono-traversable mwc-random
         primitive resourcet system-fileio system-filepath text transformers
         transformers-base unix unix-compat vector void
       ];
       testHaskellDepends = [
         base base16-bytestring base64-bytestring bytestring chunked-data
         conduit containers directory hspec mono-traversable mtl mwc-random
         QuickCheck safe silently system-filepath text transformers vector
       ];
       homepage = "https://github.com/fpco/conduit-combinators";
       description = "Commonly used conduit functions, for both chunked and unchunked data";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-combinators_0_3_0_6" = callPackage
    ({ mkDerivation, base, base16-bytestring, base64-bytestring
     , bytestring, chunked-data, conduit, conduit-extra, containers
     , directory, hspec, monad-control, mono-traversable, mtl
     , mwc-random, primitive, QuickCheck, resourcet, safe, silently
     , system-fileio, system-filepath, text, transformers
     , transformers-base, unix, unix-compat, vector, void
     }:
     mkDerivation {
       pname = "conduit-combinators";
       version = "0.3.0.6";
       sha256 = "4b087c6f115ac22d198f58ae6c5ec807e99da0ef4b34bf5fee5c709d90fe567c";
       libraryHaskellDepends = [
         base base16-bytestring base64-bytestring bytestring chunked-data
         conduit conduit-extra monad-control mono-traversable mwc-random
         primitive resourcet system-fileio system-filepath text transformers
         transformers-base unix unix-compat vector void
       ];
       testHaskellDepends = [
         base base16-bytestring base64-bytestring bytestring chunked-data
         conduit containers directory hspec mono-traversable mtl mwc-random
         QuickCheck safe silently system-filepath text transformers vector
       ];
       homepage = "https://github.com/fpco/conduit-combinators";
       description = "Commonly used conduit functions, for both chunked and unchunked data";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-combinators_0_3_1" = callPackage
    ({ mkDerivation, base, base16-bytestring, base64-bytestring
     , bytestring, chunked-data, conduit, conduit-extra, containers
     , directory, hspec, monad-control, mono-traversable, mtl
     , mwc-random, primitive, QuickCheck, resourcet, safe, silently
     , system-fileio, system-filepath, text, transformers
     , transformers-base, unix, unix-compat, vector, void
     }:
     mkDerivation {
       pname = "conduit-combinators";
       version = "0.3.1";
       sha256 = "59b8746a9ee350e517e60ee8c07545204fc6cfd3d9ece1df7beb85a1776a9b91";
       libraryHaskellDepends = [
         base base16-bytestring base64-bytestring bytestring chunked-data
         conduit conduit-extra monad-control mono-traversable mwc-random
         primitive resourcet system-fileio system-filepath text transformers
         transformers-base unix unix-compat vector void
       ];
       testHaskellDepends = [
         base base16-bytestring base64-bytestring bytestring chunked-data
         conduit containers directory hspec mono-traversable mtl mwc-random
         QuickCheck safe silently system-filepath text transformers vector
       ];
       homepage = "https://github.com/fpco/conduit-combinators";
       description = "Commonly used conduit functions, for both chunked and unchunked data";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-combinators_1_0_3" = callPackage
    ({ mkDerivation, base, base16-bytestring, base64-bytestring
     , bytestring, chunked-data, conduit, conduit-extra, containers
     , directory, filepath, hspec, monad-control, mono-traversable, mtl
     , mwc-random, primitive, QuickCheck, resourcet, safe, silently
     , text, transformers, transformers-base, unix, unix-compat, vector
     , void
     }:
     mkDerivation {
       pname = "conduit-combinators";
       version = "1.0.3";
       sha256 = "29c1f3dd854d11212474692c6c3a4158ed2929e8443ff2878eee5ea1ed6700bf";
       libraryHaskellDepends = [
         base base16-bytestring base64-bytestring bytestring chunked-data
         conduit conduit-extra filepath monad-control mono-traversable
         mwc-random primitive resourcet text transformers transformers-base
         unix unix-compat vector void
       ];
       testHaskellDepends = [
         base base16-bytestring base64-bytestring bytestring chunked-data
         conduit containers directory filepath hspec mono-traversable mtl
         mwc-random QuickCheck safe silently text transformers vector
       ];
       homepage = "https://github.com/fpco/conduit-combinators";
       description = "Commonly used conduit functions, for both chunked and unchunked data";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-combinators" = callPackage
    ({ mkDerivation, base, base16-bytestring, base64-bytestring
     , bytestring, chunked-data, conduit, conduit-extra, containers
     , directory, filepath, hspec, monad-control, mono-traversable, mtl
     , mwc-random, primitive, QuickCheck, resourcet, safe, silently
     , text, transformers, transformers-base, unix, unix-compat, vector
     , void
     }:
     mkDerivation {
       pname = "conduit-combinators";
       version = "1.0.3.1";
       sha256 = "66a40be2cc964c36b06cf9b096c1a99b107dba06b62baa4b13b9c485dc4f8b48";
       libraryHaskellDepends = [
         base base16-bytestring base64-bytestring bytestring chunked-data
         conduit conduit-extra filepath monad-control mono-traversable
         mwc-random primitive resourcet text transformers transformers-base
         unix unix-compat vector void
       ];
       testHaskellDepends = [
         base base16-bytestring base64-bytestring bytestring chunked-data
         conduit containers directory filepath hspec mono-traversable mtl
         mwc-random QuickCheck safe silently text transformers vector
       ];
       homepage = "https://github.com/fpco/conduit-combinators";
       description = "Commonly used conduit functions, for both chunked and unchunked data";
       license = stdenv.lib.licenses.mit;
     }) {};

  "conduit-connection" = callPackage
    ({ mkDerivation, base, bytestring, conduit, connection, HUnit
     , network, resourcet, test-framework, test-framework-hunit
     , transformers
     }:
     mkDerivation {
       pname = "conduit-connection";
       version = "0.1.0.1";
       sha256 = "c4020f9f2aba7baedeb7dceb9ac092e2aefaa7480d57eb38595800da911671fc";
       libraryHaskellDepends = [
         base bytestring conduit connection resourcet transformers
       ];
       testHaskellDepends = [
         base bytestring conduit connection HUnit network resourcet
         test-framework test-framework-hunit transformers
       ];
       homepage = "https://github.com/sdroege/conduit-connection";
       description = "Conduit source and sink for Network.Connection.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "conduit-extra_1_1_5" = callPackage
    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
     , conduit, directory, exceptions, filepath, hspec, monad-control
     , network, primitive, process, resourcet, stm, streaming-commons
     , text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "conduit-extra";
       version = "1.1.5";
       sha256 = "97d4777c0eb40aad094033aa455ad3cbe5692ad99b9ff1668a57aed8eeb068c4";
       revision = "1";
       editedCabalFile = "0a16835a6fb4821d8b56750af755bdc104161aa92aad8cfc2cbd197f084712cb";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring conduit directory filepath
         monad-control network primitive process resourcet stm
         streaming-commons text transformers transformers-base
       ];
       testHaskellDepends = [
         async attoparsec base blaze-builder bytestring conduit exceptions
         hspec process resourcet stm text transformers transformers-base
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Batteries included conduit: adapters for common libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-extra_1_1_5_1" = callPackage
    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
     , conduit, directory, exceptions, filepath, hspec, monad-control
     , network, primitive, process, resourcet, stm, streaming-commons
     , text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "conduit-extra";
       version = "1.1.5.1";
       sha256 = "81a1461b102bc25620f4123b1e3c0e037d1c57511e79e718b07734c7cc33631a";
       revision = "1";
       editedCabalFile = "4c8b34fe71f4ec2bccfa864149a2170216cb6659bb934fba2ec031a4f5b9c461";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring conduit directory filepath
         monad-control network primitive process resourcet stm
         streaming-commons text transformers transformers-base
       ];
       testHaskellDepends = [
         async attoparsec base blaze-builder bytestring conduit exceptions
         hspec process resourcet stm text transformers transformers-base
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Batteries included conduit: adapters for common libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-extra_1_1_6" = callPackage
    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
     , conduit, directory, exceptions, filepath, hspec, monad-control
     , network, primitive, process, resourcet, stm, streaming-commons
     , text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "conduit-extra";
       version = "1.1.6";
       sha256 = "99279ceb12e9b822b7f834da6a1830df01500281a2e61f82e9a2e4c3ce4a0ae0";
       revision = "2";
       editedCabalFile = "0a6fe547ee999c97fa1efd548411d2b88e420c597c3ad34215c2f1fffe1c4779";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring conduit directory filepath
         monad-control network primitive process resourcet stm
         streaming-commons text transformers transformers-base
       ];
       testHaskellDepends = [
         async attoparsec base blaze-builder bytestring conduit exceptions
         hspec process resourcet stm text transformers transformers-base
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Batteries included conduit: adapters for common libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-extra_1_1_6_2" = callPackage
    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
     , conduit, directory, exceptions, filepath, hspec, monad-control
     , network, primitive, process, resourcet, stm, streaming-commons
     , text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "conduit-extra";
       version = "1.1.6.2";
       sha256 = "0c86f624c6546b9cab09622703b92018aaa5f51784a1e4da496d9fd66bbf66ce";
       revision = "1";
       editedCabalFile = "f53d2387d8ca008e90cf1c2142bc19c9f366220bd098455c9f30a3ed46902707";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring conduit directory filepath
         monad-control network primitive process resourcet stm
         streaming-commons text transformers transformers-base
       ];
       testHaskellDepends = [
         async attoparsec base blaze-builder bytestring conduit exceptions
         hspec process resourcet stm text transformers transformers-base
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Batteries included conduit: adapters for common libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-extra_1_1_7_0" = callPackage
    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
     , bytestring-builder, conduit, directory, exceptions, filepath
     , hspec, monad-control, network, primitive, process, resourcet, stm
     , streaming-commons, text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "conduit-extra";
       version = "1.1.7.0";
       sha256 = "089461849a212032e9fefed330db032cfc934e62f8faf60639fbab5879c291e0";
       revision = "1";
       editedCabalFile = "aa578196364712bab0c1d41348c17949fe2147132c786919c526ef18c29e175e";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring conduit directory filepath
         monad-control network primitive process resourcet stm
         streaming-commons text transformers transformers-base
       ];
       testHaskellDepends = [
         async attoparsec base blaze-builder bytestring bytestring-builder
         conduit exceptions hspec process resourcet stm streaming-commons
         text transformers transformers-base
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Batteries included conduit: adapters for common libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-extra_1_1_7_1" = callPackage
    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
     , bytestring-builder, conduit, directory, exceptions, filepath
     , hspec, monad-control, network, primitive, process, resourcet, stm
     , streaming-commons, text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "conduit-extra";
       version = "1.1.7.1";
       sha256 = "a34bbabb1f167042540a8d56010239e5ffb3f6136d471584168912e23193f8e2";
       revision = "1";
       editedCabalFile = "c5009bb0f37919baf6c7b5db7cf919da9c600ec7f14bb268f177699f4ea7a674";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring conduit directory filepath
         monad-control network primitive process resourcet stm
         streaming-commons text transformers transformers-base
       ];
       testHaskellDepends = [
         async attoparsec base blaze-builder bytestring bytestring-builder
         conduit exceptions hspec process resourcet stm streaming-commons
         text transformers transformers-base
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Batteries included conduit: adapters for common libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-extra_1_1_7_2" = callPackage
    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
     , bytestring-builder, conduit, directory, exceptions, filepath
     , hspec, monad-control, network, primitive, process, resourcet, stm
     , streaming-commons, text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "conduit-extra";
       version = "1.1.7.2";
       sha256 = "3c8a724669b8d079eab784085386a52c470450a62cfdebb34b74d1a250d36759";
       revision = "1";
       editedCabalFile = "02b6faa9baf9bba14c8a84e264456e31572fb1f95a55da294508da1b1058bcbb";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring conduit directory filepath
         monad-control network primitive process resourcet stm
         streaming-commons text transformers transformers-base
       ];
       testHaskellDepends = [
         async attoparsec base blaze-builder bytestring bytestring-builder
         conduit exceptions hspec process resourcet stm streaming-commons
         text transformers transformers-base
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Batteries included conduit: adapters for common libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-extra_1_1_7_3" = callPackage
    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
     , bytestring-builder, conduit, directory, exceptions, filepath
     , hspec, monad-control, network, primitive, process, resourcet, stm
     , streaming-commons, text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "conduit-extra";
       version = "1.1.7.3";
       sha256 = "34518a827b43f8505d02e838b8c4e390067353ee4c01a288e3487bba1645d3de";
       revision = "1";
       editedCabalFile = "d90996b02f7aeb417e54658bab2ecba414221de6cde817d2b18186d09e605091";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring conduit directory filepath
         monad-control network primitive process resourcet stm
         streaming-commons text transformers transformers-base
       ];
       testHaskellDepends = [
         async attoparsec base blaze-builder bytestring bytestring-builder
         conduit exceptions hspec process resourcet stm streaming-commons
         text transformers transformers-base
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Batteries included conduit: adapters for common libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-extra_1_1_8" = callPackage
    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
     , bytestring-builder, conduit, directory, exceptions, filepath
     , hspec, monad-control, network, primitive, process, resourcet, stm
     , streaming-commons, text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "conduit-extra";
       version = "1.1.8";
       sha256 = "f4a74434c5529ed5ecac2a54b315bc7c29e5cb040fb64a9afc511c015a5ccd96";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring conduit directory filepath
         monad-control network primitive process resourcet stm
         streaming-commons text transformers transformers-base
       ];
       testHaskellDepends = [
         async attoparsec base blaze-builder bytestring bytestring-builder
         conduit exceptions hspec process resourcet stm streaming-commons
         text transformers transformers-base
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Batteries included conduit: adapters for common libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-extra_1_1_9" = callPackage
    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
     , bytestring-builder, conduit, directory, exceptions, filepath
     , hspec, monad-control, network, primitive, process, resourcet, stm
     , streaming-commons, text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "conduit-extra";
       version = "1.1.9";
       sha256 = "b194ff96a80ad5f92175f0b64bb3eb1c84fcd355902d5421f758bb0ef44342af";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring conduit directory filepath
         monad-control network primitive process resourcet stm
         streaming-commons text transformers transformers-base
       ];
       testHaskellDepends = [
         async attoparsec base blaze-builder bytestring bytestring-builder
         conduit exceptions hspec process resourcet stm streaming-commons
         text transformers transformers-base
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Batteries included conduit: adapters for common libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-extra_1_1_9_1" = callPackage
    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
     , bytestring-builder, conduit, directory, exceptions, filepath
     , hspec, monad-control, network, primitive, process, resourcet, stm
     , streaming-commons, text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "conduit-extra";
       version = "1.1.9.1";
       sha256 = "3f1be15bef32652caa9a98e175c95614c0f6d04ca29c35d30ddbc940a90fa0a3";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring conduit directory filepath
         monad-control network primitive process resourcet stm
         streaming-commons text transformers transformers-base
       ];
       testHaskellDepends = [
         async attoparsec base blaze-builder bytestring bytestring-builder
         conduit exceptions hspec process resourcet stm streaming-commons
         text transformers transformers-base
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Batteries included conduit: adapters for common libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-extra_1_1_9_2" = callPackage
    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
     , bytestring-builder, conduit, directory, exceptions, filepath
     , hspec, monad-control, network, primitive, process, resourcet, stm
     , streaming-commons, text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "conduit-extra";
       version = "1.1.9.2";
       sha256 = "9a7b3f44990014082f589dd91f70d8b5faef66e720677888a54fb2e463940a9f";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring conduit directory filepath
         monad-control network primitive process resourcet stm
         streaming-commons text transformers transformers-base
       ];
       testHaskellDepends = [
         async attoparsec base blaze-builder bytestring bytestring-builder
         conduit exceptions hspec process resourcet stm streaming-commons
         text transformers transformers-base
       ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Batteries included conduit: adapters for common libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-extra" = callPackage
    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
     , bytestring-builder, conduit, directory, exceptions, filepath
     , hspec, monad-control, network, primitive, process, resourcet, stm
     , streaming-commons, text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "conduit-extra";
       version = "1.1.10.1";
       sha256 = "693eeea93dd2f68c1bc4a7b42ff20fdad7556c12c45ef705beaa256de422002a";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring conduit directory filepath
         monad-control network primitive process resourcet stm
         streaming-commons text transformers transformers-base
       ];
       testHaskellDepends = [
         async attoparsec base blaze-builder bytestring bytestring-builder
         conduit exceptions hspec process resourcet stm streaming-commons
         text transformers transformers-base
       ];
       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, mtl, QuickCheck
     , test-framework, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "conduit-iconv";
       version = "0.1.1.1";
       sha256 = "54a25274f4f3590a6b35ac86a3753dc867a505867cae5d363f775781f4b6ac05";
       libraryHaskellDepends = [ base bytestring conduit ];
       testHaskellDepends = [
         base bytestring conduit mtl QuickCheck test-framework
         test-framework-quickcheck2 text
       ];
       homepage = "https://github.com/sdroege/conduit-iconv";
       description = "Conduit for character encoding conversion";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "conduit-network-stream" = callPackage
    ({ mkDerivation, base, bytestring, conduit, mtl, network-conduit
     , resourcet
     }:
     mkDerivation {
       pname = "conduit-network-stream";
       version = "0.2";
       sha256 = "6457bfc4c3dd4c72a1be60c3f3e5a236f7c3ba7aa3b93d97ed93ccf387580032";
       libraryHaskellDepends = [
         base bytestring conduit mtl network-conduit resourcet
       ];
       description = "A base layer for network protocols using Conduits";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-parse" = callPackage
    ({ mkDerivation, base, conduit, dlist, exceptions, hlint, mtl
     , parsers, resourcet, tasty, tasty-hunit, text, transformers
     }:
     mkDerivation {
       pname = "conduit-parse";
       version = "0.1.1.0";
       sha256 = "94c279c5065f996dd4ad6e4fdb1514ce072c69cdf6dddf6835a20424790b5950";
       libraryHaskellDepends = [
         base conduit dlist exceptions mtl parsers text transformers
       ];
       testHaskellDepends = [
         base conduit exceptions hlint mtl parsers resourcet tasty
         tasty-hunit
       ];
       homepage = "https://github.com/k0ral/conduit-parse";
       description = "Parsing framework based on conduit";
       license = "unknown";
     }) {};

  "conduit-resumablesink" = callPackage
    ({ mkDerivation, base, bytestring, conduit, hspec, transformers
     , void
     }:
     mkDerivation {
       pname = "conduit-resumablesink";
       version = "0.1.1";
       sha256 = "cfb58e4789b05c9d52129ffb3e11e1ed4aa0e4a316297def868d4089a1bd0daf";
       libraryHaskellDepends = [ base conduit void ];
       testHaskellDepends = [
         base bytestring conduit hspec transformers void
       ];
       jailbreak = true;
       homepage = "http://github.com/A1kmm/conduit-resumablesink";
       description = "Allows conduit to resume sinks to feed multiple sources into it";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conduit-tokenize-attoparsec" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, conduit, hspec
     , resourcet, text
     }:
     mkDerivation {
       pname = "conduit-tokenize-attoparsec";
       version = "0.1.0.0";
       sha256 = "cbb8e1127c64338baba4dba836ffa1b034f4d85967fa983a334e84e56dad00af";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring conduit resourcet text
       ];
       executableHaskellDepends = [ attoparsec base conduit resourcet ];
       testHaskellDepends = [ attoparsec base conduit hspec resourcet ];
       homepage = "http://github.com/haskell-works/conduit-tokenize-attoparsec#readme";
       description = "Conduits for tokenizing streams";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "conf" = callPackage
    ({ mkDerivation, base, haskell-src, HUnit, test-framework
     , test-framework-hunit, test-framework-th
     }:
     mkDerivation {
       pname = "conf";
       version = "0.1.1.0";
       sha256 = "dcadeb99e11e6110c6afa0849702b490c7803131c780d5fd8f33221448c8b9d7";
       libraryHaskellDepends = [ base haskell-src ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit test-framework-th
       ];
       jailbreak = true;
       description = "Parser for Haskell-based configuration files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "config-select" = callPackage
    ({ mkDerivation, base, directory, filepath, unix, vty-menu }:
     mkDerivation {
       pname = "config-select";
       version = "0.0.1";
       sha256 = "9e0c6ae70eafa6879b7ae012d3c2e58b77b360a9e2a4a75e8fbaf8c204d12eac";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath unix vty-menu
       ];
       description = "A small program for swapping out dot files";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "config-value" = callPackage
    ({ mkDerivation, alex, array, base, happy, pretty, text
     , transformers
     }:
     mkDerivation {
       pname = "config-value";
       version = "0.4.0.1";
       sha256 = "67e92a664a7d5b80c456d3f0cdbbf6f1fc8d00710509f784221fd01c60342f35";
       revision = "1";
       editedCabalFile = "a07f958c50a175dba2f3e4ee6130a1871d14eb6cb28612b4cf040251cd026b28";
       libraryHaskellDepends = [ array base pretty text transformers ];
       libraryToolDepends = [ alex happy ];
       homepage = "https://github.com/glguy/config-value";
       description = "Simple, layout-based value language similar to YAML or JSON";
       license = stdenv.lib.licenses.mit;
     }) {};

  "configifier" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring
     , case-insensitive, containers, directory, either, functor-infix
     , hspec, hspec-discover, mtl, pretty-show, QuickCheck, safe
     , scientific, string-conversions, template-haskell, text
     , unordered-containers, vector, yaml
     }:
     mkDerivation {
       pname = "configifier";
       version = "0.1.0";
       sha256 = "bda7c1ae24e838204f972f64816e6e7ec5552b3ea03a2e17eb5c9e9ea9ad030e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring case-insensitive containers directory either
         functor-infix mtl safe string-conversions template-haskell
         unordered-containers vector yaml
       ];
       executableHaskellDepends = [
         base bytestring mtl pretty-show string-conversions text yaml
       ];
       testHaskellDepends = [
         aeson aeson-pretty base case-insensitive hspec hspec-discover mtl
         pretty-show QuickCheck scientific string-conversions
         unordered-containers vector
       ];
       jailbreak = true;
       description = "parser for config files, shell variables, command line args";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "configuration" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "configuration";
       version = "0.1.1";
       sha256 = "61f6c9cb5368c2706f86cc399aea4eacd07e5f3028322f66bf96e6be6e2f0ccb";
       libraryHaskellDepends = [ base containers ];
       description = "Simple data type for application configuration";
       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, text, tls
     , transformers, unordered-containers, wai, warp, warp-tls, x509
     , x509-system, x509-validation, yaml
     }:
     mkDerivation {
       pname = "configuration-tools";
       version = "0.2.13";
       sha256 = "e2d3fef26b93ef82ae484ca06730d09a5d5035a85134fae81f05cd15122b1966";
       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 text tls
         transformers unordered-containers x509 x509-system x509-validation
         yaml
       ];
       testHaskellDepends = [
         base base-unicode-symbols bytestring Cabal enclosed-exceptions
         http-types monad-control mtl text transformers unordered-containers
         wai warp warp-tls yaml
       ];
       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, filepath
     , hashable, HUnit, test-framework, test-framework-hunit, text
     , unix-compat, unordered-containers
     }:
     mkDerivation {
       pname = "configurator";
       version = "0.3.0.0";
       sha256 = "6eb9996b672e9f7112ca23482c42fa533553312c3c13f38a8a06476e67c031b4";
       libraryHaskellDepends = [
         attoparsec base bytestring directory hashable text unix-compat
         unordered-containers
       ];
       testHaskellDepends = [
         base bytestring directory filepath HUnit test-framework
         test-framework-hunit text
       ];
       homepage = "http://github.com/bos/configurator";
       description = "Configuration management";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "configurator-export" = callPackage
    ({ mkDerivation, base, configurator, pretty, semigroups, text
     , unordered-containers
     }:
     mkDerivation {
       pname = "configurator-export";
       version = "0.1.0.0";
       sha256 = "8efbda4c0e912ebf834099667b8df8e260fbeb35e765de00a5bbf9498c7eeb92";
       libraryHaskellDepends = [
         base configurator pretty semigroups text unordered-containers
       ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/mstksg/configurator-export";
       description = "Pretty printer and exporter for configurations from the \"configurator\" library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "confsolve" = callPackage
    ({ mkDerivation, attoparsec, base, cmdargs, process, system-fileio
     , system-filepath, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "confsolve";
       version = "0.5.4";
       sha256 = "2140e46d9eb4c18fb6abca962ae47952468922ca336ba7ffa63fb706157b0425";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base cmdargs process system-fileio system-filepath text
         time unordered-containers
       ];
       jailbreak = true;
       description = "A command line tool for resolving conflicts of file synchronizers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "congruence-relation" = callPackage
    ({ mkDerivation, array, base, containers }:
     mkDerivation {
       pname = "congruence-relation";
       version = "0.1.0.0";
       sha256 = "1b853725f02a7e72f3d00f4e3c5c66280a7864a4626f27beeb41ad5bfc9a44de";
       libraryHaskellDepends = [ array base containers ];
       jailbreak = true;
       description = "Decidable congruence relations for Haskell: up to you whether this is a joke";
       license = stdenv.lib.licenses.mit;
     }) {};

  "conjugateGradient" = callPackage
    ({ mkDerivation, base, containers, random }:
     mkDerivation {
       pname = "conjugateGradient";
       version = "2.2";
       sha256 = "ca1b40dfb3227ebfb90dd052fc6e0c12339d93f409e18cea95900795839143c7";
       libraryHaskellDepends = [ base containers random ];
       homepage = "http://github.com/LeventErkok/conjugateGradient";
       description = "Sparse matrix linear-equation solver";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "conjure" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, filepath
     , html, HTTP, mtl, network, old-time, parsec, pretty, random, stm
     , unix
     }:
     mkDerivation {
       pname = "conjure";
       version = "0.1";
       sha256 = "e3029e41dc934475021ed389a76bb4e6036c8e970e948eff2a98db0c481a4309";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers filepath html HTTP mtl network
         old-time parsec pretty random stm unix
       ];
       description = "A BitTorrent client";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "conlogger" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "conlogger";
       version = "0.1.0.1";
       sha256 = "037e195fa7a7d6dbca2b18660bd1e2f595b1ba416495c759c28cc8ab8fb0b7af";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base text ];
       executableHaskellDepends = [ base text ];
       jailbreak = true;
       homepage = "https://github.com/tattsun/conlogger";
       description = "A logger for a concurrent program";
       license = stdenv.lib.licenses.mit;
     }) {};

  "connection_0_2_3" = callPackage
    ({ mkDerivation, base, bytestring, containers, cprng-aes
     , data-default-class, network, socks, tls, x509, x509-store
     , x509-system, x509-validation
     }:
     mkDerivation {
       pname = "connection";
       version = "0.2.3";
       sha256 = "4b6f62d66bebc38052e98f2b6798acdb79c9171b170d2e059aaa697d53b0b80a";
       revision = "1";
       editedCabalFile = "4f5c7a935cd0ea217ddc5e180bee996d986b53f728f3d72aa8098054f8c71362";
       libraryHaskellDepends = [
         base bytestring containers cprng-aes data-default-class network
         socks tls x509 x509-store x509-system x509-validation
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-connection";
       description = "Simple and easy network connections API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "connection_0_2_4" = callPackage
    ({ mkDerivation, base, byteable, bytestring, containers
     , crypto-random, data-default-class, network, securemem, socks, tls
     , x509, x509-store, x509-system, x509-validation
     }:
     mkDerivation {
       pname = "connection";
       version = "0.2.4";
       sha256 = "f2b82a91de6bdf9b76624335418013575d3e12ad2753c6e8997e2d016cdf806a";
       revision = "1";
       editedCabalFile = "1039af89d877fbe770804d4bc2f62dddd596fa7c3e625123f3e5d4cf5676875c";
       libraryHaskellDepends = [
         base byteable bytestring containers crypto-random
         data-default-class network securemem socks tls x509 x509-store
         x509-system x509-validation
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-connection";
       description = "Simple and easy network connections API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "connection" = callPackage
    ({ mkDerivation, base, byteable, bytestring, containers
     , data-default-class, network, socks, tls, x509, x509-store
     , x509-system, x509-validation
     }:
     mkDerivation {
       pname = "connection";
       version = "0.2.5";
       sha256 = "8895d4427985202ac439b884deb4b5675ccba3d9498fce3687f1542b4ba21124";
       libraryHaskellDepends = [
         base byteable bytestring containers data-default-class network
         socks tls x509 x509-store x509-system x509-validation
       ];
       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, streaming-commons, time
     , transformers-base
     }:
     mkDerivation {
       pname = "connection-pool";
       version = "0.2";
       sha256 = "a6c3ba5f1905832cefdf9afc55cbf46a6c6a321ecac19254f20f091402b440fa";
       libraryHaskellDepends = [
         base between data-default-class monad-control network resource-pool
         streaming-commons time transformers-base
       ];
       homepage = "https://github.com/trskop/connection-pool";
       description = "Connection pool built on top of resource-pool and streaming-commons";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "consistent" = callPackage
    ({ mkDerivation, base, lifted-async, lifted-base, monad-control
     , stm, transformers, transformers-base, unordered-containers
     }:
     mkDerivation {
       pname = "consistent";
       version = "0.0.1";
       sha256 = "a57d5872c68de93d5f2cf9aaa45c091559ed3877d26eab2b025fae6a60b57b00";
       libraryHaskellDepends = [
         base lifted-async lifted-base monad-control stm transformers
         transformers-base unordered-containers
       ];
       testHaskellDepends = [ base lifted-async transformers ];
       description = "Eventually consistent STM transactions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "console-program" = callPackage
    ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, containers
     , directory, haskeline, parsec, parsec-extra, split, transformers
     , unix, utility-ht
     }:
     mkDerivation {
       pname = "console-program";
       version = "0.4.1.0";
       sha256 = "688cbecb6288c5e12c48c2bafaf27f470fe1b9d61c293b529581799cf95c7146";
       libraryHaskellDepends = [
         ansi-terminal ansi-wl-pprint base containers directory haskeline
         parsec parsec-extra split transformers unix utility-ht
       ];
       description = "Interpret the command line and settings in a config file as commands and options";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "const-math-ghc-plugin" = callPackage
    ({ mkDerivation, base, containers, directory, ghc, process }:
     mkDerivation {
       pname = "const-math-ghc-plugin";
       version = "1.0.0.0";
       sha256 = "b4fd39a813f905c3174b8600958383d3be89cf6325d3b12a23d876efb41e92b9";
       libraryHaskellDepends = [ base containers ghc ];
       testHaskellDepends = [ base directory process ];
       homepage = "https://github.com/kfish/const-math-ghc-plugin";
       description = "Compiler plugin for constant math elimination";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "constrained-categories" = callPackage
    ({ mkDerivation, base, tagged, void }:
     mkDerivation {
       pname = "constrained-categories";
       version = "0.2.1.1";
       sha256 = "fe2b93bb06a5acf4ebd872af25d7fd9b838067a676f56571845d36a0f6148c54";
       libraryHaskellDepends = [ base tagged void ];
       homepage = "https://github.com/leftaroundabout/constrained-categories";
       description = "Constrained clones of the category-theory type classes, using ConstraintKinds";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "constrained-normal" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "constrained-normal";
       version = "1.0.2";
       sha256 = "4c3dae1c10a037f152b5904048b9d55f2f17d2dfddcf96ae4a5de666b1e000d7";
       libraryHaskellDepends = [ base ];
       homepage = "http://dx.doi.org/10.1145/2500365.2500602";
       description = "Normalised Deep Embeddings for Constrained Type-Class Instances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "constraints_0_4" = callPackage
    ({ mkDerivation, base, ghc-prim, newtype }:
     mkDerivation {
       pname = "constraints";
       version = "0.4";
       sha256 = "e5ea72a487dcb65faa77451a1348f771b672be219134fd244188b3f5a9a7d75a";
       revision = "2";
       editedCabalFile = "271a82e2293a1a08a90d2fe17a824d1e2b30fc95190cd564817b09ea017c073f";
       libraryHaskellDepends = [ base ghc-prim newtype ];
       homepage = "http://github.com/ekmett/constraints/";
       description = "Constraint manipulation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "constraints_0_4_1_1" = callPackage
    ({ mkDerivation, base, ghc-prim, newtype }:
     mkDerivation {
       pname = "constraints";
       version = "0.4.1.1";
       sha256 = "3463b9edb046bd37878f7d8192c9f5b34741652a4e70e2fb7a2573d1151de96c";
       revision = "2";
       editedCabalFile = "76ca1503a834b091b236c5454ef7922868cd05cdde1ef599915334b64e6b9cc5";
       libraryHaskellDepends = [ base ghc-prim newtype ];
       homepage = "http://github.com/ekmett/constraints/";
       description = "Constraint manipulation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "constraints_0_4_1_2" = callPackage
    ({ mkDerivation, base, ghc-prim, newtype }:
     mkDerivation {
       pname = "constraints";
       version = "0.4.1.2";
       sha256 = "6711cf0893715f55ba070ff065829a02b1093ba18bb0e14f7b9dd86b2f2c2930";
       revision = "2";
       editedCabalFile = "9508552b31b6f8a77b3a24d50fc3082deaa04550fbce840d03c53111dabe7c2c";
       libraryHaskellDepends = [ base ghc-prim newtype ];
       homepage = "http://github.com/ekmett/constraints/";
       description = "Constraint manipulation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "constraints_0_4_1_3" = callPackage
    ({ mkDerivation, base, ghc-prim, newtype }:
     mkDerivation {
       pname = "constraints";
       version = "0.4.1.3";
       sha256 = "dd4353b66c85980363050566a13d17ad0216f072a06f207cb8d36530ded67af0";
       revision = "1";
       editedCabalFile = "8704acefc3b56f37d36de0316625107bffdef2c37d27e599f3a8f26618223459";
       libraryHaskellDepends = [ base ghc-prim newtype ];
       homepage = "http://github.com/ekmett/constraints/";
       description = "Constraint manipulation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "constraints_0_6" = callPackage
    ({ mkDerivation, base, binary, deepseq, ghc-prim, hashable, mtl
     , transformers, transformers-compat
     }:
     mkDerivation {
       pname = "constraints";
       version = "0.6";
       sha256 = "bcec9873c2701e411dc54cbc142d159ff5816c9a653561ccd1719f9e5a517b27";
       libraryHaskellDepends = [
         base binary deepseq ghc-prim hashable mtl transformers
         transformers-compat
       ];
       homepage = "http://github.com/ekmett/constraints/";
       description = "Constraint manipulation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "constraints" = callPackage
    ({ mkDerivation, base, binary, deepseq, ghc-prim, hashable, mtl
     , transformers, transformers-compat
     }:
     mkDerivation {
       pname = "constraints";
       version = "0.8";
       sha256 = "4cd08765345a151f21a0a4c5ef0a85661f4e53ffe807a623d5502d9ed3ae1588";
       libraryHaskellDepends = [
         base binary deepseq ghc-prim hashable mtl transformers
         transformers-compat
       ];
       homepage = "http://github.com/ekmett/constraints/";
       description = "Constraint manipulation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "constructible" = callPackage
    ({ mkDerivation, arithmoi, base, binary-search, complex-generic }:
     mkDerivation {
       pname = "constructible";
       version = "0.1.0.1";
       sha256 = "30aab02b0ee5befec3da9ad1bdea0e605bf60a90f9866031c2c69314a0487d34";
       libraryHaskellDepends = [
         arithmoi base binary-search complex-generic
       ];
       homepage = "http://andersk.mit.edu/haskell/constructible/";
       description = "Exact computation with constructible real numbers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "constructive-algebra" = callPackage
    ({ mkDerivation, base, QuickCheck, type-level }:
     mkDerivation {
       pname = "constructive-algebra";
       version = "0.3.0";
       sha256 = "3dfc28bb02704074d4ebb0e75d1b0e0701b6b840eb686e0ee47ff082e7064b9d";
       libraryHaskellDepends = [ base QuickCheck type-level ];
       jailbreak = true;
       description = "A library of constructive algebra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "consul-haskell_0_1" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , http-client, HUnit, network, tasty, tasty-hunit, text
     , transformers
     }:
     mkDerivation {
       pname = "consul-haskell";
       version = "0.1";
       sha256 = "a6ca8eb03f0ee205055c85fcf318e645a8e7388f4bb15c0d59332ed2fac1dd44";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring http-client network text
         transformers
       ];
       testHaskellDepends = [
         base http-client HUnit network tasty tasty-hunit
       ];
       doCheck = false;
       homepage = "https://github.com/alphaHeavy/consul-haskell";
       description = "A consul client for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "consul-haskell_0_2_1" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , http-client, http-types, HUnit, lifted-async, lifted-base
     , monad-control, network, stm, tasty, tasty-hunit, text
     , transformers
     }:
     mkDerivation {
       pname = "consul-haskell";
       version = "0.2.1";
       sha256 = "a79fa05bf4b26521d8d85535324979d70b1d9d5193b73721c8a76b5b2cf6838d";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring http-client http-types
         lifted-async lifted-base monad-control network stm text
         transformers
       ];
       testHaskellDepends = [
         base http-client HUnit network tasty tasty-hunit text transformers
       ];
       doCheck = false;
       homepage = "https://github.com/alphaHeavy/consul-haskell";
       description = "A consul client for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "consul-haskell" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , connection, either, http-client, http-client-tls, http-types
     , HUnit, lifted-async, lifted-base, monad-control, network, stm
     , tasty, tasty-hunit, text, transformers
     }:
     mkDerivation {
       pname = "consul-haskell";
       version = "0.3";
       sha256 = "073efdcba614f92e3add447e21e5df032a1f46ec987aa3e12de2353e38121634";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring connection either
         http-client http-client-tls http-types lifted-async lifted-base
         monad-control network stm text transformers
       ];
       testHaskellDepends = [
         base http-client HUnit network tasty tasty-hunit text transformers
       ];
       doCheck = false;
       homepage = "https://github.com/alphaHeavy/consul-haskell";
       description = "A consul client for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "consumers" = callPackage
    ({ mkDerivation, base, containers, exceptions, hpqtypes
     , lifted-base, lifted-threads, log, monad-control, mtl, stm, time
     , transformers-base
     }:
     mkDerivation {
       pname = "consumers";
       version = "1.0";
       sha256 = "2bc2a6c50462d734a82487cad419e48835d016747cb4f3a5fdda252569b2f2b8";
       libraryHaskellDepends = [
         base containers exceptions hpqtypes lifted-base lifted-threads log
         monad-control mtl stm time transformers-base
       ];
       homepage = "https://github.com/scrive/consumers";
       description = "Concurrent PostgreSQL data consumers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "container" = callPackage
    ({ mkDerivation, base, containers, data-default, data-layer
     , functor-utils, lens, lens-utils, mtl, template-haskell, text
     , transformers, transformers-base, typelevel, vector
     }:
     mkDerivation {
       pname = "container";
       version = "1.0.2";
       sha256 = "413ef2df4f8f99c8ba85547435d816eee87a72784e08aae49563bba112f41b79";
       libraryHaskellDepends = [
         base containers data-default data-layer functor-utils lens
         lens-utils mtl template-haskell text transformers transformers-base
         typelevel vector
       ];
       homepage = "https://github.com/wdanilo/containers";
       description = "Containers abstraction and utilities";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "container-classes" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "container-classes";
       version = "0.0.0.0";
       sha256 = "fb9a562f8f114996ec8ec584c06836122892cd9fac7236c75061df742b28bda2";
       libraryHaskellDepends = [ base ];
       description = "Generic classes for interacting with different container types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "containers_0_4_2_1" = callPackage
    ({ mkDerivation, array, base, deepseq }:
     mkDerivation {
       pname = "containers";
       version = "0.4.2.1";
       sha256 = "556720da0be90d23a82927acbf741f770d17f13fdcf313ba2c5f65d369f7b283";
       revision = "2";
       editedCabalFile = "4cdf787be0b51ffe34f02055117470f87d03c2f6567cd53d908b048c5fc970c8";
       libraryHaskellDepends = [ array base deepseq ];
       jailbreak = true;
       description = "Assorted concrete container types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "containers_0_5_7_1" = callPackage
    ({ mkDerivation, array, base, ChasingBottoms, deepseq, ghc-prim
     , HUnit, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "containers";
       version = "0.5.7.1";
       sha256 = "73856c3307e2ea26c33474309af4dcdfb80e7644e9a82ef4146c742a6e400f79";
       libraryHaskellDepends = [ array base deepseq ghc-prim ];
       testHaskellDepends = [
         array base ChasingBottoms deepseq ghc-prim HUnit QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       description = "Assorted concrete container types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "containers-benchmark" = callPackage
    ({ mkDerivation, base, bytestring, containers, criterion, deepseq
     , ghc-prim, random
     }:
     mkDerivation {
       pname = "containers-benchmark";
       version = "1.1.0.0";
       sha256 = "a09ee8011bcd47c43ff803784b62c0b2f992605426cdb4d266cac7c71f450886";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers criterion deepseq ghc-prim random
       ];
       jailbreak = true;
       homepage = "http://git.auryn.cz/haskell/containers-benchmark/";
       description = "Extensive benchmark suite for containers package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "containers-deepseq" = callPackage
    ({ mkDerivation, base, containers, deepseq }:
     mkDerivation {
       pname = "containers-deepseq";
       version = "0.1.0.1";
       sha256 = "8114b5bf3c5bc1c8afba3ecf4dd3389c251602259e1b2e97becf3b63243c2d51";
       libraryHaskellDepends = [ base containers deepseq ];
       description = "Provide orphan NFData instances for containers as needed. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "containers-unicode-symbols" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, containers }:
     mkDerivation {
       pname = "containers-unicode-symbols";
       version = "0.3.1.1";
       sha256 = "4655f286a2d116cb5f2b89f472df54df739bf904ac8e932b2fd34d3f713e9b31";
       libraryHaskellDepends = [ base base-unicode-symbols containers ];
       homepage = "http://haskell.org/haskellwiki/Unicode-symbols";
       description = "Unicode alternatives for common functions and operators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "context-free-grammar" = callPackage
    ({ mkDerivation, array, base, containers, control-monad-omega
     , dlist, HUnit, mtl, pretty, QuickCheck, quickcheck-properties
     , template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "context-free-grammar";
       version = "0.1.0";
       sha256 = "410d97240c586354d7cb68e8032886174a87f2e50c797289e700c73420da4687";
       libraryHaskellDepends = [
         array base containers control-monad-omega dlist mtl pretty
         template-haskell
       ];
       testHaskellDepends = [
         base containers HUnit pretty QuickCheck quickcheck-properties
         template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       homepage = "http://github.com/nedervold/context-free-grammar";
       description = "Basic algorithms on context-free grammars";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "context-stack" = callPackage
    ({ mkDerivation, base, classy-prelude, mtl, unordered-containers }:
     mkDerivation {
       pname = "context-stack";
       version = "0.1.0.1";
       sha256 = "dd8cf31cac9477345e720d6edaa350f316bcb46290adb75031c40ca236eda178";
       libraryHaskellDepends = [
         base classy-prelude mtl unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/thinkpad20/context-stack";
       description = "An abstraction of a stack and stack-based monadic context";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "continue" = callPackage
    ({ mkDerivation, base, bifunctors, monad-control, mtl
     , semigroupoids, transformers, transformers-base
     }:
     mkDerivation {
       pname = "continue";
       version = "0.2.0";
       sha256 = "2a95bffad99731fff9b38999035ba0ffc9de2acad1d5d68d241bcdfa17e6d847";
       libraryHaskellDepends = [
         base bifunctors monad-control mtl semigroupoids transformers
         transformers-base
       ];
       jailbreak = true;
       description = "Monads with suspension and arbitrary-spot reentry";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "continued-fractions" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "continued-fractions";
       version = "0.9.1.1";
       sha256 = "d0da6d0fca5f1ae750b53951ea50d22523a79b346028a50970add6fa950f173f";
       libraryHaskellDepends = [ base ];
       homepage = "/dev/null";
       description = "Continued fractions";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "continuum" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, data-default
     , foldl, hyperleveldb, leveldb-haskell-fork, mtl, nanomsg-haskell
     , parallel-io, resourcet, stm, suspend, time, timers, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "continuum";
       version = "0.1.0.7";
       sha256 = "a6bbd7bee80d5216e4678fc9bdf85f4136b079ed8d2e2cf8585c76420bb0386e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal containers mtl nanomsg-haskell time
       ];
       executableHaskellDepends = [
         base bytestring cereal containers data-default foldl
         leveldb-haskell-fork mtl nanomsg-haskell parallel-io resourcet stm
         suspend time timers transformers transformers-base
       ];
       executableSystemDepends = [ hyperleveldb ];
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {hyperleveldb = null;};

  "continuum-client" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, mtl
     , nanomsg-haskell, time
     }:
     mkDerivation {
       pname = "continuum-client";
       version = "0.1.0.0";
       sha256 = "f338dd2f4480d64d1f6d1d9527deff62e6ccc7e5687c5ba6225ea901c56f6763";
       libraryHaskellDepends = [
         base bytestring cereal containers mtl nanomsg-haskell time
       ];
       license = stdenv.lib.licenses.mit;
     }) {};

  "contravariant_1_2" = callPackage
    ({ mkDerivation, base, semigroups, transformers
     , transformers-compat, void
     }:
     mkDerivation {
       pname = "contravariant";
       version = "1.2";
       sha256 = "0ed101054717ccc031337626317eb262f9f8e75103a5f4f19688bcd8c74af33f";
       revision = "1";
       editedCabalFile = "68bffb9f8c3d0c7a668f2a67c87574fa0b7ab8344c28f868e7a934217fa7eae5";
       libraryHaskellDepends = [
         base semigroups transformers transformers-compat void
       ];
       homepage = "http://github.com/ekmett/contravariant/";
       description = "Contravariant functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "contravariant_1_2_0_1" = callPackage
    ({ mkDerivation, base, semigroups, transformers
     , transformers-compat, void
     }:
     mkDerivation {
       pname = "contravariant";
       version = "1.2.0.1";
       sha256 = "868c3a1ba9bbc2f97330cbc10fb9ac351bf79679e9c5e6625ef7b5b479575e1a";
       revision = "1";
       editedCabalFile = "dd01fca687e4bd5a1c6d4408f70f7863228155a7d7db2cdd0c20fec264d638a0";
       libraryHaskellDepends = [
         base semigroups transformers transformers-compat void
       ];
       homepage = "http://github.com/ekmett/contravariant/";
       description = "Contravariant functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "contravariant_1_2_2" = callPackage
    ({ mkDerivation, base, foreign-var, semigroups, transformers
     , transformers-compat, void
     }:
     mkDerivation {
       pname = "contravariant";
       version = "1.2.2";
       sha256 = "e5f942046fce53f9800cd0e9d6550ac5628df6edbb1144f70098661e55340fb8";
       libraryHaskellDepends = [
         base foreign-var semigroups transformers transformers-compat void
       ];
       homepage = "http://github.com/ekmett/contravariant/";
       description = "Contravariant functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "contravariant_1_2_2_1" = callPackage
    ({ mkDerivation, base, foreign-var, semigroups, transformers
     , transformers-compat, void
     }:
     mkDerivation {
       pname = "contravariant";
       version = "1.2.2.1";
       sha256 = "e5c8606402bea3b15220cd7545ecc24be29ba0350b940c8333c92d5e507f3370";
       libraryHaskellDepends = [
         base foreign-var semigroups transformers transformers-compat void
       ];
       homepage = "http://github.com/ekmett/contravariant/";
       description = "Contravariant functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "contravariant_1_3_1" = callPackage
    ({ mkDerivation, base, semigroups, StateVar, transformers
     , transformers-compat, void
     }:
     mkDerivation {
       pname = "contravariant";
       version = "1.3.1";
       sha256 = "bcb351c0e6e6c95623f79d38f9ccf24cbad470fd52aab696d3e045d28495f5a3";
       revision = "1";
       editedCabalFile = "5acc76cd43990021d06a0e5528c794bf6a89f1ed2a1bfb09fd01781e5d77c857";
       libraryHaskellDepends = [
         base semigroups StateVar transformers transformers-compat void
       ];
       homepage = "http://github.com/ekmett/contravariant/";
       description = "Contravariant functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "contravariant_1_3_1_1" = callPackage
    ({ mkDerivation, base, semigroups, StateVar, transformers
     , transformers-compat, void
     }:
     mkDerivation {
       pname = "contravariant";
       version = "1.3.1.1";
       sha256 = "dab5bac57c985ea03429614389d363854c82222a269d5bc8e164dc3f1a8d4e4e";
       libraryHaskellDepends = [
         base semigroups StateVar transformers transformers-compat void
       ];
       homepage = "http://github.com/ekmett/contravariant/";
       description = "Contravariant functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "contravariant_1_3_2" = callPackage
    ({ mkDerivation, base, semigroups, StateVar, transformers
     , transformers-compat, void
     }:
     mkDerivation {
       pname = "contravariant";
       version = "1.3.2";
       sha256 = "52baae0676d6d5bcf7d891e6cda4580e58646c747d570bdde69b0023c2576639";
       libraryHaskellDepends = [
         base semigroups StateVar transformers transformers-compat void
       ];
       homepage = "http://github.com/ekmett/contravariant/";
       description = "Contravariant functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "contravariant_1_3_3" = callPackage
    ({ mkDerivation, base, semigroups, StateVar, transformers
     , transformers-compat, void
     }:
     mkDerivation {
       pname = "contravariant";
       version = "1.3.3";
       sha256 = "65390e2bde01c1cc91cfe414b5ad0aa9dcb26e527f0646719d19dbaf616590a0";
       libraryHaskellDepends = [
         base semigroups StateVar transformers transformers-compat void
       ];
       homepage = "http://github.com/ekmett/contravariant/";
       description = "Contravariant functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "contravariant" = callPackage
    ({ mkDerivation, base, semigroups, StateVar, transformers
     , transformers-compat, void
     }:
     mkDerivation {
       pname = "contravariant";
       version = "1.4";
       sha256 = "e1666df1373ed784baa7d1e8e963bbc2d1f3c391578ac550ae74e7399173ee84";
       libraryHaskellDepends = [
         base semigroups StateVar transformers transformers-compat void
       ];
       homepage = "http://github.com/ekmett/contravariant/";
       description = "Contravariant functors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "contravariant-extras_0_3" = callPackage
    ({ mkDerivation, base, base-prelude, contravariant
     , template-haskell, tuple-th
     }:
     mkDerivation {
       pname = "contravariant-extras";
       version = "0.3";
       sha256 = "e637b117267bf1822d7f0bf696d25816d857ad238ac4da557214d803a34a1440";
       libraryHaskellDepends = [
         base base-prelude contravariant template-haskell tuple-th
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/contravariant-extras";
       description = "Extras for the \"contravariant\" package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "contravariant-extras" = callPackage
    ({ mkDerivation, base, base-prelude, contravariant
     , template-haskell, tuple-th
     }:
     mkDerivation {
       pname = "contravariant-extras";
       version = "0.3.1";
       sha256 = "5bbdc3f535163677825b95f520f0d2f9c63cafff39aabc0f23aecd6b27f99de3";
       libraryHaskellDepends = [
         base base-prelude contravariant template-haskell tuple-th
       ];
       homepage = "https://github.com/nikita-volkov/contravariant-extras";
       description = "Extras for the \"contravariant\" package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "control-bool" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "control-bool";
       version = "0.2.1";
       sha256 = "e46a85d2985a65f8d7ecbcdab0cfb12734b4d6e4c558631e6ab01fe742ed5581";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/fumieval/control-bool";
       description = "Useful combinators for boolean expressions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "control-event" = callPackage
    ({ mkDerivation, base, containers, stm, time }:
     mkDerivation {
       pname = "control-event";
       version = "1.2.1.1";
       sha256 = "c59453ad675b3bbcbec10e5a662846a0fce0343d6e5878d558247edb758b9a43";
       libraryHaskellDepends = [ base containers stm time ];
       description = "Event scheduling system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "control-monad-attempt" = callPackage
    ({ mkDerivation, attempt, base, transformers }:
     mkDerivation {
       pname = "control-monad-attempt";
       version = "0.3.0.1";
       sha256 = "bac8217c9980bccfce3381ea6a28eb0e117d9aaf99f2cc3c2e5ffad5f6111690";
       libraryHaskellDepends = [ attempt base transformers ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/control-monad-attempt";
       description = "Monad transformer for attempt. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "control-monad-exception" = callPackage
    ({ mkDerivation, base, failure, lifted-base, monad-control
     , monadloc, transformers, transformers-base
     }:
     mkDerivation {
       pname = "control-monad-exception";
       version = "0.11.2";
       sha256 = "970459a274585c2704699059be0a7bd4b144d1c0a5473d53210430e362d1b56d";
       libraryHaskellDepends = [
         base failure lifted-base monad-control monadloc transformers
         transformers-base
       ];
       homepage = "http://pepeiborra.github.com/control-monad-exception";
       description = "Explicitly typed, checked exceptions with stack traces";
       license = stdenv.lib.licenses.mit;
     }) {};

  "control-monad-exception-monadsfd" = callPackage
    ({ mkDerivation, base, control-monad-exception, monads-fd
     , transformers
     }:
     mkDerivation {
       pname = "control-monad-exception-monadsfd";
       version = "0.10.3";
       sha256 = "35da0c839c04b5407deb959c6aab6009a7b1223b9a3d84627a7218e433eefec7";
       libraryHaskellDepends = [
         base control-monad-exception monads-fd transformers
       ];
       homepage = "http://pepeiborra.github.com/control-monad-exception";
       description = "Monads-fd instances for the EMT exceptions monad transformer";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "control-monad-exception-monadstf" = callPackage
    ({ mkDerivation, base, control-monad-exception, monads-tf
     , transformers
     }:
     mkDerivation {
       pname = "control-monad-exception-monadstf";
       version = "0.10.3";
       sha256 = "ea9bc0ed343b1067f2df3e699cdb053c265622b9ae585e9422cbdcf2c2f144e2";
       libraryHaskellDepends = [
         base control-monad-exception monads-tf transformers
       ];
       homepage = "http://pepeiborra.github.com/control-monad-exception";
       description = "Monads-tf instances for the EMT exceptions monad transformer";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "control-monad-exception-mtl" = callPackage
    ({ mkDerivation, base, control-monad-exception, mtl }:
     mkDerivation {
       pname = "control-monad-exception-mtl";
       version = "0.10.3";
       sha256 = "d1d2657a3d638d2ddce9f38e2c15dd6f2d06aa67c959269abbda89c6fab098f3";
       libraryHaskellDepends = [ base control-monad-exception mtl ];
       doHaddock = false;
       homepage = "http://pepeiborra.github.com/control-monad-exception";
       description = "MTL instances for the EMT exceptions monad transformer";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "control-monad-failure" = callPackage
    ({ mkDerivation, base, failure, transformers }:
     mkDerivation {
       pname = "control-monad-failure";
       version = "0.7.0.1";
       sha256 = "78524bf400bcd382bada63479e5d32be627199d9f6ec2d780ca84317162760bc";
       libraryHaskellDepends = [ base failure transformers ];
       jailbreak = true;
       homepage = "http://github.com/pepeiborra/control-monad-failure";
       description = "A class for monads which can fail with an error. (deprecated)";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "control-monad-failure-mtl" = callPackage
    ({ mkDerivation, base, failure, mtl }:
     mkDerivation {
       pname = "control-monad-failure-mtl";
       version = "0.7.1";
       sha256 = "12d9b9cd2cc0f9a5f51145511e3c86a4a4c9b1ab0915d17742670c8077413149";
       libraryHaskellDepends = [ base failure mtl ];
       jailbreak = true;
       homepage = "http://github.com/pepeiborra/control-monad-failure";
       description = "A class for monads which can fail with an error for mtl 1 (deprecated)";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "control-monad-free_0_5_3" = callPackage
    ({ mkDerivation, base, deepseq, transformers }:
     mkDerivation {
       pname = "control-monad-free";
       version = "0.5.3";
       sha256 = "61eeb33b98fe2cd7c78a4878b2c33ca82475696e3d7425bdca11bddb1857fcc5";
       libraryHaskellDepends = [ base deepseq transformers ];
       homepage = "http://github.com/pepeiborra/control-monad-free";
       description = "Free monads and monad transformers";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "control-monad-free" = callPackage
    ({ mkDerivation, base, prelude-extras, transformers }:
     mkDerivation {
       pname = "control-monad-free";
       version = "0.6.1";
       sha256 = "fea9173d3c29729a8e0789d654bf3b16928e0b740465bd8798ac2cfeec492286";
       revision = "1";
       editedCabalFile = "d08dceee154098bee492a1c00ef699a2a3a0e8a3851c5d49ccd49d5645a501a4";
       libraryHaskellDepends = [ base prelude-extras transformers ];
       homepage = "http://github.com/pepeiborra/control-monad-free";
       description = "Free monads and monad transformers";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "control-monad-loop" = callPackage
    ({ mkDerivation, base, transformers, transformers-base }:
     mkDerivation {
       pname = "control-monad-loop";
       version = "0.1";
       sha256 = "f29b08497897268daf4c547390dad69f4ee00032082e3d5305c33e6eee257300";
       libraryHaskellDepends = [ base transformers transformers-base ];
       homepage = "https://github.com/joeyadams/haskell-control-monad-loop";
       description = "Simple monad transformer for imperative-style loops";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "control-monad-omega" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "control-monad-omega";
       version = "0.3.1";
       sha256 = "383b98ecf5db5add42f318672af9eb1c8b9d99ec42d48c240e209a93b5cf1186";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/luqui/control-monad-omega";
       description = "A breadth-first list monad";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "control-monad-queue" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "control-monad-queue";
       version = "0.2.0.1";
       sha256 = "d428f7e761024716118605107b8f2f4b9d721f1163bd36865b969f3892f6d1b5";
       libraryHaskellDepends = [ base ];
       description = "Reusable corecursive queues, via continuations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "control-timeout" = callPackage
    ({ mkDerivation, base, containers, stm, time }:
     mkDerivation {
       pname = "control-timeout";
       version = "0.1.2";
       sha256 = "6f7bf5981f2179658658116d6efd44bb6b51ed70036d4438e39339d508333dbc";
       libraryHaskellDepends = [ base containers stm time ];
       description = "Timeout handling";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "contstuff" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "contstuff";
       version = "1.2.6";
       sha256 = "0300643fc8877c0ad604d2a4607c6a7aa5117940c875ed4e019049a9a85e8267";
       libraryHaskellDepends = [ base transformers ];
       homepage = "http://haskell.org/haskellwiki/Contstuff";
       description = "Fast, easy to use CPS-based monad transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "contstuff-monads-tf" = callPackage
    ({ mkDerivation, base, contstuff, monads-tf }:
     mkDerivation {
       pname = "contstuff-monads-tf";
       version = "0.2.1";
       sha256 = "05f647352b54179e2f76a36f7686c13473f554cf7467cfba14c4549095399e48";
       libraryHaskellDepends = [ base contstuff monads-tf ];
       description = "ContStuff instances for monads-tf transformers (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "contstuff-transformers" = callPackage
    ({ mkDerivation, base, contstuff, transformers }:
     mkDerivation {
       pname = "contstuff-transformers";
       version = "0.1.1";
       sha256 = "262a527d696e3252ee000e528936b2a64990a7e19277e61c8917f715eed4bb2c";
       libraryHaskellDepends = [ base contstuff transformers ];
       jailbreak = true;
       description = "Deprecated interface between contstuff 0.7.0 and the transformers package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "converge" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "converge";
       version = "0.1.0.1";
       sha256 = "72df25e93cd41af26c17c28d6c0930b22d51c903ee4fc181ca76c2fbe6a94878";
       libraryHaskellDepends = [ base ];
       homepage = "/dev/null";
       description = "Limit operations for converging sequences";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "conversion" = callPackage
    ({ mkDerivation, base-prelude }:
     mkDerivation {
       pname = "conversion";
       version = "1.2";
       sha256 = "d5f8b437aaa61bd414247a5a4f947eb6ee41929c1725b4874af30252fea022a9";
       libraryHaskellDepends = [ base-prelude ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/conversion";
       description = "Universal converter between values of different types";
       license = stdenv.lib.licenses.mit;
     }) {};

  "conversion-bytestring" = callPackage
    ({ mkDerivation, base-prelude, bytestring, conversion }:
     mkDerivation {
       pname = "conversion-bytestring";
       version = "1.0.0.1";
       sha256 = "7e4c4264a8a9aa4fc3809411146257989404d50dfe4943bdddf063546e754bbf";
       libraryHaskellDepends = [ base-prelude bytestring conversion ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/conversion-bytestring";
       description = "\"Conversion\" instances for the \"bytestring\" library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "conversion-case-insensitive" = callPackage
    ({ mkDerivation, case-insensitive, conversion }:
     mkDerivation {
       pname = "conversion-case-insensitive";
       version = "1.0.0.0";
       sha256 = "97b591d3acf63efa882b7fd8d2e024b2564010034a766369cb985e66a32cae92";
       libraryHaskellDepends = [ case-insensitive conversion ];
       homepage = "https://github.com/nikita-volkov/conversion-case-insensitive";
       description = "\"Conversion\" instances for the \"case-insensitive\" library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "conversion-text" = callPackage
    ({ mkDerivation, base-prelude, bytestring, conversion
     , conversion-bytestring, text
     }:
     mkDerivation {
       pname = "conversion-text";
       version = "1.0.0.2";
       sha256 = "7e5d2cefc064804aace10e32232cc155a819ca2da341041b7d698bc4b904f248";
       libraryHaskellDepends = [
         base-prelude bytestring conversion conversion-bytestring text
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/conversion-text";
       description = "\"Conversion\" instances for the \"text\" library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "convert" = callPackage
    ({ mkDerivation, base, bytestring, containers, either, lens, mtl
     , old-locale, old-time, template-haskell, text, time
     }:
     mkDerivation {
       pname = "convert";
       version = "1.0.2";
       sha256 = "388502eb341523d153276e510815c5b2d1fa83c125c5da6b19844bb084149e6f";
       libraryHaskellDepends = [
         base bytestring containers either lens mtl old-locale old-time
         template-haskell text time
       ];
       homepage = "https://github.com/wdanilo/convert";
       description = "Safe and unsafe data conversion utilities with strong type-level operation. checking.";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "convertible_1_1_0_0" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, old-locale
     , old-time, text, time
     }:
     mkDerivation {
       pname = "convertible";
       version = "1.1.0.0";
       sha256 = "13c4943c302700a207426aabcd6dab5a5de85de2353acacbcf4159e924f9835d";
       revision = "3";
       editedCabalFile = "9958bc1e79fce365c2c3a1629abe13ce1cf35588252d625bc86e5e10667401fa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers mtl old-locale old-time text time
       ];
       homepage = "http://hackage.haskell.org/cgi-bin/hackage-scripts/package/convertible";
       description = "Typeclasses and instances for converting between types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "convertible" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, old-locale
     , old-time, 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
       ];
       homepage = "http://hackage.haskell.org/package/convertible";
       description = "Typeclasses and instances for converting between types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "convertible-ascii" = callPackage
    ({ mkDerivation, ascii, base, base-unicode-symbols, blaze-builder
     , bytestring, convertible-text, failure, text
     }:
     mkDerivation {
       pname = "convertible-ascii";
       version = "0.1.0.1";
       sha256 = "5cea401d103279b35868253b45877ee518cae5e86912623b65f1834132c0ee7b";
       libraryHaskellDepends = [
         ascii base base-unicode-symbols blaze-builder bytestring
         convertible-text failure text
       ];
       jailbreak = true;
       homepage = "https://github.com/phonohawk/convertible-ascii";
       description = "convertible instances for ascii";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "convertible-text" = callPackage
    ({ mkDerivation, attempt, base, bytestring, containers, old-time
     , template-haskell, text, time
     }:
     mkDerivation {
       pname = "convertible-text";
       version = "0.4.0.2";
       sha256 = "df8dc391ff4d82e3d18b049e3c4db50198aa1345c101d088683a075d5ba217f3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attempt base bytestring containers old-time template-haskell text
         time
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/convertible/tree/text";
       description = "Typeclasses and instances for converting between types (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cookbook" = callPackage
    ({ mkDerivation, base, directory, strict }:
     mkDerivation {
       pname = "cookbook";
       version = "3.0.0.1";
       sha256 = "7142f3f1235e2ae5a7e6b040ad2d53f8ed332ca11cea8b3a0ff199b7ce2312d6";
       libraryHaskellDepends = [ base directory strict ];
       description = "Tiered general-purpose libraries with domain-specific applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cookie_0_4_1_4" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, data-default
     , deepseq, HUnit, old-locale, QuickCheck, tasty, tasty-hunit
     , tasty-quickcheck, text, time
     }:
     mkDerivation {
       pname = "cookie";
       version = "0.4.1.4";
       sha256 = "2d8ca4519f20c8e2b5af32aae5fa4bd76bb933a21877dedd215c3232b8a4bb2b";
       revision = "2";
       editedCabalFile = "85ddcaf1e9385161304beb116362d93cfe168d63e1fc7edc647353ece481d765";
       libraryHaskellDepends = [
         base blaze-builder bytestring data-default deepseq old-locale text
         time
       ];
       testHaskellDepends = [
         base blaze-builder bytestring HUnit QuickCheck tasty tasty-hunit
         tasty-quickcheck text time
       ];
       homepage = "http://github.com/snoyberg/cookie";
       description = "HTTP cookie parsing and rendering";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cookie_0_4_1_5" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring
     , data-default-class, deepseq, HUnit, old-locale, QuickCheck, tasty
     , tasty-hunit, tasty-quickcheck, text, time
     }:
     mkDerivation {
       pname = "cookie";
       version = "0.4.1.5";
       sha256 = "b6e6c793691776348698cbb2a7143a3a97afd43b71f1632e92ea69f10d8d3358";
       revision = "2";
       editedCabalFile = "f9789afefed0c211dfe33d029f26bd464a3ca2f51b277629230a68ed58ee49e2";
       libraryHaskellDepends = [
         base blaze-builder bytestring data-default-class deepseq old-locale
         text time
       ];
       testHaskellDepends = [
         base blaze-builder bytestring HUnit QuickCheck tasty tasty-hunit
         tasty-quickcheck text time
       ];
       homepage = "http://github.com/snoyberg/cookie";
       description = "HTTP cookie parsing and rendering";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cookie" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring
     , data-default-class, deepseq, HUnit, old-locale, QuickCheck, tasty
     , tasty-hunit, tasty-quickcheck, text, time
     }:
     mkDerivation {
       pname = "cookie";
       version = "0.4.1.6";
       sha256 = "3a2da4db7478ae45f848ebd5fcd40c23c84ecd00be79dec857e526619da9de2c";
       libraryHaskellDepends = [
         base blaze-builder bytestring data-default-class deepseq old-locale
         text time
       ];
       testHaskellDepends = [
         base blaze-builder bytestring HUnit QuickCheck tasty tasty-hunit
         tasty-quickcheck text time
       ];
       homepage = "http://github.com/snoyberg/cookie";
       description = "HTTP cookie parsing and rendering";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "coordinate" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, lens
     , QuickCheck, radian, tagged, template-haskell, transformers
     }:
     mkDerivation {
       pname = "coordinate";
       version = "0.0.19";
       sha256 = "596039a14f30eed5d732bc5b9d04f20f3f0fba675c196083fb1e4fd17d6dc605";
       libraryHaskellDepends = [ base lens radian tagged transformers ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck template-haskell
       ];
       homepage = "https://github.com/NICTA/coordinate";
       description = "A representation of latitude and longitude";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "copilot" = callPackage
    ({ mkDerivation, base, copilot-c99, copilot-cbmc, copilot-core
     , copilot-language, copilot-libraries, copilot-sbv, copilot-theorem
     , directory, random
     }:
     mkDerivation {
       pname = "copilot";
       version = "2.2.0";
       sha256 = "5ab66248bbfb63435ffb931323be965dfec045c4a56c16ebfb77b7a9020c4853";
       revision = "3";
       editedCabalFile = "5566482d53a961c2f08f95f8b1aa7ddae00120ffa29e99df936e9221beac6d6c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base copilot-c99 copilot-cbmc copilot-core copilot-language
         copilot-libraries copilot-sbv copilot-theorem
       ];
       executableHaskellDepends = [
         base copilot-c99 copilot-cbmc copilot-core copilot-language
         copilot-libraries copilot-sbv copilot-theorem directory random
       ];
       homepage = "http://leepike.github.com/Copilot/";
       description = "A stream DSL for writing embedded C programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "copilot-c99" = callPackage
    ({ mkDerivation, atom, base, bytestring, containers, copilot-core
     , csv, directory, pretty, process, QuickCheck, random, text, vector
     }:
     mkDerivation {
       pname = "copilot-c99";
       version = "2.2.0";
       sha256 = "e9b9f55242db21d02080a9c96266967e84f9d49e74231526a49778913d6e7e9c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         atom base bytestring containers copilot-core csv directory pretty
         process QuickCheck random text vector
       ];
       executableHaskellDepends = [
         atom base bytestring containers copilot-core csv directory pretty
         process QuickCheck random text vector
       ];
       description = "A compiler for Copilot targeting C99";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "copilot-cbmc" = callPackage
    ({ mkDerivation, base, bytestring, copilot-c99, copilot-core
     , copilot-sbv, directory, pretty, process
     }:
     mkDerivation {
       pname = "copilot-cbmc";
       version = "2.2.0";
       sha256 = "ac9fe6c89c28864be84cc4fc9724d9081f1b118c798567541a9c2380f23cae0e";
       libraryHaskellDepends = [
         base bytestring copilot-c99 copilot-core copilot-sbv directory
         pretty process
       ];
       description = "Copilot interface to a C model-checker";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "copilot-core" = callPackage
    ({ mkDerivation, base, containers, dlist, mtl, pretty, pretty-ncols
     , random
     }:
     mkDerivation {
       pname = "copilot-core";
       version = "2.2.0";
       sha256 = "2a9a6c7954d66179b03654cf04297800de015ba9b11f76b9e80b02c290f060a1";
       libraryHaskellDepends = [
         base containers dlist mtl pretty pretty-ncols random
       ];
       description = "An intermediate representation for Copilot";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "copilot-language" = callPackage
    ({ mkDerivation, array, base, containers, copilot-core
     , copilot-theorem, data-reify, ghc-prim, mtl
     }:
     mkDerivation {
       pname = "copilot-language";
       version = "2.2.0";
       sha256 = "35bbc98550819f06978a73f5d19e15f93463b4b0a8cc6eae33cef45f30bf127c";
       revision = "1";
       editedCabalFile = "7ab61bdf2be4f514ad0b5241d32dd28ab67ecfcc865883f6d6811a9b4e7050af";
       libraryHaskellDepends = [
         array base containers copilot-core copilot-theorem data-reify
         ghc-prim mtl
       ];
       description = "A Haskell-embedded DSL for monitoring hard real-time distributed systems";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "copilot-libraries" = callPackage
    ({ mkDerivation, array, base, containers, copilot-language, mtl
     , parsec
     }:
     mkDerivation {
       pname = "copilot-libraries";
       version = "2.2.0";
       sha256 = "a6ae67ceb7fd7b63e7fa13af7f2039a606be8932430a702a9d7b8c7674f50b2b";
       libraryHaskellDepends = [
         array base containers copilot-language mtl parsec
       ];
       homepage = "https://github.com/leepike/copilot-libraries";
       description = "Libraries for the Copilot language";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "copilot-sbv" = callPackage
    ({ mkDerivation, base, containers, copilot-core, directory
     , filepath, pretty, sbv
     }:
     mkDerivation {
       pname = "copilot-sbv";
       version = "2.2.0";
       sha256 = "8d657406fa3c846b14b05948857fce47dc66ba5eb73140ae6855dd98f6859dae";
       libraryHaskellDepends = [
         base containers copilot-core directory filepath pretty sbv
       ];
       description = "A compiler for CoPilot targeting SBV";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "copilot-theorem" = callPackage
    ({ mkDerivation, ansi-terminal, base, bimap, containers
     , copilot-core, data-default, directory, mtl, parsec, pretty
     , process, random, smtlib2, transformers, xml
     }:
     mkDerivation {
       pname = "copilot-theorem";
       version = "2.2.0";
       sha256 = "c24948bd2fcfc695f5ebf61116a72a75d6e0fbcadbbb91a5cbde4083285cf30c";
       libraryHaskellDepends = [
         ansi-terminal base bimap containers copilot-core data-default
         directory mtl parsec pretty process random smtlib2 transformers xml
       ];
       description = "k-induction for Copilot";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "copr" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, hlint
     , HsOpenSSL, http-streams, io-streams, semigroups, text
     }:
     mkDerivation {
       pname = "copr";
       version = "1.1.1";
       sha256 = "dce6829db3ed8b6c8949e00af8e2d798174280758d23309f497f7b143330ef7d";
       revision = "1";
       editedCabalFile = "ef9fb8be7d257feae9e4647de62d489860e2bd6510e34a35465cf5b763fa2425";
       libraryHaskellDepends = [
         aeson base bytestring containers HsOpenSSL http-streams io-streams
         semigroups text
       ];
       testHaskellDepends = [ base hlint ];
       jailbreak = true;
       homepage = "https://github.com/relrod/copr-hs";
       description = "Haskell interface to the Fedora Copr system";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "core" = callPackage
    ({ mkDerivation, base, bytestring, parsec, pretty }:
     mkDerivation {
       pname = "core";
       version = "0.5";
       sha256 = "9fb1840f37a40c40bcfeb838ee45d6e44fa5ee31aa4d50044114d938da720fbb";
       libraryHaskellDepends = [ base bytestring parsec pretty ];
       description = "External core parser and pretty printer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "core-haskell" = callPackage
    ({ mkDerivation, base, haskeline, haskell-src-exts, hint }:
     mkDerivation {
       pname = "core-haskell";
       version = "0.6.4";
       sha256 = "b9e39fc2240a618708add5c8e162cf5c3712ef935a06a01e3bbc1b89ae9055f2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base haskeline haskell-src-exts hint
       ];
       homepage = "https://github.com/happlebao/Core-Haskell";
       description = "A subset of Haskell using in UCC for teaching purpose";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "corebot-bliki" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, containers
     , directory, filepath, filestore, http-types, monads-tf, pandoc
     , template-haskell, text, time, yesod
     }:
     mkDerivation {
       pname = "corebot-bliki";
       version = "0.2.2.0";
       sha256 = "0f076d6196c08942b739699c7313c76a2e047994a8fdc8042b05f2c017f9ee82";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring containers directory filepath
         filestore http-types monads-tf pandoc template-haskell text time
         yesod
       ];
       executableHaskellDepends = [
         aeson base blaze-builder bytestring containers directory filepath
         filestore http-types monads-tf pandoc template-haskell text time
         yesod
       ];
       homepage = "http://github.com/coreyoconnor/corebot-bliki";
       description = "A bliki written using yesod. Uses pandoc to process files stored in git.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "coroutine-enumerator" = callPackage
    ({ mkDerivation, base, enumerator, monad-coroutine }:
     mkDerivation {
       pname = "coroutine-enumerator";
       version = "0.1.1";
       sha256 = "e7429de12e84f6cbde0d23069ebcd22954fc94cd5a1e12b95235f05dfc854be6";
       libraryHaskellDepends = [ base enumerator monad-coroutine ];
       jailbreak = true;
       homepage = "http://trac.haskell.org/SCC/wiki/coroutine-enumerator";
       description = "Bridge between the monad-coroutine and enumerator packages";
       license = "GPL";
     }) {};

  "coroutine-iteratee" = callPackage
    ({ mkDerivation, base, iteratee, monad-coroutine }:
     mkDerivation {
       pname = "coroutine-iteratee";
       version = "0.1.1";
       sha256 = "8d838a6295c45459324342e7bc455075ec2e014eab31629e27e3b3cb27c991f9";
       libraryHaskellDepends = [ base iteratee monad-coroutine ];
       jailbreak = true;
       homepage = "http://trac.haskell.org/SCC/wiki/coroutine-iteratee";
       description = "Bridge between the monad-coroutine and iteratee packages";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "coroutine-object" = callPackage
    ({ mkDerivation, base, either, free, mtl, transformers }:
     mkDerivation {
       pname = "coroutine-object";
       version = "0.3.0";
       sha256 = "cf0fb74baee84167898e899f9e5779c0c71c9d2967fc4a52d25941aeddf0f7c1";
       libraryHaskellDepends = [ base either free mtl transformers ];
       description = "Object-oriented programming realization using coroutine";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "couch-hs" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, hint, random
     , text, transformers, vector
     }:
     mkDerivation {
       pname = "couch-hs";
       version = "0.1.6";
       sha256 = "079b3eb630f4841e54b2bed0d9e1e514d627e186c5be51ba35f3cf0465053d57";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring hint random text transformers
         vector
       ];
       jailbreak = true;
       description = "A CouchDB view server for Haskell";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "couch-simple" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bifunctors, bytestring
     , couchdb, data-default, directory, exceptions, filepath
     , hjsonschema, hlint, http-client, http-types, integer-gmp, mtl
     , random, tasty, tasty-hunit, text, transformers
     , unordered-containers, uuid, vector
     }:
     mkDerivation {
       pname = "couch-simple";
       version = "0.0.1.0";
       sha256 = "bf62acc13979f31c729e2aba4bb00ad451f026dbdb725ecedd122a806051ab9d";
       libraryHaskellDepends = [
         aeson attoparsec base bifunctors bytestring data-default exceptions
         http-client http-types integer-gmp mtl text transformers
         unordered-containers uuid vector
       ];
       testHaskellDepends = [
         aeson base bytestring data-default directory exceptions filepath
         hjsonschema hlint http-client http-types random tasty tasty-hunit
         text transformers unordered-containers uuid
       ];
       testToolDepends = [ couchdb ];
       homepage = "https://github.com/mdorman/couch-simple";
       description = "A modern, lightweight, complete client for CouchDB";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) couchdb;};

  "couchdb-conduit" = callPackage
    ({ mkDerivation, aeson, attoparsec, attoparsec-conduit, base
     , blaze-builder, bytestring, conduit, containers, data-default
     , http-conduit, http-types, HUnit, lifted-base, monad-control
     , resourcet, string-conversions, syb, test-framework
     , test-framework-hunit, text, transformers, transformers-base
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "couchdb-conduit";
       version = "0.10.6";
       sha256 = "54897f96994f1725b2dff75d3e19f862d180fa7a884b09cb03c2a66a8abce566";
       libraryHaskellDepends = [
         aeson attoparsec attoparsec-conduit base blaze-builder bytestring
         conduit containers data-default http-conduit http-types lifted-base
         monad-control resourcet string-conversions syb text transformers
         unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec attoparsec-conduit base blaze-builder bytestring
         conduit containers data-default http-conduit http-types HUnit
         lifted-base monad-control string-conversions syb test-framework
         test-framework-hunit text transformers transformers-base
         unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/akaspin/couchdb-conduit";
       description = "Couch DB client library using http-conduit and aeson";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "couchdb-enumerator" = callPackage
    ({ mkDerivation, aeson, attoparsec, attoparsec-enumerator, base
     , bytestring, enumerator, http-enumerator, http-types, HUnit
     , lifted-base, monad-control, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     , transformers, unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "couchdb-enumerator";
       version = "0.3.7";
       sha256 = "f6a2e4d01e7b1ff3127f5ddf5219e8ef31d734d4405ea8c1951eb2d58251000a";
       libraryHaskellDepends = [
         aeson attoparsec attoparsec-enumerator base bytestring enumerator
         http-enumerator http-types lifted-base monad-control text
         transformers unordered-containers utf8-string
       ];
       testHaskellDepends = [
         aeson attoparsec attoparsec-enumerator base bytestring enumerator
         http-enumerator http-types HUnit lifted-base monad-control
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 text transformers unordered-containers
         utf8-string vector
       ];
       jailbreak = true;
       homepage = "http://bitbucket.org/wuzzeb/couchdb-enumerator";
       description = "Couch DB client library using http-enumerator and aeson";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "count" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "count";
       version = "0.0.1";
       sha256 = "fdcd6dd6c9587df80e9dc5ee540e9e68b149b07b7c71aeff7397609943dee2ab";
       libraryHaskellDepends = [ base ];
       description = "Bijective mappings between values and possibly infinite prefixes of [0..]";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "countable" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "countable";
       version = "0.2";
       sha256 = "3352e7cf080c88ce775da53107f21e86d9a5fc80386ca3fd7b07151dc3bce6ab";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/AshleyYakeley/countable";
       description = "Countable, Searchable, Finite, Empty classes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "counter" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "counter";
       version = "0.1.0.1";
       sha256 = "5fcde1f42a49b8376319db7a8e986c727e8c67c3766fa6f958f82c032f19cf5d";
       libraryHaskellDepends = [ base containers ];
       homepage = "https://github.com/wei2912/counter";
       description = "An object frequency counter";
       license = stdenv.lib.licenses.mit;
     }) {};

  "country-codes_0_1_2" = callPackage
    ({ mkDerivation, aeson, base, HTF, HUnit, shakespeare, tagsoup
     , text
     }:
     mkDerivation {
       pname = "country-codes";
       version = "0.1.2";
       sha256 = "e49ccaa859c375f41def1429d7718f8b1440e31d30146e13b46f11fbf24be298";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ aeson base shakespeare text ];
       executableHaskellDepends = [ base tagsoup text ];
       testHaskellDepends = [ aeson base HTF HUnit ];
       homepage = "https://github.com/prowdsponsor/country-codes";
       description = "ISO 3166 country codes and i18n names";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "country-codes" = callPackage
    ({ mkDerivation, aeson, base, HTF, HUnit, shakespeare, tagsoup
     , text
     }:
     mkDerivation {
       pname = "country-codes";
       version = "0.1.3";
       sha256 = "062843cebfcb4df513e4688456311f07a2eb693935a053ce2eade2c8d586d1b5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ aeson base shakespeare text ];
       executableHaskellDepends = [ base tagsoup text ];
       testHaskellDepends = [ aeson base HTF HUnit ];
       homepage = "https://github.com/prowdsponsor/country-codes";
       description = "ISO 3166 country codes and i18n names";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "courier_0_1_0_15" = callPackage
    ({ mkDerivation, async, base, bytestring, cereal, containers
     , directory, hslogger, HUnit, network, stm, test-framework
     , test-framework-hunit, text, uuid
     }:
     mkDerivation {
       pname = "courier";
       version = "0.1.0.15";
       sha256 = "5b14d1d5d2bd4efb563a8e5111cd23c5892034b6bfcd2e34ead8c9c3b35549aa";
       libraryHaskellDepends = [
         async base bytestring cereal containers hslogger network stm text
         uuid
       ];
       testHaskellDepends = [
         async base cereal containers directory hslogger HUnit network stm
         test-framework test-framework-hunit
       ];
       homepage = "http://github.com/hargettp/courier";
       description = "A message-passing library for simplifying network applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "courier_0_1_1_1" = callPackage
    ({ mkDerivation, async, base, bytestring, cereal, containers
     , directory, hslogger, HUnit, network, stm, test-framework
     , test-framework-hunit, text, uuid
     }:
     mkDerivation {
       pname = "courier";
       version = "0.1.1.1";
       sha256 = "950216558b5729d592c2bfd9b230ab25fe0403cd5cfa6825ec9b6123fc330ad6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base bytestring cereal containers hslogger network stm text
         uuid
       ];
       executableHaskellDepends = [ base cereal ];
       testHaskellDepends = [
         async base cereal containers directory hslogger HUnit network stm
         test-framework test-framework-hunit
       ];
       homepage = "http://github.com/hargettp/courier";
       description = "A message-passing library for simplifying network applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "courier" = callPackage
    ({ mkDerivation, async, base, bytestring, cereal, containers
     , directory, hslogger, HUnit, network, stm, test-framework
     , test-framework-hunit, text, uuid
     }:
     mkDerivation {
       pname = "courier";
       version = "0.1.1.2";
       sha256 = "1b15696197ab61fb8a675541923cbe23ee75950e43657161b2460f1897b75330";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base bytestring cereal containers hslogger network stm text
         uuid
       ];
       executableHaskellDepends = [ base cereal ];
       testHaskellDepends = [
         async base cereal containers directory hslogger HUnit network stm
         test-framework test-framework-hunit
       ];
       homepage = "http://github.com/hargettp/courier";
       description = "A message-passing library for simplifying network applications";
       license = stdenv.lib.licenses.mit;
     }) {};

  "court" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, filepath
     , old-locale, optparse-applicative, process, stm, text, time, unix
     }:
     mkDerivation {
       pname = "court";
       version = "0.1.0.1";
       sha256 = "bf285d7d1071029b189098e0b137e89d54887661f1a4d55d4d4e4d6790a463fb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring directory filepath old-locale
         optparse-applicative process stm text time unix
       ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/thoferon/court";
       description = "Simple and flexible CI system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "coverage" = callPackage
    ({ mkDerivation, base, hspec, HUnit, QuickCheck }:
     mkDerivation {
       pname = "coverage";
       version = "0.1.0.4";
       sha256 = "d9b7499e5f806d4f841b52230faa752de383fa4e4129054d52ebabb4f7e782da";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec HUnit QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/nicodelpiano/coverage";
       description = "Exhaustivity Checking Library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cpio-conduit" = callPackage
    ({ mkDerivation, base, base16-bytestring, binary, bytestring
     , conduit, conduit-extra, resourcet
     }:
     mkDerivation {
       pname = "cpio-conduit";
       version = "0.7.0";
       sha256 = "8f0be7538b234496ef3b2fb2633336908ae99040ecb6d9832b3dbd1d0750f513";
       libraryHaskellDepends = [
         base base16-bytestring binary bytestring conduit conduit-extra
       ];
       testHaskellDepends = [
         base base16-bytestring binary bytestring conduit conduit-extra
         resourcet
       ];
       homepage = "http://github.com/da-x/cpio-conduit";
       description = "Conduit-based CPIO";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cplusplus-th" = callPackage
    ({ mkDerivation, base, bytestring, containers, process, QuickCheck
     , template-haskell
     }:
     mkDerivation {
       pname = "cplusplus-th";
       version = "1.0.0.0";
       sha256 = "12e7a49040c11a6a73b7e07d21248d80ac76d383461849ba22329a96cbb0ba3e";
       libraryHaskellDepends = [
         base bytestring containers process template-haskell
       ];
       testHaskellDepends = [ base process QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/nicta/cplusplus-th";
       description = "C++ Foreign Import Generation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cpphs_1_18_6" = callPackage
    ({ mkDerivation, base, directory, old-locale, old-time, polyparse
     }:
     mkDerivation {
       pname = "cpphs";
       version = "1.18.6";
       sha256 = "ac3f120aaa4d9982f8a2e63826a40b3413ed853bf04bca86e3fac5a5be084737";
       revision = "3";
       editedCabalFile = "4ae34ae875a14ddc717ecfc9afb2695b2c5052a7ac470fb562d0ba5eed7dc310";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory old-locale old-time polyparse
       ];
       executableHaskellDepends = [
         base directory old-locale old-time polyparse
       ];
       homepage = "http://projects.haskell.org/cpphs/";
       description = "A liberalised re-implementation of cpp, the C pre-processor";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cpphs_1_18_7" = callPackage
    ({ mkDerivation, base, directory, old-locale, old-time, polyparse
     }:
     mkDerivation {
       pname = "cpphs";
       version = "1.18.7";
       sha256 = "850fe0310246bdb72d7a31c617aeccadba6114973c1847719e07217ec6d90271";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory old-locale old-time polyparse
       ];
       executableHaskellDepends = [
         base directory old-locale old-time polyparse
       ];
       homepage = "http://projects.haskell.org/cpphs/";
       description = "A liberalised re-implementation of cpp, the C pre-processor";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cpphs_1_18_8" = callPackage
    ({ mkDerivation, base, directory, old-locale, old-time, polyparse
     }:
     mkDerivation {
       pname = "cpphs";
       version = "1.18.8";
       sha256 = "a3a4780f91082e23d3d7b9d0f20dde13d42641891b4c488b63fa97e0e01ebb20";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory old-locale old-time polyparse
       ];
       executableHaskellDepends = [
         base directory old-locale old-time polyparse
       ];
       homepage = "http://projects.haskell.org/cpphs/";
       description = "A liberalised re-implementation of cpp, the C pre-processor";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cpphs_1_18_9" = callPackage
    ({ mkDerivation, base, directory, old-locale, old-time, polyparse
     }:
     mkDerivation {
       pname = "cpphs";
       version = "1.18.9";
       sha256 = "06bb757e88aa3fc133235a3df87a78f08080b6b63f1577298ee6a9f963b9c92d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory old-locale old-time polyparse
       ];
       executableHaskellDepends = [
         base directory old-locale old-time polyparse
       ];
       homepage = "http://projects.haskell.org/cpphs/";
       description = "A liberalised re-implementation of cpp, the C pre-processor";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cpphs_1_19" = callPackage
    ({ mkDerivation, base, directory, old-locale, old-time, polyparse
     }:
     mkDerivation {
       pname = "cpphs";
       version = "1.19";
       sha256 = "e05c97be645eafeed5c7475f84a02016ad56eaf67ad0a725b8ebff7fbcc73e3a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory old-locale old-time polyparse
       ];
       executableHaskellDepends = [
         base directory old-locale old-time polyparse
       ];
       homepage = "http://projects.haskell.org/cpphs/";
       description = "A liberalised re-implementation of cpp, the C pre-processor";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cpphs_1_19_2" = callPackage
    ({ mkDerivation, base, directory, old-locale, old-time, polyparse
     }:
     mkDerivation {
       pname = "cpphs";
       version = "1.19.2";
       sha256 = "bb45b22d8b00605942bc2f675c43ba826e9a861cfe1474f1aad9d427e16690a4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory old-locale old-time polyparse
       ];
       executableHaskellDepends = [
         base directory old-locale old-time polyparse
       ];
       homepage = "http://projects.haskell.org/cpphs/";
       description = "A liberalised re-implementation of cpp, the C pre-processor";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cpphs" = callPackage
    ({ mkDerivation, base, directory, old-locale, old-time, polyparse
     }:
     mkDerivation {
       pname = "cpphs";
       version = "1.19.3";
       sha256 = "e2546aa382e9c22942c5c2849631edc6b1d8cbea2c50762f66b740755faf57da";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory old-locale old-time polyparse
       ];
       executableHaskellDepends = [
         base directory old-locale old-time polyparse
       ];
       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
     }:
     mkDerivation {
       pname = "cprng-aes";
       version = "0.6.1";
       sha256 = "64592a01de8c6683c5e29f538dceee918887ffe211d87214a2e38559d72c21f3";
       libraryHaskellDepends = [
         base byteable bytestring cipher-aes crypto-random
       ];
       homepage = "http://github.com/vincenthz/hs-cprng-aes";
       description = "Crypto Pseudo Random Number Generator using AES in counter mode";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cprng-aes-effect" = callPackage
    ({ mkDerivation, base, cprng-aes, crypto-random
     , crypto-random-effect, extensible-effects
     }:
     mkDerivation {
       pname = "cprng-aes-effect";
       version = "0.1.0.2";
       sha256 = "cbe94de1ebbaba64233d5f6bfbdddbd62b210d04ddcd71eb366ccbebe4818310";
       revision = "1";
       editedCabalFile = "b9752152bb1764da66976eaf18776b09dabf80eeb6f252bcee0da10fa0a1057e";
       libraryHaskellDepends = [
         base cprng-aes crypto-random crypto-random-effect
         extensible-effects
       ];
       jailbreak = true;
       homepage = "https://github.com/ibotty/crypto-random-effect";
       description = "Run random effect using cprng-aes, a crypto pseudo number generator";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cpsa" = callPackage
    ({ mkDerivation, array, base, containers, parallel }:
     mkDerivation {
       pname = "cpsa";
       version = "2.5.4";
       sha256 = "d9b1c49aace29dda1189a711888ca39c6af4ab5adb4798e65a1bef489813449e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base containers parallel ];
       description = "Symbolic cryptographic protocol analyzer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cpu" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "cpu";
       version = "0.1.2";
       sha256 = "5627feb4974a3ff8499c42cc958927e88761a2e004c4000d34e9cd6a15ad2974";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/vincenthz/hs-cpu";
       description = "Cpu information and properties helpers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cpuid" = callPackage
    ({ mkDerivation, base, data-accessor, enumset }:
     mkDerivation {
       pname = "cpuid";
       version = "0.2.3";
       sha256 = "f8198ab4408219fe001c0a50908af38a766e2a0b3afb8260307838e5517add88";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base data-accessor enumset ];
       homepage = "http://code.haskell.org/cpuid/";
       description = "Binding for the cpuid machine instruction on x86 compatible processors";
       license = "GPL";
     }) {};

  "cpuperf" = callPackage
    ({ mkDerivation, base, mtl, process }:
     mkDerivation {
       pname = "cpuperf";
       version = "0.1.1";
       sha256 = "809aaf4757f81db6563ddb1ff8122fff246cde64305ab5a98bbfcfa746cdd5f6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base mtl process ];
       homepage = "http://code.haskell.org/~dons/code/cpuperf";
       description = "Modify the cpu frequency on OpenBSD systems";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cpython" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, python34, text }:
     mkDerivation {
       pname = "cpython";
       version = "3.4.0";
       sha256 = "75424a6d82ca641a2d95eb25c298ee6ec40d974957d75056bb98b5757fe0c7c8";
       libraryHaskellDepends = [ base bytestring text ];
       libraryPkgconfigDepends = [ python34 ];
       libraryToolDepends = [ c2hs ];
       homepage = "https://john-millikin.com/software/haskell-python/";
       description = "Bindings for libpython";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {python34 = null;};

  "cql_3_0_5" = callPackage
    ({ mkDerivation, base, bytestring, cereal, Decimal, iproute
     , network, QuickCheck, tasty, tasty-quickcheck, template-haskell
     , text, time, transformers, uuid, vector
     }:
     mkDerivation {
       pname = "cql";
       version = "3.0.5";
       sha256 = "c1e07262eb6f25715165c6074e51d2b276b560bd5fc1d6211b87a7282984658b";
       libraryHaskellDepends = [
         base bytestring cereal Decimal iproute network template-haskell
         text time transformers uuid vector
       ];
       testHaskellDepends = [
         base bytestring cereal Decimal iproute network QuickCheck tasty
         tasty-quickcheck text time uuid
       ];
       jailbreak = true;
       homepage = "https://github.com/twittner/cql/";
       description = "Cassandra CQL binary protocol";
       license = stdenv.lib.licenses.mpl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cql_3_0_6" = callPackage
    ({ mkDerivation, base, bytestring, cereal, Decimal, iproute
     , network, QuickCheck, tasty, tasty-quickcheck, template-haskell
     , text, time, transformers, uuid, vector
     }:
     mkDerivation {
       pname = "cql";
       version = "3.0.6";
       sha256 = "072dec36887b4d51023f056e987e0c30d89b55e98562c0658f01f9d52c959ed9";
       libraryHaskellDepends = [
         base bytestring cereal Decimal iproute network template-haskell
         text time transformers uuid vector
       ];
       testHaskellDepends = [
         base bytestring cereal Decimal iproute network QuickCheck tasty
         tasty-quickcheck text time uuid
       ];
       homepage = "https://github.com/twittner/cql/";
       description = "Cassandra CQL binary protocol";
       license = stdenv.lib.licenses.mpl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cql" = callPackage
    ({ mkDerivation, base, bytestring, cereal, Decimal, iproute
     , network, QuickCheck, tasty, tasty-quickcheck, template-haskell
     , text, time, transformers, uuid, vector
     }:
     mkDerivation {
       pname = "cql";
       version = "3.0.7";
       sha256 = "54f8535ac3fe7abeb31557ec560f8135941346fc1ec8eb7922a9e0eda10fea76";
       libraryHaskellDepends = [
         base bytestring cereal Decimal iproute network template-haskell
         text time transformers uuid vector
       ];
       testHaskellDepends = [
         base bytestring cereal Decimal iproute network QuickCheck tasty
         tasty-quickcheck text time uuid
       ];
       homepage = "https://github.com/twittner/cql/";
       description = "Cassandra CQL binary protocol";
       license = stdenv.lib.licenses.mpl20;
     }) {};

  "cql-io_0_14_5" = callPackage
    ({ mkDerivation, async, auto-update, base, bytestring, containers
     , cql, cryptohash, data-default-class, exceptions, hashable
     , iproute, lens, monad-control, mtl, mwc-random, network
     , semigroups, stm, text, time, tinylog, transformers
     , transformers-base, uuid, vector
     }:
     mkDerivation {
       pname = "cql-io";
       version = "0.14.5";
       sha256 = "3e5edb6c79c1eae93689ccf074a26ea90312c67710115e378d2867d786d5424f";
       libraryHaskellDepends = [
         async auto-update base bytestring containers cql cryptohash
         data-default-class exceptions hashable iproute lens monad-control
         mtl mwc-random network semigroups stm text time tinylog
         transformers transformers-base uuid vector
       ];
       jailbreak = true;
       homepage = "https://github.com/twittner/cql-io/";
       description = "Cassandra CQL client";
       license = stdenv.lib.licenses.mpl20;
       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, stm, text, time, tinylog, transformers
     , transformers-base, uuid, vector
     }:
     mkDerivation {
       pname = "cql-io";
       version = "0.15.2";
       sha256 = "cba9bdaae9056151a413760e5d9dea10604a7ef90867fd2c834ddc1a5b6d5669";
       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 uuid vector
       ];
       homepage = "https://github.com/twittner/cql-io/";
       description = "Cassandra CQL client";
       license = stdenv.lib.licenses.mpl20;
     }) {};

  "cqrs" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "cqrs";
       version = "0.9.1";
       sha256 = "b5f0f5c9169ae733525c186ab5c7b3dbc3621d8375e66acbfb0872c350b31fd6";
       libraryHaskellDepends = [ base ];
       doHaddock = false;
       description = "Command-Query Responsibility Segregation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cqrs-core" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, io-streams
     , transformers, uuid-types
     }:
     mkDerivation {
       pname = "cqrs-core";
       version = "0.10.0";
       sha256 = "21d7b9b86fa7dd697df2740cdde23079f081b2bdbe851d87889eca4ebc835f9c";
       libraryHaskellDepends = [
         base bytestring containers deepseq io-streams transformers
         uuid-types
       ];
       description = "Command-Query Responsibility Segregation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cqrs-example" = callPackage
    ({ mkDerivation, aeson, async, base, blaze-builder, bytestring
     , cereal, containers, cqrs-core, cqrs-memory, deepseq, io-streams
     , random, scotty, stm, text, transformers, uuid-types, wai-extra
     , wai-middleware-static, warp
     }:
     mkDerivation {
       pname = "cqrs-example";
       version = "0.10.0";
       sha256 = "fe5348c0b29e59b313d9e0a8c9a427994038279de66fce52d88ffc505e6157b0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson async base blaze-builder bytestring cereal containers
         cqrs-core cqrs-memory deepseq io-streams random scotty stm text
         transformers uuid-types wai-extra wai-middleware-static warp
       ];
       jailbreak = true;
       description = "Example for cqrs package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cqrs-memory" = callPackage
    ({ mkDerivation, base, bytestring, containers, cqrs-core
     , cqrs-testkit, hspec, io-streams, random, stm, uuid-types
     }:
     mkDerivation {
       pname = "cqrs-memory";
       version = "0.10.0";
       sha256 = "36f053bca39da3c8e98cc8771a0b982bcbc22ae500405ea4284b1100632798f0";
       libraryHaskellDepends = [
         base bytestring containers cqrs-core io-streams stm uuid-types
       ];
       testHaskellDepends = [ base cqrs-core cqrs-testkit hspec random ];
       description = "Memory backend for the cqrs package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cqrs-postgresql" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-lexing, cqrs-core
     , cqrs-testkit, deepseq, enclosed-exceptions, hspec, io-streams
     , pg-harness-client, postgresql-libpq, random, resource-pool, text
     , time, transformers, uuid-types
     }:
     mkDerivation {
       pname = "cqrs-postgresql";
       version = "0.10.0";
       sha256 = "e4222248c3ff048a79c15a219a85c4b7f70ff0bfc3ef0fbc9d4b4f694ca0ea30";
       libraryHaskellDepends = [
         base bytestring bytestring-lexing cqrs-core deepseq
         enclosed-exceptions io-streams postgresql-libpq resource-pool text
         time transformers uuid-types
       ];
       testHaskellDepends = [
         base bytestring cqrs-core cqrs-testkit hspec io-streams
         pg-harness-client postgresql-libpq random resource-pool uuid-types
       ];
       jailbreak = true;
       description = "PostgreSQL backend for the cqrs package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cqrs-sqlite3" = callPackage
    ({ mkDerivation, base, bytestring, conduit, cqrs-test, cqrs-types
     , direct-sqlite, hspec, pool-conduit, text, transformers
     }:
     mkDerivation {
       pname = "cqrs-sqlite3";
       version = "0.9.0";
       sha256 = "503bf0160bc823b99e19e4089bdd134eb76e37c30883d662135d64a9ce2fcf20";
       libraryHaskellDepends = [
         base bytestring conduit cqrs-types direct-sqlite pool-conduit text
         transformers
       ];
       testHaskellDepends = [
         base bytestring conduit cqrs-test direct-sqlite hspec pool-conduit
         text transformers
       ];
       jailbreak = true;
       description = "SQLite3 backend for the cqrs package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cqrs-test" = callPackage
    ({ mkDerivation, base, bytestring, conduit, cqrs-types, hspec
     , HUnit, pool-conduit, stm, transformers
     }:
     mkDerivation {
       pname = "cqrs-test";
       version = "0.9.0";
       sha256 = "f4958986d121ebba797be9274b3e8841bcf1f89422d4ab87b99318769a6087c4";
       libraryHaskellDepends = [
         base bytestring conduit cqrs-types hspec HUnit pool-conduit stm
         transformers
       ];
       jailbreak = true;
       description = "Command-Query Responsibility Segregation Test Support";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cqrs-testkit" = callPackage
    ({ mkDerivation, base, bytestring, containers, cqrs-core, deepseq
     , hspec, HUnit, io-streams, lifted-base, random, transformers
     , uuid-types
     }:
     mkDerivation {
       pname = "cqrs-testkit";
       version = "0.10.0";
       sha256 = "50c8d272488a3b0ee41d2f6843608bb3d5be7b5c37bb32b5c5550ecaf0fce7d5";
       libraryHaskellDepends = [
         base bytestring containers cqrs-core deepseq hspec HUnit io-streams
         lifted-base random transformers uuid-types
       ];
       description = "Command-Query Responsibility Segregation Test Support";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cqrs-types" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "cqrs-types";
       version = "0.9.1";
       sha256 = "68ec6f54afe655e764691f30c844778913957ad9f617e3f5587032307629276e";
       libraryHaskellDepends = [ base ];
       doHaddock = false;
       description = "Command-Query Responsibility Segregation. Modules for the basic types.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cr" = callPackage
    ({ mkDerivation, base, cmdargs, directory, process, shelly, text
     , transformers, unix
     }:
     mkDerivation {
       pname = "cr";
       version = "1.2";
       sha256 = "c1c637b26cd6994c1c3747edcf951c8f83994000201cd7b0f459e485ae87ec80";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs directory process shelly text transformers unix
       ];
       homepage = "https://github.com/scvalex/cr";
       description = "Code review tool";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crack" = callPackage
    ({ mkDerivation, base, crack }:
     mkDerivation {
       pname = "crack";
       version = "0.1";
       sha256 = "33ffccecbdad718720cf305cba7c4701fdedf880d297a423fa47013cd6dedc65";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ crack ];
       description = "A haskell binding to cracklib";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {crack = null;};

  "crackNum_1_3" = callPackage
    ({ mkDerivation, base, data-binary-ieee754, ieee754 }:
     mkDerivation {
       pname = "crackNum";
       version = "1.3";
       sha256 = "48ec1bfd16da67ab655a2cd2fdbc12c4df6fb6f50f60e6964a86debdf9a76a19";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base data-binary-ieee754 ieee754 ];
       executableHaskellDepends = [ base data-binary-ieee754 ieee754 ];
       description = "Crack various integer, floating-point data formats";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crackNum" = callPackage
    ({ mkDerivation, base, data-binary-ieee754, ieee754 }:
     mkDerivation {
       pname = "crackNum";
       version = "1.5";
       sha256 = "ef41fe4afa6866a578b17f84ee231ed70493696fdca9fe54341e124215c1e205";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base data-binary-ieee754 ieee754 ];
       executableHaskellDepends = [ base data-binary-ieee754 ieee754 ];
       description = "Crack various integer, floating-point data formats";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "craftwerk" = callPackage
    ({ mkDerivation, base, colour, mtl, vector-space }:
     mkDerivation {
       pname = "craftwerk";
       version = "0.1";
       sha256 = "a39d24c7e05469883f35d642c393c04a8bca6d03d1bd41905fd5a981ddb00200";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base colour mtl vector-space ];
       jailbreak = true;
       homepage = "http://mahrz.github.com/craftwerk.html";
       description = "2D graphics library with integrated TikZ output";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "craftwerk-cairo" = callPackage
    ({ mkDerivation, base, cairo, craftwerk, mtl }:
     mkDerivation {
       pname = "craftwerk-cairo";
       version = "0.1";
       sha256 = "9f54fb8a2c38242f449649fc7912d9e0719fef76a736ea0a3a33912de841369a";
       libraryHaskellDepends = [ base cairo craftwerk mtl ];
       jailbreak = true;
       homepage = "http://mahrz.github.com/craftwerk.html";
       description = "Cairo backend for Craftwerk";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "craftwerk-gtk" = callPackage
    ({ mkDerivation, base, cairo, containers, craftwerk
     , craftwerk-cairo, gtk, mtl
     }:
     mkDerivation {
       pname = "craftwerk-gtk";
       version = "0.1";
       sha256 = "ced95080b5b735d57a13b9082ebdadf5015926f4f49a3b181a3e974ba01f66a1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cairo containers craftwerk craftwerk-cairo gtk mtl
       ];
       jailbreak = true;
       homepage = "http://mahrz.github.com/craftwerk.html";
       description = "Gtk UI for Craftwerk";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crc16" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "crc16";
       version = "0.1.1";
       sha256 = "7f1d9bfe18b26b45a42cbe3ee92e5385a7fe050b53c9042a39e4f92d30efa397";
       libraryHaskellDepends = [ base bytestring ];
       description = "Calculate the crc16-ccitt";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crc16-table" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "crc16-table";
       version = "0.1";
       sha256 = "5f38e45b6ecf2cb4e63e88d470aa542760e6e58d42097ce44cc7c8c52a1f2475";
       libraryHaskellDepends = [ array base ];
       description = "Compute CRC16 checksums using a lookup table";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "creatur" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, cereal, cond
     , directory, exceptions, filepath, gray-extended, hdaemonize
     , hsyslog, HUnit, MonadRandom, mtl, old-locale, process, QuickCheck
     , random, split, temporary, test-framework, test-framework-hunit
     , test-framework-quickcheck2, time, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "creatur";
       version = "5.9.9";
       sha256 = "3662a2b632bb86edb14b5f89d5be7cbda94401e651aa43d4e24f15ddf72aa209";
       libraryHaskellDepends = [
         array base bytestring cereal cond directory exceptions filepath
         gray-extended hdaemonize hsyslog MonadRandom mtl old-locale process
         random split time transformers unix zlib
       ];
       testHaskellDepends = [
         array base binary cereal directory filepath hsyslog HUnit
         MonadRandom mtl QuickCheck temporary test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/mhwombat/creatur";
       description = "Framework for artificial life experiments";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "crf-chain1" = callPackage
    ({ mkDerivation, array, base, binary, containers, data-lens
     , logfloat, monad-codec, parallel, random, sgd, vector
     , vector-binary, vector-th-unbox
     }:
     mkDerivation {
       pname = "crf-chain1";
       version = "0.2.2";
       sha256 = "18f2686ac1187fb1a0012e0b08f5ef9f959b26f72368917e1faae264f7ad156c";
       revision = "1";
       editedCabalFile = "a28bf6d6103c13301f352b2042eff9f7447ef623b5bbfd34c2d37121e049029a";
       libraryHaskellDepends = [
         array base binary containers data-lens logfloat monad-codec
         parallel random sgd vector vector-binary vector-th-unbox
       ];
       jailbreak = true;
       homepage = "https://github.com/kawu/crf-chain1";
       description = "First-order, linear-chain conditional random fields";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crf-chain1-constrained" = callPackage
    ({ mkDerivation, array, base, binary, containers, data-lens
     , logfloat, monad-codec, parallel, random, sgd, vector
     , vector-binary, vector-th-unbox
     }:
     mkDerivation {
       pname = "crf-chain1-constrained";
       version = "0.3.2";
       sha256 = "4a3ab2ace6b29475e0fde27dde72ab274e109b5e7715f21b73b5d26c124eae0b";
       libraryHaskellDepends = [
         array base binary containers data-lens logfloat monad-codec
         parallel random sgd vector vector-binary vector-th-unbox
       ];
       homepage = "https://github.com/kawu/crf-chain1-constrained";
       description = "First-order, constrained, linear-chain conditional random fields";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crf-chain2-generic" = callPackage
    ({ mkDerivation, array, base, binary, comonad-transformers
     , containers, data-lens, logfloat, monad-codec, parallel, sgd
     , vector, vector-binary
     }:
     mkDerivation {
       pname = "crf-chain2-generic";
       version = "0.3.0";
       sha256 = "bec3d92b03eb565f3b99d365c51160e833d948757a9d934c5d04e1e2b2289980";
       libraryHaskellDepends = [
         array base binary comonad-transformers containers data-lens
         logfloat monad-codec parallel sgd vector vector-binary
       ];
       jailbreak = true;
       homepage = "https://github.com/kawu/crf-chain2-generic";
       description = "Second-order, generic, constrained, linear conditional random fields";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crf-chain2-tiers" = callPackage
    ({ mkDerivation, array, base, binary, comonad, containers
     , data-lens, logfloat, monad-codec, parallel, sgd, vector
     , vector-binary, vector-th-unbox
     }:
     mkDerivation {
       pname = "crf-chain2-tiers";
       version = "0.2.4";
       sha256 = "21f66d385440e433b35dd621e34fdc887ac6aedf0cd1a00ee9e61845752eaa6b";
       libraryHaskellDepends = [
         array base binary comonad containers data-lens logfloat monad-codec
         parallel sgd vector vector-binary vector-th-unbox
       ];
       homepage = "https://github.com/kawu/crf-chain2-tiers";
       description = "Second-order, tiered, constrained, linear conditional random fields";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "critbit" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , QuickCheck, test-framework, test-framework-quickcheck2, text
     , transformers, vector
     }:
     mkDerivation {
       pname = "critbit";
       version = "0.2.0.0";
       sha256 = "02a9d70aef2a8dc1c06fab7deeaa7abf7eb55c5cc2443f030e723b378e54aff5";
       libraryHaskellDepends = [
         array base bytestring deepseq text vector
       ];
       testHaskellDepends = [
         base bytestring containers QuickCheck test-framework
         test-framework-quickcheck2 text transformers vector
       ];
       homepage = "https://github.com/bos/critbit";
       description = "Crit-bit maps and sets";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "criterion_1_0_2_0" = callPackage
    ({ mkDerivation, aeson, ansi-wl-pprint, base, binary, bytestring
     , cassava, containers, deepseq, directory, either, filepath, Glob
     , hastache, HUnit, mtl, mwc-random, optparse-applicative, parsec
     , QuickCheck, statistics, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time, transformers, vector
     , vector-algorithms
     }:
     mkDerivation {
       pname = "criterion";
       version = "1.0.2.0";
       sha256 = "1de2f6c9975135959fd8948ad2889310e5d19a736f9051a48c0fec081359ac0a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-wl-pprint base binary bytestring cassava containers
         deepseq directory either filepath Glob hastache mtl mwc-random
         optparse-applicative parsec statistics text time transformers
         vector vector-algorithms
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck statistics test-framework
         test-framework-hunit test-framework-quickcheck2 vector
       ];
       homepage = "http://www.serpentine.com/criterion";
       description = "Robust, reliable performance measurement and analysis";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "criterion" = callPackage
    ({ mkDerivation, aeson, ansi-wl-pprint, base, binary, bytestring
     , cassava, containers, deepseq, directory, filepath, Glob, hastache
     , HUnit, mtl, mwc-random, optparse-applicative, parsec, QuickCheck
     , statistics, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time, transformers
     , transformers-compat, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "criterion";
       version = "1.1.0.0";
       sha256 = "5cedd41bb6e5a85e65b51fdb00cb32038b826b8d18af072a8319cab43a452d38";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-wl-pprint base binary bytestring cassava containers
         deepseq directory filepath Glob hastache mtl mwc-random
         optparse-applicative parsec statistics text time transformers
         transformers-compat vector vector-algorithms
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck statistics test-framework
         test-framework-hunit test-framework-quickcheck2 vector
       ];
       homepage = "http://www.serpentine.com/criterion";
       description = "Robust, reliable performance measurement and analysis";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "criterion-plus" = callPackage
    ({ mkDerivation, base, criterion, deepseq, HTF, HUnit, loch-th
     , monad-control, mtl, optparse-applicative, placeholders
     , QuickCheck, statistics, string-conversions, system-fileio
     , system-filepath, text, th-printf, transformers, transformers-base
     , vector
     }:
     mkDerivation {
       pname = "criterion-plus";
       version = "0.1.3";
       sha256 = "b471b64718bb4d943c9b84fa0dbfd57792aa449a396fba1476ebb3272ec4f688";
       libraryHaskellDepends = [
         base criterion deepseq loch-th monad-control mtl
         optparse-applicative placeholders statistics string-conversions
         system-fileio system-filepath text th-printf transformers
         transformers-base vector
       ];
       testHaskellDepends = [
         base criterion deepseq HTF HUnit loch-th monad-control mtl
         optparse-applicative placeholders QuickCheck statistics
         string-conversions system-fileio system-filepath text th-printf
         transformers transformers-base vector
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/criterion-plus";
       description = "Enhancement of the \"criterion\" benchmarking library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "criterion-to-html" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , containers, filepath
     }:
     mkDerivation {
       pname = "criterion-to-html";
       version = "0.0.0.3";
       sha256 = "b627a4f4ef19ca7a7b7eff0fbc9b32d213cf683da04fc7c21dfcc6f799291d04";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers filepath
       ];
       jailbreak = true;
       homepage = "http://github.com/jaspervdj/criterion-to-html";
       description = "Convert criterion output to HTML reports";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "crockford" = callPackage
    ({ mkDerivation, base, digits, QuickCheck, safe }:
     mkDerivation {
       pname = "crockford";
       version = "0.2";
       sha256 = "463c5dbde6612479eae43915baa3501804520c4bd880fdc63a326c3085abfab9";
       libraryHaskellDepends = [ base digits QuickCheck safe ];
       description = "An implementation of Douglas Crockford's base32 encoding";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "crocodile" = callPackage
    ({ mkDerivation, base, bmp, bytestring, deepseq, ghc-prim, heap
     , HUnit, mersenne-random-pure64, mtl, parallel
     }:
     mkDerivation {
       pname = "crocodile";
       version = "0.1.2";
       sha256 = "6800bfb7a0c1a5605dd44295308eb07047ea11bb967361799726a6e58b653bcf";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bmp bytestring deepseq ghc-prim heap HUnit
         mersenne-random-pure64 mtl parallel
       ];
       homepage = "https://github.com/TomHammersley/HaskellRenderer/";
       description = "An offline renderer supporting ray tracing and photon mapping";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cron_0_3_0" = callPackage
    ({ mkDerivation, attoparsec, base, derive, hspec
     , hspec-expectations, mtl, mtl-compat, old-locale, QuickCheck, text
     , time, transformers-compat
     }:
     mkDerivation {
       pname = "cron";
       version = "0.3.0";
       sha256 = "3369302abbf131db159c4a4a8666d93e8dfbd4478c9aa56ca9d0ff45926bcaa3";
       libraryHaskellDepends = [
         attoparsec base mtl mtl-compat old-locale text time
       ];
       testHaskellDepends = [
         attoparsec base derive hspec hspec-expectations QuickCheck text
         time transformers-compat
       ];
       homepage = "http://github.com/michaelxavier/cron";
       description = "Cron datatypes and Attoparsec parser";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cron" = callPackage
    ({ mkDerivation, attoparsec, base, derive, mtl, mtl-compat
     , old-locale, tasty, tasty-hunit, tasty-quickcheck, text, time
     , transformers-compat
     }:
     mkDerivation {
       pname = "cron";
       version = "0.3.2";
       sha256 = "d20917bef00c1bf8b5edbd274292defa951ac1dc734f972c00d27e4ad9356086";
       libraryHaskellDepends = [
         attoparsec base mtl mtl-compat old-locale text time
       ];
       testHaskellDepends = [
         attoparsec base derive tasty tasty-hunit tasty-quickcheck text time
         transformers-compat
       ];
       doCheck = false;
       homepage = "http://github.com/michaelxavier/cron";
       description = "Cron datatypes and Attoparsec parser";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cron-compat" = callPackage
    ({ mkDerivation, attoparsec, base, cron, derive, hspec
     , hspec-expectations, mtl, mtl-compat, old-locale, QuickCheck, text
     , time, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "cron-compat";
       version = "0.2.6";
       sha256 = "ddddc399995d4e23eba6b17e75999332abd3f0ddb7af5d93ca7763d78704a74e";
       libraryHaskellDepends = [
         attoparsec base mtl mtl-compat old-locale text time
         transformers-compat
       ];
       testHaskellDepends = [
         attoparsec base cron derive hspec hspec-expectations QuickCheck
         text time transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/michaelxavier/cron";
       description = "Cron datatypes and Attoparsec parser";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cruncher-types" = callPackage
    ({ mkDerivation, aeson, base, containers, hlint, lens, text }:
     mkDerivation {
       pname = "cruncher-types";
       version = "1.1.0";
       sha256 = "302de122ae22bbe6365c924743991ae42bf3ccfed06b56e614c1be5d51dde04e";
       libraryHaskellDepends = [ aeson base containers lens text ];
       testHaskellDepends = [ base hlint ];
       homepage = "http://github.com/eval-so/cruncher-types";
       description = "Request and Response types for Eval.so's API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crunghc" = callPackage
    ({ mkDerivation, base, bytestring, directory, filelock, filepath
     , process, SHA, text, time, transformers, unix
     }:
     mkDerivation {
       pname = "crunghc";
       version = "0.1.1.1";
       sha256 = "154ff77bcc1f4828c09d2f28748416664f080919358ad826b5e028d6760d6420";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory filelock filepath process SHA text time
         transformers unix
       ];
       jailbreak = true;
       description = "A runghc replacement with transparent caching";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crypto-api" = callPackage
    ({ mkDerivation, base, bytestring, cereal, entropy, tagged
     , transformers
     }:
     mkDerivation {
       pname = "crypto-api";
       version = "0.13.2";
       sha256 = "5331d511a9761d5073e6661148234228d88f8ace14e2994171f0bcf5183e82ed";
       libraryHaskellDepends = [
         base bytestring cereal entropy tagged transformers
       ];
       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, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "crypto-api-tests";
       version = "0.3";
       sha256 = "f44aecdd4ceb9da9f38330e84d9c17745a82b0611085ebb34442d2dce4207270";
       libraryHaskellDepends = [
         base bytestring cereal crypto-api directory filepath HUnit
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       homepage = "http://trac.haskell.org/crypto-api/wiki";
       description = "A test framework and KATs for cryptographic operations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "crypto-cipher-benchmarks" = callPackage
    ({ mkDerivation, base, byteable, bytestring, criterion
     , crypto-cipher-types, mtl, pretty, securemem
     }:
     mkDerivation {
       pname = "crypto-cipher-benchmarks";
       version = "0.0.5";
       sha256 = "185a750a8bc396f7c0dcef2b686be6f17cb0a9413c2ea7cea83beb611df8beb5";
       libraryHaskellDepends = [
         base byteable bytestring criterion crypto-cipher-types mtl pretty
         securemem
       ];
       homepage = "http://github.com/vincenthz/hs-crypto-cipher";
       description = "Generic cryptography cipher benchmarks";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crypto-cipher-tests" = callPackage
    ({ mkDerivation, base, byteable, bytestring, crypto-cipher-types
     , HUnit, mtl, QuickCheck, securemem, 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
       ];
       testHaskellDepends = [
         base byteable bytestring crypto-cipher-types HUnit mtl QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       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 }:
     mkDerivation {
       pname = "crypto-cipher-types";
       version = "0.0.9";
       sha256 = "2073f6b70df7916aebe2da49d224497183662d56d19da87b76f70039430c0a0f";
       libraryHaskellDepends = [ base byteable bytestring securemem ];
       homepage = "http://github.com/vincenthz/hs-crypto-cipher";
       description = "Generic cryptography cipher types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "crypto-classical" = callPackage
    ({ mkDerivation, base, bytestring, containers, crypto-numbers
     , crypto-random, microlens, microlens-th, modular-arithmetic
     , QuickCheck, random, random-shuffle, text, transformers
     }:
     mkDerivation {
       pname = "crypto-classical";
       version = "0.2.0";
       sha256 = "8911490fc1f12ee76593552aa601f000359cafc4596eab7c98562d5bb8ded83e";
       libraryHaskellDepends = [
         base bytestring containers crypto-numbers crypto-random microlens
         microlens-th modular-arithmetic QuickCheck random random-shuffle
         text transformers
       ];
       homepage = "https://github.com/fosskers/crypto-classical";
       description = "An educational tool for studying classical cryptography schemes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "crypto-conduit" = callPackage
    ({ mkDerivation, base, bytestring, cereal, conduit, conduit-extra
     , crypto-api, cryptocipher, cryptohash-cryptoapi, hspec, resourcet
     , skein, transformers
     }:
     mkDerivation {
       pname = "crypto-conduit";
       version = "0.5.5";
       sha256 = "ced360b56aba0d669e11af90fa603e68911e802f0e7d44750d5dcc3c64d5a47d";
       libraryHaskellDepends = [
         base bytestring cereal conduit conduit-extra crypto-api resourcet
         transformers
       ];
       testHaskellDepends = [
         base bytestring cereal conduit conduit-extra crypto-api
         cryptocipher cryptohash-cryptoapi hspec skein transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/prowdsponsor/crypto-conduit";
       description = "Conduit interface for cryptographic operations (from crypto-api)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "crypto-enigma" = callPackage
    ({ mkDerivation, base, containers, HUnit, MissingH, mtl, QuickCheck
     , split
     }:
     mkDerivation {
       pname = "crypto-enigma";
       version = "0.0.2.6";
       sha256 = "eb162e2b4ea2d73bb3594e12438f02988e338ae58c602e817a31970163533142";
       revision = "1";
       editedCabalFile = "4cc74c0744e15e1149d7419e47232db6f0bf53a56360f35d71665b180c2f2a53";
       libraryHaskellDepends = [ base containers MissingH mtl split ];
       testHaskellDepends = [ base HUnit QuickCheck ];
       homepage = "https://github.com/orome/crypto-enigma-hs";
       description = "An Enigma machine simulator with display";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "crypto-numbers_0_2_3" = callPackage
    ({ mkDerivation, base, byteable, bytestring, crypto-random, HUnit
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "crypto-numbers";
       version = "0.2.3";
       sha256 = "f77dabd4dd6aa6343ba351b2ae1c55e4b9ef85c7911eadf6914704401cada25b";
       revision = "4";
       editedCabalFile = "696ab7efd05590e0a45b905855e89493fe79e841291fdd45186b4215b6f7f6d2";
       libraryHaskellDepends = [ base bytestring crypto-random vector ];
       testHaskellDepends = [
         base byteable bytestring crypto-random HUnit QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
         vector
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://github.com/vincenthz/hs-crypto-numbers";
       description = "Cryptographic numbers: functions and algorithms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crypto-numbers" = callPackage
    ({ mkDerivation, base, byteable, bytestring, crypto-random
     , ghc-prim, integer-gmp, tasty, tasty-hunit, tasty-quickcheck
     , vector
     }:
     mkDerivation {
       pname = "crypto-numbers";
       version = "0.2.7";
       sha256 = "420aeb17e9cdcfdf8c950c6c6f10c54503c5524d36f611aa7238e3fd65f189a6";
       revision = "1";
       editedCabalFile = "2b493386b7605b70a67f751d6496e9feff8ef319a5294b122a3ff3895a8453ca";
       libraryHaskellDepends = [
         base bytestring crypto-random ghc-prim integer-gmp vector
       ];
       testHaskellDepends = [
         base byteable bytestring crypto-random tasty tasty-hunit
         tasty-quickcheck vector
       ];
       doCheck = false;
       homepage = "https://github.com/vincenthz/hs-crypto-numbers";
       description = "Cryptographic numbers: functions and algorithms";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "crypto-pubkey_0_2_5" = callPackage
    ({ mkDerivation, base, byteable, bytestring, crypto-numbers
     , crypto-pubkey-types, crypto-random, cryptohash, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "crypto-pubkey";
       version = "0.2.5";
       sha256 = "b8d301dbbc232c4d1b5f2cc946cc34d63ca1a4e1b78823b4251dddfeaaa93da3";
       libraryHaskellDepends = [
         base byteable bytestring crypto-numbers crypto-pubkey-types
         crypto-random cryptohash
       ];
       testHaskellDepends = [
         base byteable bytestring crypto-numbers crypto-pubkey-types
         crypto-random cryptohash HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "http://github.com/vincenthz/hs-crypto-pubkey";
       description = "Public Key cryptography";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crypto-pubkey_0_2_6" = callPackage
    ({ mkDerivation, base, byteable, bytestring, crypto-numbers
     , crypto-pubkey-types, crypto-random, cryptohash, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "crypto-pubkey";
       version = "0.2.6";
       sha256 = "ff754de36002f55f4f482b54bdc97688d149da0140070102991515fb830192a7";
       libraryHaskellDepends = [
         base byteable bytestring crypto-numbers crypto-pubkey-types
         crypto-random cryptohash
       ];
       testHaskellDepends = [
         base byteable bytestring crypto-numbers crypto-pubkey-types
         crypto-random cryptohash HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "http://github.com/vincenthz/hs-crypto-pubkey";
       description = "Public Key cryptography";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crypto-pubkey_0_2_7" = callPackage
    ({ mkDerivation, base, byteable, bytestring, crypto-numbers
     , crypto-pubkey-types, crypto-random, cryptohash, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "crypto-pubkey";
       version = "0.2.7";
       sha256 = "e0ca763a81de7fcfaf229bfb4061b58efcb52a551209478672cb6994aab72578";
       libraryHaskellDepends = [
         base byteable bytestring crypto-numbers crypto-pubkey-types
         crypto-random cryptohash
       ];
       testHaskellDepends = [
         base byteable bytestring crypto-numbers crypto-pubkey-types
         crypto-random cryptohash HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "https://github.com/vincenthz/hs-crypto-pubkey";
       description = "Public Key cryptography";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crypto-pubkey" = callPackage
    ({ mkDerivation, base, byteable, bytestring, crypto-numbers
     , crypto-pubkey-types, crypto-random, cryptohash, tasty
     , tasty-hunit, tasty-kat, tasty-quickcheck
     }:
     mkDerivation {
       pname = "crypto-pubkey";
       version = "0.2.8";
       sha256 = "c0ccf2f5c38517de1f1626cb0a2542f35aefad8842f8ad5c1fac0b8c9de8b56e";
       libraryHaskellDepends = [
         base byteable bytestring crypto-numbers crypto-pubkey-types
         crypto-random cryptohash
       ];
       testHaskellDepends = [
         base byteable bytestring crypto-numbers crypto-pubkey-types
         crypto-random cryptohash tasty tasty-hunit tasty-kat
         tasty-quickcheck
       ];
       doCheck = false;
       homepage = "https://github.com/vincenthz/hs-crypto-pubkey";
       description = "Public Key cryptography";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "crypto-pubkey-openssh" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, attoparsec, base
     , base64-bytestring, bytestring, cereal, crypto-pubkey-types
     , deepseq, filepath, pem, process, QuickCheck, tasty
     , tasty-quickcheck, temporary
     }:
     mkDerivation {
       pname = "crypto-pubkey-openssh";
       version = "0.2.7";
       sha256 = "849085c854c561b94974f2086bf1ad4004fb17be7168b75068ab0f2a330bab59";
       libraryHaskellDepends = [
         asn1-encoding asn1-types attoparsec base base64-bytestring
         bytestring cereal crypto-pubkey-types pem
       ];
       testHaskellDepends = [
         asn1-encoding asn1-types attoparsec base base64-bytestring
         bytestring cereal crypto-pubkey-types deepseq filepath pem process
         QuickCheck tasty tasty-quickcheck temporary
       ];
       homepage = "https://github.com/knsd/crypto-pubkey-openssh";
       description = "OpenSSH keys decoder/encoder";
       license = stdenv.lib.licenses.mit;
     }) {};

  "crypto-pubkey-types_0_4_2_3" = callPackage
    ({ mkDerivation, asn1-types, base }:
     mkDerivation {
       pname = "crypto-pubkey-types";
       version = "0.4.2.3";
       sha256 = "a2f4bc75638f78be27d181b9971afe613d0813f34b5eaa5b441b264f43f64ec7";
       libraryHaskellDepends = [ asn1-types base ];
       homepage = "http://github.com/vincenthz/hs-crypto-pubkey-types";
       description = "Generic cryptography Public keys algorithm types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crypto-pubkey-types" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base }:
     mkDerivation {
       pname = "crypto-pubkey-types";
       version = "0.4.3";
       sha256 = "7ed9f52281ec4e34021a91818fe45288e33d65bff937f60334a3f45be5a71c60";
       libraryHaskellDepends = [ asn1-encoding asn1-types base ];
       homepage = "http://github.com/vincenthz/hs-crypto-pubkey-types";
       description = "Generic cryptography Public keys algorithm types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "crypto-random_0_0_8" = callPackage
    ({ mkDerivation, base, bytestring, securemem, unix, vector }:
     mkDerivation {
       pname = "crypto-random";
       version = "0.0.8";
       sha256 = "7b2e5e2e2a1863d346e3c3fdfef652e087ad6176ac88fede8ab9445b40a51115";
       libraryHaskellDepends = [ base bytestring securemem unix vector ];
       homepage = "http://github.com/vincenthz/hs-crypto-random";
       description = "Simple cryptographic random related types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crypto-random" = callPackage
    ({ mkDerivation, base, bytestring, securemem, unix, vector }:
     mkDerivation {
       pname = "crypto-random";
       version = "0.0.9";
       sha256 = "170a7a18441379c2d1c19b502ee5919026a19adc6e78641cd4fb40b1d69a6904";
       libraryHaskellDepends = [ base bytestring securemem unix vector ];
       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 }:
     mkDerivation {
       pname = "crypto-random-api";
       version = "0.2.0";
       sha256 = "56e9777061bd9ce553683d097ba3a11fdc371724060b62ca103f1f291f9f897c";
       libraryHaskellDepends = [ base bytestring entropy ];
       homepage = "http://github.com/vincenthz/hs-crypto-random-api";
       description = "Simple random generators API for cryptography related code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "crypto-random-effect" = callPackage
    ({ mkDerivation, base, bytestring, crypto-random
     , extensible-effects, securemem, transformers
     }:
     mkDerivation {
       pname = "crypto-random-effect";
       version = "0.2.0.4.1";
       sha256 = "9977b1c64a2bc8922705f7c3dea74b7e5199fda8d892ede1d35ba6134d0644be";
       revision = "1";
       editedCabalFile = "f217573816b1efe3fcc9b1dcbd6325015bc9a87872200547f56a80ec2b959c31";
       libraryHaskellDepends = [
         base bytestring crypto-random extensible-effects securemem
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/ibotty/crypto-random-effect";
       description = "A random effect using crypto-random";
       license = stdenv.lib.licenses.mit;
     }) {};

  "crypto-totp" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, cryptohash
     , tagged, unix
     }:
     mkDerivation {
       pname = "crypto-totp";
       version = "0.1.0.1";
       sha256 = "bae10b9f72cc660261d2dd2c8b975efb8951b95eabbd7385252b83db959f726e";
       libraryHaskellDepends = [
         base bytestring cereal containers cryptohash tagged unix
       ];
       description = "Provides generation and verification services for time-based one-time keys";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cryptocipher" = callPackage
    ({ mkDerivation, base, cipher-aes, cipher-blowfish, cipher-camellia
     , cipher-des, cipher-rc4, crypto-cipher-types
     }:
     mkDerivation {
       pname = "cryptocipher";
       version = "0.6.2";
       sha256 = "34b9e62dee36c4019dd0c0e86576295d0bd1bb573eeb24686ec635a09550e346";
       libraryHaskellDepends = [
         base cipher-aes cipher-blowfish cipher-camellia cipher-des
         cipher-rc4 crypto-cipher-types
       ];
       homepage = "http://github.com/vincenthz/hs-crypto-cipher";
       description = "Symmetrical block and stream ciphers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cryptohash" = callPackage
    ({ mkDerivation, base, byteable, bytestring, ghc-prim, HUnit
     , QuickCheck, tasty, tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "cryptohash";
       version = "0.11.6";
       sha256 = "da382334857a88f3e94ce0fb83f425f0a0787b0644100913c61f6e94bb62df37";
       libraryHaskellDepends = [ base byteable bytestring ghc-prim ];
       testHaskellDepends = [
         base byteable bytestring HUnit QuickCheck tasty tasty-hunit
         tasty-quickcheck
       ];
       homepage = "http://github.com/vincenthz/hs-cryptohash";
       description = "collection of crypto hashes, fast, pure and practical";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cryptohash-conduit" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , cryptohash, resourcet, transformers
     }:
     mkDerivation {
       pname = "cryptohash-conduit";
       version = "0.1.1";
       sha256 = "ea516d898d3e34dae6be3e8bc59c9f61a61cb1222233dbfe84a84bb0ded4b4ce";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra cryptohash resourcet
         transformers
       ];
       homepage = "http://github.com/vincenthz/hs-cryptohash-conduit";
       description = "cryptohash conduit";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cryptohash-cryptoapi" = callPackage
    ({ mkDerivation, base, bytestring, cereal, crypto-api, cryptohash
     , tagged
     }:
     mkDerivation {
       pname = "cryptohash-cryptoapi";
       version = "0.1.3";
       sha256 = "56f080ba13b891b664bd986db17d6c1240adaea4792a14c173146929c61d4572";
       libraryHaskellDepends = [
         base bytestring cereal crypto-api cryptohash tagged
       ];
       homepage = "http://github.com/vincenthz/hs-cryptohash-cryptoapi";
       description = "Crypto-api interfaces for cryptohash";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cryptol_2_2_1" = callPackage
    ({ mkDerivation, alex, ansi-terminal, array, async, base
     , containers, deepseq, directory, filepath, gitrev, GraphSCC, happy
     , haskeline, heredoc, monadLib, old-time, presburger, pretty
     , process, QuickCheck, random, sbv, smtLib, syb, template-haskell
     , text, tf-random, transformers, utf8-string
     }:
     mkDerivation {
       pname = "cryptol";
       version = "2.2.1";
       sha256 = "e7b14148edd3e437245f3180a7fc8d123d5675761126740559fe79b0a71cb419";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array async base containers deepseq directory filepath gitrev
         GraphSCC heredoc monadLib old-time presburger pretty process
         QuickCheck random sbv smtLib syb template-haskell text tf-random
         transformers utf8-string
       ];
       libraryToolDepends = [ alex happy ];
       executableHaskellDepends = [
         ansi-terminal base containers deepseq directory filepath haskeline
         monadLib process random sbv tf-random transformers
       ];
       homepage = "http://www.cryptol.net/";
       description = "Cryptol: The Language of Cryptography";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cryptol_2_2_2" = callPackage
    ({ mkDerivation, alex, ansi-terminal, array, async, base
     , containers, deepseq, directory, filepath, gitrev, GraphSCC, happy
     , haskeline, heredoc, monadLib, old-time, presburger, pretty
     , process, QuickCheck, random, sbv, smtLib, syb, template-haskell
     , text, tf-random, transformers, utf8-string
     }:
     mkDerivation {
       pname = "cryptol";
       version = "2.2.2";
       sha256 = "4034a597d2b52f9bdbb2d6d4da9eb432a9130ee21eba5fead151c7b9bbcc16e7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array async base containers deepseq directory filepath gitrev
         GraphSCC heredoc monadLib old-time presburger pretty process
         QuickCheck random sbv smtLib syb template-haskell text tf-random
         transformers utf8-string
       ];
       libraryToolDepends = [ alex happy ];
       executableHaskellDepends = [
         ansi-terminal base containers deepseq directory filepath haskeline
         monadLib process random sbv tf-random transformers
       ];
       jailbreak = true;
       homepage = "http://www.cryptol.net/";
       description = "Cryptol: The Language of Cryptography";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cryptol_2_2_4" = callPackage
    ({ mkDerivation, alex, ansi-terminal, array, async, base
     , containers, deepseq, directory, filepath, gitrev, GraphSCC, happy
     , haskeline, heredoc, monadLib, old-time, presburger, pretty
     , process, QuickCheck, random, sbv, smtLib, syb, template-haskell
     , text, tf-random, transformers, utf8-string
     }:
     mkDerivation {
       pname = "cryptol";
       version = "2.2.4";
       sha256 = "df88bdf50383244be60b89af1ef3b69f8870802ac237bf6c9bda9837c5894a1d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array async base containers deepseq directory filepath gitrev
         GraphSCC heredoc monadLib old-time presburger pretty process
         QuickCheck random sbv smtLib syb template-haskell text tf-random
         transformers utf8-string
       ];
       libraryToolDepends = [ alex happy ];
       executableHaskellDepends = [
         ansi-terminal base containers deepseq directory filepath haskeline
         monadLib process random sbv tf-random transformers
       ];
       homepage = "http://www.cryptol.net/";
       description = "Cryptol: The Language of Cryptography";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cryptol_2_2_5" = callPackage
    ({ mkDerivation, alex, ansi-terminal, array, async, base
     , containers, deepseq, directory, filepath, gitrev, GraphSCC, happy
     , haskeline, heredoc, monadLib, old-time, presburger, pretty
     , process, QuickCheck, random, sbv, smtLib, syb, template-haskell
     , text, tf-random, transformers, utf8-string
     }:
     mkDerivation {
       pname = "cryptol";
       version = "2.2.5";
       sha256 = "805b80aefc23144eccdb37884a1597f3047d360efdc23094dd98441f12790282";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array async base containers deepseq directory filepath gitrev
         GraphSCC heredoc monadLib old-time presburger pretty process
         QuickCheck random sbv smtLib syb template-haskell text tf-random
         transformers utf8-string
       ];
       libraryToolDepends = [ alex happy ];
       executableHaskellDepends = [
         ansi-terminal base containers deepseq directory filepath haskeline
         monadLib process random sbv tf-random transformers
       ];
       jailbreak = true;
       homepage = "http://www.cryptol.net/";
       description = "Cryptol: The Language of Cryptography";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cryptol_2_2_6" = callPackage
    ({ mkDerivation, alex, ansi-terminal, array, async, base
     , base-compat, containers, deepseq, directory, filepath, gitrev
     , GraphSCC, happy, haskeline, heredoc, monadLib, old-time
     , presburger, pretty, process, QuickCheck, random, sbv, smtLib, syb
     , template-haskell, text, tf-random, transformers, utf8-string
     }:
     mkDerivation {
       pname = "cryptol";
       version = "2.2.6";
       sha256 = "8fb05368e34f78b5c3872ff7b495bd3d4c21e9de7a0d72fc07cc79f93dc18cf3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array async base base-compat containers deepseq directory filepath
         gitrev GraphSCC heredoc monadLib old-time presburger pretty process
         QuickCheck random sbv smtLib syb template-haskell text tf-random
         transformers utf8-string
       ];
       libraryToolDepends = [ alex happy ];
       executableHaskellDepends = [
         ansi-terminal base containers deepseq directory filepath haskeline
         monadLib process random sbv tf-random transformers
       ];
       homepage = "http://www.cryptol.net/";
       description = "Cryptol: The Language of Cryptography";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cryptol" = callPackage
    ({ mkDerivation, alex, ansi-terminal, array, async, base
     , base-compat, bytestring, containers, deepseq, deepseq-generics
     , directory, filepath, generic-trie, gitrev, GraphSCC, happy
     , haskeline, heredoc, monad-control, monadLib, old-time, presburger
     , pretty, process, QuickCheck, random, sbv, simple-smt, smtLib, syb
     , template-haskell, text, tf-random, transformers
     , transformers-base, utf8-string
     }:
     mkDerivation {
       pname = "cryptol";
       version = "2.3.0";
       sha256 = "403577bb14a3ebb5683b2221d9b424ff53b8e8faddb64b27f47a6b00414138ce";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array async base base-compat bytestring containers deepseq
         deepseq-generics directory filepath generic-trie gitrev GraphSCC
         heredoc monad-control monadLib old-time presburger pretty process
         QuickCheck random sbv simple-smt smtLib syb template-haskell text
         tf-random transformers transformers-base utf8-string
       ];
       libraryToolDepends = [ alex happy ];
       executableHaskellDepends = [
         ansi-terminal base base-compat containers deepseq directory
         filepath haskeline monad-control monadLib process random sbv
         tf-random transformers
       ];
       homepage = "http://www.cryptol.net/";
       description = "Cryptol: The Language of Cryptography";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cryptonite_0_6" = callPackage
    ({ mkDerivation, base, byteable, bytestring, deepseq, ghc-prim
     , integer-gmp, memory, tasty, tasty-hunit, tasty-kat
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "cryptonite";
       version = "0.6";
       sha256 = "a016ccaa38579beb4517807a8917801baf6e6ddb830a74af91fc064c35acf853";
       libraryHaskellDepends = [
         base bytestring deepseq ghc-prim integer-gmp memory
       ];
       testHaskellDepends = [
         base byteable bytestring memory tasty tasty-hunit tasty-kat
         tasty-quickcheck
       ];
       homepage = "https://github.com/vincenthz/cryptonite";
       description = "Cryptography Primitives sink";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cryptonite_0_10" = callPackage
    ({ mkDerivation, base, byteable, bytestring, deepseq, ghc-prim
     , integer-gmp, memory, tasty, tasty-hunit, tasty-kat
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "cryptonite";
       version = "0.10";
       sha256 = "55343f018f78de480ea1e7f09dd72307ce0b5eb5e82331512370d5b01ac9735b";
       libraryHaskellDepends = [
         base bytestring deepseq ghc-prim integer-gmp memory
       ];
       testHaskellDepends = [
         base byteable bytestring memory tasty tasty-hunit tasty-kat
         tasty-quickcheck
       ];
       homepage = "https://github.com/haskell-crypto/cryptonite";
       description = "Cryptography Primitives sink";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cryptonite" = callPackage
    ({ mkDerivation, base, byteable, bytestring, deepseq, ghc-prim
     , integer-gmp, memory, tasty, tasty-hunit, tasty-kat
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "cryptonite";
       version = "0.12";
       sha256 = "8ab0570f6f0864004d6bdce012aaafbf365a45b1721061c7d35554b92f1ababd";
       libraryHaskellDepends = [
         base bytestring deepseq ghc-prim integer-gmp memory
       ];
       testHaskellDepends = [
         base byteable bytestring memory tasty tasty-hunit tasty-kat
         tasty-quickcheck
       ];
       homepage = "https://github.com/haskell-crypto/cryptonite";
       description = "Cryptography Primitives sink";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cryptsy-api" = callPackage
    ({ mkDerivation, aeson, base, bytestring, deepseq, either
     , http-client, http-client-tls, old-locale, pipes-attoparsec
     , pipes-http, text, time, transformers, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "cryptsy-api";
       version = "0.2.1";
       sha256 = "7a7980ac98b202a60c88f2d77045df57ec607e4a993b2bd43c39137f0efcd6ce";
       libraryHaskellDepends = [
         aeson base bytestring deepseq either http-client http-client-tls
         old-locale pipes-attoparsec pipes-http text time transformers
         unordered-containers vector
       ];
       jailbreak = true;
       description = "Bindings for Cryptsy cryptocurrency exchange API";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "crystalfontz" = callPackage
    ({ mkDerivation, base, crc16-table, MaybeT, serialport }:
     mkDerivation {
       pname = "crystalfontz";
       version = "0.1";
       sha256 = "bbbfc0aafde40383f027279010c2ece86004ded26d9da06f6476b2375102b092";
       libraryHaskellDepends = [ base crc16-table MaybeT serialport ];
       description = "Control Crystalfontz LCD displays";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cse-ghc-plugin" = callPackage
    ({ mkDerivation, base, ghc }:
     mkDerivation {
       pname = "cse-ghc-plugin";
       version = "0.1.1";
       sha256 = "2e11a8d5990a44138712065184c37d72c5b1d262c65d8575a6482e9623087d88";
       libraryHaskellDepends = [ base ghc ];
       homepage = "http://thoughtpolice.github.com/cse-ghc-plugin";
       description = "Compiler plugin for common subexpression elimination";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "csound-catalog" = callPackage
    ({ mkDerivation, base, csound-expression, csound-sampler
     , sharc-timbre, transformers
     }:
     mkDerivation {
       pname = "csound-catalog";
       version = "0.4.0";
       sha256 = "721440f3f891f3117fd38042ad8111b9a23dc0259ea51c177b17115763bac157";
       libraryHaskellDepends = [
         base csound-expression csound-sampler sharc-timbre transformers
       ];
       homepage = "https://github.com/anton-k/csound-catalog";
       description = "a gallery of Csound instruments";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "csound-expression" = callPackage
    ({ mkDerivation, base, Boolean, colour, containers
     , csound-expression-dynamic, csound-expression-opcodes
     , csound-expression-typed, data-default, process, temporal-media
     , transformers
     }:
     mkDerivation {
       pname = "csound-expression";
       version = "4.9.1";
       sha256 = "c0dcb47cba9902f81bd3567ad79250a6cc2c4b421da3f0ffea40dfcace513d23";
       libraryHaskellDepends = [
         base Boolean colour containers csound-expression-dynamic
         csound-expression-opcodes csound-expression-typed data-default
         process temporal-media transformers
       ];
       homepage = "https://github.com/anton-k/csound-expression";
       description = "library to make electronic music";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "csound-expression-dynamic" = callPackage
    ({ mkDerivation, array, base, Boolean, containers, data-default
     , data-fix, data-fix-cse, hashable, transformers, wl-pprint
     }:
     mkDerivation {
       pname = "csound-expression-dynamic";
       version = "0.1.5";
       sha256 = "65a80a536d28e5e8b55e3aed7121df88635636a5b337f7706301a319edbcf80c";
       libraryHaskellDepends = [
         array base Boolean containers data-default data-fix data-fix-cse
         hashable transformers wl-pprint
       ];
       homepage = "https://github.com/anton-k/csound-expression-dynamic";
       description = "dynamic core for csound-expression library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "csound-expression-opcodes" = callPackage
    ({ mkDerivation, base, csound-expression-dynamic
     , csound-expression-typed, transformers
     }:
     mkDerivation {
       pname = "csound-expression-opcodes";
       version = "0.0.3";
       sha256 = "65e954adabbd4e4949f2782063ee97f8df9861f4c277b5130e23ea9b6de6f638";
       libraryHaskellDepends = [
         base csound-expression-dynamic csound-expression-typed transformers
       ];
       description = "opcodes for the library csound-expression";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "csound-expression-typed" = callPackage
    ({ mkDerivation, base, Boolean, colour, containers
     , csound-expression-dynamic, data-default, deepseq, ghc-prim
     , hashable, temporal-media, transformers, wl-pprint
     }:
     mkDerivation {
       pname = "csound-expression-typed";
       version = "0.0.9.1";
       sha256 = "d578b5bae42df143962d2d1121385a4dea39d751eaebbe11f07e08b615320a12";
       libraryHaskellDepends = [
         base Boolean colour containers csound-expression-dynamic
         data-default deepseq ghc-prim hashable temporal-media transformers
         wl-pprint
       ];
       homepage = "https://github.com/anton-k/csound-expression-typed";
       description = "typed core for the library csound-expression";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "csound-sampler" = callPackage
    ({ mkDerivation, base, csound-expression, transformers }:
     mkDerivation {
       pname = "csound-sampler";
       version = "0.0.6.4";
       sha256 = "e3928a9f104b4c81ed9b4724a3f8352b7fbf2b1df60ebec66c45d2ddbac950d6";
       libraryHaskellDepends = [ base csound-expression transformers ];
       homepage = "https://github.com/anton-k/csound-sampler";
       description = "A musical sampler based on Csound";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "csp" = callPackage
    ({ mkDerivation, base, containers, mtl, nondeterminism, tasty
     , tasty-hunit
     }:
     mkDerivation {
       pname = "csp";
       version = "1.3";
       sha256 = "8be3102fda62818d3ccb4649dc73b8cb6bb29d9620d7284023475297c6efdd32";
       libraryHaskellDepends = [ base containers mtl nondeterminism ];
       testHaskellDepends = [ base nondeterminism tasty tasty-hunit ];
       description = "Discrete constraint satisfaction problem (CSP) solver";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cspmchecker" = callPackage
    ({ mkDerivation, base, directory, filepath, haskeline, libcspm, mtl
     }:
     mkDerivation {
       pname = "cspmchecker";
       version = "1.0.0";
       sha256 = "6168f7bdaa7a58fcd201dfd0b5143dd35a01aeffda9d2ba03bcaf0f7b627e9fb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath haskeline libcspm mtl
       ];
       homepage = "https://github.com/tomgr/libcspm";
       description = "A command line type checker for CSPM files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "css" = callPackage
    ({ mkDerivation, base, mtl, text }:
     mkDerivation {
       pname = "css";
       version = "0.2";
       sha256 = "69cb9d55d466f1976888c4dd0cad01dcfaf59bcf942d663e2aa6a7029c6e0f94";
       libraryHaskellDepends = [ base mtl text ];
       description = "Minimal monadic CSS DSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "css-syntax" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, directory, hspec
     , scientific, text
     }:
     mkDerivation {
       pname = "css-syntax";
       version = "0.0.4";
       sha256 = "9b9254e3471b7be615f8546a5f46b1a338d81be0f2724aa107311c3ee6ee6bd9";
       libraryHaskellDepends = [
         attoparsec base bytestring scientific text
       ];
       testHaskellDepends = [
         attoparsec base bytestring directory hspec scientific text
       ];
       description = "This package implments a parser for the CSS syntax";
       license = stdenv.lib.licenses.mit;
     }) {};

  "css-text" = callPackage
    ({ mkDerivation, attoparsec, base, hspec, QuickCheck, text }:
     mkDerivation {
       pname = "css-text";
       version = "0.1.2.1";
       sha256 = "dc0291da7ec756e4dda9dfadef303c78750eca63d07a5ad21dc4a3079cb021f6";
       libraryHaskellDepends = [ attoparsec base text ];
       testHaskellDepends = [ attoparsec base hspec QuickCheck text ];
       homepage = "http://www.yesodweb.com/";
       description = "CSS parser and renderer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "csv" = callPackage
    ({ mkDerivation, base, filepath, parsec }:
     mkDerivation {
       pname = "csv";
       version = "0.1.2";
       sha256 = "8cf43442325faa1368f9b55ad952beccf677d9980cdffa3d70a7f204a23ae600";
       libraryHaskellDepends = [ base filepath parsec ];
       description = "CSV loader and dumper";
       license = stdenv.lib.licenses.mit;
     }) {};

  "csv-conduit_0_6_3" = callPackage
    ({ mkDerivation, array, attoparsec, attoparsec-conduit, base
     , blaze-builder, bytestring, conduit, conduit-extra, containers
     , data-default, directory, ghc-prim, HUnit, mmorph, monad-control
     , mtl, primitive, resourcet, test-framework, test-framework-hunit
     , text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "csv-conduit";
       version = "0.6.3";
       sha256 = "e42711dde5be65630d63dfabf48dff5bbf47fe83e1e5591972de67402fe561b5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array attoparsec attoparsec-conduit base blaze-builder bytestring
         conduit conduit-extra containers data-default ghc-prim mmorph
         monad-control mtl primitive resourcet text transformers
         unordered-containers vector
       ];
       executableHaskellDepends = [
         base bytestring containers directory mtl primitive text
         transformers vector
       ];
       testHaskellDepends = [
         base bytestring containers directory HUnit mtl primitive
         test-framework test-framework-hunit text transformers vector
       ];
       jailbreak = true;
       homepage = "http://github.com/ozataman/csv-conduit";
       description = "A flexible, fast, conduit-based CSV parser library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "csv-conduit" = callPackage
    ({ mkDerivation, array, attoparsec, base, blaze-builder, bytestring
     , conduit, conduit-extra, containers, data-default, directory
     , ghc-prim, HUnit, mmorph, monad-control, mtl, primitive, resourcet
     , test-framework, test-framework-hunit, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "csv-conduit";
       version = "0.6.6";
       sha256 = "7329056af16c2f81382ad0cc3437232b80e9910288daf687519a2e2cd2ee5d8b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array attoparsec base blaze-builder bytestring conduit
         conduit-extra containers data-default ghc-prim mmorph monad-control
         mtl primitive resourcet text transformers unordered-containers
         vector
       ];
       executableHaskellDepends = [
         base bytestring containers directory mtl primitive text
         transformers vector
       ];
       testHaskellDepends = [
         base bytestring containers directory HUnit mtl primitive
         test-framework test-framework-hunit text transformers vector
       ];
       homepage = "http://github.com/ozataman/csv-conduit";
       description = "A flexible, fast, conduit-based CSV parser library for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "csv-enumerator" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , bytestring, containers, directory, enumerator, safe, transformers
     , unix-compat
     }:
     mkDerivation {
       pname = "csv-enumerator";
       version = "0.10.2.0";
       sha256 = "f01d002d7eabdbcc84d6c2b4e1d5372b05c9152ec63a596d1a3cc9cf73623f58";
       libraryHaskellDepends = [
         attoparsec attoparsec-enumerator base bytestring containers
         directory enumerator safe transformers unix-compat
       ];
       homepage = "http://github.com/ozataman/csv-enumerator";
       description = "A flexible, fast, enumerator-based CSV parser library for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "csv-nptools" = callPackage
    ({ mkDerivation, aeson, base, bytestring, csv, html, tabular, text
     , txt-sushi, vector
     }:
     mkDerivation {
       pname = "csv-nptools";
       version = "0.4.1";
       sha256 = "7e1da915fdf44b2f294e0220da085dafffba96483cfac67c7db2cf7847292821";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring csv html tabular text txt-sushi vector
       ];
       description = "A collection of CSV tools";
       license = "GPL";
     }) {};

  "csv-to-qif" = callPackage
    ({ mkDerivation, base, Cabal, explicit-exception, hspec, regex-tdfa
     , split, spreadsheet
     }:
     mkDerivation {
       pname = "csv-to-qif";
       version = "0.3.2";
       sha256 = "7d9cba937186c540a8dfc34e8b41c58855cdca15ea8163f1ff5fa4b85d0aded5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base explicit-exception regex-tdfa split spreadsheet
       ];
       testHaskellDepends = [ base Cabal hspec regex-tdfa split ];
       homepage = "https://github.com/mrVanDalo/csv-to-qif/";
       description = "A small program that will read csv files and create qif files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ctemplate" = callPackage
    ({ mkDerivation, base, bytestring, ctemplate }:
     mkDerivation {
       pname = "ctemplate";
       version = "0.1";
       sha256 = "a8539c4d8480a51c1f20f6aa2a4cbfa799f9d793df70140066489c773fe0ba0b";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ ctemplate ];
       homepage = "http://darcs.imperialviolet.org/ctemplate";
       description = "Binding to the Google ctemplate library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {ctemplate = null;};

  "ctkl" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "ctkl";
       version = "0.27.0.0";
       sha256 = "f580a4810dc5cad1525886831444e7540975700b2d6ff99e140673fa0978196b";
       libraryHaskellDepends = [ array base ];
       jailbreak = true;
       description = "packaging of Manuel Chakravarty's CTK Light for Hackage";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ctpl" = callPackage
    ({ mkDerivation, base, chatty-text, chatty-utils }:
     mkDerivation {
       pname = "ctpl";
       version = "0.1.0.1";
       sha256 = "3b6bb011e0cc647fcc1254c52b182a5928a730a26cb55cfbcc19d9f2e27a78d5";
       libraryHaskellDepends = [ base chatty-text chatty-utils ];
       jailbreak = true;
       description = "A programming language for text modification";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ctrie" = callPackage
    ({ mkDerivation, atomic-primops, base, containers, hashable
     , primitive, QuickCheck, test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "ctrie";
       version = "0.1.0.3";
       sha256 = "39111bf907776cb33890ca5cba82e204d576aacd320df2f150fc090e34055b7c";
       libraryHaskellDepends = [ atomic-primops base hashable primitive ];
       testHaskellDepends = [
         base containers hashable QuickCheck test-framework
         test-framework-quickcheck2
       ];
       homepage = "https://github.com/mcschroeder/ctrie";
       description = "Non-blocking concurrent map";
       license = stdenv.lib.licenses.mit;
     }) {};

  "cube" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, hspec, STL
     }:
     mkDerivation {
       pname = "cube";
       version = "0.2.0";
       sha256 = "d71f6392f0323ab12da36c43e8780a39c3d547e217d63d19205f056839a30c6a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring cereal containers STL ];
       executableHaskellDepends = [
         base bytestring cereal containers hspec STL
       ];
       testHaskellDepends = [
         base bytestring cereal containers hspec STL
       ];
       description = "Cubic DSL for 3D printing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cubical" = callPackage
    ({ mkDerivation, alex, array, base, BNFC, directory, filepath
     , happy, haskeline, mtl, transformers
     }:
     mkDerivation {
       pname = "cubical";
       version = "0.2.0";
       sha256 = "d285c5ed24f3743825209f1a427ba0c887f512e1293909d754b1e4a1d36884d8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base BNFC directory filepath haskeline mtl transformers
       ];
       executableToolDepends = [ alex happy ];
       homepage = "https://github.com/simhu/cubical";
       description = "Implementation of Univalence in Cubical Sets";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cubicbezier" = callPackage
    ({ mkDerivation, base, containers, integration, matrices, microlens
     , microlens-mtl, microlens-th, mtl, parsec, tasty, tasty-hunit
     , vector
     }:
     mkDerivation {
       pname = "cubicbezier";
       version = "0.4.0.2";
       sha256 = "b3e87a3fa4000f44121b6278d1a0b258acc2c71425fe7bf9d565fa7c36581a17";
       libraryHaskellDepends = [
         base containers integration matrices microlens microlens-mtl
         microlens-th mtl vector
       ];
       testHaskellDepends = [ base parsec tasty tasty-hunit ];
       description = "Efficient manipulating of 2D cubic bezier curves";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cubicspline_0_1_1" = callPackage
    ({ mkDerivation, base, hmatrix, safe }:
     mkDerivation {
       pname = "cubicspline";
       version = "0.1.1";
       sha256 = "1ac5800f351a7c2d802a4f3eeff291f57cb4d14f17031b1c2f50232737408c58";
       revision = "1";
       editedCabalFile = "9a41e57d036a8210e1749a8a17929446725aa7cd2e7b8b0945f50303a3d59394";
       libraryHaskellDepends = [ base hmatrix safe ];
       jailbreak = true;
       description = "Natural cubic spline interpolation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cubicspline" = callPackage
    ({ mkDerivation, base, hmatrix, safe }:
     mkDerivation {
       pname = "cubicspline";
       version = "0.1.2";
       sha256 = "5b6ced9ca65b0d01ddceaf18605c8f915491d8d4a6aaef73475c4e8d4b1a9b79";
       libraryHaskellDepends = [ base hmatrix safe ];
       description = "Natural cubic spline interpolation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cublas" = callPackage
    ({ mkDerivation, base, c2hs, cublas, cuda, cusparse, filepath
     , language-c, storable-complex, template-haskell
     }:
     mkDerivation {
       pname = "cublas";
       version = "0.2.1.0";
       sha256 = "3c6031d2f7332a6a2357a1ec9adc4ba1404c5c05cb5a42193847ceac7652a80b";
       libraryHaskellDepends = [
         base cuda filepath language-c storable-complex template-haskell
       ];
       librarySystemDepends = [ cublas cusparse ];
       libraryToolDepends = [ c2hs ];
       jailbreak = true;
       homepage = "https://github.com/bmsherman/cublas";
       description = "FFI bindings to the CUDA CUBLAS and CUSPARSE libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {cublas = null; cusparse = null;};

  "cuboid" = callPackage
    ({ mkDerivation, base, GLUT, Yampa }:
     mkDerivation {
       pname = "cuboid";
       version = "0.14.2";
       sha256 = "cbe47ad3b0ead8d98856f98ab6ce81d1a1fb7319700ee97169e9968692c38822";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base GLUT Yampa ];
       description = "3D Yampa/GLUT Puzzle Game";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "cuda" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, pretty, template-haskell
     }:
     mkDerivation {
       pname = "cuda";
       version = "0.7.0.0";
       sha256 = "b51b6da7f1aad9c1c2abacb6c45cc5efbd7fc7ddb4c1245de12bf7b0b0777ba6";
       revision = "1";
       editedCabalFile = "1ff19bb4645ce9ba77b84189c8b6e44fb635d1c8b3a5c7560c8633ee2005f37e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring template-haskell ];
       libraryToolDepends = [ c2hs ];
       executableHaskellDepends = [ base pretty ];
       homepage = "https://github.com/tmcdonell/cuda";
       description = "FFI binding to the CUDA interface for programming NVIDIA GPUs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "cudd" = callPackage
    ({ mkDerivation, array, base, c2hs, cudd, dddmp, epd, mtl, mtr, st
     , transformers, util
     }:
     mkDerivation {
       pname = "cudd";
       version = "0.1.0.2";
       sha256 = "59008e024553375eeeabfd9dd7c2e8a186b0edd75edb52640e38cc9d31911a7e";
       libraryHaskellDepends = [ array base mtl transformers ];
       librarySystemDepends = [ cudd dddmp epd mtr st util ];
       libraryToolDepends = [ c2hs ];
       homepage = "https://github.com/adamwalker/haskell_cudd";
       description = "Bindings to the CUDD binary decision diagrams library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {cudd = null; dddmp = null; epd = null; inherit (pkgs) mtr; 
         inherit (pkgs) st; util = null;};

  "cufft" = callPackage
    ({ mkDerivation, base, c2hs, cuda }:
     mkDerivation {
       pname = "cufft";
       version = "0.1.2.1";
       sha256 = "d29c4de93e2ccf1d9124cff6466b1e0a04108c8cfc284164713b5ec79bb879e2";
       libraryHaskellDepends = [ base cuda ];
       libraryToolDepends = [ c2hs ];
       homepage = "http://github.com/robeverest/cufft";
       description = "Haskell bindings for the CUFFT library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "curl" = callPackage
    ({ mkDerivation, base, bytestring, containers, curl }:
     mkDerivation {
       pname = "curl";
       version = "1.3.8";
       sha256 = "9087c936bfcdb865bad3166baa3f12bf37acf076fa76010e3b5f82a1d485446e";
       libraryHaskellDepends = [ base bytestring containers ];
       librarySystemDepends = [ curl ];
       description = "Haskell binding to libcurl";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) curl;};

  "curl-aeson" = callPackage
    ({ mkDerivation, aeson, base, curl, text, utf8-string }:
     mkDerivation {
       pname = "curl-aeson";
       version = "0.0.4";
       sha256 = "3defd8313d3e34657bd4c5aa7f0c4e1b7a6e533eaeffc1571eee2de31021f1ba";
       libraryHaskellDepends = [ aeson base curl text utf8-string ];
       homepage = "https://github.com/zouppen/haskell-curl-aeson";
       description = "Communicate with HTTP service using JSON";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "curlhs" = callPackage
    ({ mkDerivation, base, bytestring, hspec, rtld, time }:
     mkDerivation {
       pname = "curlhs";
       version = "0.1.6";
       sha256 = "6be0c9ea6cb295e2cf91db0b6a730477a54708f322fe5fbdbcf4dd9ba6cb07fa";
       revision = "1";
       editedCabalFile = "ac8dbe0348ce66746774f019fe62dbdaf40a200bed62f5b7fb0ecb9bd11cfa1c";
       libraryHaskellDepends = [ base bytestring rtld time ];
       testHaskellDepends = [ base hspec ];
       homepage = "https://github.com/kkardzis/curlhs";
       description = "bindings to libcurl, the multiprotocol file transfer library";
       license = "unknown";
     }) {};

  "currency" = callPackage
    ({ mkDerivation, base, containers, hashable, iso3166-country-codes
     }:
     mkDerivation {
       pname = "currency";
       version = "0.2.0.0";
       sha256 = "bcd517f3d9f47f0dd3c4e802143159239e4a90db2fc552be4a99d759ffe9417a";
       libraryHaskellDepends = [
         base containers hashable iso3166-country-codes
       ];
       homepage = "https://github.com/singpolyma/currency-haskell";
       description = "Types representing standard and non-standard currencies";
       license = "unknown";
     }) {};

  "current-locale" = callPackage
    ({ mkDerivation, base, old-locale, process, split }:
     mkDerivation {
       pname = "current-locale";
       version = "0.2.0.1";
       sha256 = "25fbab8e2f7a9673bebd2359c4b4e580df1b8d566c4160da3a40fcfb9d218fa2";
       libraryHaskellDepends = [ base old-locale process split ];
       homepage = "https://github.com/koterpillar/current-locale";
       description = "Get the current system locale in System.Locale format";
       license = stdenv.lib.licenses.mit;
     }) {};

  "curry-base" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, mtl
     , old-time, pretty, syb
     }:
     mkDerivation {
       pname = "curry-base";
       version = "0.2.9";
       sha256 = "40049798fc9bec2ea15964ea7fd84d210b2d409320eb7fe25f6c57bcf4f3bc69";
       libraryHaskellDepends = [
         base containers directory filepath mtl old-time pretty syb
       ];
       homepage = "http://www.curry-language.org";
       description = "Functions for manipulating Curry programs";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "curry-frontend" = callPackage
    ({ mkDerivation, base, containers, curry-base, filepath, mtl
     , old-time, pretty, syb
     }:
     mkDerivation {
       pname = "curry-frontend";
       version = "0.2.12";
       sha256 = "9030b7ebe434c65e1a55634f54c293fa0b819f313a12371b8d41727e22d1fec5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ filepath ];
       executableHaskellDepends = [
         base containers curry-base mtl old-time pretty syb
       ];
       homepage = "http://www.curry-language.org";
       description = "Compile the functional logic language Curry to several intermediate formats";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "cursedcsv" = callPackage
    ({ mkDerivation, base, bytestring, csv-enumerator, enumerator
     , hscurses, mtl, natural-sort, parseargs, regex-tdfa, safe, unix
     }:
     mkDerivation {
       pname = "cursedcsv";
       version = "0.1.2";
       sha256 = "6c5b7b75bf05eb6d40762571928b2ba558ac00a653c8ce076fec497ea177b410";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring csv-enumerator enumerator hscurses mtl natural-sort
         parseargs regex-tdfa safe unix
       ];
       description = "Terminal tool for viewing tabular data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "curve25519" = callPackage
    ({ mkDerivation, base, bytestring, crypto-api, DRBG, HUnit
     , QuickCheck, tagged, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "curve25519";
       version = "0.2.2";
       sha256 = "baa776233ff1e56d3e4c9ecfc30c0c607e98bb2f4fdb8ef9a057d29d5dabe8f2";
       libraryHaskellDepends = [ base bytestring crypto-api ];
       testHaskellDepends = [
         base bytestring crypto-api DRBG HUnit QuickCheck tagged
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/acw/curve25519";
       description = "Fast implementations of the curve25519 elliptic curve primitives";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "curves" = callPackage
    ({ mkDerivation, base, bytestring, containers, filepath, HaXml
     , JuicyPixels, QuickCheck
     }:
     mkDerivation {
       pname = "curves";
       version = "1.1.0.2";
       sha256 = "aa393af56cbd13832ce9ae5583e64780884f2f1888aa877d222901e74b618f1c";
       libraryHaskellDepends = [
         base bytestring containers filepath HaXml JuicyPixels QuickCheck
       ];
       description = "Library for drawing curve based images";
       license = stdenv.lib.licenses.mit;
     }) {};

  "custom-prelude" = callPackage
    ({ mkDerivation, base, basic-prelude, monad-loops }:
     mkDerivation {
       pname = "custom-prelude";
       version = "0.2.2.0";
       sha256 = "c67edf7134d4f45d3d6306fcd253d96d84391c21a676a3c18af6cf74e8bc9302";
       libraryHaskellDepends = [ base basic-prelude monad-loops ];
       jailbreak = true;
       homepage = "https://github.com/ajnsit/custom-prelude";
       description = "An enhanced prelude, serving as a foundation for my projects";
       license = "GPL";
     }) {};

  "cv-combinators" = callPackage
    ({ mkDerivation, allocated-processor, base, HOpenCV, vector-space
     }:
     mkDerivation {
       pname = "cv-combinators";
       version = "0.2.0.2";
       sha256 = "fdb44fb8ed7ecadb8702eb6b610b45245dcfbac98ddd6cdb5122d4e9f0d98e7e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         allocated-processor base HOpenCV vector-space
       ];
       executableHaskellDepends = [
         allocated-processor base HOpenCV vector-space
       ];
       description = "Functional Combinators for Computer Vision";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "cyclotomic" = callPackage
    ({ mkDerivation, arithmoi, base, containers }:
     mkDerivation {
       pname = "cyclotomic";
       version = "0.4.4";
       sha256 = "72ef126d3bf18542a709d740baef78dc4e4a065e1044fd50274a3730e3feeb97";
       libraryHaskellDepends = [ arithmoi base containers ];
       description = "A subfield of the complex numbers for exact calculation";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "cypher" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , classy-parallel, conduit, http-conduit, http-types, resourcet
     , text, transformers, transformers-base, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "cypher";
       version = "0.8.1";
       sha256 = "a330ba3acd374e50312f8c247d8c6270e25b7024ecbac800aa9fd924433ae938";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring classy-parallel conduit
         http-conduit http-types resourcet text transformers
         transformers-base unordered-containers vector
       ];
       jailbreak = true;
       description = "Haskell bindings for the neo4j \"cypher\" query language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "d-bus" = callPackage
    ({ mkDerivation, async, attoparsec, base, binary, blaze-builder
     , bytestring, conduit, conduit-extra, containers
     , data-binary-ieee754, data-default, exceptions, free, hslogger
     , mtl, network, QuickCheck, singletons, stm, tasty, tasty-hunit
     , tasty-quickcheck, tasty-th, template-haskell, text, transformers
     , xml-conduit, xml-hamlet, xml-picklers, xml-types
     }:
     mkDerivation {
       pname = "d-bus";
       version = "0.1.3.3";
       sha256 = "81d22b29f72c77c8a8ffb89e14801adbd6b7730c7f24d3c24a311c028b9b624a";
       libraryHaskellDepends = [
         async attoparsec base binary blaze-builder bytestring conduit
         conduit-extra containers data-binary-ieee754 data-default
         exceptions free hslogger mtl network singletons stm
         template-haskell text transformers xml-conduit xml-picklers
         xml-types
       ];
       testHaskellDepends = [
         base binary bytestring mtl QuickCheck singletons tasty tasty-hunit
         tasty-quickcheck tasty-th text xml-hamlet
       ];
       description = "Permissively licensed D-Bus client library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "d3js" = callPackage
    ({ mkDerivation, base, mtl, random, text }:
     mkDerivation {
       pname = "d3js";
       version = "0.1.0.0";
       sha256 = "028f9b7933013bdd0ca90fcea6747295307a41ab2136cd6fd8d125ad9fdb3d73";
       libraryHaskellDepends = [ base mtl random text ];
       jailbreak = true;
       homepage = "https://github.com/nebuta/d3js-haskell";
       description = "Declarative visualization on a web browser with DSL approach";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "daemonize-doublefork" = callPackage
    ({ mkDerivation, base, directory, unix }:
     mkDerivation {
       pname = "daemonize-doublefork";
       version = "0.1.1";
       sha256 = "c25ff03326fa0efc10889c0e616d6d11c9347672c0073208d95221e73a3684bc";
       libraryHaskellDepends = [ base directory unix ];
       homepage = "https://github.com/scvalex/daemonize-doublefork";
       description = "Start background daemons by double-forking";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "daemons" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, data-default
     , directory, filepath, ghc-prim, HUnit, network, pipes
     , test-framework, test-framework-hunit, transformers, unix
     }:
     mkDerivation {
       pname = "daemons";
       version = "0.2.1";
       sha256 = "17c5d6b41173aac225d4c9c2d126dfbf73439e841e5c6d0d301f06bac340c97d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal data-default directory filepath ghc-prim
         network pipes transformers unix
       ];
       executableHaskellDepends = [
         base bytestring cereal containers data-default ghc-prim network
         pipes transformers
       ];
       testHaskellDepends = [
         base data-default directory ghc-prim HUnit test-framework
         test-framework-hunit unix
       ];
       homepage = "https://github.com/scvalex/daemons";
       description = "Daemons in Haskell made fun and easy";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "dag" = callPackage
    ({ mkDerivation, base, constraints, hspec, QuickCheck
     , quickcheck-instances, singletons
     }:
     mkDerivation {
       pname = "dag";
       version = "0.1.0.2";
       sha256 = "775f4306d1e701572785df01349a3c0888951b3769868b2c91f2f08fbff70e4e";
       libraryHaskellDepends = [ base constraints singletons ];
       testHaskellDepends = [
         base hspec QuickCheck quickcheck-instances
       ];
       description = "Compile-time, type-safe directed acyclic graphs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "damnpacket" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, deepseq
     , QuickCheck, text
     }:
     mkDerivation {
       pname = "damnpacket";
       version = "0.6.0";
       sha256 = "cb2f95b9bbac573f71f14a4f4ddb05df2c5d05bd2a0fc45d472e29e1359bec8c";
       libraryHaskellDepends = [
         attoparsec base bytestring containers deepseq text
       ];
       testHaskellDepends = [ base containers QuickCheck text ];
       jailbreak = true;
       homepage = "https://github.com/joelteon/damnpacket";
       description = "Parsing dAmn packets";
       license = stdenv.lib.licenses.mit;
     }) {};

  "dao" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , Crypto, data-binary-ieee754, deepseq, directory, filepath, mtl
     , process, random, time, transformers, utf8-string
     }:
     mkDerivation {
       pname = "dao";
       version = "0.1.0.1";
       sha256 = "69520629b7e657dc129d3f32822c1c7c9d5073cb67c1a77f2e228941f1d04a31";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers Crypto data-binary-ieee754
         deepseq directory filepath mtl process random time transformers
         utf8-string
       ];
       executableHaskellDepends = [
         array base binary bytestring containers Crypto data-binary-ieee754
         deepseq directory filepath mtl process random time transformers
         utf8-string
       ];
       testHaskellDepends = [
         array base binary bytestring containers Crypto data-binary-ieee754
         deepseq directory filepath mtl process random time transformers
         utf8-string
       ];
       description = "Dao is meta programming language with its own built-in interpreted language, designed with artificial intelligence applications in mind";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dapi" = callPackage
    ({ mkDerivation, base, containers, explicit-exception, multiarg
     , old-locale, parsec, prednote, rainbow, text, time, transformers
     }:
     mkDerivation {
       pname = "dapi";
       version = "0.2.0.0";
       sha256 = "5f52db8731dd704a351a15adcc62df83cd325bdb281cbe9c41424f8cc521b145";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers explicit-exception multiarg old-locale parsec
         prednote rainbow text time transformers
       ];
       jailbreak = true;
       homepage = "http://massysett.github.com/dapi";
       description = "Prints a series of dates";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "darcs_2_10_2" = callPackage
    ({ mkDerivation, array, attoparsec, base, base16-bytestring, binary
     , bytestring, cmdargs, containers, cryptohash, curl, data-ordlist
     , directory, filepath, FindBin, hashable, haskeline, html, HTTP
     , HUnit, mmap, mtl, network, network-uri, old-locale, old-time
     , parsec, process, QuickCheck, random, regex-applicative
     , regex-compat-tdfa, sandi, shelly, split, tar, terminfo
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, time, transformers, transformers-compat, unix, unix-compat
     , utf8-string, vector, zip-archive, zlib
     }:
     mkDerivation {
       pname = "darcs";
       version = "2.10.2";
       sha256 = "6337d3fac04711fa2ef5813558b409c59166c5599b0c9d68c418d21cdccfb327";
       revision = "1";
       editedCabalFile = "ef15936009bbe7f50614dfc66bcb182d28129b353e312e82ae301b0517af24fe";
       configureFlags = [ "-fforce-char8-encoding" "-flibrary" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array attoparsec base base16-bytestring binary bytestring
         containers cryptohash data-ordlist directory filepath hashable
         haskeline html HTTP mmap mtl network network-uri old-locale
         old-time parsec process random regex-applicative regex-compat-tdfa
         sandi tar terminfo text time transformers transformers-compat unix
         unix-compat utf8-string vector zip-archive zlib
       ];
       librarySystemDepends = [ curl ];
       executableHaskellDepends = [ base filepath regex-compat-tdfa ];
       testHaskellDepends = [
         array base binary bytestring cmdargs containers cryptohash
         directory filepath FindBin html HUnit mmap mtl parsec process
         QuickCheck regex-compat-tdfa sandi shelly split test-framework
         test-framework-hunit test-framework-quickcheck2 text unix-compat
         zip-archive zlib
       ];
       jailbreak = true;
       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 = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) curl;};

  "darcs" = callPackage
    ({ mkDerivation, array, attoparsec, base, base16-bytestring, binary
     , bytestring, cmdargs, containers, cryptohash, curl, data-ordlist
     , directory, filepath, FindBin, hashable, haskeline, html, HTTP
     , HUnit, mmap, mtl, network, network-uri, old-time, parsec, process
     , QuickCheck, random, regex-applicative, regex-compat-tdfa, sandi
     , shelly, split, tar, terminfo, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , transformers, transformers-compat, unix, unix-compat, utf8-string
     , vector, zip-archive, zlib
     }:
     mkDerivation {
       pname = "darcs";
       version = "2.10.3";
       sha256 = "ca00c40d08276f94868c7c1bbc6dbd9b6b41a15c1907c34947aaa51d4dbbf642";
       configureFlags = [ "-fforce-char8-encoding" "-flibrary" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array attoparsec base base16-bytestring binary bytestring
         containers cryptohash data-ordlist directory filepath hashable
         haskeline html HTTP mmap mtl network network-uri old-time parsec
         process random regex-applicative regex-compat-tdfa sandi tar
         terminfo text time transformers transformers-compat unix
         unix-compat utf8-string vector zip-archive zlib
       ];
       librarySystemDepends = [ curl ];
       executableHaskellDepends = [ base filepath regex-compat-tdfa ];
       testHaskellDepends = [
         array base binary bytestring cmdargs containers cryptohash
         directory filepath FindBin html HUnit mmap mtl parsec process
         QuickCheck regex-compat-tdfa sandi shelly split test-framework
         test-framework-hunit test-framework-quickcheck2 text unix-compat
         zip-archive zlib
       ];
       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 = "GPL";
     }) {inherit (pkgs) curl;};

  "darcs-benchmark" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, containers, datetime
     , directory, filepath, hs-gchart, html, HTTP, json, mtl, network
     , old-locale, process, regex-posix, SHA, split, statistics, strict
     , tabular, tar, time, utf8-string, uvector, zlib
     }:
     mkDerivation {
       pname = "darcs-benchmark";
       version = "0.1.9";
       sha256 = "72fb05e54492627cfabd1af3486cb7e294383eed08d6c86931972aa3952790e3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs containers datetime directory filepath
         hs-gchart html HTTP json mtl network old-locale process regex-posix
         SHA split statistics strict tabular tar time utf8-string uvector
         zlib
       ];
       jailbreak = true;
       homepage = "http://wiki.darcs.net/Development/Benchmarks";
       description = "Comparative benchmark suite for darcs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "darcs-beta" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, curl
     , directory, extensible-exceptions, filepath, hashed-storage
     , haskeline, html, HTTP, mmap, mtl, network, old-time, parsec
     , process, random, regex-compat, tar, terminfo, text, unix, vector
     , zlib
     }:
     mkDerivation {
       pname = "darcs-beta";
       version = "2.7.99.2";
       sha256 = "4508a56509987daaa956497d462e8409050ceada9fd4df0e65109e2826f26f4a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers directory extensible-exceptions
         filepath hashed-storage haskeline html HTTP mmap mtl network
         old-time parsec process random regex-compat tar terminfo text unix
         vector zlib
       ];
       librarySystemDepends = [ curl ];
       executableHaskellDepends = [
         array base bytestring containers directory extensible-exceptions
         filepath hashed-storage haskeline html HTTP mmap mtl network
         old-time parsec process random regex-compat tar terminfo text unix
         vector zlib
       ];
       executableSystemDepends = [ curl ];
       jailbreak = true;
       homepage = "http://darcs.net/";
       description = "a distributed, interactive, smart revision control system";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) curl;};

  "darcs-buildpackage" = callPackage
    ({ mkDerivation, base, ConfigFile, directory, hslogger, MissingH
     , network, parsec, process, regex-compat, unix
     }:
     mkDerivation {
       pname = "darcs-buildpackage";
       version = "0.5.12";
       sha256 = "0e2389815667e3e626dda98479b631845837d3778dd880c50992a3ffd6c90231";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base ConfigFile directory hslogger MissingH network parsec process
         regex-compat unix
       ];
       description = "Tools to help manage Debian packages with Darcs";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "darcs-cabalized" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, curl
     , directory, html, HUnit, mtl, ncurses, old-time, parsec, process
     , QuickCheck, regex-compat, unix, zlib
     }:
     mkDerivation {
       pname = "darcs-cabalized";
       version = "2.0.2.2";
       sha256 = "2d98a879ca40a3f68d6b64e4d69895377988e1cb6a3421a2b999d1fac1d881d1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring containers directory html HUnit mtl old-time
         parsec process QuickCheck regex-compat unix
       ];
       executableSystemDepends = [ curl ncurses zlib ];
       homepage = "http://darcs.net/";
       description = "David's Advanced Version Control System";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) curl; inherit (pkgs) ncurses; 
         inherit (pkgs) zlib;};

  "darcs-fastconvert" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, cmdlib, containers
     , darcs, datetime, directory, filepath, hashed-storage, mtl
     , old-time, utf8-string
     }:
     mkDerivation {
       pname = "darcs-fastconvert";
       version = "0.2.1";
       sha256 = "3ac1b843c8d61300ce53c2b44890af872cb3cbff1549795ba598159be8d889a8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base bytestring cmdlib containers darcs datetime
         directory filepath hashed-storage mtl old-time utf8-string
       ];
       jailbreak = true;
       description = "Import/export git fast-import streams to/from darcs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "darcs-graph" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory
     , old-locale, old-time, process, time
     }:
     mkDerivation {
       pname = "darcs-graph";
       version = "1.0";
       sha256 = "6633e9fe4746723dbb10f8010a67a2eaf27885d62df2e3e829ba6569e9258004";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory old-locale old-time process
         time
       ];
       jailbreak = true;
       description = "Generate graphs of darcs repository activity";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "darcs-monitor" = callPackage
    ({ mkDerivation, base, containers, directory, HaXml, mtl, process
     }:
     mkDerivation {
       pname = "darcs-monitor";
       version = "0.4.2";
       sha256 = "d8aa968f6ce573e8df62dce2f60d948a13ca94da02658744fe5dad1f1575e666";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory HaXml mtl process
       ];
       jailbreak = true;
       homepage = "http://wiki.darcs.net/RelatedSoftware/DarcsMonitor";
       description = "Darcs repository monitor (sends email)";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "darcs-scripts" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "darcs-scripts";
       version = "0.1.1";
       sha256 = "6acde756a7a679e845b58a42fa88bb85a6943e04725ec7a2c785d984340afa19";
       libraryHaskellDepends = [ base ];
       doHaddock = false;
       description = "Shell scripts for support of darcs workflow";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "darcs2dot" = callPackage
    ({ mkDerivation, base, containers, darcs, graph-wrapper
     , string-conversions
     }:
     mkDerivation {
       pname = "darcs2dot";
       version = "0.1.0.1";
       sha256 = "938712de23d7d46b6f7e9a6f69cd9122dee48bcc34e32218c807bb3b45ccd064";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers darcs graph-wrapper string-conversions
       ];
       jailbreak = true;
       description = "Outputs dependencies of darcs patches in dot format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "darcsden" = callPackage
    ({ mkDerivation, aeson, base, base64-string, blaze-builder
     , blaze-html, blaze-markup, bytestring, containers, CouchDB, darcs
     , directory, filepath, harp, hashed-storage, highlighting-kate
     , HsOpenSSL, hsp, http-conduit, HUnit, json, mime-mail, mtl
     , old-locale, old-time, pandoc, pcre-light, process, pureMD5
     , random, redis, safe, SHA, snap-core, snap-server, split, ssh
     , system-uuid, text, time, utf8-string, webdriver, xhtml, xml
     }:
     mkDerivation {
       pname = "darcsden";
       version = "1.1.1";
       sha256 = "85011d74d264d2dcf4a90665da5c7a17da77a3d74160309d16b12ea38c3ae8b7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base base64-string blaze-builder blaze-html blaze-markup
         bytestring containers CouchDB darcs directory filepath harp
         hashed-storage highlighting-kate HsOpenSSL hsp http-conduit HUnit
         json mime-mail mtl old-locale old-time pandoc pcre-light process
         pureMD5 random redis safe SHA snap-core snap-server split ssh
         system-uuid text time utf8-string webdriver xhtml xml
       ];
       jailbreak = true;
       homepage = "http://hackage.haskell.org/package/darcsden";
       description = "Darcs repository UI and hosting/collaboration app (hub.darcs.net branch).";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "darcswatch" = callPackage
    ({ mkDerivation, base, bytestring, cgi, concurrentoutput
     , containers, Crypto, directory, filepath, HTTP, mime-string, mtl
     , nano-md5, network, old-locale, old-time, parsec, process
     , regex-compat, safe, time, unix, xhtml, zlib
     }:
     mkDerivation {
       pname = "darcswatch";
       version = "0.4.4";
       sha256 = "4ecffe205bf1ae1e9b50807d414ce6f72b28231a7b1dcc94f56641fae9e580be";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cgi concurrentoutput containers Crypto directory
         filepath HTTP mime-string mtl nano-md5 network old-locale old-time
         parsec process regex-compat safe time unix xhtml zlib
       ];
       homepage = "http://darcswatch.nomeata.de/";
       description = "Track application of Darcs patches";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "darkplaces-demo" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , darkplaces-text, data-binary-ieee754, directory, mtl
     , optparse-applicative, regex-tdfa, transformers
     }:
     mkDerivation {
       pname = "darkplaces-demo";
       version = "0.1";
       sha256 = "6e484df96e6207a2b2f2f0207ac9820227edc6ab3d779120b5a2626b1d3a5755";
       revision = "1";
       editedCabalFile = "d16b0f7e29060476084a0457d38e524e1965b05e591af570197f287d574a8d01";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers data-binary-ieee754 regex-tdfa
         transformers
       ];
       executableHaskellDepends = [
         base bytestring darkplaces-text directory mtl optparse-applicative
       ];
       jailbreak = true;
       homepage = "https://github.com/bacher09/darkplaces-demo";
       description = "Utility and parser for DarkPlaces demo files";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "darkplaces-rcon" = callPackage
    ({ mkDerivation, base, byteable, bytestring, cryptohash, hspec
     , hspec-core, network, time
     }:
     mkDerivation {
       pname = "darkplaces-rcon";
       version = "0.1";
       sha256 = "e5ec14c2e14516ced46fb815c643183508abbc6420cf1e0b48f428f9cd92fd59";
       libraryHaskellDepends = [
         base byteable bytestring cryptohash network time
       ];
       testHaskellDepends = [ base bytestring hspec hspec-core ];
       jailbreak = true;
       homepage = "https://github.com/bacher09/darkplaces-rcon";
       description = "Darkplaces rcon client library";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "darkplaces-rcon-util" = callPackage
    ({ mkDerivation, base, bytestring, ConfigFile, containers
     , darkplaces-rcon, darkplaces-text, directory, filepath, haskeline
     , HostAndPort, hspec, hspec-core, mtl, optparse-applicative, text
     , time, utf8-string
     }:
     mkDerivation {
       pname = "darkplaces-rcon-util";
       version = "0.1.1";
       sha256 = "8fe2da4a1838e678a8848608ad39e5d8c892a9c9c91933d79f6f8ba70c4869f7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring ConfigFile containers darkplaces-rcon
         darkplaces-text directory filepath haskeline HostAndPort mtl
         optparse-applicative text time utf8-string
       ];
       executableHaskellDepends = [
         base bytestring darkplaces-rcon darkplaces-text haskeline mtl
         optparse-applicative text utf8-string
       ];
       testHaskellDepends = [
         base bytestring darkplaces-rcon darkplaces-text hspec hspec-core
         text
       ];
       jailbreak = true;
       homepage = "https://github.com/bacher09/darkplaces-rcon";
       description = "Darplaces rcon utility";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "darkplaces-text" = callPackage
    ({ mkDerivation, alex, ansi-terminal, array, base, bytestring
     , hspec, QuickCheck, text, utf8-string, vector
     }:
     mkDerivation {
       pname = "darkplaces-text";
       version = "0.2.1";
       sha256 = "35131f15db7b21c8a0ab21b84837c350666be05632181ab30d1bcc5b00c8da8a";
       libraryHaskellDepends = [
         ansi-terminal array base bytestring text utf8-string vector
       ];
       libraryToolDepends = [ alex ];
       testHaskellDepends = [ base bytestring hspec QuickCheck ];
       homepage = "https://github.com/bacher09/darkplaces-text";
       description = "Parser for darkplaces colorful text";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "dash-haskell" = callPackage
    ({ mkDerivation, base, Cabal, containers, direct-sqlite, directory
     , either, filepath, ghc, haddock-api, optparse-applicative, parsec
     , pipes, sqlite-simple, tagsoup, text, transformers
     }:
     mkDerivation {
       pname = "dash-haskell";
       version = "1.1.0.2";
       sha256 = "d20cfdc67ba8ffd968c2b1ffcb3022bfda7cf7f650c42eeab34216ca845742c0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers direct-sqlite directory either filepath ghc
         haddock-api optparse-applicative parsec pipes sqlite-simple tagsoup
         text transformers
       ];
       homepage = "http://www.github.com/jfeltz/dash-haskell";
       description = "Convert package Haddock to Dash docsets (IDE docs)";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "data-accessor_0_2_2_6" = callPackage
    ({ mkDerivation, array, base, containers, transformers }:
     mkDerivation {
       pname = "data-accessor";
       version = "0.2.2.6";
       sha256 = "ee9de7fd9716f2681695deffcd04045d605bd24f0f2c7d6f0849dc4ae9c3c818";
       libraryHaskellDepends = [ array base containers transformers ];
       homepage = "http://www.haskell.org/haskellwiki/Record_access";
       description = "Utilities for accessing and manipulating fields of records";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-accessor" = callPackage
    ({ mkDerivation, array, base, containers, transformers }:
     mkDerivation {
       pname = "data-accessor";
       version = "0.2.2.7";
       sha256 = "3465227ad5f81059a885d354e2f3c108d550287580e6939e18350fa65e78c2ed";
       libraryHaskellDepends = [ array base containers transformers ];
       homepage = "http://www.haskell.org/haskellwiki/Record_access";
       description = "Utilities for accessing and manipulating fields of records";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-accessor-monadLib" = callPackage
    ({ mkDerivation, base, data-accessor, monadLib }:
     mkDerivation {
       pname = "data-accessor-monadLib";
       version = "0.0.1";
       sha256 = "1185f90348212ae07cb77a0f5a5e90f8366d0107d3607ab467c4674972e53e50";
       libraryHaskellDepends = [ base data-accessor monadLib ];
       jailbreak = true;
       description = "Accessor functions for monadLib's monads";
       license = "unknown";
     }) {};

  "data-accessor-monads-fd" = callPackage
    ({ mkDerivation, base, data-accessor, monads-fd, transformers }:
     mkDerivation {
       pname = "data-accessor-monads-fd";
       version = "0.2.0.3";
       sha256 = "1ff628067c081547764a92eb039ce8bfa5d79191832fcfde4beea88c4b996efb";
       libraryHaskellDepends = [
         base data-accessor monads-fd transformers
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Record_access";
       description = "Use Accessor to access state in monads-fd State monad class";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-accessor-monads-tf" = callPackage
    ({ mkDerivation, base, data-accessor, monads-tf, transformers }:
     mkDerivation {
       pname = "data-accessor-monads-tf";
       version = "0.2.1.4";
       sha256 = "b312502ff7adf92e87df67dd81b4e9eaf026bca8aa40929bdb1ae900ac57538b";
       libraryHaskellDepends = [
         base data-accessor monads-tf transformers
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Record_access";
       description = "Use Accessor to access state in monads-tf State monad type family";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-accessor-mtl" = callPackage
    ({ mkDerivation, base, data-accessor, mtl }:
     mkDerivation {
       pname = "data-accessor-mtl";
       version = "0.2.0.4";
       sha256 = "10cf9166e2e046076b7e58987718e57b31408e7cada9f26c8ff111e0379814c5";
       libraryHaskellDepends = [ base data-accessor mtl ];
       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, template-haskell, utility-ht
     }:
     mkDerivation {
       pname = "data-accessor-template";
       version = "0.2.1.12";
       sha256 = "07042d79a2f26892ef0b847a36a78f8fc217843a47dd8684d24ffbb7174e795e";
       libraryHaskellDepends = [
         base data-accessor template-haskell utility-ht
       ];
       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, transformers }:
     mkDerivation {
       pname = "data-accessor-transformers";
       version = "0.2.1.7";
       sha256 = "20c8823dc16c7ca6f55c64eb5564c9aae4b5565406987a046ded2ea73618e07a";
       libraryHaskellDepends = [ base data-accessor transformers ];
       homepage = "http://www.haskell.org/haskellwiki/Record_access";
       description = "Use Accessor to access state in transformers State monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-aviary" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-aviary";
       version = "0.4.0";
       sha256 = "b60b765cb7c8b3c704c539cde308651d83164d4c5a0da17ae97ca1c4cfa2500e";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.google.com/p/copperbox/";
       description = "Combinator birds";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-base" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-base";
       version = "1.1";
       sha256 = "1d85ee03627495104cd73e8f4fc2459f3ff2e873a46cbd0db9708c6168ae25d1";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/wdanilo/data-base";
       description = "Utilities for accessing and comparing types based on so called bases - representations with limited polymorphism";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "data-binary-ieee754" = callPackage
    ({ mkDerivation, base, binary }:
     mkDerivation {
       pname = "data-binary-ieee754";
       version = "0.4.4";
       sha256 = "59975abed8f4caa602f0780c10a9b2493479e6feb71ad189bb10c3ac5678df0a";
       libraryHaskellDepends = [ base binary ];
       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, tasty, tasty-quickcheck }:
     mkDerivation {
       pname = "data-bword";
       version = "0.1";
       sha256 = "8d90db097d4df7688f2767f86d27534c79e8aa933a274962fc4a3ab4428b0ee8";
       libraryHaskellDepends = [ base ghc-prim ];
       testHaskellDepends = [ base tasty tasty-quickcheck ];
       homepage = "https://github.com/mvv/data-bword";
       description = "Extra operations on binary words of fixed length";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-carousel" = callPackage
    ({ mkDerivation, base, containers, lens }:
     mkDerivation {
       pname = "data-carousel";
       version = "0.1.0.0";
       sha256 = "505ba1c890aacf7b91745c64de05e5d8ca5d28154265e1c723fc0a850439e1ee";
       revision = "1";
       editedCabalFile = "56aa17d4ad0390625d0694ff6f8e281720d96bdabc678cc10934ac9becc663ea";
       libraryHaskellDepends = [ base containers lens ];
       description = "A rotating sequence data structure";
       license = stdenv.lib.licenses.mit;
     }) {};

  "data-category" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "data-category";
       version = "0.6.1";
       sha256 = "0ccb310d6b0b94df9e148c7f7d1ac792340b6767dc8d542e249c12f6e2e77de6";
       homepage = "http://github.com/sjoerdvisscher/data-category";
       description = "Category theory";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-cell" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-cell";
       version = "1.0.0.2";
       sha256 = "f9a91186a977d9a8c7f06d1a6b05d8e9a30c69a9b49196118920e517cc54910e";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/zadarnowski/data-cell";
       description = "Generic cellular data representation library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-checked" = callPackage
    ({ mkDerivation, base, deepseq }:
     mkDerivation {
       pname = "data-checked";
       version = "0.3";
       sha256 = "dc87d09c7c8587c9e6e372166e8de3b42c2cd804a493ff100c253e4d713c5676";
       libraryHaskellDepends = [ base deepseq ];
       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 }:
     mkDerivation {
       pname = "data-clist";
       version = "0.0.7.4";
       sha256 = "769f40b42d01d6e917a15fdfd381daafaabaed8d550bd7f85e6d45cb1cb2d96e";
       libraryHaskellDepends = [ base deepseq QuickCheck ];
       homepage = "https://github.com/sw17ch/data-clist";
       description = "Simple functional ring type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-concurrent-queue" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "data-concurrent-queue";
       version = "0.3.0.0";
       sha256 = "bb4e206a60521ec22dc9420c5ae96c282a1906399edcbed1a96abf5bf025b666";
       libraryHaskellDepends = [ base stm ];
       jailbreak = true;
       description = "A Library for directional queues";
       license = stdenv.lib.licenses.mit;
     }) {};

  "data-construction" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-construction";
       version = "1.1";
       sha256 = "e8e55864def9f07c65137535d4494b694203e724e450494f89b502751d92b341";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/wdanilo/data-construction";
       description = "Data construction abstractions including Constructor, Destructor, Maker, Destroyer, Producer and Consumer";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "data-cycle" = callPackage
    ({ mkDerivation, base, collections-api, collections-base-instances
     }:
     mkDerivation {
       pname = "data-cycle";
       version = "0.1.2";
       sha256 = "0f206c5ee2baf2bf53aea755eb8ce15cb9e88eb247a002bda291afbdc914eacc";
       libraryHaskellDepends = [
         base collections-api collections-base-instances
       ];
       description = "a cyclic doubly linked list";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-default" = callPackage
    ({ mkDerivation, base, data-default-class
     , data-default-instances-base, data-default-instances-containers
     , data-default-instances-dlist, data-default-instances-old-locale
     }:
     mkDerivation {
       pname = "data-default";
       version = "0.5.3";
       sha256 = "ec5470f41bf6dc60d65953fc8788823ffff85fd59564a8bf9ea3c69928a83034";
       libraryHaskellDepends = [
         base data-default-class data-default-instances-base
         data-default-instances-containers data-default-instances-dlist
         data-default-instances-old-locale
       ];
       description = "A class for types with a default value";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-default-class" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-default-class";
       version = "0.0.1";
       sha256 = "adc8ee80a6f0e5903339a2b8685220b32bc3e23856d3c12186cc464ae5c88f31";
       libraryHaskellDepends = [ base ];
       description = "A class for types with a default value";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-default-extra" = callPackage
    ({ mkDerivation, base, data-default-class
     , data-default-instances-base, data-default-instances-bytestring
     , data-default-instances-case-insensitive
     , data-default-instances-containers
     , data-default-instances-new-base
     , data-default-instances-old-locale, data-default-instances-text
     , data-default-instances-unordered-containers
     , data-default-instances-vector
     }:
     mkDerivation {
       pname = "data-default-extra";
       version = "0.0.1";
       sha256 = "ddd73777101f49566654bae02203424bc7f4dd55ba5b839b5d2d8d4fa6d0812e";
       libraryHaskellDepends = [
         base data-default-class data-default-instances-base
         data-default-instances-bytestring
         data-default-instances-case-insensitive
         data-default-instances-containers data-default-instances-new-base
         data-default-instances-old-locale data-default-instances-text
         data-default-instances-unordered-containers
         data-default-instances-vector
       ];
       homepage = "https://github.com/trskop/data-default-extra";
       description = "A class for types with a default value";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-default-generics" = callPackage
    ({ mkDerivation, base, bytestring, containers, dlist, ghc-prim
     , hspec, HUnit, old-locale, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "data-default-generics";
       version = "0.3";
       sha256 = "db07eb55dba3b763292ea58e64e04f52257c9cb70aeee2e6f73d12316c8e522b";
       libraryHaskellDepends = [
         base bytestring containers dlist ghc-prim old-locale text time
         unordered-containers vector
       ];
       testHaskellDepends = [
         base bytestring containers dlist ghc-prim hspec HUnit old-locale
         text time unordered-containers vector
       ];
       description = "A class for types with a default value";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-default-instances-base" = callPackage
    ({ mkDerivation, base, data-default-class }:
     mkDerivation {
       pname = "data-default-instances-base";
       version = "0.0.1";
       sha256 = "eb12ff0174ae1fe2613058b87d0752f94e64df9a9bf971780c2e24bf0cb662a0";
       libraryHaskellDepends = [ base data-default-class ];
       description = "Default instances for types in base";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-default-instances-bytestring" = callPackage
    ({ mkDerivation, base, bytestring, data-default-class }:
     mkDerivation {
       pname = "data-default-instances-bytestring";
       version = "0.0.1";
       sha256 = "4c431278d0dc1054fd531281db70d8615f88d9b2a29924aba2567fb3cf647220";
       libraryHaskellDepends = [ base bytestring data-default-class ];
       homepage = "https://github.com/trskop/data-default-extra";
       description = "Default instances for (lazy and strict) ByteString, Builder and ShortByteString";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-default-instances-case-insensitive" = callPackage
    ({ mkDerivation, case-insensitive, data-default-class }:
     mkDerivation {
       pname = "data-default-instances-case-insensitive";
       version = "0.0.1";
       sha256 = "430135708ad9d0730a4c3a3d1eb574bdc6f07547a5a9c5f30202e1e786070ab4";
       libraryHaskellDepends = [ case-insensitive data-default-class ];
       homepage = "https://github.com/trskop/data-default-extra";
       description = "Default instance for CI type from case-insensitive package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-default-instances-containers" = callPackage
    ({ mkDerivation, base, containers, data-default-class }:
     mkDerivation {
       pname = "data-default-instances-containers";
       version = "0.0.1";
       sha256 = "a55e07af005c9815d82f3fc95e125db82994377c9f4a769428878701d4ec081a";
       libraryHaskellDepends = [ base containers data-default-class ];
       description = "Default instances for types in containers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-default-instances-dlist" = callPackage
    ({ mkDerivation, base, data-default-class, dlist }:
     mkDerivation {
       pname = "data-default-instances-dlist";
       version = "0.0.1";
       sha256 = "7d683711cbf08abd7adcd5ac2be825381308d220397315a5570fe61b719b5959";
       libraryHaskellDepends = [ base data-default-class dlist ];
       description = "Default instances for types in dlist";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-default-instances-new-base" = callPackage
    ({ mkDerivation, base, data-default-class
     , data-default-instances-base
     }:
     mkDerivation {
       pname = "data-default-instances-new-base";
       version = "0.0.1";
       sha256 = "d923d291a26817f2bc54ba110efc8cb1cefcdb17c7a5af8e2d12506c594b7edc";
       libraryHaskellDepends = [
         base data-default-class data-default-instances-base
       ];
       homepage = "https://github.com/trskop/data-default-extra";
       description = "Default instances for types in newer versions of base package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-default-instances-old-locale" = callPackage
    ({ mkDerivation, base, data-default-class, old-locale }:
     mkDerivation {
       pname = "data-default-instances-old-locale";
       version = "0.0.1";
       sha256 = "60d3b02922958c4908d7bf2b24ddf61511665745f784227d206745784b0c0802";
       libraryHaskellDepends = [ base data-default-class old-locale ];
       description = "Default instances for types in old-locale";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-default-instances-text" = callPackage
    ({ mkDerivation, base, data-default-class, text }:
     mkDerivation {
       pname = "data-default-instances-text";
       version = "0.0.1";
       sha256 = "db5d4c46cf36ce5956ffd0affe0f2c48e1c000b9bd61821d3e6c1b0171060cdf";
       libraryHaskellDepends = [ base data-default-class text ];
       homepage = "https://github.com/trskop/data-default-extra";
       description = "Default instances for (lazy and strict) Text and Text Builder";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-default-instances-unordered-containers" = callPackage
    ({ mkDerivation, data-default-class, unordered-containers }:
     mkDerivation {
       pname = "data-default-instances-unordered-containers";
       version = "0.0.1";
       sha256 = "b382a7ea90fd61127782e95fa5e7ee3a17969b762bf0aac4efd15fa7c2552fc0";
       libraryHaskellDepends = [
         data-default-class unordered-containers
       ];
       homepage = "https://github.com/trskop/data-default-extra";
       description = "Default instances for unordered-containers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-default-instances-vector" = callPackage
    ({ mkDerivation, data-default-class, vector }:
     mkDerivation {
       pname = "data-default-instances-vector";
       version = "0.0.1";
       sha256 = "9ac84473a3af8b0c5e795ea5f84a34a0c18c3b2d5e17ce428206203f9d794666";
       libraryHaskellDepends = [ data-default-class vector ];
       homepage = "https://github.com/trskop/data-default-extra";
       description = "Default instances for types defined in vector package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-dispersal" = callPackage
    ({ mkDerivation, AES, array, base, binary, bytestring, entropy
     , finite-field, matrix, QuickCheck, secret-sharing, spool, syb
     , test-framework, test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "data-dispersal";
       version = "1.0.0.2";
       sha256 = "86af3b6970bf6d06b8ff27246af8e87f7b3734573c2d31b5d73105a83a69dcf4";
       libraryHaskellDepends = [
         AES array base binary bytestring entropy finite-field matrix
         secret-sharing syb vector
       ];
       testHaskellDepends = [
         array base binary bytestring QuickCheck spool syb test-framework
         test-framework-quickcheck2 vector
       ];
       homepage = "http://monoid.at/code";
       description = "Space-efficient and privacy-preserving data dispersal algorithms";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-dword" = callPackage
    ({ mkDerivation, base, data-bword, ghc-prim, hashable, tasty
     , tasty-quickcheck, template-haskell
     }:
     mkDerivation {
       pname = "data-dword";
       version = "0.3";
       sha256 = "e3f8bd8b529cd1e720d07a9ab9861f4e6f2cf63594a246d405d0c8125bad9254";
       libraryHaskellDepends = [
         base data-bword ghc-prim hashable template-haskell
       ];
       testHaskellDepends = [ base tasty tasty-quickcheck ];
       homepage = "https://github.com/mvv/data-dword";
       description = "Stick two binary words together to get a bigger one";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-easy" = callPackage
    ({ mkDerivation, base, containers, directory, errors
     , haskell-src-exts, hlint, hspec, HUnit, QuickCheck, safe, text
     , transformers, unix
     }:
     mkDerivation {
       pname = "data-easy";
       version = "0.6.1";
       sha256 = "3bc1e2d63e713f7ca34cfc75df1d8e22c4cab9de1893244dc0feada11960f406";
       libraryHaskellDepends = [ base containers safe ];
       testHaskellDepends = [
         base containers directory errors haskell-src-exts hlint hspec HUnit
         QuickCheck safe text transformers unix
       ];
       jailbreak = true;
       homepage = "https://github.com/jcristovao/data-easy";
       description = "Consistent set of utility functions for Maybe, Either, List and Monoids";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-embed" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, directory
     , executable-path, hashable, utf8-string
     }:
     mkDerivation {
       pname = "data-embed";
       version = "0.1.0.0";
       sha256 = "180c54a1b5db9905454386c8161e18cb8c8e733897e17b4f0c67390d3869f7de";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal containers directory executable-path
         hashable utf8-string
       ];
       executableHaskellDepends = [
         base bytestring cereal containers directory executable-path
         hashable utf8-string
       ];
       jailbreak = true;
       homepage = "https://github.com/valderman/data-embed";
       description = "Embed files and other binary blobs inside executables without Template Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "data-endian" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-endian";
       version = "0.1";
       sha256 = "39b84a6b516c8d7e0fdb72ed16a77f87bae9fcffb9c9437797d406de47bb9b46";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/mvv/data-endian";
       description = "Endian-sensitive data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-extend-generic" = callPackage
    ({ mkDerivation, base, hspec }:
     mkDerivation {
       pname = "data-extend-generic";
       version = "0.1.0.0";
       sha256 = "b5cf36c5ccf72a400bc8dca3a983c3a4b65a7788fbd07eca93e5b23dca27f1bd";
       revision = "2";
       editedCabalFile = "6d1bf0f2f19daf06b81fe4108a37bf889c9b96905920d3aa04846f0b5d05b6b3";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec ];
       homepage = "http://github.com/ylilarry/data-extend-generic";
       description = "Extend Haskell data or newtype like in OOP languages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-extra" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "data-extra";
       version = "2.5.5";
       sha256 = "815db3afa7d28f606a72a5de59fc59c3263312db39eae08d2f423dfceb50c45f";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-filepath" = callPackage
    ({ mkDerivation, base, bifunctors, ghc-prim, semigroups, split
     , template-haskell
     }:
     mkDerivation {
       pname = "data-filepath";
       version = "2.2.0.0";
       sha256 = "c79d7a7373f71ca35a346bf112fb6a338e9ed9a13100c24d3cf3e12cc0d3e1d0";
       libraryHaskellDepends = [
         base bifunctors ghc-prim semigroups split template-haskell
       ];
       jailbreak = true;
       homepage = "https://github.com/maxpow4h/data-filepath";
       description = "A type safe file path data structure";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-fin" = callPackage
    ({ mkDerivation, base, lazysmallcheck, prelude-safeenum, QuickCheck
     , reflection, smallcheck, tagged
     }:
     mkDerivation {
       pname = "data-fin";
       version = "0.1.1.3";
       sha256 = "3e5367284ffade4bdb7d8fc9ae3692a2d73d033cb060be13297f1cf9486ec30a";
       libraryHaskellDepends = [
         base lazysmallcheck prelude-safeenum QuickCheck reflection
         smallcheck tagged
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~wren/";
       description = "Finite totally ordered sets";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-fin-simple" = callPackage
    ({ mkDerivation, base, doctest }:
     mkDerivation {
       pname = "data-fin-simple";
       version = "0.1.0.0";
       sha256 = "e6e6e7c30c69cfe5ec67f0763c880d28e37d05c336e9b5c76c53e549c71a129f";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base doctest ];
       homepage = "https://github.com/seagull-kamome/data-fin-simple";
       description = "Simple integral finite set";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-fix" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-fix";
       version = "0.0.1";
       sha256 = "f93a17bedc61402014fa8b7ffdea2dfe3cee13866e4d5ec6356a8ab433452027";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/anton-k/data-fix";
       description = "Fixpoint data types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-fix-cse" = callPackage
    ({ mkDerivation, base, containers, data-fix, transformers }:
     mkDerivation {
       pname = "data-fix-cse";
       version = "0.0.2";
       sha256 = "e22697076125286a36cab1e7cb3f8367368d8ed72d9c86fc105ab792a3c5c6f6";
       libraryHaskellDepends = [ base containers data-fix transformers ];
       homepage = "https://github.com/anton-k/data-fix-cse";
       description = "Common subexpression elimination for the fixploint types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-flags" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "data-flags";
       version = "0.0.3.1";
       sha256 = "45bfa0c14b4e31364c5b7c70bf19f1ee3aa6ae692e08e7a70b56668503970de8";
       libraryHaskellDepends = [ base template-haskell ];
       description = "A package for working with bit masks and flags in general";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-flagset" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-flagset";
       version = "1.0.0.0";
       sha256 = "82aba0f5410728a2fdfe2888960f218453b42f4f73eb018493536fb158fefb79";
       libraryHaskellDepends = [ base ];
       description = "An efficient data type for sets of flags";
       license = stdenv.lib.licenses.mit;
     }) {};

  "data-fresh" = callPackage
    ({ mkDerivation, base, free, transformers }:
     mkDerivation {
       pname = "data-fresh";
       version = "0.2013.251.0";
       sha256 = "c11d5445f43f7cdf9525ce81678bd2dde61931793ecc149c26bca2b37d05e3c3";
       libraryHaskellDepends = [ base free transformers ];
       description = "Interface and functor transformers for fresh values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-hash" = callPackage
    ({ mkDerivation, array, base, containers, QuickCheck
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "data-hash";
       version = "0.2.0.1";
       sha256 = "9117dd49013ca28ff188fc71c3595ac3af23d56d301c1f39bac93d44d8c60bbe";
       libraryHaskellDepends = [ array base containers ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       description = "Combinators for building fast hashing functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-interval" = callPackage
    ({ mkDerivation, base, containers, deepseq, extended-reals
     , hashable, HUnit, lattices, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     , test-framework-th
     }:
     mkDerivation {
       pname = "data-interval";
       version = "1.2.0";
       sha256 = "75129fd2944ad2c7dcc808571e9f2fc5b6e99ee9b7d9cad0429364908b403b8d";
       libraryHaskellDepends = [
         base deepseq extended-reals hashable lattices
       ];
       testHaskellDepends = [
         base containers HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 test-framework-th
       ];
       description = "Interval arithmetic for both open and closed intervals";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-inttrie_0_1_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-inttrie";
       version = "0.1.0";
       sha256 = "24a0e18f436ba3d48502c67e07a148b96670de89a3d77c19220878c0d9707f02";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/luqui/data-inttrie";
       description = "A lazy, infinite trie of integers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-inttrie" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-inttrie";
       version = "0.1.2";
       sha256 = "8ddae7ad7d3cafdf349d93c0eed5767ab1213d854980bc28d7d935163c5f1df9";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/luqui/data-inttrie";
       description = "A lazy, infinite trie of integers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-ivar" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "data-ivar";
       version = "0.30";
       sha256 = "62b96f30b8b7b6a5abe2839bdf27c665e2b2e84f55e931b4b793e509e3aecbee";
       libraryHaskellDepends = [ base containers ];
       description = "Write-once variables with concurrency support";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-json-token" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-json-token";
       version = "0.1.0.0";
       sha256 = "c58910c76fe08d082f174e7a6e8f04388e9e1bf9326ec4f4dd69908ce6ecfe2d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/haskell-works/data-json-token#readme";
       description = "Json Token datatype";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-kiln" = callPackage
    ({ mkDerivation, base, containers, data-fix, IfElse, mtl
     , transformers
     }:
     mkDerivation {
       pname = "data-kiln";
       version = "0.1.0.0";
       sha256 = "de4621bb587fb96878b2b9a3de7eee161c4e404e543318ac64071d2f6fbdf38e";
       libraryHaskellDepends = [
         base containers data-fix IfElse mtl transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/kwf/data-kiln";
       description = "Sculpt mutable recursive data with reference equality; bake it using a data kiln into an immutable lazy structure";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-layer" = callPackage
    ({ mkDerivation, base, convert, data-construction, lens }:
     mkDerivation {
       pname = "data-layer";
       version = "1.0.4";
       sha256 = "3c11be8dc0da7f4cb080023e2d0ae9f58ad202e193c6f1aea015b7b7873a936d";
       libraryHaskellDepends = [ base convert data-construction lens ];
       homepage = "https://github.com/wdanilo/layer";
       description = "Data layering utilities. Layer is a data-type which wrapps other one, but keeping additional information. If you want to access content of simple newtype object, use Lens.Wrapper instead.";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "data-layout" = callPackage
    ({ mkDerivation, base, bytestring, vector }:
     mkDerivation {
       pname = "data-layout";
       version = "0.1.0.0";
       sha256 = "a5070520bcb6c3d8e7dcc969d94ac35c8bc5894abf45b65155b58571f82619f1";
       libraryHaskellDepends = [ base bytestring vector ];
       homepage = "http://github.com/jystic/data-layout";
       description = "Read/write arbitrary binary layouts to a \"Data.Vector.Storable\".";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-lens" = callPackage
    ({ mkDerivation, base, comonad, containers, semigroupoids
     , transformers
     }:
     mkDerivation {
       pname = "data-lens";
       version = "2.10.7";
       sha256 = "3b198a84158d757d074b6cf71fe16c8ad900e24991d9813d0b6361a1fd97e050";
       libraryHaskellDepends = [
         base comonad containers semigroupoids transformers
       ];
       homepage = "http://github.com/roconnor/data-lens/";
       description = "Used to be Haskell 98 Lenses";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-lens-fd" = callPackage
    ({ mkDerivation, base, comonad, data-lens, mtl, transformers }:
     mkDerivation {
       pname = "data-lens-fd";
       version = "2.0.5";
       sha256 = "d3df1cedb0ccacfa6a2926466e10388b2a2e7bd78f5718cb2260746eec730c65";
       libraryHaskellDepends = [
         base comonad data-lens mtl transformers
       ];
       homepage = "http://github.com/roconnor/data-lens-fd/";
       description = "Lenses";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-lens-ixset" = callPackage
    ({ mkDerivation, base, data-lens, ixset, QuickCheck }:
     mkDerivation {
       pname = "data-lens-ixset";
       version = "0.1.4";
       sha256 = "a1186fa7823dab18ec0c6c8593e2dae10f791db007d41095f32af07399933f3b";
       libraryHaskellDepends = [ base data-lens ixset ];
       testHaskellDepends = [ QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/dag/data-lens-ixset";
       description = "A Lens for IxSet";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-lens-light" = callPackage
    ({ mkDerivation, base, mtl, template-haskell }:
     mkDerivation {
       pname = "data-lens-light";
       version = "0.1.2.1";
       sha256 = "1c1947f9f5f4247ba5ff905a9ecae367e495f69b821a22c0c261f64dd6771b0d";
       libraryHaskellDepends = [ base mtl template-haskell ];
       homepage = "https://github.com/feuerbach/data-lens-light";
       description = "Simple lenses, minimum dependencies";
       license = stdenv.lib.licenses.mit;
     }) {};

  "data-lens-template" = callPackage
    ({ mkDerivation, base, data-lens, template-haskell }:
     mkDerivation {
       pname = "data-lens-template";
       version = "2.1.9";
       sha256 = "cf94f5d81569ad8f0ce4194649f5920226adf990d4012728958516d9821af236";
       libraryHaskellDepends = [ base data-lens template-haskell ];
       homepage = "http://github.com/roconnor/data-lens-template/";
       description = "Utilities for Data.Lens";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-list-sequences" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-list-sequences";
       version = "0.1";
       sha256 = "684f915a5a4244162706dcd67848df7f37f2b603df7600ca6b1accd7a9317e64";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/jkramer/data-list-sequences";
       description = "Utilities for working with sequences within lists";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "data-map-multikey" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "data-map-multikey";
       version = "0.0.1.2";
       sha256 = "6ed634f52207a9add10882ab03f17abfea5d91e310a0ec3f54197163bf980412";
       libraryHaskellDepends = [ base containers ];
       jailbreak = true;
       homepage = "http://github.com/jhickner/data-map-multikey";
       description = "Data.Map with multiple, unique keys";
       license = stdenv.lib.licenses.mit;
     }) {};

  "data-memocombinators" = callPackage
    ({ mkDerivation, array, base, data-inttrie }:
     mkDerivation {
       pname = "data-memocombinators";
       version = "0.5.1";
       sha256 = "b4341d2024b84a43f92edc39f6d6766bf4f0f00a40fd834b9f6f8e987b606ed7";
       libraryHaskellDepends = [ array base data-inttrie ];
       homepage = "http://github.com/luqui/data-memocombinators";
       description = "Combinators for building memo tables";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-named" = callPackage
    ({ mkDerivation, attoparsec, base, binary, containers, text }:
     mkDerivation {
       pname = "data-named";
       version = "0.5.2";
       sha256 = "5d43477697af2202b899300bb8283540d95b9f1004194daea924cab3d8b2fcd7";
       libraryHaskellDepends = [ attoparsec base binary containers text ];
       homepage = "https://github.com/kawu/data-named";
       description = "Data types for named entities";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-nat" = callPackage
    ({ mkDerivation, base, semigroups }:
     mkDerivation {
       pname = "data-nat";
       version = "0.1.2";
       sha256 = "1540be01a754638b1f45d2d386e9ec68fc7dad83da83a67c34c7ff0e209bfdfb";
       libraryHaskellDepends = [ base semigroups ];
       jailbreak = true;
       homepage = "http://github.com/glehel/data-nat";
       description = "data Nat = Zero | Succ Nat";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-object" = callPackage
    ({ mkDerivation, base, bytestring, failure, text, time }:
     mkDerivation {
       pname = "data-object";
       version = "0.3.1.9";
       sha256 = "14250ab80e6a1c235efcda2ad8c61194dfdee9dec1a31c3c844656c4e710157d";
       libraryHaskellDepends = [ base bytestring failure text time ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/data-object/tree/master";
       description = "Represent hierachichal structures, called objects in JSON. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-object-json" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-trie
     , convertible-text, data-object, failure, JSONb, text
     }:
     mkDerivation {
       pname = "data-object-json";
       version = "0.3.1.8";
       sha256 = "130ff587725b72dda9206586b444e43f93233df12620581dc185ce4b248ef31b";
       libraryHaskellDepends = [
         base bytestring bytestring-trie convertible-text data-object
         failure JSONb text
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/data-object-json/tree/master";
       description = "Serialize JSON data to/from Haskell using the data-object library. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-object-yaml" = callPackage
    ({ mkDerivation, base, bytestring, conduit, containers
     , convertible-text, data-object, failure, text, transformers, yaml
     }:
     mkDerivation {
       pname = "data-object-yaml";
       version = "0.3.4.2";
       sha256 = "5785ea86b5c2da50edc5dc595d9deadae0a5868f294a6b9664f1aceb38c949a1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring conduit containers convertible-text data-object
         failure text transformers yaml
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/data-object-yaml";
       description = "Serialize data to and from Yaml files (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-or" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-or";
       version = "1.0.0.5";
       sha256 = "9defb64f1c7210460a940beb7f32ba1c79f363fbf3a5bd126feb876930c6e672";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.haskell.org/~wren/";
       description = "A data type for non-exclusive disjunction";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-ordlist" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-ordlist";
       version = "0.4.7.0";
       sha256 = "6f6c1e7a9a9155ad78ca78cb9abd6f7e2e1c78b3e549b179dc0874e6428f490d";
       libraryHaskellDepends = [ base ];
       description = "Set and bag operations on ordered lists";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-partition" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "data-partition";
       version = "0.3.0.0";
       sha256 = "4bcab7b5da1044e7877e1c5b223175224e770dbf787148954cecba83d3732816";
       libraryHaskellDepends = [ base containers ];
       homepage = "https://github.com/luqui/data-partition";
       description = "A pure disjoint set (union find) data structure";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-pprint" = callPackage
    ({ mkDerivation, base, deepseq, mtl, parallel, pretty, time }:
     mkDerivation {
       pname = "data-pprint";
       version = "0.2.4";
       sha256 = "659bf5b10d5c177982bed9f6676a656387c70e9223ea0b1060afbe446f499864";
       libraryHaskellDepends = [ base deepseq mtl parallel pretty time ];
       description = "Prettyprint and compare Data values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-quotientref" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-quotientref";
       version = "0.1";
       sha256 = "489e7108071f45f1abf862f91594ab643cc561cb18bdaec4a7f30c0ea7aa917a";
       libraryHaskellDepends = [ base ];
       description = "Reference cells that need two independent indices to be accessed";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-r-tree" = callPackage
    ({ mkDerivation, base, binary, containers, deepseq, HUnit
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "data-r-tree";
       version = "0.0.5.0";
       sha256 = "de6f7956043503f86e45d6a76d39a7d3b45c0ef004324ac159d0f50f04a8fcfd";
       libraryHaskellDepends = [ base binary deepseq ];
       testHaskellDepends = [
         base binary containers HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/sebastian-philipp/r-tree";
       description = "R-Tree is a spatial data structure similar to Quadtrees or B-Trees";
       license = stdenv.lib.licenses.mit;
     }) {};

  "data-ref" = callPackage
    ({ mkDerivation, base, stm, transformers }:
     mkDerivation {
       pname = "data-ref";
       version = "0.0.1.1";
       sha256 = "a4dabee83c7419199791d0ebf7870f926b1ca834a361ecfeb3c134f7fa64f268";
       libraryHaskellDepends = [ base stm transformers ];
       homepage = "http://wiki.haskell.org/Mutable_variable";
       description = "Unify STRef and IORef in plain Haskell 98";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-reify_0_6" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "data-reify";
       version = "0.6";
       sha256 = "47997d8b36d3103d024ed572255abf51707984743514f619e2fb17796b422e56";
       revision = "1";
       editedCabalFile = "60185d3fdb87fe62f297eb4473d58a7ccf93d1b6ee790a8b2faed79e1ac833c1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [ base ];
       homepage = "http://www.ittc.ku.edu/csdl/fpg/Tools/IOReification";
       description = "Reify a recursive data structure into an explicit graph";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-reify" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "data-reify";
       version = "0.6.1";
       sha256 = "61350a1e96cb1276c2b6b8b13fa1bade5d4e63c702509a3f5e90bbc19ad9b202";
       revision = "1";
       editedCabalFile = "f7f3a5b2f482a67eb77f4ba32e15f91bcfa4c220cdda9dde22cd9d9ff18ab447";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [ base ];
       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-reify-cse" = callPackage
    ({ mkDerivation, base, containers, data-reify }:
     mkDerivation {
       pname = "data-reify-cse";
       version = "0.0.3";
       sha256 = "59186a2290a630d53fb2d796d9cca1260dbd70fa414814778e1cab0aeeba4e6e";
       libraryHaskellDepends = [ base containers data-reify ];
       description = "Common Sub-Expression Elimination for graphs generated by Data.Reify.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-repr" = callPackage
    ({ mkDerivation, base, generic-deriving, lens }:
     mkDerivation {
       pname = "data-repr";
       version = "1.0";
       sha256 = "4939d7b8a7debb9a98cad8f468e07dcc7cd6424fdfd51dc4da74a35ff6536492";
       libraryHaskellDepends = [ base generic-deriving lens ];
       homepage = "https://github.com/wdanilo/data-repr";
       description = "Alternative to Show data printing utility";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "data-result" = callPackage
    ({ mkDerivation, base, poly-control, prologue }:
     mkDerivation {
       pname = "data-result";
       version = "1.0";
       sha256 = "b266c0184e55ed2fe7af03cf837a2666c6c3265b5de9d5f7416926f981bf0605";
       libraryHaskellDepends = [ base poly-control prologue ];
       homepage = "https://github.com/wdanilo/data-result";
       description = "Data types for returning results distinguishable by types";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "data-rev" = callPackage
    ({ mkDerivation, base, bytestring, containers, text, vector }:
     mkDerivation {
       pname = "data-rev";
       version = "0.1.0.1";
       sha256 = "81ce8fb0d8bf1172f3869e67b5911b358bef10880011be1935d130bdf7b8788d";
       libraryHaskellDepends = [ base bytestring containers text vector ];
       jailbreak = true;
       homepage = "https://github.com/jxv/data-rev";
       description = "A typeclass for reversing order of contents";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-rope" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-mmap, unix }:
     mkDerivation {
       pname = "data-rope";
       version = "0.3";
       sha256 = "88f39dba154ee62ccab9b8ccd22142c56a878c21b0bfca14d96a9436c1375f1b";
       libraryHaskellDepends = [ base bytestring bytestring-mmap unix ];
       description = "Ropes, an alternative to (Byte)Strings";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-rtuple" = callPackage
    ({ mkDerivation, base, lens, typelevel }:
     mkDerivation {
       pname = "data-rtuple";
       version = "1.0";
       sha256 = "4e2824b8d23d5eafce4c5f86a90fb58d97f461b45a287006f37cf8f2bd09fb05";
       libraryHaskellDepends = [ base lens typelevel ];
       homepage = "https://github.com/wdanilo/rtuple";
       description = "Recursive tuple data structure. It is very usefull when implementing some lo-level operations, allowing to traverse different elements using Haskell's type classes.";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "data-size" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, text }:
     mkDerivation {
       pname = "data-size";
       version = "0.1.1.7";
       sha256 = "fe286e41e1cb08d117536dd503381e5c47fb2f5c0fb40f4c6a4f3aa1601a2f48";
       libraryHaskellDepends = [
         base bytestring containers deepseq text
       ];
       description = "Profiling of data structures";
       license = stdenv.lib.licenses.mit;
     }) {};

  "data-spacepart" = callPackage
    ({ mkDerivation, base, vector-space }:
     mkDerivation {
       pname = "data-spacepart";
       version = "20090215.0";
       sha256 = "330fdfbcfcf5fb8211a8bf7e8bfafb14c8f4efb535c1edc464df2eb9a227df40";
       libraryHaskellDepends = [ base vector-space ];
       jailbreak = true;
       homepage = "http://code.haskell.org/data-spacepart";
       description = "Deprecated. Now called \"spacepart\". Space partitioning data structures.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-store" = callPackage
    ({ mkDerivation, base, cereal, containers, deepseq, lens
     , QuickCheck, safecopy, test-framework, test-framework-quickcheck2
     , transformers, vector
     }:
     mkDerivation {
       pname = "data-store";
       version = "0.3.0.7";
       sha256 = "6d85d661c40003ccb28bce8a8a2ca3fd2945234f338532b6ecde7bee46136033";
       libraryHaskellDepends = [
         base cereal containers deepseq lens safecopy transformers
       ];
       testHaskellDepends = [
         base cereal containers deepseq lens QuickCheck safecopy
         test-framework test-framework-quickcheck2 transformers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/Palmik/data-store";
       description = "Type safe, in-memory dictionary with multidimensional keys";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-stringmap" = callPackage
    ({ mkDerivation, base, binary, containers, deepseq, ghc-heap-view
     , HUnit, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "data-stringmap";
       version = "1.0.1.1";
       sha256 = "415d3000ef4d3dec1cd2df04fbad184aeea8ddc04cc4fe2401b943538b9f4b36";
       libraryHaskellDepends = [ base binary containers deepseq ];
       testHaskellDepends = [
         base containers deepseq ghc-heap-view HUnit QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       description = "An efficient implementation of maps from strings to arbitrary values";
       license = stdenv.lib.licenses.mit;
     }) {};

  "data-structure-inferrer" = callPackage
    ({ mkDerivation, alex, ansi-terminal, array, base, deepseq, derive
     , directory, filepath, happy, language-c, mtl, random, safe
     , utility-ht
     }:
     mkDerivation {
       pname = "data-structure-inferrer";
       version = "1.0";
       sha256 = "899b42ac23f5a0643aa3402fe923f97657850a14a7f31fe59673d51ca6f66b4a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal array base deepseq derive directory filepath
         language-c mtl random safe utility-ht
       ];
       executableToolDepends = [ alex happy ];
       homepage = "http://github.com/alistra/data-structure-inferrer";
       description = "Program that infers the fastest data structure available for your program";
       license = stdenv.lib.licenses.mit;
     }) {};

  "data-tensor" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-tensor";
       version = "0.1.0.0";
       sha256 = "c88613f44b62ed4cc6cf268f419d1e99d6bffd5b1b24dd87bea6433ae4d3d248";
       libraryHaskellDepends = [ base ];
       homepage = "https://bitbucket.org/tdammers/data-tensor";
       description = "Tensor and Group typeclasses";
       license = stdenv.lib.licenses.mit;
     }) {};

  "data-textual" = callPackage
    ({ mkDerivation, base, bytestring, parsers, QuickCheck
     , test-framework, test-framework-quickcheck2, text, text-latin1
     , text-printer, type-hint
     }:
     mkDerivation {
       pname = "data-textual";
       version = "0.3.0.2";
       sha256 = "44c530b081a486c50d668004637814223d1f1890716d39f7b692c83644d29830";
       libraryHaskellDepends = [
         base bytestring parsers text text-latin1 text-printer
       ];
       testHaskellDepends = [
         base parsers QuickCheck test-framework test-framework-quickcheck2
         text-printer type-hint
       ];
       homepage = "https://github.com/mvv/data-textual";
       description = "Human-friendly textual representations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-timeout" = callPackage
    ({ mkDerivation, base, data-textual, parsers, tagged, text-printer
     , transformers-base
     }:
     mkDerivation {
       pname = "data-timeout";
       version = "0.3";
       sha256 = "50a143a474206780a10fee19f4d8572c9c65b060d79fadad9f61c114ba70caac";
       libraryHaskellDepends = [
         base data-textual parsers tagged text-printer transformers-base
       ];
       homepage = "https://github.com/mvv/data-timeout";
       description = "64-bit timeouts of nanosecond precision";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-transform" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "data-transform";
       version = "0.1.0.0";
       sha256 = "516ab72802b18befd0e0f3b9ab051ad1f5af9aea5d52ce088624104d205f0cd6";
       libraryHaskellDepends = [ base containers mtl ];
       description = "Functions to transform data structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-treify" = callPackage
    ({ mkDerivation, base, containers, ty }:
     mkDerivation {
       pname = "data-treify";
       version = "0.3.4";
       sha256 = "6966917338d1283747ece373b9ea08584eb50a56bd208119cda438004586ac0f";
       libraryHaskellDepends = [ base containers ty ];
       homepage = "http://ittc.ku.edu/~andygill/data-reify.php";
       description = "Reify a recursive data structure into an explicit graph";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-type" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-type";
       version = "0.1.0";
       sha256 = "7263c2c4f8b9d1f984c3e481b83b15132ce3c0f3be3a1d0cf05da74ba3d57cf4";
       libraryHaskellDepends = [ base ];
       description = "Basic type wrangling types and classes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "data-util" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "data-util";
       version = "0.5";
       sha256 = "b2efae3502106d841bcc1d728334ed019c36656645127726517807a701c9177e";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/cutsea110/data-util";
       description = "utilities for handle data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "data-variant" = callPackage
    ({ mkDerivation, base, safe }:
     mkDerivation {
       pname = "data-variant";
       version = "0.28.0.5";
       sha256 = "b3c2af96b46dffd5ba62e2dab6d8761f8f86f1f61eb1d90f52e87724f0192a86";
       libraryHaskellDepends = [ base safe ];
       homepage = "https://bitbucket.org/tdammers/data-variant";
       description = "A variant data type, useful for modeling dynamically-typed programming languages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "database-migrate" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, containers, directory
     , either, filepath, lens, postgresql-simple, text, time
     , transformers
     }:
     mkDerivation {
       pname = "database-migrate";
       version = "0.2.0";
       sha256 = "fe2f5e3332d883425da78eaee1b0d360da6f5773519f341c3bf87d1f0a1a1dc2";
       libraryHaskellDepends = [
         base bytestring cmdargs containers directory either filepath lens
         postgresql-simple text time transformers
       ];
       homepage = "https://github.com/markhibberd/database-migrate";
       description = "Database versioning and migration (experimental)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "database-study" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "database-study";
       version = "0.0.1";
       sha256 = "a73d412476ae3a21f78051df671262b105f62a00c7b2947070a89c6b883a17ab";
       libraryHaskellDepends = [ base containers ];
       jailbreak = true;
       homepage = "http://dbs.informatik.uni-halle.de/Lehre/LP09/";
       description = "Demonstrate how a database can be implemented the functional way";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "datadog" = callPackage
    ({ mkDerivation, aeson, auto-update, base, buffer-builder
     , bytestring, lens, lifted-base, monad-control, network, old-locale
     , text, time, transformers-base
     }:
     mkDerivation {
       pname = "datadog";
       version = "0.1.0.1";
       sha256 = "c31855ea4008644941320574cfdff1085e8c160414288e528af8ad1fd5bc0e16";
       libraryHaskellDepends = [
         aeson auto-update base buffer-builder bytestring lens lifted-base
         monad-control network old-locale text time transformers-base
       ];
       homepage = "https://github.com/iand675/datadog";
       description = "Datadog client for Haskell. Currently only StatsD supported, other support forthcoming.";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "dataenc" = callPackage
    ({ mkDerivation, array, base, containers }:
     mkDerivation {
       pname = "dataenc";
       version = "0.14.0.7";
       sha256 = "f9d370a1ac1b9cd3c66abd13ad351270d020a21fcd774f49dae6cfa9f8a98ff3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base containers ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Library/Data_encoding";
       description = "Data encoding library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dataflow" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, bytestring, containers
     , filepath, gitrev, hastache, hspec, HUnit, markdown, MissingH, mtl
     , parsec, text, vector
     }:
     mkDerivation {
       pname = "dataflow";
       version = "0.7.3.0";
       sha256 = "312f2f0497cbd7e34d6eb3c4f1d113443e5375346b70628c0a22211e4baf883a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base blaze-html bytestring containers filepath hastache
         markdown MissingH mtl parsec text vector
       ];
       executableHaskellDepends = [ base bytestring gitrev text ];
       testHaskellDepends = [
         aeson base bytestring containers hspec HUnit parsec vector
       ];
       homepage = "https://github.com/sonyxperiadev/dataflow";
       description = "Generate Graphviz documents from a Haskell representation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "datalog" = callPackage
    ({ mkDerivation, base, containers, exceptions, hashable, haskeline
     , HUnit, parsec, pretty, test-framework, test-framework-hunit, text
     , transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "datalog";
       version = "0.2.0.2";
       sha256 = "0665f0580449d79218b71b5a4d4ff3d1a9b9e678eecc9a0530482169dcabd2d9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers exceptions hashable text transformers
         unordered-containers vector
       ];
       executableHaskellDepends = [
         base containers exceptions hashable haskeline parsec pretty text
         transformers unordered-containers vector
       ];
       testHaskellDepends = [
         base containers hashable HUnit test-framework test-framework-hunit
         text
       ];
       jailbreak = true;
       description = "An implementation of datalog in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "datapacker" = callPackage
    ({ mkDerivation, base, directory, filepath, hslogger, MissingH, mtl
     , process, unix
     }:
     mkDerivation {
       pname = "datapacker";
       version = "1.0.1";
       sha256 = "8f2aad20f035ae5278946b77934b22f63b859aff32c074ade3e6e4c5c90fd281";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath hslogger MissingH mtl process unix
       ];
       homepage = "http://software.complete.org/datapacker";
       description = "Tool to help pack files into the minimum number of CDs/DVDs/etc";
       license = "GPL";
     }) {};

  "dataurl" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, bytestring
     , HTF, text
     }:
     mkDerivation {
       pname = "dataurl";
       version = "0.1.0.0";
       sha256 = "b1e72b48dbe72520f0b43b06ae75cb025e9750213982583f527e16b605660fb2";
       libraryHaskellDepends = [
         attoparsec base base64-bytestring bytestring text
       ];
       testHaskellDepends = [
         attoparsec base base64-bytestring bytestring HTF text
       ];
       homepage = "http://github.com/agrafix/dataurl#readme";
       description = "Handle data-urls";
       license = stdenv.lib.licenses.mit;
     }) {};

  "date-cache" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "date-cache";
       version = "0.3.0";
       sha256 = "abce44f11dd9da4abaca9e33da2c74bd32b42fea027d171c03b6c10cda62303f";
       libraryHaskellDepends = [ base bytestring ];
       description = "Date cacher";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dates" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, parsec, syb, time }:
     mkDerivation {
       pname = "dates";
       version = "0.2.2.1";
       sha256 = "6dbd2a18aa21435341ab4f537899b60eac38de384597efd2e9eb8c95030c8c09";
       libraryHaskellDepends = [
         base base-unicode-symbols parsec syb time
       ];
       homepage = "http://redmine.iportnov.ru/projects/dates/";
       description = "Small library for parsing different dates formats";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "datetime" = callPackage
    ({ mkDerivation, base, HUnit, old-locale, old-time, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , time
     }:
     mkDerivation {
       pname = "datetime";
       version = "0.3.1";
       sha256 = "333c7577c5051eb23d172568b9d4fe186f8b5bc750ba1d09822c275d76edbd4a";
       libraryHaskellDepends = [ base old-locale old-time time ];
       testHaskellDepends = [
         base HUnit old-locale old-time QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 time
       ];
       homepage = "http://github.com/stackbuilders/datetime";
       description = "Utilities to make Data.Time.* easier to use";
       license = "GPL";
     }) {};

  "datetime-sb" = callPackage
    ({ mkDerivation, base, HUnit, old-locale, old-time, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , time
     }:
     mkDerivation {
       pname = "datetime-sb";
       version = "0.2.4";
       sha256 = "4e56759835f76e1dbe5d9dda022e0eb62af253c5d202146bdd0cb7d824b057dc";
       libraryHaskellDepends = [ base old-locale old-time time ];
       testHaskellDepends = [
         base HUnit old-locale old-time QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 time
       ];
       homepage = "http://github.com/stackbuilders/datetime";
       description = "Utilities to make Data.Time.* easier to use.";
       license = "GPL";
     }) {};

  "dawdle" = callPackage
    ({ mkDerivation, base, filepath, parsec, pretty, text, time }:
     mkDerivation {
       pname = "dawdle";
       version = "0.1.0.2";
       sha256 = "6228a3bd300d3577936cea83bd25cad3b015977eeb4b7ba7c18b0665da941856";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base parsec pretty text time ];
       executableHaskellDepends = [ base filepath parsec pretty text ];
       homepage = "https://github.com/arnons1/dawdle";
       description = "Generates DDL suggestions based on a CSV file";
       license = stdenv.lib.licenses.mit;
     }) {};

  "dawg" = callPackage
    ({ mkDerivation, base, binary, containers, mtl, transformers
     , vector, vector-binary
     }:
     mkDerivation {
       pname = "dawg";
       version = "0.11";
       sha256 = "299dfabdea78a7a89ab22f22b60963747f29a23f1a349aca36241b7361e17377";
       libraryHaskellDepends = [
         base binary containers mtl transformers vector vector-binary
       ];
       homepage = "https://github.com/kawu/dawg";
       description = "Directed acyclic word graphs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dawg-ord" = callPackage
    ({ mkDerivation, base, containers, HUnit, mtl, smallcheck, tasty
     , tasty-hunit, tasty-quickcheck, tasty-smallcheck, transformers
     , vector
     }:
     mkDerivation {
       pname = "dawg-ord";
       version = "0.5.0.1";
       sha256 = "febbe3a465f67931bf1a96069680c862b8cd9a423013f85e21204832626a5dee";
       libraryHaskellDepends = [
         base containers mtl transformers vector
       ];
       testHaskellDepends = [
         base containers HUnit mtl smallcheck tasty tasty-hunit
         tasty-quickcheck tasty-smallcheck
       ];
       homepage = "https://github.com/kawu/dawg-ord";
       description = "Directed acyclic word graphs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dbcleaner" = callPackage
    ({ mkDerivation, base, hspec, postgresql-simple, text }:
     mkDerivation {
       pname = "dbcleaner";
       version = "0.1.1";
       sha256 = "8c45177c9f36943a7aa332534d7e120b5c1a50f8d628d6d56ef49cd21ca08ad8";
       libraryHaskellDepends = [ base postgresql-simple text ];
       testHaskellDepends = [ base hspec postgresql-simple text ];
       description = "Clean database tables automatically around hspec tests";
       license = stdenv.lib.licenses.mit;
     }) {};

  "dbf" = callPackage
    ({ mkDerivation, base, binary, bytestring, monad-loops, rwlock }:
     mkDerivation {
       pname = "dbf";
       version = "0.0.0.2";
       sha256 = "c216e6fa2cb5794e3f81a1d47163ad6e7e9b827d73e8cf2ad471f7bad6215edd";
       libraryHaskellDepends = [
         base binary bytestring monad-loops rwlock
       ];
       homepage = "http://code.haskell.org/~mokus/dbf";
       description = "Read and write XBase \".dbf\" files";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "dbjava" = callPackage
    ({ mkDerivation, base, binary, bytestring, haskell98, process
     , uulib
     }:
     mkDerivation {
       pname = "dbjava";
       version = "1.7";
       sha256 = "ae4ce9d32216b54605d0e52dda740ddf8fb33e078fa6f03531594a8d8602bf1b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring haskell98 process uulib
       ];
       executableHaskellDepends = [
         base binary bytestring haskell98 process uulib
       ];
       homepage = "http://devel.comunidadhaskell.org/dbjava/";
       description = "Decompiler Bytecode Java";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dbmigrations_1_0" = callPackage
    ({ mkDerivation, base, bytestring, configurator, containers
     , directory, fgl, filepath, HDBC, HDBC-postgresql, HDBC-sqlite3
     , HUnit, MissingH, mtl, process, random, template-haskell, text
     , time, yaml-light
     }:
     mkDerivation {
       pname = "dbmigrations";
       version = "1.0";
       sha256 = "5dcd9d29eb4794070b8f41f1ec59e1937eebc68cc6de40c14219e815e56e16f6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring configurator containers directory fgl filepath HDBC
         HDBC-postgresql HDBC-sqlite3 mtl random template-haskell text time
         yaml-light
       ];
       executableHaskellDepends = [ base configurator ];
       testHaskellDepends = [
         base bytestring configurator containers directory fgl filepath HDBC
         HDBC-postgresql HDBC-sqlite3 HUnit MissingH mtl process
         template-haskell text time yaml-light
       ];
       doCheck = false;
       description = "An implementation of relational database \"migrations\"";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dbmigrations" = callPackage
    ({ mkDerivation, base, bytestring, configurator, containers
     , directory, fgl, filepath, HDBC, HDBC-postgresql, HDBC-sqlite3
     , HUnit, MissingH, mtl, mysql, mysql-simple, process, random, split
     , template-haskell, text, time, yaml-light
     }:
     mkDerivation {
       pname = "dbmigrations";
       version = "1.1";
       sha256 = "fe8075f25f1b55a55e792e654b8708e7f093c78b2cd75c1f1867efbf1a3cc2bc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring configurator containers directory fgl filepath HDBC
         HDBC-postgresql HDBC-sqlite3 mtl mysql mysql-simple random split
         template-haskell text time yaml-light
       ];
       executableHaskellDepends = [ base configurator ];
       testHaskellDepends = [
         base bytestring configurator containers directory fgl filepath HDBC
         HDBC-postgresql HDBC-sqlite3 HUnit MissingH mtl mysql mysql-simple
         process split template-haskell text time yaml-light
       ];
       doCheck = false;
       description = "An implementation of relational database \"migrations\"";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dbus_0_10_10" = callPackage
    ({ mkDerivation, base, bytestring, cereal, chell, chell-quickcheck
     , containers, directory, filepath, libxml-sax, network, parsec
     , process, QuickCheck, random, text, transformers, unix, vector
     , xml-types
     }:
     mkDerivation {
       pname = "dbus";
       version = "0.10.10";
       sha256 = "cd68c5613fbad01a31be17501e2b4cf242b09625d5fed9474db6c4b5c4f22468";
       libraryHaskellDepends = [
         base bytestring cereal containers libxml-sax network parsec random
         text transformers unix vector xml-types
       ];
       testHaskellDepends = [
         base bytestring cereal chell chell-quickcheck containers directory
         filepath libxml-sax network parsec process QuickCheck random text
         transformers unix vector xml-types
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://john-millikin.com/software/haskell-dbus/";
       description = "A client library for the D-Bus IPC system";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dbus_0_10_11" = callPackage
    ({ mkDerivation, base, bytestring, cereal, chell, chell-quickcheck
     , containers, directory, filepath, libxml-sax, network, parsec
     , process, QuickCheck, random, text, transformers, unix, vector
     , xml-types
     }:
     mkDerivation {
       pname = "dbus";
       version = "0.10.11";
       sha256 = "73e6b2b2021215dd8b9540d770e5cc353427f37083c7d84ebc244ac48e630482";
       libraryHaskellDepends = [
         base bytestring cereal containers libxml-sax network parsec random
         text transformers unix vector xml-types
       ];
       testHaskellDepends = [
         base bytestring cereal chell chell-quickcheck containers directory
         filepath libxml-sax network parsec process QuickCheck random text
         transformers unix vector xml-types
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://john-millikin.com/software/haskell-dbus/";
       description = "A client library for the D-Bus IPC system";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dbus" = callPackage
    ({ mkDerivation, base, bytestring, cereal, chell, chell-quickcheck
     , containers, directory, filepath, libxml-sax, network, parsec
     , process, QuickCheck, random, text, transformers, unix, vector
     , xml-types
     }:
     mkDerivation {
       pname = "dbus";
       version = "0.10.12";
       sha256 = "f6d7b5640eb03e9598e38b1a2b2e7af1e9d357f3f845fc9528f9750965b92d54";
       libraryHaskellDepends = [
         base bytestring cereal containers libxml-sax network parsec random
         text transformers unix vector xml-types
       ];
       testHaskellDepends = [
         base bytestring cereal chell chell-quickcheck containers directory
         filepath libxml-sax network parsec process QuickCheck random text
         transformers unix vector xml-types
       ];
       doCheck = false;
       homepage = "https://john-millikin.com/software/haskell-dbus/";
       description = "A client library for the D-Bus IPC system";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "dbus-client" = callPackage
    ({ mkDerivation, base, containers, dbus-core, monads-tf, text
     , transformers
     }:
     mkDerivation {
       pname = "dbus-client";
       version = "0.4.1";
       sha256 = "58ea9c43eeab968225abecdcb752297d0af87bb8ac13cd9524ed4ba76630e07c";
       libraryHaskellDepends = [
         base containers dbus-core monads-tf text transformers
       ];
       jailbreak = true;
       homepage = "http://john-millikin.com/software/haskell-dbus/";
       description = "Monadic and object-oriented interfaces to DBus";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dbus-core" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , data-binary-ieee754, libxml-sax, network, parsec, text, unix
     , vector, xml-types
     }:
     mkDerivation {
       pname = "dbus-core";
       version = "0.9.3";
       sha256 = "cabddfbc4ff452f114f242dd364c91705448de9993230acf04b8461bfd380384";
       libraryHaskellDepends = [
         base binary bytestring containers data-binary-ieee754 libxml-sax
         network parsec text unix vector xml-types
       ];
       jailbreak = true;
       homepage = "https://john-millikin.com/software/dbus-core/";
       description = "Low-level D-Bus protocol implementation";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dbus-qq" = callPackage
    ({ mkDerivation, base, containers, dbus, parsec, QuickCheck
     , template-haskell
     }:
     mkDerivation {
       pname = "dbus-qq";
       version = "0.1.0";
       sha256 = "bdcbcbacf054a57551ebb21584847b20316954d819f805b96f5eea75b61de035";
       libraryHaskellDepends = [
         base containers dbus parsec template-haskell
       ];
       testHaskellDepends = [ base containers dbus QuickCheck ];
       jailbreak = true;
       description = "Quasi-quoter for DBus functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dbus-th" = callPackage
    ({ mkDerivation, base, containers, dbus, syb, template-haskell
     , text
     }:
     mkDerivation {
       pname = "dbus-th";
       version = "0.1.1.1";
       sha256 = "6c113c42bc87a9c874f0a0d408368aa021b197f88e2d0a2ce8ecb4e6503db36b";
       libraryHaskellDepends = [
         base containers dbus syb template-haskell text
       ];
       description = "TemplateHaskell generator of DBus bindings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dclabel" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, QuickCheck
     , quickcheck-instances, test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "dclabel";
       version = "0.9.0.0";
       sha256 = "39eee5fff3f8d776fc4c152d4d4d837c496a7fc96f9eaf9fe428f575e5c2cb2e";
       libraryHaskellDepends = [ base bytestring cereal containers ];
       testHaskellDepends = [
         base bytestring cereal containers QuickCheck quickcheck-instances
         test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       description = "This packge is deprecated. See the the \"LIO.DCLabel\" in the \"lio\" package.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dclabel-eci11" = callPackage
    ({ mkDerivation, base, pretty, QuickCheck }:
     mkDerivation {
       pname = "dclabel-eci11";
       version = "0.3";
       sha256 = "d364b95d3aee48dfedb31cb8998903853d53edd536cf7b3ffdf263476e4cccad";
       libraryHaskellDepends = [ base pretty QuickCheck ];
       description = "The Disjunction Category Label Format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ddc-base" = callPackage
    ({ mkDerivation, base, containers, deepseq, parsec, transformers
     , wl-pprint
     }:
     mkDerivation {
       pname = "ddc-base";
       version = "0.4.1.3";
       sha256 = "d5e178099df92c82edf41999f01c292b19602e9cb7d599ada4284bc5dc9e78ec";
       libraryHaskellDepends = [
         base containers deepseq parsec transformers wl-pprint
       ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciplined Disciple Compiler common utilities";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ddc-build" = callPackage
    ({ mkDerivation, base, containers, ddc-base, ddc-core
     , ddc-core-eval, ddc-core-flow, ddc-core-llvm, ddc-core-salt
     , ddc-core-simpl, ddc-core-tetra, ddc-source-tetra, deepseq
     , directory, filepath, mtl, process
     }:
     mkDerivation {
       pname = "ddc-build";
       version = "0.4.1.3";
       sha256 = "5a3a6488df40354294bea963e5432909e5bbdc6381e1a41e54e122f2526e7295";
       libraryHaskellDepends = [
         base containers ddc-base ddc-core ddc-core-eval ddc-core-flow
         ddc-core-llvm ddc-core-salt ddc-core-simpl ddc-core-tetra
         ddc-source-tetra deepseq directory filepath mtl process
       ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciplined Disciple Compiler build framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ddc-code" = callPackage
    ({ mkDerivation, base, filepath }:
     mkDerivation {
       pname = "ddc-code";
       version = "0.4.1.3";
       sha256 = "d9bceabc172cc9ab9ca9404971edd8ee657a5ff0017d9ae5545f33a1832520d5";
       libraryHaskellDepends = [ base filepath ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciplined Disciple Compiler base libraries";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ddc-core" = callPackage
    ({ mkDerivation, array, base, containers, ddc-base, deepseq
     , directory, mtl, transformers
     }:
     mkDerivation {
       pname = "ddc-core";
       version = "0.4.1.3";
       sha256 = "a5b5f0c484379060149efc82f6f704abf64691cb126c687c5d1adf311f0b4595";
       libraryHaskellDepends = [
         array base containers ddc-base deepseq directory mtl transformers
       ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciplined Disciple Compiler core language and type checker";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ddc-core-eval" = callPackage
    ({ mkDerivation, array, base, containers, ddc-base, ddc-core
     , deepseq, mtl, transformers
     }:
     mkDerivation {
       pname = "ddc-core-eval";
       version = "0.4.1.3";
       sha256 = "adfbec804f60893af7b8c6dd6de7cd1acdd6aadf0d3fcaa4bd44b972e8e72168";
       libraryHaskellDepends = [
         array base containers ddc-base ddc-core deepseq mtl transformers
       ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciplined Disciple Compiler semantic evaluator for the core language";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ddc-core-flow" = callPackage
    ({ mkDerivation, array, base, containers, ddc-base, ddc-core
     , ddc-core-salt, ddc-core-simpl, deepseq, mtl, transformers
     }:
     mkDerivation {
       pname = "ddc-core-flow";
       version = "0.4.1.3";
       sha256 = "de0981453dd7b22c81e7a598f8ae3764397ba29152cda5d18a850a764b4ffeeb";
       libraryHaskellDepends = [
         array base containers ddc-base ddc-core ddc-core-salt
         ddc-core-simpl deepseq mtl transformers
       ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciplined Disciple Compiler data flow compiler";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ddc-core-llvm" = callPackage
    ({ mkDerivation, array, base, containers, ddc-base, ddc-core
     , ddc-core-salt, ddc-core-simpl, mtl, transformers
     }:
     mkDerivation {
       pname = "ddc-core-llvm";
       version = "0.4.1.3";
       sha256 = "654d4a10027c1afa17189be38d07246be1531e2e029b2a55e11b629a805f0c38";
       libraryHaskellDepends = [
         array base containers ddc-base ddc-core ddc-core-salt
         ddc-core-simpl mtl transformers
       ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciplined Disciple Compiler LLVM code generator";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ddc-core-salt" = callPackage
    ({ mkDerivation, array, base, containers, ddc-base, ddc-core
     , deepseq, mtl, transformers
     }:
     mkDerivation {
       pname = "ddc-core-salt";
       version = "0.4.1.3";
       sha256 = "f8f8b3c30b91b3efb542e5b61a06e5dcd3e3f1de216a84af53cadc3f6ee79ea1";
       libraryHaskellDepends = [
         array base containers ddc-base ddc-core deepseq mtl transformers
       ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciplined Disciple Compiler C code generator";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ddc-core-simpl" = callPackage
    ({ mkDerivation, array, base, containers, ddc-base, ddc-core
     , deepseq, mtl, transformers
     }:
     mkDerivation {
       pname = "ddc-core-simpl";
       version = "0.4.1.3";
       sha256 = "7f2dde9108f0a1cc90d447ddbc9f5f8cba207288d9fd6386afb8192828eb7978";
       libraryHaskellDepends = [
         array base containers ddc-base ddc-core deepseq mtl transformers
       ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciplined Disciple Compiler code transformations";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ddc-core-tetra" = callPackage
    ({ mkDerivation, array, base, containers, ddc-base, ddc-core
     , ddc-core-salt, ddc-core-simpl, deepseq, mtl, transformers
     }:
     mkDerivation {
       pname = "ddc-core-tetra";
       version = "0.4.1.3";
       sha256 = "6237cc475d9ef79fc1b2074c54292ed4259d2d0bbc9930069812b99c632b5d05";
       libraryHaskellDepends = [
         array base containers ddc-base ddc-core ddc-core-salt
         ddc-core-simpl deepseq mtl transformers
       ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciplined Disciple Compiler intermediate language";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ddc-driver" = callPackage
    ({ mkDerivation, base, containers, ddc-base, ddc-build, ddc-core
     , ddc-core-eval, ddc-core-flow, ddc-core-llvm, ddc-core-salt
     , ddc-core-simpl, ddc-core-tetra, ddc-interface, ddc-source-tetra
     , deepseq, directory, filepath, mtl, process, transformers
     }:
     mkDerivation {
       pname = "ddc-driver";
       version = "0.4.1.3";
       sha256 = "33678ecdd06c06a967fe7519d7b58c10d5b7456dc720a8454ebb00695dacdb47";
       libraryHaskellDepends = [
         base containers ddc-base ddc-build ddc-core ddc-core-eval
         ddc-core-flow ddc-core-llvm ddc-core-salt ddc-core-simpl
         ddc-core-tetra ddc-interface ddc-source-tetra deepseq directory
         filepath mtl process transformers
       ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciplined Disciple Compiler top-level driver";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ddc-interface" = callPackage
    ({ mkDerivation, base, containers, ddc-base, directory }:
     mkDerivation {
       pname = "ddc-interface";
       version = "0.4.1.3";
       sha256 = "6e68e8ae8ea7f7ff507d238541536959298068e62985e4305d3df5457fb77a5d";
       libraryHaskellDepends = [ base containers ddc-base directory ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciplined Disciple Compiler user interface support";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ddc-source-tetra" = callPackage
    ({ mkDerivation, array, base, containers, ddc-base, ddc-core
     , ddc-core-salt, ddc-core-tetra, deepseq, mtl, transformers
     }:
     mkDerivation {
       pname = "ddc-source-tetra";
       version = "0.4.1.3";
       sha256 = "3acbf2b2f3ab0ae269238b6e4728c929488050909bb4febbef1e3ad2b7d21421";
       libraryHaskellDepends = [
         array base containers ddc-base ddc-core ddc-core-salt
         ddc-core-tetra deepseq mtl transformers
       ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciplined Disciple Compiler source language";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ddc-tools" = callPackage
    ({ mkDerivation, base, containers, ddc-base, ddc-build, ddc-code
     , ddc-core, ddc-core-eval, ddc-core-flow, ddc-core-llvm
     , ddc-core-salt, ddc-core-simpl, ddc-core-tetra, ddc-driver
     , ddc-interface, ddc-source-tetra, directory, filepath, haskeline
     , mtl, process, transformers
     }:
     mkDerivation {
       pname = "ddc-tools";
       version = "0.4.1.3";
       sha256 = "c2fc1cef2298a75b40d72f8a4a119f9b53d5db52ec88bc1772faac8ca582e6c1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers ddc-base ddc-build ddc-code ddc-core ddc-core-eval
         ddc-core-flow ddc-core-llvm ddc-core-salt ddc-core-simpl
         ddc-core-tetra ddc-driver ddc-interface ddc-source-tetra directory
         filepath haskeline mtl process transformers
       ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciplined Disciple Compiler command line tools";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ddc-war" = callPackage
    ({ mkDerivation, base, buildbox, containers, directory, filepath
     , process, random, stm
     }:
     mkDerivation {
       pname = "ddc-war";
       version = "0.4.1.3";
       sha256 = "5e8051ebf83213093e4b3409dfee7dae3e15a7500f39c913af8fbfdcc2273079";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base buildbox containers directory filepath process random stm
       ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciplined Disciple Compiler test driver and buildbot";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ddci-core" = callPackage
    ({ mkDerivation, base, containers, ddc-base, ddc-core
     , ddc-core-eval, ddc-core-simpl, haskeline, haskell-src-exts
     }:
     mkDerivation {
       pname = "ddci-core";
       version = "0.2.1.2";
       sha256 = "801b01f0000bc019947c1816ceb5ae6cb4bfa0e878da4e647d89c1bb236693f0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers ddc-base ddc-core ddc-core-eval ddc-core-simpl
         haskeline haskell-src-exts
       ];
       jailbreak = true;
       homepage = "http://disciple.ouroborus.net";
       description = "Disciple Core language interactive interpreter";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dead-code-detection" = callPackage
    ({ mkDerivation, base, containers, directory, filepath
     , getopt-generics, ghc, ghc-paths, gitrev, Glob, graph-wrapper
     , hspec, interpolate, mockery, silently, string-conversions
     , uniplate
     }:
     mkDerivation {
       pname = "dead-code-detection";
       version = "0.4";
       sha256 = "bcf7c5e477840d264f1e4e74c5251c140d4410f182fc96a907cad7efc28761d6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers getopt-generics ghc ghc-paths gitrev Glob
         graph-wrapper silently string-conversions uniplate
       ];
       testHaskellDepends = [
         base containers directory filepath getopt-generics ghc ghc-paths
         gitrev Glob graph-wrapper hspec interpolate mockery silently
         string-conversions uniplate
       ];
       jailbreak = true;
       homepage = "https://github.com/soenkehahn/dead-code-detection#readme";
       description = "detect dead code in haskell projects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dead-simple-json" = callPackage
    ({ mkDerivation, base, containers, parsec, template-haskell
     , transformers, vector
     }:
     mkDerivation {
       pname = "dead-simple-json";
       version = "0.1.2";
       sha256 = "f9feb24297c8e052ac0593077f76a8f4dc4427b77adb09e998744fd8ef499783";
       libraryHaskellDepends = [
         base containers parsec template-haskell transformers vector
       ];
       homepage = "http://hub.darcs.net/scravy/dead-simple-json";
       description = "Dead simple JSON parser, with some Template Haskell sugar";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "debian_3_87_2" = callPackage
    ({ mkDerivation, base, bytestring, bzlib, containers, directory
     , either, exceptions, filepath, HaXml, HUnit, ListLike, mtl
     , network, network-uri, old-locale, parsec, pretty, process
     , process-extras, pureMD5, regex-compat, regex-tdfa
     , template-haskell, text, time, unix, Unixutils, utf8-string, zlib
     }:
     mkDerivation {
       pname = "debian";
       version = "3.87.2";
       sha256 = "2994078f24cc7467bf8ffbd14cd8838aebaceb659856f77fb91d59bbbe06ae8c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring bzlib containers directory either exceptions
         filepath HaXml HUnit ListLike mtl network network-uri old-locale
         parsec pretty process process-extras pureMD5 regex-compat
         regex-tdfa template-haskell text time unix Unixutils utf8-string
         zlib
       ];
       executableHaskellDepends = [
         base directory filepath HaXml pretty process unix
       ];
       testHaskellDepends = [ base HUnit parsec pretty regex-tdfa text ];
       homepage = "https://github.com/ddssff/debian-haskell";
       description = "Modules for working with the Debian package system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "debian" = callPackage
    ({ mkDerivation, base, bytestring, bzlib, containers, directory
     , either, exceptions, filepath, HaXml, HUnit, ListLike, mtl
     , network, network-uri, old-locale, parsec, pretty, process
     , process-extras, pureMD5, regex-compat, regex-tdfa
     , template-haskell, text, time, unix, Unixutils, utf8-string, zlib
     }:
     mkDerivation {
       pname = "debian";
       version = "3.89";
       sha256 = "ec0da528635c8438f26f29a60f12c3ff606ec696ab641cf40b56b1d5ec92401c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring bzlib containers directory either exceptions
         filepath HaXml HUnit ListLike mtl network network-uri old-locale
         parsec pretty process process-extras pureMD5 regex-compat
         regex-tdfa template-haskell text time unix Unixutils utf8-string
         zlib
       ];
       executableHaskellDepends = [
         base directory filepath HaXml pretty process unix
       ];
       testHaskellDepends = [ base HUnit parsec pretty regex-tdfa text ];
       homepage = "https://github.com/ddssff/debian-haskell";
       description = "Modules for working with the Debian package system";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "debian-binary" = callPackage
    ({ mkDerivation, base, directory, filepath, HSH }:
     mkDerivation {
       pname = "debian-binary";
       version = "0.0.1";
       sha256 = "d89123fc880de17634dffa08682a942eb3d8a67998e24b68f3f08a1bb0a2cb4c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory filepath HSH ];
       description = "Utilities to work with debian binary packages";
       license = "unknown";
     }) {};

  "debian-build" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, process, split
     , transformers
     }:
     mkDerivation {
       pname = "debian-build";
       version = "0.9.1.0";
       sha256 = "0087c11290576edd02dddcafb9a85dd95743025758c9e078f5e24abafc2fc9cd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal directory filepath process split transformers
       ];
       executableHaskellDepends = [ base filepath ];
       homepage = "http://twitter.com/khibino/";
       description = "Debian package build sequence tools";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "debug-diff" = callPackage
    ({ mkDerivation, base, groom, process, temporary }:
     mkDerivation {
       pname = "debug-diff";
       version = "0.1";
       sha256 = "8de679b042eff7fd19ffeae8af395a934e61213204d030b2c5a24079457269a6";
       libraryHaskellDepends = [ base groom process temporary ];
       description = "Display a colorized diff between two Haskell values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "debug-time" = callPackage
    ({ mkDerivation, base, clock, containers }:
     mkDerivation {
       pname = "debug-time";
       version = "0.1.0.1";
       sha256 = "6076a78e42012a902b8ee157ec9069ca3148cb89ca659e4dff5267f11aca4d99";
       libraryHaskellDepends = [ base clock containers ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/LukaHorvat/debug-time#readme";
       description = "Debug.Trace equivalent for timing computations";
       license = stdenv.lib.licenses.mit;
     }) {};

  "decepticons" = callPackage
    ({ mkDerivation, base, comonad-transformers }:
     mkDerivation {
       pname = "decepticons";
       version = "0.1.0.0";
       sha256 = "7bccd3aa39b5bc4dcfa359bbad9565d75ee4720d5f08596adf30de960513d7ba";
       libraryHaskellDepends = [ base comonad-transformers ];
       jailbreak = true;
       description = "The categorical dual of transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "declarative" = callPackage
    ({ mkDerivation, base, hasty-hamiltonian, lens, mcmc-types
     , mighty-metropolis, mwc-probability, pipes, primitive
     , speedy-slice, transformers
     }:
     mkDerivation {
       pname = "declarative";
       version = "0.1.0.1";
       sha256 = "22bc7bed888b083c289ce027f3c545718e853736a8d19e9fe32a91da61355bad";
       libraryHaskellDepends = [
         base hasty-hamiltonian lens mcmc-types mighty-metropolis
         mwc-probability pipes primitive speedy-slice transformers
       ];
       testHaskellDepends = [ base mwc-probability ];
       homepage = "http://github.com/jtobin/declarative";
       description = "DIY Markov Chains";
       license = stdenv.lib.licenses.mit;
     }) {};

  "decode-utf8" = callPackage
    ({ mkDerivation, api-opentheory-unicode, base, opentheory-unicode
     }:
     mkDerivation {
       pname = "decode-utf8";
       version = "1.2";
       sha256 = "f0e2fc4060dcbf995a8552a302afeb7dab9469c9349081366aa4bd22c341b282";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         api-opentheory-unicode base opentheory-unicode
       ];
       description = "Decode a UTF-8 byte stream on standard input";
       license = stdenv.lib.licenses.mit;
     }) {};

  "decoder-conduit" = callPackage
    ({ mkDerivation, base, binary, bytestring, conduit }:
     mkDerivation {
       pname = "decoder-conduit";
       version = "0.0.1.1";
       sha256 = "8719937a665bd8b59e186419b6a5e3b8c57fb277562fb18f2b68b44e28cbb37c";
       libraryHaskellDepends = [ base binary bytestring conduit ];
       jailbreak = true;
       homepage = "https://github.com/hansonkd/decoder-conduit";
       description = "Conduit for decoding ByteStrings using Data.Binary.Get";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dedukti" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , haskell-src-exts, haskell-src-exts-qq, hmk, mtl, parsec, process
     , Stream, stringtable-atom, time, unix, wl-pprint
     }:
     mkDerivation {
       pname = "dedukti";
       version = "1.1.4";
       sha256 = "4d9c67f653b2044b64296ee2079f128d8e9073d9ccea2317a27dd4240a12e32c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ time unix ];
       executableHaskellDepends = [
         base bytestring containers directory filepath haskell-src-exts
         haskell-src-exts-qq hmk mtl parsec process Stream stringtable-atom
         wl-pprint
       ];
       jailbreak = true;
       homepage = "http://www.lix.polytechnique.fr/dedukti";
       description = "A type-checker for the λΠ-modulo calculus";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "deepcontrol" = callPackage
    ({ mkDerivation, base, containers, doctest, HUnit, mmorph, mtl
     , QuickCheck, safe, transformers
     }:
     mkDerivation {
       pname = "deepcontrol";
       version = "0.5.4.3";
       sha256 = "2e943a13531120a5c3df908c849d0697c22ef82e6dc4bf102f6fe39e9faa0e35";
       libraryHaskellDepends = [ base mmorph mtl transformers ];
       testHaskellDepends = [
         base containers doctest HUnit mtl QuickCheck safe transformers
       ];
       homepage = "https://github.com/ocean0yohsuke/deepcontrol";
       description = "A library that provides deep-level programming style and(or) notation on Applicative and Monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "deeplearning-hs" = callPackage
    ({ mkDerivation, accelerate, base, mtl, QuickCheck, repa
     , repa-algorithms, test-framework, test-framework-quickcheck2
     , vector
     }:
     mkDerivation {
       pname = "deeplearning-hs";
       version = "0.1.0.2";
       sha256 = "0da58dd777b5a9d097cef43dede6f72cca18d56577cab131106bfaa7634f82b3";
       revision = "1";
       editedCabalFile = "eca23efe079b6311afd52bf1a70f8b9617c2b943e13b2ddb0ac2be5249622afa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         accelerate base mtl repa repa-algorithms vector
       ];
       executableHaskellDepends = [
         accelerate base mtl repa repa-algorithms vector
       ];
       testHaskellDepends = [
         accelerate base mtl QuickCheck repa repa-algorithms test-framework
         test-framework-quickcheck2 vector
       ];
       jailbreak = true;
       homepage = "https://github.com/ajtulloch/deeplearning-hs";
       description = "Deep Learning in Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "deepseq_1_3_0_1" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "deepseq";
       version = "1.3.0.1";
       sha256 = "9792d2aff7c65c1e3a9d720ba7fe109eb6aea50a51477ffafd2b5f9e8d9a1f19";
       libraryHaskellDepends = [ array base ];
       jailbreak = true;
       description = "Deep evaluation of data structures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "deepseq_1_4_1_2" = callPackage
    ({ mkDerivation, array, base, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "deepseq";
       version = "1.4.1.2";
       sha256 = "3b7cfa5ff5eb169b3f97285be978f030d664c6e3e84a2525b2fafca4f7380651";
       libraryHaskellDepends = [ array base ];
       testHaskellDepends = [
         array base HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       description = "Deep evaluation of data structures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "deepseq-bounded" = callPackage
    ({ mkDerivation, array, base, cpphs, deepseq, deepseq-generics
     , generics-sop, ghc-prim, HUnit, mtl, parallel, random, syb
     , template-haskell
     }:
     mkDerivation {
       pname = "deepseq-bounded";
       version = "0.8.0.0";
       sha256 = "2e20a5473b923b4e3527efe98e99938103147adba99feec58b3aafd7a2c750a4";
       libraryHaskellDepends = [
         array base cpphs deepseq deepseq-generics generics-sop mtl parallel
         random syb
       ];
       testHaskellDepends = [
         base cpphs deepseq deepseq-generics generics-sop ghc-prim HUnit
         parallel random syb template-haskell
       ];
       jailbreak = true;
       homepage = "http://fremissant.net/deepseq-bounded";
       description = "Bounded deepseq, including support for generic deriving";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "deepseq-generics_0_1_1_1" = callPackage
    ({ mkDerivation, base, deepseq, ghc-prim, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "deepseq-generics";
       version = "0.1.1.1";
       sha256 = "08e8438de375a822f38fa33ea1cd9a24e494b7f6deea0a4aa052daa5fb138cc5";
       libraryHaskellDepends = [ base deepseq ghc-prim ];
       testHaskellDepends = [
         base deepseq ghc-prim HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "https://github.com/hvr/deepseq-generics";
       description = "GHC.Generics-based Control.DeepSeq.rnf implementation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "deepseq-generics" = callPackage
    ({ mkDerivation, base, deepseq, ghc-prim, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "deepseq-generics";
       version = "0.1.1.2";
       sha256 = "839e1d6ead4c45faa4165f0e82aa8a9d1df7a7c1118bfb1787e8268bfa8bfb06";
       revision = "1";
       editedCabalFile = "3f52867fe9267876504d8ce20c77dcfb2ac6613af8c915017859b6022d3cc9fd";
       libraryHaskellDepends = [ base deepseq ghc-prim ];
       testHaskellDepends = [
         base deepseq ghc-prim HUnit test-framework test-framework-hunit
       ];
       homepage = "https://github.com/hvr/deepseq-generics";
       description = "GHC.Generics-based Control.DeepSeq.rnf implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "deepseq-generics_0_2_0_0" = callPackage
    ({ mkDerivation, base, deepseq, ghc-prim, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "deepseq-generics";
       version = "0.2.0.0";
       sha256 = "b0b3ef5546c0768ef9194519a90c629f8f2ba0348487e620bb89d512187c7c9d";
       libraryHaskellDepends = [ base deepseq ghc-prim ];
       testHaskellDepends = [
         base deepseq ghc-prim HUnit test-framework test-framework-hunit
       ];
       homepage = "https://github.com/hvr/deepseq-generics";
       description = "GHC.Generics-based Control.DeepSeq.rnf implementation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "deepseq-magic" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "deepseq-magic";
       version = "1.0.0.3";
       sha256 = "d71fbbe20170f26eb66085599fd79b54c190844314ad51c2bf373a06abd4d196";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/ezyang/deepseq-magic";
       description = "Deep evaluation of data structures without NFData";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "deepseq-th" = callPackage
    ({ mkDerivation, base, deepseq, template-haskell }:
     mkDerivation {
       pname = "deepseq-th";
       version = "0.1.0.4";
       sha256 = "c5a4b8e6173163cdf5cee22e21267507161cb2222bfcff855822dcfc2244938b";
       libraryHaskellDepends = [ base deepseq template-haskell ];
       testHaskellDepends = [ base deepseq template-haskell ];
       jailbreak = true;
       description = "Template Haskell based deriver for optimised NFData instances";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "deepzoom" = callPackage
    ({ mkDerivation, base, directory, filepath, hsmagick }:
     mkDerivation {
       pname = "deepzoom";
       version = "0.1";
       sha256 = "13c9e8dd1f15518227e688f17738a28c726eeb0cb18676a6122810ecbc993ac2";
       libraryHaskellDepends = [ base directory filepath hsmagick ];
       description = "A DeepZoom image slicer. Only known to work on 32bit Linux";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "defargs" = callPackage
    ({ mkDerivation, base, cluss }:
     mkDerivation {
       pname = "defargs";
       version = "0.3";
       sha256 = "6f32a30b2b10a793a2807faf15324ad92cbc9c6564fbabc900517235103fe3e7";
       libraryHaskellDepends = [ base cluss ];
       homepage = "https://github.com/Kinokkory/defargs";
       description = "default arguments in haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "definitive-base" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , ghc-prim, GLURaw, OpenGL, OpenGLRaw, primitive, vector
     }:
     mkDerivation {
       pname = "definitive-base";
       version = "2.3";
       sha256 = "896bf09e3c25f0c00a4469d95f2886e3ba2208d3139817adec088569e6b1d488";
       libraryHaskellDepends = [
         array base bytestring containers deepseq ghc-prim GLURaw OpenGL
         OpenGLRaw primitive vector
       ];
       jailbreak = true;
       homepage = "http://coiffier.net/projects/definitive-framework.html";
       description = "The base modules of the Definitive framework";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "definitive-filesystem" = callPackage
    ({ mkDerivation, array, base, bytestring, clock, containers
     , deepseq, definitive-base, definitive-reactive, directory
     , filepath, old-locale, primitive, time, unix, vector
     }:
     mkDerivation {
       pname = "definitive-filesystem";
       version = "1.2";
       sha256 = "2d22b782dfb24050df054b85ff1662f3042c49edad2bb98aa8ebe3f8224a802d";
       revision = "1";
       editedCabalFile = "3a78d4d8aaa291ca95d889b62a979c4132bbe6f91073ab2bd9fdb0d55ed63121";
       libraryHaskellDepends = [
         array base bytestring clock containers deepseq definitive-base
         definitive-reactive directory filepath old-locale primitive time
         unix vector
       ];
       jailbreak = true;
       homepage = "http://coiffier.net/projects/definitive-framework.html";
       description = "A library that enable you to interact with the filesystem in a definitive way";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "definitive-graphics" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, clock, containers
     , cpu, deepseq, definitive-base, definitive-parser
     , definitive-reactive, GLFW, JuicyPixels, mtl, primitive
     , stb-truetype, transformers, utf8-string, vector, zlib
     }:
     mkDerivation {
       pname = "definitive-graphics";
       version = "1.2";
       sha256 = "d97f94941ee794043846991cc648cbe3d51659d4390864e3ba8626aa844c012a";
       revision = "1";
       editedCabalFile = "a6d867ea8098390daff40c088c81f854ca054f9a0c8b097f9194be329416baed";
       libraryHaskellDepends = [
         array base binary bytestring clock containers cpu deepseq
         definitive-base definitive-parser definitive-reactive GLFW
         JuicyPixels mtl primitive stb-truetype transformers utf8-string
         vector zlib
       ];
       jailbreak = true;
       homepage = "http://coiffier.net/projects/definitive-framework.html";
       description = "A definitive package allowing you to open windows, read image files and render text to be displayed or saved";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "definitive-parser" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, cpu, deepseq
     , definitive-base, ghc-prim, GLURaw, OpenGL, OpenGLRaw, primitive
     , utf8-string, vector
     }:
     mkDerivation {
       pname = "definitive-parser";
       version = "2.1";
       sha256 = "b0daf9e7628cd18be904eab9005e0d02fdb8fd706426d46b3256ee335f3f876a";
       libraryHaskellDepends = [
         array base bytestring containers cpu deepseq definitive-base
         ghc-prim GLURaw OpenGL OpenGLRaw primitive utf8-string vector
       ];
       jailbreak = true;
       homepage = "http://coiffier.net/projects/definitive-framework.html";
       description = "A parser combinator library for the Definitive framework";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "definitive-reactive" = callPackage
    ({ mkDerivation, array, base, bytestring, clock, containers
     , deepseq, definitive-base, primitive, vector
     }:
     mkDerivation {
       pname = "definitive-reactive";
       version = "1.0";
       sha256 = "a3f6d300a30914183662e01ddd1e56965188b76d459c765fefd297298049633e";
       revision = "1";
       editedCabalFile = "8c3c6afcc4ce7569ede32c8006d1d66fb10448321159f875d1dec03419bd7797";
       libraryHaskellDepends = [
         array base bytestring clock containers deepseq definitive-base
         primitive vector
       ];
       jailbreak = true;
       homepage = "http://coiffier.net/projects/definitive-framework.html";
       description = "A simple Reactive library";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "definitive-sound" = callPackage
    ({ mkDerivation, alsa-core, alsa-pcm, array, base, bytestring
     , clock, containers, deepseq, definitive-base, primitive
     , sample-frame, storable-record, vector
     }:
     mkDerivation {
       pname = "definitive-sound";
       version = "1.0";
       sha256 = "f2ef71f24583d0614da0a560ad9e2d502f6b5f6076b10c5927173ab2d5816406";
       revision = "1";
       editedCabalFile = "1491f0a01f47b84ea8f01a94492738a7f3b5fe7c68c805cca8701926cc443d71";
       libraryHaskellDepends = [
         alsa-core alsa-pcm array base bytestring clock containers deepseq
         definitive-base primitive sample-frame storable-record vector
       ];
       jailbreak = true;
       homepage = "http://coiffier.net/projects/definitive-framework.html";
       description = "A definitive package to handle sound and play it back";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "deiko-config" = callPackage
    ({ mkDerivation, array, base, containers, exceptions, mtl, parsec
     , text, transformers
     }:
     mkDerivation {
       pname = "deiko-config";
       version = "0.5.0.0";
       sha256 = "5e52ad0f6dac9c2c73065abcc0fc01b3c3e1130b5c3b51205605a45ac709117e";
       libraryHaskellDepends = [
         array base containers exceptions mtl parsec text transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/YoEight/deiko-config";
       description = "Small and typesafe configuration library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dejafu" = callPackage
    ({ mkDerivation, atomic-primops, base, containers, deepseq
     , exceptions, monad-loops, mtl, random, stm, transformers
     }:
     mkDerivation {
       pname = "dejafu";
       version = "0.2.0.0";
       sha256 = "a90d2695d2429b2d00e7a8e60edcc65f2c9d509ccf9a3744838dc2b122928e95";
       libraryHaskellDepends = [
         atomic-primops base containers deepseq exceptions monad-loops mtl
         random stm transformers
       ];
       homepage = "https://github.com/barrucadu/dejafu";
       description = "Overloadable primitives for testable, potentially non-deterministic, concurrency";
       license = stdenv.lib.licenses.mit;
     }) {};

  "deka" = callPackage
    ({ mkDerivation, base, bytestring, mpdec, parsec, transformers }:
     mkDerivation {
       pname = "deka";
       version = "0.6.0.2";
       sha256 = "44baa0f9c38fb3d606904873334aa3ab3721c73e48756fe916e7490e765943d0";
       libraryHaskellDepends = [ base bytestring parsec transformers ];
       librarySystemDepends = [ mpdec ];
       jailbreak = true;
       homepage = "https://github.com/massysett/deka";
       description = "Decimal floating point arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {mpdec = null;};

  "deka-tests" = callPackage
    ({ mkDerivation, base, bytestring, containers, deka, parsec, pipes
     , QuickCheck, quickpull, transformers
     }:
     mkDerivation {
       pname = "deka-tests";
       version = "0.6.0.2";
       sha256 = "c95fbf3d7a0637d0fea763e6961ef29838eb8a1e0a45f6585e6813a3d8364220";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring deka QuickCheck ];
       executableHaskellDepends = [
         base bytestring containers deka parsec pipes QuickCheck
         transformers
       ];
       testHaskellDepends = [ base bytestring deka QuickCheck quickpull ];
       jailbreak = true;
       homepage = "https://github.com/massysett/deka";
       description = "Tests for deka, decimal floating point arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "delaunay" = callPackage
    ({ mkDerivation, AC-Vector, base, hashable, HUnit, QuickCheck
     , unordered-containers
     }:
     mkDerivation {
       pname = "delaunay";
       version = "0.1.0.2";
       sha256 = "6dbfde3c642685a7ad8725eac5e6c7f1adca61ad785f692615d38d3d8110aa90";
       libraryHaskellDepends = [
         AC-Vector base hashable unordered-containers
       ];
       testHaskellDepends = [ AC-Vector base HUnit QuickCheck ];
       homepage = "http://github.com/mruegenberg/Delaunay";
       description = "Build a Delaunay triangulation of a set of points";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "delicious" = callPackage
    ({ mkDerivation, base, bytestring, curl, feed, json, nano-md5, xml
     }:
     mkDerivation {
       pname = "delicious";
       version = "0.3.4";
       sha256 = "a030b08b33f803b43914f2a28e55058d5d414610af4a148c968cb3ff9ef0a2b7";
       libraryHaskellDepends = [
         base bytestring curl feed json nano-md5 xml
       ];
       homepage = "https://github.com/sof/delicious";
       description = "Accessing the del.icio.us APIs from Haskell (v2)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "delimited-text" = callPackage
    ({ mkDerivation, attoparsec, base, binary, bytestring
     , bytestring-show
     }:
     mkDerivation {
       pname = "delimited-text";
       version = "0.3.0";
       sha256 = "053074240aaae39a3236b9a702626932d5d5c79a4927c60afe8b8f6ac9d6c656";
       libraryHaskellDepends = [
         attoparsec base binary bytestring bytestring-show
       ];
       homepage = "http://space.k-hornz.de/software/delimited-text";
       description = "Parse character delimited textual data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "delimiter-separated" = callPackage
    ({ mkDerivation, base, uhc-util, uulib }:
     mkDerivation {
       pname = "delimiter-separated";
       version = "0.1.0.0";
       sha256 = "0682662d702022579f40b411b234d36982faca72ff3ca7f9942c62ab6f4cce9d";
       libraryHaskellDepends = [ base uhc-util uulib ];
       homepage = "https://github.com/atzedijkstra/delimiter-separated";
       description = "Library for dealing with tab and/or comma (or other) separated files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "delta" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, hspec
     , optparse-applicative, process, sodium, time
     }:
     mkDerivation {
       pname = "delta";
       version = "0.2.1.2";
       sha256 = "d259f9be51562f4ae4bb9a1853e0e5a2aecfbdb70a5a536e17360feddc164a64";
       revision = "2";
       editedCabalFile = "630e85a07132fe54b49c71f855b3d633982026d78120279e00888bc95a9d14dd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory filepath sodium time
       ];
       executableHaskellDepends = [
         base directory optparse-applicative process sodium
       ];
       testHaskellDepends = [ base directory filepath hspec ];
       homepage = "https://github.com/kryoxide/delta";
       description = "A library for detecting file changes";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "delta-h" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, monad-atom
     , nlp-scores, text
     }:
     mkDerivation {
       pname = "delta-h";
       version = "0.0.3";
       sha256 = "8f037078a3ab300fd035058e65b27783d20dbb27e83dcbf50b842775f7834079";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers monad-atom nlp-scores text
       ];
       executableHaskellDepends = [
         base binary bytestring containers monad-atom nlp-scores text
       ];
       homepage = "https://bitbucket.org/gchrupala/delta-h";
       description = "Online entropy-based model of lexical category acquisition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "demarcate" = callPackage
    ({ mkDerivation, base, free, hspec, transformers }:
     mkDerivation {
       pname = "demarcate";
       version = "0.1.0";
       sha256 = "43b745fbc969084aaf3bb04f779162a001f83b08caeb1dff9395e760c8991e8c";
       libraryHaskellDepends = [ base free transformers ];
       testHaskellDepends = [ base hspec ];
       homepage = "https://github.com/fizruk/demarcate";
       description = "Demarcating transformed monad";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "denominate" = callPackage
    ({ mkDerivation, base, directory, filepath }:
     mkDerivation {
       pname = "denominate";
       version = "0.5.0";
       sha256 = "61a6c5aa370d03ddbcf5349032d97991e240a8ac0d1acbafaa9a723344c84d1a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory filepath ];
       executableHaskellDepends = [ base directory filepath ];
       jailbreak = true;
       homepage = "http://protempore.net/denominate/";
       description = "Functions supporting bulk file and directory name normalization";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dependent-map_0_1_1_3" = callPackage
    ({ mkDerivation, base, containers, dependent-sum }:
     mkDerivation {
       pname = "dependent-map";
       version = "0.1.1.3";
       sha256 = "44dd913868dddfaa104c27794cbf852e8c4783fe78f49b3b2dd635b4731ec8af";
       libraryHaskellDepends = [ base containers dependent-sum ];
       jailbreak = true;
       homepage = "https://github.com/mokus0/dependent-map";
       description = "Dependent finite maps (partial dependent products)";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dependent-map" = callPackage
    ({ mkDerivation, base, containers, dependent-sum }:
     mkDerivation {
       pname = "dependent-map";
       version = "0.2.1.0";
       sha256 = "567d81bf090feda43c9bc01708e6f3684399628329b64a266ba6a6a79351d284";
       libraryHaskellDepends = [ base containers dependent-sum ];
       homepage = "https://github.com/mokus0/dependent-map";
       description = "Dependent finite maps (partial dependent products)";
       license = "unknown";
     }) {};

  "dependent-state" = callPackage
    ({ mkDerivation, base, lens, mtl, prologue }:
     mkDerivation {
       pname = "dependent-state";
       version = "1.0.1";
       sha256 = "093aa20845a345c1d44e3d0258eadd6f8c38e3596cd6486be64879d0b60e7467";
       libraryHaskellDepends = [ base lens mtl prologue ];
       homepage = "https://github.com/wdanilo/dependent-state";
       description = "Control structure similar to Control.Monad.State, allowing multiple nested states, distinguishable by provided phantom types.";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "dependent-sum_0_2_1_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "dependent-sum";
       version = "0.2.1.0";
       sha256 = "835e799c9749822f2818dd5c7dc1e887d4c5b5a6bb37c7e4c0661a2060d6dcc0";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/mokus0/dependent-sum";
       description = "Dependent sum type";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dependent-sum" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "dependent-sum";
       version = "0.3.2.1";
       sha256 = "b91338c9d18b8977114c3ef962dc224b6a7ff12b0861c536f560260429b6a42f";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/mokus0/dependent-sum";
       description = "Dependent sum type";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "dependent-sum-template" = callPackage
    ({ mkDerivation, base, dependent-sum, template-haskell, th-extras
     }:
     mkDerivation {
       pname = "dependent-sum-template";
       version = "0.0.0.4";
       sha256 = "99dfc6913a688d714d95b1a2d723ca9c7d54c4d169c0fae63d2fb7c1ffef7280";
       libraryHaskellDepends = [
         base dependent-sum template-haskell th-extras
       ];
       homepage = "/dev/null";
       description = "Template Haskell code to generate instances of classes in dependent-sum package";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "depends" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, hspec
     , process, QuickCheck, transformers, yaml-config
     }:
     mkDerivation {
       pname = "depends";
       version = "0.0.1";
       sha256 = "f8114e2c2f72e7d3e6726229567afa1e1228bce32c78c09e389be8d23b5c8378";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath process transformers yaml-config
       ];
       testHaskellDepends = [
         base containers directory filepath hspec process QuickCheck
         transformers yaml-config
       ];
       description = "A simple configuration management tool for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dephd" = callPackage
    ({ mkDerivation, base, bio, bytestring, cmdargs, directory, process
     , regex-compat
     }:
     mkDerivation {
       pname = "dephd";
       version = "0.1.6";
       sha256 = "309639c8e2d8dc218bc8b5f5d1f5045341995e281467e18a5ab24e7ea4a5f861";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bio bytestring cmdargs directory process regex-compat
       ];
       homepage = "http://malde.org/~ketil/biohaskell/dephd";
       description = "Analyze quality of nucleotide sequences";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dequeue" = callPackage
    ({ mkDerivation, base, Cabal, cabal-test-quickcheck, QuickCheck
     , safe
     }:
     mkDerivation {
       pname = "dequeue";
       version = "0.1.12";
       sha256 = "c70aedbb1965affe07b7151f12e9a8e42f2cb54652bb0a0bbc5d0ba8e21721ab";
       libraryHaskellDepends = [ base QuickCheck safe ];
       testHaskellDepends = [ base Cabal cabal-test-quickcheck ];
       description = "A typeclass and an implementation for double-ended queues";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "derangement" = callPackage
    ({ mkDerivation, base, fgl }:
     mkDerivation {
       pname = "derangement";
       version = "0.1.0";
       sha256 = "00b2620ca4943017cbeefd16af0e808cd62536e1e2911fddf9eaca66d729828f";
       libraryHaskellDepends = [ base fgl ];
       description = "Find derangements of lists";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "derivation-trees" = callPackage
    ({ mkDerivation, applicative-extras, base, labeled-tree, mtl }:
     mkDerivation {
       pname = "derivation-trees";
       version = "0.7.3";
       sha256 = "5ec7f59b65b87ed19129a04dac123c0a25494453c8bcc97d0e49c58fe73ec715";
       libraryHaskellDepends = [
         applicative-extras base labeled-tree mtl
       ];
       jailbreak = true;
       description = "Typeset Derivation Trees via MetaPost";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "derive_2_5_18" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , haskell-src-exts, pretty, process, syb, template-haskell
     , transformers, uniplate
     }:
     mkDerivation {
       pname = "derive";
       version = "2.5.18";
       sha256 = "73b0a4ad4b9fdfcfed355781b5347737653f6f80a7de5c3b622a9316367a16cb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers directory filepath haskell-src-exts
         pretty process syb template-haskell transformers uniplate
       ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~ndm/derive/";
       description = "A program and library to derive instances for data types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "derive_2_5_19" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , haskell-src-exts, pretty, process, syb, template-haskell
     , transformers, uniplate
     }:
     mkDerivation {
       pname = "derive";
       version = "2.5.19";
       sha256 = "5a4a52d54ccc9e0368b369357a5fc03d16da13791885e257d7a07f35120a5624";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers directory filepath haskell-src-exts
         pretty process syb template-haskell transformers uniplate
       ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~ndm/derive/";
       description = "A program and library to derive instances for data types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "derive_2_5_20" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , haskell-src-exts, pretty, process, syb, template-haskell
     , transformers, uniplate
     }:
     mkDerivation {
       pname = "derive";
       version = "2.5.20";
       sha256 = "b98da230644f77b607e3d6eae693daa35c4be259eaf44209ed62473c2099687f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers directory filepath haskell-src-exts
         pretty process syb template-haskell transformers uniplate
       ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~ndm/derive/";
       description = "A program and library to derive instances for data types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "derive_2_5_21" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , haskell-src-exts, pretty, process, syb, template-haskell
     , transformers, uniplate
     }:
     mkDerivation {
       pname = "derive";
       version = "2.5.21";
       sha256 = "d569260c3de3107ddbca3a16fc964312c4391a01b43ee3ede48f9eae60665557";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers directory filepath haskell-src-exts
         pretty process syb template-haskell transformers uniplate
       ];
       jailbreak = true;
       homepage = "https://github.com/ndmitchell/derive#readme";
       description = "A program and library to derive instances for data types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "derive_2_5_22" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , haskell-src-exts, pretty, process, syb, template-haskell
     , transformers, uniplate
     }:
     mkDerivation {
       pname = "derive";
       version = "2.5.22";
       sha256 = "c2f9305d12d4056ae49376448228d75c2970182bdd46c93979c80ee1d3cf4f3c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers directory filepath haskell-src-exts
         pretty process syb template-haskell transformers uniplate
       ];
       jailbreak = true;
       homepage = "https://github.com/ndmitchell/derive#readme";
       description = "A program and library to derive instances for data types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "derive" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , haskell-src-exts, pretty, process, syb, template-haskell
     , transformers, uniplate
     }:
     mkDerivation {
       pname = "derive";
       version = "2.5.23";
       sha256 = "1f8378503cf8eca858621717d87bafaf022f33de12b32ec4d22e4ecd8b418dba";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers directory filepath haskell-src-exts
         pretty process syb template-haskell transformers uniplate
       ];
       homepage = "https://github.com/ndmitchell/derive#readme";
       description = "A program and library to derive instances for data types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "derive-IG" = callPackage
    ({ mkDerivation, base, instant-generics, template-haskell }:
     mkDerivation {
       pname = "derive-IG";
       version = "0.1.1";
       sha256 = "99bf95f72fdb5a3f6777432ac9e3d408ed24ba1718ed723eeb6fadb1a490ef2d";
       libraryHaskellDepends = [ base instant-generics template-haskell ];
       jailbreak = true;
       homepage = "http://github.com/konn/derive-IG";
       description = "Macro to derive instances for Instant-Generics using Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "derive-enumerable" = callPackage
    ({ mkDerivation, base, data-default }:
     mkDerivation {
       pname = "derive-enumerable";
       version = "0.1.1.0";
       sha256 = "5777fdf3313a2a2c39d03690069c12f5554bf6c941097fa0cd1956d693f5f023";
       libraryHaskellDepends = [ base data-default ];
       jailbreak = true;
       homepage = "https://github.com/mgoszcz2/derive-enumerable";
       description = "Generic instances for enumerating complex data types";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "derive-gadt" = callPackage
    ({ mkDerivation, base, containers, haskell-src-exts
     , haskell-src-meta, pretty, template-haskell
     }:
     mkDerivation {
       pname = "derive-gadt";
       version = "0.1.1";
       sha256 = "a69d2d88ac37562d30da64522cc2b4dab414be88fa1b45887fc14136d658db68";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers haskell-src-exts haskell-src-meta pretty
         template-haskell
       ];
       executableHaskellDepends = [
         base haskell-src-exts haskell-src-meta template-haskell
       ];
       jailbreak = true;
       description = "Instance deriving for (a subset of) GADTs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "derive-monoid" = callPackage
    ({ mkDerivation, base, semigroups, template-haskell }:
     mkDerivation {
       pname = "derive-monoid";
       version = "0.0.0";
       sha256 = "d0da3cac1639996e2095ae3058ec32704ec85e2e95d61415d8896090f58255d3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base semigroups template-haskell ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base semigroups ];
       homepage = "https://github.com/sboosali/derive-monoid#readme";
       description = "derive Semigroup/Monoid/IsList";
       license = stdenv.lib.licenses.mit;
     }) {};

  "derive-topdown" = callPackage
    ({ mkDerivation, base, derive, mtl, template-haskell
     , template-haskell-util
     }:
     mkDerivation {
       pname = "derive-topdown";
       version = "0.0.0.2";
       sha256 = "176502a815b4c4e889e9b06de3ae68aa5d6645a75bfd49c69532e91930a6aa3d";
       libraryHaskellDepends = [
         base derive mtl template-haskell template-haskell-util
       ];
       homepage = "https://github.com/HaskellZhangSong/derive-topdown";
       description = "This library will help you generate Haskell empty Generic instances and deriving type instances from the top automatically to the bottom for composited data types";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "derive-trie" = callPackage
    ({ mkDerivation, array, base, containers, template-haskell }:
     mkDerivation {
       pname = "derive-trie";
       version = "0.2.1";
       sha256 = "ccca249c26c02501cc1566b9b95fa697ec5146a9ce499ada8a5fe5022b3a8385";
       libraryHaskellDepends = [ array base containers template-haskell ];
       jailbreak = true;
       homepage = "http://github.com/baldo/derive-trie";
       description = "Automatic derivation of Trie implementations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "deriving-compat" = callPackage
    ({ mkDerivation, base, base-compat, containers, ghc-prim, hspec
     , QuickCheck, template-haskell
     }:
     mkDerivation {
       pname = "deriving-compat";
       version = "0.1";
       sha256 = "c33dfa865e409f3c520bda7f8c3d7b678c2497cb8857882d8741b796241da0ec";
       revision = "1";
       editedCabalFile = "364c925a70e5c49d3f98c2feb310e462c9db95b4ca3e173273144a1c715112fc";
       libraryHaskellDepends = [
         base containers ghc-prim template-haskell
       ];
       testHaskellDepends = [ base base-compat hspec QuickCheck ];
       homepage = "https://github.com/haskell-compat/deriving-compat";
       description = "Backports of GHC deriving extensions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "derp" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "derp";
       version = "0.1.6";
       sha256 = "136a001ad5afc5db65495832a539ab027e2685ce5f6ed82d5fb72a29314a1e3d";
       libraryHaskellDepends = [ base containers ];
       description = "Derivative Parsing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "derp-lib" = callPackage
    ({ mkDerivation, base, derp }:
     mkDerivation {
       pname = "derp-lib";
       version = "0.0.0.1";
       sha256 = "1d6c500058ffcdbd29ecddfbdef67149bf2974e253d2ee98f94ca719001f0849";
       libraryHaskellDepends = [ base derp ];
       homepage = "http://darcsden.com/kyagrd/derp-lib";
       description = "combinators based on parsing with derivatives (derp) package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "descrilo" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "descrilo";
       version = "0.1.0.3";
       sha256 = "82479f64aa13a8df7fafcf091ea34ca7044fad2e582489772fb1b46c3645a7a7";
       libraryHaskellDepends = [ base ];
       description = "Loads a list of items with fields";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "descriptive_0_0_2" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, containers, mtl, text
     , transformers
     }:
     mkDerivation {
       pname = "descriptive";
       version = "0.0.2";
       sha256 = "1711cae6ac16ecf03eef771ef101cdda4c64f7a16d69a912ae1a57ad15a1004a";
       revision = "3";
       editedCabalFile = "0aeae1dd5ab8c21ade57c1e036600b8162cd790823618a9c5894417ba68e2ea2";
       libraryHaskellDepends = [
         aeson base bifunctors containers mtl text transformers
       ];
       homepage = "https://github.com/chrisdone/descriptive";
       description = "Self-describing consumers/parsers; forms, cmd-line args, JSON, etc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "descriptive_0_9_3" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, containers, hspec, HUnit
     , mtl, scientific, text, transformers, vector
     }:
     mkDerivation {
       pname = "descriptive";
       version = "0.9.3";
       sha256 = "e0e36a270d91ee6f3a935217f20b1db92b57d32d88d16f6414e86977147366cd";
       revision = "3";
       editedCabalFile = "62c7ffc97a1863e3ff63a643b010a3a9acad5030c2091b94dbf097ef501a9cdc";
       libraryHaskellDepends = [
         aeson base bifunctors containers mtl scientific text transformers
         vector
       ];
       testHaskellDepends = [
         aeson base bifunctors containers hspec HUnit mtl text transformers
       ];
       homepage = "https://github.com/chrisdone/descriptive";
       description = "Self-describing consumers/parsers; forms, cmd-line args, JSON, etc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "descriptive" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, containers, hspec, HUnit
     , mtl, scientific, text, transformers, vector
     }:
     mkDerivation {
       pname = "descriptive";
       version = "0.9.4";
       sha256 = "795ec65756bf87ec6ea4c92d85a25d0eb0d8cfa1df40685ddcf74b83099bba2f";
       libraryHaskellDepends = [
         aeson base bifunctors containers mtl scientific text transformers
         vector
       ];
       testHaskellDepends = [
         aeson base bifunctors containers hspec HUnit mtl text transformers
       ];
       homepage = "https://github.com/chrisdone/descriptive";
       description = "Self-describing consumers/parsers; forms, cmd-line args, JSON, etc";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "despair" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "despair";
       version = "0.0.6";
       sha256 = "6ca60cf6b0539ea70f4712144f1778c5464d3b369408c99f54e5bdbed7d3815a";
       libraryHaskellDepends = [ base random ];
       description = "Despair";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "deterministic-game-engine" = callPackage
    ({ mkDerivation, base, hspec, mtl }:
     mkDerivation {
       pname = "deterministic-game-engine";
       version = "0.4.0";
       sha256 = "3adffba07d4fdca79909331ec0029e09cf7895cadada5613f3e359d777c8bcc1";
       libraryHaskellDepends = [ base mtl ];
       testHaskellDepends = [ base hspec ];
       jailbreak = true;
       homepage = "https://github.com/TGOlson/deterministic-game-engine";
       description = "Simple deterministic game engine";
       license = stdenv.lib.licenses.mit;
     }) {};

  "detrospector" = callPackage
    ({ mkDerivation, base, binary, bytestring, cmdargs, containers
     , hashable, mwc-random, text, unordered-containers, zlib
     }:
     mkDerivation {
       pname = "detrospector";
       version = "0.3";
       sha256 = "96755100ab9d5b038a5ac5642be9ec2a071cc77f52e702a1a90bfe249f5a4d3b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring cmdargs containers hashable mwc-random text
         unordered-containers zlib
       ];
       description = "Markov chain text generator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "deunicode" = callPackage
    ({ mkDerivation, base, bytestring, utf8-string }:
     mkDerivation {
       pname = "deunicode";
       version = "0.1";
       sha256 = "2e95b08fb1cd88908ca4b50531ed849cdddc263edaa0da691d30490986695323";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bytestring utf8-string ];
       jailbreak = true;
       description = "Get rid of unicode (utf-8) symbols in Haskell sources";
       license = stdenv.lib.licenses.mit;
     }) {};

  "devil" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, filepath
     , hinotify, process, split, text, unix, unordered-containers
     }:
     mkDerivation {
       pname = "devil";
       version = "0.1.1.0";
       sha256 = "c4654ab78f7473d8099bac553bcfa0a597508d8d2f49b4255853650d48fdb9d8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring directory filepath hinotify process split
         text unix unordered-containers
       ];
       homepage = "https://github.com/luanzhu/devil";
       description = "A small tool to make it easier to update program managed by Angel";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "dewdrop" = callPackage
    ({ mkDerivation, base, bytestring, containers, elf, hdis86, syb }:
     mkDerivation {
       pname = "dewdrop";
       version = "0.1";
       sha256 = "1650846ada2fa4d8e48e7a9e5a2b744d97f10625facb51eff24b5218464327f6";
       libraryHaskellDepends = [
         base bytestring containers elf hdis86 syb
       ];
       homepage = "https://github.com/kmcallister/dewdrop";
       description = "Find gadgets for return-oriented programming on x86";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dfrac" = callPackage
    ({ mkDerivation, base, scientific }:
     mkDerivation {
       pname = "dfrac";
       version = "0.1.2.0";
       sha256 = "c7ffbce9085601838c0a716d0fb4430ca77e10c7a695ee68caab1504ed2a78f9";
       libraryHaskellDepends = [ base scientific ];
       description = "A package for precise decimal arithmatic using rationals";
       license = stdenv.lib.licenses.mit;
     }) {};

  "dfsbuild" = callPackage
    ({ mkDerivation, base, ConfigFile, directory, filepath, HSH
     , hslogger, MissingH, network, old-time, parsec, random
     , regex-compat, unix
     }:
     mkDerivation {
       pname = "dfsbuild";
       version = "1.0.2";
       sha256 = "bd0039edd7b0ee2c035739d2fcd19ed4cfa4b33840b71887289ca98ad666055a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base ConfigFile directory filepath HSH hslogger MissingH network
         old-time parsec random regex-compat unix
       ];
       description = "Build Debian From Scratch CD/DVD images";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dgim" = callPackage
    ({ mkDerivation, base, Cabal, QuickCheck }:
     mkDerivation {
       pname = "dgim";
       version = "0.0.3";
       sha256 = "c615817f03ffc8794af3409143708c32d95b05516dc1548cc8af65ae9c772eaf";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base Cabal QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/musically-ut/haskell-dgim";
       description = "Implementation of DGIM algorithm";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dgs" = callPackage
    ({ mkDerivation, base, HTTP, mtl, network, split }:
     mkDerivation {
       pname = "dgs";
       version = "0.2";
       sha256 = "dddee01c6e6079e0ca62c1e34278b2bc78ce17c0c737b23ca5730c0f71a71d80";
       libraryHaskellDepends = [ base HTTP mtl network split ];
       jailbreak = true;
       homepage = "http://www.dmwit.com/dgs";
       description = "Haskell front-end for DGS' bot interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dia-base" = callPackage
    ({ mkDerivation, base, deepseq }:
     mkDerivation {
       pname = "dia-base";
       version = "0.1.1.3";
       sha256 = "e5ac6200e802e81b9d40b497b117cb1b29086170ec9fbff6c574baa53e6ba7cf";
       libraryHaskellDepends = [ base deepseq ];
       description = "An EDSL for teaching Haskell with diagrams - data types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dia-functions" = callPackage
    ({ mkDerivation, base, containers, data-pprint, deepseq, dia-base
     , mtl, xhtml
     }:
     mkDerivation {
       pname = "dia-functions";
       version = "0.2.1.4";
       sha256 = "4730fbef211f42b4567f4a034dc27bd82f2770adac55b3d04b555067dd550e92";
       libraryHaskellDepends = [
         base containers data-pprint deepseq dia-base mtl xhtml
       ];
       description = "An EDSL for teaching Haskell with diagrams - functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams_1_2" = callPackage
    ({ mkDerivation, diagrams-contrib, diagrams-core, diagrams-lib
     , diagrams-svg
     }:
     mkDerivation {
       pname = "diagrams";
       version = "1.2";
       sha256 = "0f3adb7ec43efa98408804ce84cd51af47e8c17a2a856811d33541839a87479e";
       libraryHaskellDepends = [
         diagrams-contrib diagrams-core diagrams-lib diagrams-svg
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Embedded domain-specific language for declarative vector graphics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams_1_3" = callPackage
    ({ mkDerivation, diagrams-contrib, diagrams-core, diagrams-lib
     , diagrams-svg
     }:
     mkDerivation {
       pname = "diagrams";
       version = "1.3";
       sha256 = "c929ac130f8a04b1e0936a877dc1fc2410bc7a8cc680d1504df85f8985baacb8";
       libraryHaskellDepends = [
         diagrams-contrib diagrams-core diagrams-lib diagrams-svg
       ];
       doHaddock = false;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Embedded domain-specific language for declarative vector graphics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams" = callPackage
    ({ mkDerivation, diagrams-contrib, diagrams-core, diagrams-lib
     , diagrams-svg
     }:
     mkDerivation {
       pname = "diagrams";
       version = "1.3.0.1";
       sha256 = "ee8abf5c262955a6a535ddc297bdf829ccd17bc179f61faf953371118ec4e4a7";
       libraryHaskellDepends = [
         diagrams-contrib diagrams-core diagrams-lib diagrams-svg
       ];
       doHaddock = false;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Embedded domain-specific language for declarative vector graphics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-builder_0_6_0_2" = callPackage
    ({ mkDerivation, base, blaze-svg, bytestring, cmdargs
     , diagrams-cairo, diagrams-lib, diagrams-postscript, diagrams-svg
     , directory, exceptions, filepath, hashable, haskell-src-exts, hint
     , lens, mtl, split, transformers
     }:
     mkDerivation {
       pname = "diagrams-builder";
       version = "0.6.0.2";
       sha256 = "05a7b21d3addd74a69f50c8948a608fe8d087c6c2e5dcf82a33d43ee39a45ba1";
       configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cmdargs diagrams-lib directory exceptions filepath hashable
         haskell-src-exts hint lens mtl split transformers
       ];
       executableHaskellDepends = [
         base blaze-svg bytestring cmdargs diagrams-cairo diagrams-lib
         diagrams-postscript diagrams-svg directory filepath lens
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "hint-based build service for the diagrams graphics EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-builder_0_6_0_3" = callPackage
    ({ mkDerivation, base, blaze-svg, bytestring, cmdargs
     , diagrams-cairo, diagrams-lib, diagrams-postscript, diagrams-svg
     , directory, exceptions, filepath, hashable, haskell-src-exts, hint
     , lens, mtl, split, transformers
     }:
     mkDerivation {
       pname = "diagrams-builder";
       version = "0.6.0.3";
       sha256 = "e06480bdd6ac16ec0b3ae87fe05666da09f01c02ffed787ea5c032f5a0b18df1";
       configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cmdargs diagrams-lib directory exceptions filepath hashable
         haskell-src-exts hint lens mtl split transformers
       ];
       executableHaskellDepends = [
         base blaze-svg bytestring cmdargs diagrams-cairo diagrams-lib
         diagrams-postscript diagrams-svg directory filepath lens
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "hint-based build service for the diagrams graphics EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-builder_0_7_1_1" = callPackage
    ({ mkDerivation, base, base-orphans, bytestring, cmdargs
     , diagrams-cairo, diagrams-lib, diagrams-postscript
     , diagrams-rasterific, diagrams-svg, directory, exceptions
     , filepath, hashable, haskell-src-exts, hint, JuicyPixels, lens
     , lucid-svg, mtl, split, transformers
     }:
     mkDerivation {
       pname = "diagrams-builder";
       version = "0.7.1.1";
       sha256 = "50bdfd9fbba8d2ef7fbf1a3f2f81c9c4441abc37b410fdc7cbbc2d4202ac95ce";
       configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-orphans cmdargs diagrams-lib directory exceptions
         filepath hashable haskell-src-exts hint lens mtl split transformers
       ];
       executableHaskellDepends = [
         base bytestring cmdargs diagrams-cairo diagrams-lib
         diagrams-postscript diagrams-rasterific diagrams-svg directory
         filepath JuicyPixels lens lucid-svg
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "hint-based build service for the diagrams graphics EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-builder_0_7_2_0" = callPackage
    ({ mkDerivation, base, base-orphans, bytestring, cmdargs
     , diagrams-cairo, diagrams-lib, diagrams-postscript
     , diagrams-rasterific, diagrams-svg, directory, exceptions
     , filepath, hashable, haskell-src-exts, hint, JuicyPixels, lens
     , lucid-svg, mtl, split, transformers
     }:
     mkDerivation {
       pname = "diagrams-builder";
       version = "0.7.2.0";
       sha256 = "b41c5022404ea59d5b2c545d77486ed44c3ce2501e5f127ea823bf511e09ad8e";
       configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-orphans cmdargs diagrams-lib directory exceptions
         filepath hashable haskell-src-exts hint lens mtl split transformers
       ];
       executableHaskellDepends = [
         base bytestring cmdargs diagrams-cairo diagrams-lib
         diagrams-postscript diagrams-rasterific diagrams-svg directory
         filepath JuicyPixels lens lucid-svg
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "hint-based build service for the diagrams graphics EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-builder_0_7_2_1" = callPackage
    ({ mkDerivation, base, base-orphans, bytestring, cmdargs
     , diagrams-cairo, diagrams-lib, diagrams-postscript
     , diagrams-rasterific, diagrams-svg, directory, exceptions
     , filepath, hashable, haskell-src-exts, hint, JuicyPixels, lens
     , lucid-svg, mtl, split, transformers
     }:
     mkDerivation {
       pname = "diagrams-builder";
       version = "0.7.2.1";
       sha256 = "85f889d8ecc484c6ed6f364a37697f7cc410f2ef8ec33c9d7f8d83e6eb31201f";
       configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-orphans cmdargs diagrams-lib directory exceptions
         filepath hashable haskell-src-exts hint lens mtl split transformers
       ];
       executableHaskellDepends = [
         base bytestring cmdargs diagrams-cairo diagrams-lib
         diagrams-postscript diagrams-rasterific diagrams-svg directory
         filepath JuicyPixels lens lucid-svg
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "hint-based build service for the diagrams graphics EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "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, hint, JuicyPixels, lens
     , lucid-svg, mtl, split, transformers
     }:
     mkDerivation {
       pname = "diagrams-builder";
       version = "0.7.2.2";
       sha256 = "f489b766b89a70700d213df0270e4962e0597928c339e41e02d6b90c9d32567d";
       configureFlags = [ "-fcairo" "-fps" "-frasterific" "-fsvg" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-orphans cmdargs diagrams-lib directory exceptions
         filepath hashable haskell-src-exts hint lens mtl split transformers
       ];
       executableHaskellDepends = [
         base bytestring cmdargs diagrams-cairo diagrams-lib
         diagrams-postscript diagrams-rasterific diagrams-svg directory
         filepath JuicyPixels lens lucid-svg
       ];
       homepage = "http://projects.haskell.org/diagrams";
       description = "hint-based build service for the diagrams graphics EDSL";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-cairo_1_2_0_4" = callPackage
    ({ mkDerivation, base, bytestring, cairo, colour, containers
     , data-default-class, diagrams-core, diagrams-lib, directory
     , filepath, hashable, JuicyPixels, lens, mtl, old-time
     , optparse-applicative, pango, process, split, statestack, time
     , transformers, unix, vector
     }:
     mkDerivation {
       pname = "diagrams-cairo";
       version = "1.2.0.4";
       sha256 = "182f10d4a946f8247f8f8732735f704ed0e1086d4fbb22cd4a8928288b92e6f9";
       libraryHaskellDepends = [
         base bytestring cairo colour containers data-default-class
         diagrams-core diagrams-lib directory filepath hashable JuicyPixels
         lens mtl old-time optparse-applicative pango process split
         statestack time transformers unix vector
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Cairo backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-cairo_1_2_0_5" = callPackage
    ({ mkDerivation, base, bytestring, cairo, colour, containers
     , data-default-class, diagrams-core, diagrams-lib, directory
     , filepath, hashable, JuicyPixels, lens, mtl, old-time
     , optparse-applicative, pango, process, split, statestack, time
     , transformers, unix, vector
     }:
     mkDerivation {
       pname = "diagrams-cairo";
       version = "1.2.0.5";
       sha256 = "8ccf9467464c75508820cb7bf9bad66bf5cb489f9afed36efec6e22050a14498";
       libraryHaskellDepends = [
         base bytestring cairo colour containers data-default-class
         diagrams-core diagrams-lib directory filepath hashable JuicyPixels
         lens mtl old-time optparse-applicative pango process split
         statestack time transformers unix vector
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Cairo backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-cairo_1_2_0_6" = callPackage
    ({ mkDerivation, base, bytestring, cairo, colour, containers
     , data-default-class, diagrams-core, diagrams-lib, directory
     , filepath, hashable, JuicyPixels, lens, mtl, old-time
     , optparse-applicative, pango, process, split, statestack, time
     , transformers, unix, vector
     }:
     mkDerivation {
       pname = "diagrams-cairo";
       version = "1.2.0.6";
       sha256 = "0a40489ff99fefb132a7eefbabed9d95faf0123b7bcaaf06ca8ccaa1127a1a15";
       libraryHaskellDepends = [
         base bytestring cairo colour containers data-default-class
         diagrams-core diagrams-lib directory filepath hashable JuicyPixels
         lens mtl old-time optparse-applicative pango process split
         statestack time transformers unix vector
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Cairo backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-cairo_1_2_0_7" = callPackage
    ({ mkDerivation, base, bytestring, cairo, colour, containers
     , data-default-class, diagrams-core, diagrams-lib, directory
     , filepath, hashable, JuicyPixels, lens, mtl, old-time
     , optparse-applicative, pango, process, split, statestack, time
     , transformers, unix, vector
     }:
     mkDerivation {
       pname = "diagrams-cairo";
       version = "1.2.0.7";
       sha256 = "53fed5c0f5e9ce144631a610b03cfbf1e83b0f97f933ce7fe942922f6ec6077d";
       libraryHaskellDepends = [
         base bytestring cairo colour containers data-default-class
         diagrams-core diagrams-lib directory filepath hashable JuicyPixels
         lens mtl old-time optparse-applicative pango process split
         statestack time transformers unix vector
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Cairo backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-cairo_1_3_0_3" = callPackage
    ({ mkDerivation, 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
     }:
     mkDerivation {
       pname = "diagrams-cairo";
       version = "1.3.0.3";
       sha256 = "ba6c929134a15ee0fe53264081286d1a17c511c2dd8324a3641e16b2c29fc224";
       libraryHaskellDepends = [
         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
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Cairo backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-cairo_1_3_0_4" = callPackage
    ({ mkDerivation, 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
     }:
     mkDerivation {
       pname = "diagrams-cairo";
       version = "1.3.0.4";
       sha256 = "151bbc362bad467b9f47eef5446b4bf27a7654f7fb9d5de18bb4985b1e487c37";
       libraryHaskellDepends = [
         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
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Cairo backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-cairo" = callPackage
    ({ mkDerivation, 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
     }:
     mkDerivation {
       pname = "diagrams-cairo";
       version = "1.3.0.5";
       sha256 = "9d83fbdc43e09d9041ae7fc80dc5ad1e9906fd44bc06d9717d49f376cd6933d5";
       libraryHaskellDepends = [
         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
       ];
       homepage = "http://projects.haskell.org/diagrams";
       description = "Cairo backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-canvas_0_3_0_3" = callPackage
    ({ mkDerivation, base, blank-canvas, cmdargs, containers
     , data-default-class, diagrams-core, diagrams-lib, lens, mtl
     , NumInstances, optparse-applicative, statestack, text
     , vector-space
     }:
     mkDerivation {
       pname = "diagrams-canvas";
       version = "0.3.0.3";
       sha256 = "d97f9050aa00d3d5a9534aae9e4ad1f1faa6d3f14ef9776b012357c8829cb8e3";
       libraryHaskellDepends = [
         base blank-canvas cmdargs containers data-default-class
         diagrams-core diagrams-lib lens mtl NumInstances
         optparse-applicative statestack text vector-space
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "HTML5 canvas backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-canvas_0_3_0_4" = callPackage
    ({ mkDerivation, base, blank-canvas, cmdargs, containers
     , data-default-class, diagrams-core, diagrams-lib, lens, mtl
     , NumInstances, optparse-applicative, statestack, text
     , vector-space
     }:
     mkDerivation {
       pname = "diagrams-canvas";
       version = "0.3.0.4";
       sha256 = "bcec0c8a43d942ff0a345c6529b426354e7df53de1036f3f0be5e5348e3f84c9";
       libraryHaskellDepends = [
         base blank-canvas cmdargs containers data-default-class
         diagrams-core diagrams-lib lens mtl NumInstances
         optparse-applicative statestack text vector-space
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "HTML5 canvas backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-canvas" = callPackage
    ({ mkDerivation, base, blank-canvas, cmdargs, containers
     , data-default-class, diagrams-core, diagrams-lib, lens, mtl
     , NumInstances, optparse-applicative, statestack, text
     }:
     mkDerivation {
       pname = "diagrams-canvas";
       version = "1.3.0.3";
       sha256 = "de44724fa034506ab8c7cd9e494eea1856f0b6a80226ccd2e58b86dcb00e13c1";
       libraryHaskellDepends = [
         base blank-canvas cmdargs containers data-default-class
         diagrams-core diagrams-lib lens mtl NumInstances
         optparse-applicative statestack text
       ];
       homepage = "http://projects.haskell.org/diagrams/";
       description = "HTML5 canvas backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-contrib_1_1_2_4" = callPackage
    ({ mkDerivation, arithmoi, base, circle-packing, colour, containers
     , data-default, data-default-class, diagrams-core, diagrams-lib
     , force-layout, HUnit, lens, MonadRandom, mtl, parsec, QuickCheck
     , semigroups, split, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, vector-space
     , vector-space-points
     }:
     mkDerivation {
       pname = "diagrams-contrib";
       version = "1.1.2.4";
       sha256 = "3c28ab3701004e68e6aa073edb651cfd2ca096f5f92a8d2131a64a5ebcbe0547";
       libraryHaskellDepends = [
         arithmoi base circle-packing colour containers data-default
         data-default-class diagrams-core diagrams-lib force-layout lens
         MonadRandom mtl parsec semigroups split text vector-space
         vector-space-points
       ];
       testHaskellDepends = [
         base containers diagrams-lib HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Collection of user contributions to diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-contrib_1_1_2_5" = callPackage
    ({ mkDerivation, arithmoi, base, circle-packing, colour, containers
     , data-default, data-default-class, diagrams-core, diagrams-lib
     , force-layout, HUnit, lens, MonadRandom, mtl, parsec, QuickCheck
     , semigroups, split, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, vector-space
     , vector-space-points
     }:
     mkDerivation {
       pname = "diagrams-contrib";
       version = "1.1.2.5";
       sha256 = "78ace7064de0cb7c9c0a257364cd9ca5609c781f22676f767ab82a57a54ceeb4";
       libraryHaskellDepends = [
         arithmoi base circle-packing colour containers data-default
         data-default-class diagrams-core diagrams-lib force-layout lens
         MonadRandom mtl parsec semigroups split text vector-space
         vector-space-points
       ];
       testHaskellDepends = [
         base containers diagrams-lib HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Collection of user contributions to diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-contrib_1_1_2_6" = callPackage
    ({ mkDerivation, arithmoi, base, circle-packing, colour, containers
     , data-default, data-default-class, diagrams-core, diagrams-lib
     , force-layout, HUnit, lens, MonadRandom, mtl, parsec, QuickCheck
     , semigroups, split, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, vector-space
     , vector-space-points
     }:
     mkDerivation {
       pname = "diagrams-contrib";
       version = "1.1.2.6";
       sha256 = "20ea1a20f48732564d0a87ce64d926a0bfe580788a350e0d06a3b74927a1712e";
       libraryHaskellDepends = [
         arithmoi base circle-packing colour containers data-default
         data-default-class diagrams-core diagrams-lib force-layout lens
         MonadRandom mtl parsec semigroups split text vector-space
         vector-space-points
       ];
       testHaskellDepends = [
         base containers diagrams-lib HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Collection of user contributions to diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-contrib_1_3_0_4" = callPackage
    ({ mkDerivation, base, circle-packing, colour, containers
     , data-default, data-default-class, diagrams-core, diagrams-lib
     , diagrams-solve, force-layout, HUnit, lens, linear, MonadRandom
     , mtl, parsec, QuickCheck, random, semigroups, split
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text
     }:
     mkDerivation {
       pname = "diagrams-contrib";
       version = "1.3.0.4";
       sha256 = "6e5abdadbe7c7dfb33681dcaf639de065efd0f9e68d84665ee12094027a92457";
       libraryHaskellDepends = [
         base circle-packing colour containers data-default
         data-default-class diagrams-core diagrams-lib diagrams-solve
         force-layout lens linear MonadRandom mtl parsec random semigroups
         split text
       ];
       testHaskellDepends = [
         base containers diagrams-lib HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Collection of user contributions to diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-contrib_1_3_0_5" = callPackage
    ({ mkDerivation, base, circle-packing, colour, containers
     , data-default, data-default-class, diagrams-core, diagrams-lib
     , diagrams-solve, force-layout, HUnit, lens, linear, MonadRandom
     , mtl, parsec, QuickCheck, random, semigroups, split
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text
     }:
     mkDerivation {
       pname = "diagrams-contrib";
       version = "1.3.0.5";
       sha256 = "9549fb1e1e305698646ba6360b137e0c9cd63ab0f7c33f3e6d814ad763116e77";
       libraryHaskellDepends = [
         base circle-packing colour containers data-default
         data-default-class diagrams-core diagrams-lib diagrams-solve
         force-layout lens linear MonadRandom mtl parsec random semigroups
         split text
       ];
       testHaskellDepends = [
         base containers diagrams-lib HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Collection of user contributions to diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-contrib_1_3_0_6" = callPackage
    ({ mkDerivation, base, circle-packing, colour, containers
     , data-default, data-default-class, diagrams-core, diagrams-lib
     , diagrams-solve, force-layout, HUnit, lens, linear, MonadRandom
     , mtl, parsec, QuickCheck, random, semigroups, split
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text
     }:
     mkDerivation {
       pname = "diagrams-contrib";
       version = "1.3.0.6";
       sha256 = "5e8af43e4416e48549d29150a0b653cba32fec8df859f5e37295473d4bfd6acc";
       libraryHaskellDepends = [
         base circle-packing colour containers data-default
         data-default-class diagrams-core diagrams-lib diagrams-solve
         force-layout lens linear MonadRandom mtl parsec random semigroups
         split text
       ];
       testHaskellDepends = [
         base containers diagrams-lib HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Collection of user contributions to diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-contrib_1_3_0_7" = callPackage
    ({ mkDerivation, base, circle-packing, colour, containers
     , data-default, data-default-class, diagrams-core, diagrams-lib
     , diagrams-solve, force-layout, HUnit, lens, linear, MonadRandom
     , mtl, parsec, QuickCheck, random, semigroups, split
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text
     }:
     mkDerivation {
       pname = "diagrams-contrib";
       version = "1.3.0.7";
       sha256 = "afd3f74ba3aa89f564cc7541e7a1e2aad578c99a099cb1d1d3396dd13bb28e6a";
       libraryHaskellDepends = [
         base circle-packing colour containers data-default
         data-default-class diagrams-core diagrams-lib diagrams-solve
         force-layout lens linear MonadRandom mtl parsec random semigroups
         split text
       ];
       testHaskellDepends = [
         base containers diagrams-lib HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Collection of user contributions to diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-contrib" = callPackage
    ({ mkDerivation, base, circle-packing, colour, containers
     , data-default, data-default-class, diagrams-core, diagrams-lib
     , diagrams-solve, force-layout, HUnit, lens, linear, MonadRandom
     , mtl, parsec, QuickCheck, random, semigroups, split
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text
     }:
     mkDerivation {
       pname = "diagrams-contrib";
       version = "1.3.0.8";
       sha256 = "e311406aed0718c315ba910cb96324810bceb6f526790a7c2978e44a09558dec";
       libraryHaskellDepends = [
         base circle-packing colour containers data-default
         data-default-class diagrams-core diagrams-lib diagrams-solve
         force-layout lens linear MonadRandom mtl parsec random semigroups
         split text
       ];
       testHaskellDepends = [
         base containers diagrams-lib HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Collection of user contributions to diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-core_1_2_0_4" = callPackage
    ({ mkDerivation, base, containers, dual-tree, lens, MemoTrie
     , monoid-extras, newtype, semigroups, vector-space
     , vector-space-points
     }:
     mkDerivation {
       pname = "diagrams-core";
       version = "1.2.0.4";
       sha256 = "783ec5a4efc56f9c318e4e96dc152215c090bf452164b70bfc5b128df37db3ab";
       libraryHaskellDepends = [
         base containers dual-tree lens MemoTrie monoid-extras newtype
         semigroups vector-space vector-space-points
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Core libraries for diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-core_1_2_0_5" = callPackage
    ({ mkDerivation, base, containers, dual-tree, lens, MemoTrie
     , monoid-extras, newtype, semigroups, vector-space
     , vector-space-points
     }:
     mkDerivation {
       pname = "diagrams-core";
       version = "1.2.0.5";
       sha256 = "9cadaf44680a0c8c361b348a214c06d698c6209ec50853e8a5a5ac64b2990586";
       libraryHaskellDepends = [
         base containers dual-tree lens MemoTrie monoid-extras newtype
         semigroups vector-space vector-space-points
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Core libraries for diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-core_1_2_0_6" = callPackage
    ({ mkDerivation, base, containers, dual-tree, lens, MemoTrie
     , monoid-extras, newtype, semigroups, vector-space
     , vector-space-points
     }:
     mkDerivation {
       pname = "diagrams-core";
       version = "1.2.0.6";
       sha256 = "9a7ed0f7e84b8b790a37c5f2c1833fdab2eaf7f88d4a98f6fc5860f8b33a10c5";
       libraryHaskellDepends = [
         base containers dual-tree lens MemoTrie monoid-extras newtype
         semigroups vector-space vector-space-points
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Core libraries for diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-core_1_3_0_2" = callPackage
    ({ mkDerivation, adjunctions, base, containers, distributive
     , dual-tree, lens, linear, monoid-extras, mtl, semigroups
     , unordered-containers
     }:
     mkDerivation {
       pname = "diagrams-core";
       version = "1.3.0.2";
       sha256 = "f57baa9b197a412b0411896b47412b19051f8b4b6c8cdd6b988d08152fbc3f53";
       libraryHaskellDepends = [
         adjunctions base containers distributive dual-tree lens linear
         monoid-extras mtl semigroups unordered-containers
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Core libraries for diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-core_1_3_0_3" = callPackage
    ({ mkDerivation, adjunctions, base, containers, distributive
     , dual-tree, lens, linear, monoid-extras, mtl, semigroups
     , unordered-containers
     }:
     mkDerivation {
       pname = "diagrams-core";
       version = "1.3.0.3";
       sha256 = "b76d971b75e61fcadf468b43e011d8ab6f0fdb76018d627a86cff852821666b3";
       libraryHaskellDepends = [
         adjunctions base containers distributive dual-tree lens linear
         monoid-extras mtl semigroups unordered-containers
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Core libraries for diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-core_1_3_0_4" = callPackage
    ({ mkDerivation, adjunctions, base, containers, distributive
     , dual-tree, lens, linear, monoid-extras, mtl, semigroups
     , unordered-containers
     }:
     mkDerivation {
       pname = "diagrams-core";
       version = "1.3.0.4";
       sha256 = "1f2ca2f8c7b9e096b76ac62b563f02c83fec53c61bd2b0de4a8f557d14fc5935";
       libraryHaskellDepends = [
         adjunctions base containers distributive dual-tree lens linear
         monoid-extras mtl semigroups unordered-containers
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Core libraries for diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-core_1_3_0_5" = callPackage
    ({ mkDerivation, adjunctions, base, containers, distributive
     , dual-tree, lens, linear, monoid-extras, mtl, semigroups
     , unordered-containers
     }:
     mkDerivation {
       pname = "diagrams-core";
       version = "1.3.0.5";
       sha256 = "e898afe6cb88fb8caf9555b700a22021e84783d2cbe825d16cbb8cee461fae8c";
       libraryHaskellDepends = [
         adjunctions base containers distributive dual-tree lens linear
         monoid-extras mtl semigroups unordered-containers
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Core libraries for diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-core" = callPackage
    ({ mkDerivation, adjunctions, base, containers, distributive
     , dual-tree, lens, linear, monoid-extras, mtl, semigroups
     , unordered-containers
     }:
     mkDerivation {
       pname = "diagrams-core";
       version = "1.3.0.6";
       sha256 = "33c6079b2ec235c3fbbcb8ea7103335ccec1d1d53c27549c549f3b9ca692b9d3";
       libraryHaskellDepends = [
         adjunctions base containers distributive dual-tree lens linear
         monoid-extras mtl semigroups unordered-containers
       ];
       homepage = "http://projects.haskell.org/diagrams";
       description = "Core libraries for diagrams EDSL";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-graphviz" = callPackage
    ({ mkDerivation, base, containers, diagrams-lib, fgl, graphviz
     , split
     }:
     mkDerivation {
       pname = "diagrams-graphviz";
       version = "1.3.0.0";
       sha256 = "8bf1a7defbe595da7e824aab68c979329e25900dab84365218dafad0099fcf86";
       libraryHaskellDepends = [
         base containers diagrams-lib fgl graphviz split
       ];
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Graph layout and drawing with GrahpViz and diagrams";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-gtk" = callPackage
    ({ mkDerivation, base, cairo, diagrams-cairo, diagrams-lib, gtk }:
     mkDerivation {
       pname = "diagrams-gtk";
       version = "1.3.0.1";
       sha256 = "a328abe54875119b3cc0aaee3b0f913868cc9d24bdf46ac2ab7876b89fd8a309";
       libraryHaskellDepends = [
         base cairo diagrams-cairo diagrams-lib gtk
       ];
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Backend for rendering diagrams directly to GTK windows";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-haddock_0_2_2_12" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring, blaze-svg
     , bytestring, Cabal, cautious-file, cmdargs, containers, cpphs
     , diagrams-builder, diagrams-lib, diagrams-svg, directory, filepath
     , haskell-src-exts, lens, mtl, parsec, QuickCheck, split, strict
     , tasty, tasty-quickcheck, text, uniplate, vector-space
     }:
     mkDerivation {
       pname = "diagrams-haddock";
       version = "0.2.2.12";
       sha256 = "063244076401aa80ca6a8b10706bbf5c5580501e5db161ed3db0c3480ace2bfb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring blaze-svg bytestring
         cautious-file containers cpphs diagrams-builder diagrams-lib
         diagrams-svg directory filepath haskell-src-exts lens mtl parsec
         split strict text uniplate vector-space
       ];
       executableHaskellDepends = [
         base Cabal cmdargs cpphs directory filepath
       ];
       testHaskellDepends = [
         base containers haskell-src-exts lens parsec QuickCheck tasty
         tasty-quickcheck
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Preprocessor for embedding diagrams in Haddock documentation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-haddock_0_2_2_13" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring, blaze-svg
     , bytestring, Cabal, cautious-file, cmdargs, containers, cpphs
     , diagrams-builder, diagrams-lib, diagrams-svg, directory, filepath
     , haskell-src-exts, lens, mtl, parsec, QuickCheck, split, strict
     , tasty, tasty-quickcheck, text, uniplate, vector-space
     }:
     mkDerivation {
       pname = "diagrams-haddock";
       version = "0.2.2.13";
       sha256 = "907ff3a94e4e8cbc6129dd4a258ba0476edfa52607b4d0b83f17efc2512a2304";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring blaze-svg bytestring
         cautious-file containers cpphs diagrams-builder diagrams-lib
         diagrams-svg directory filepath haskell-src-exts lens mtl parsec
         split strict text uniplate vector-space
       ];
       executableHaskellDepends = [
         base Cabal cmdargs cpphs directory filepath
       ];
       testHaskellDepends = [
         base containers haskell-src-exts lens parsec QuickCheck tasty
         tasty-quickcheck
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Preprocessor for embedding diagrams in Haddock documentation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-haddock_0_3_0_6" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring, bytestring
     , Cabal, cautious-file, cmdargs, containers, cpphs
     , diagrams-builder, diagrams-lib, diagrams-svg, directory, filepath
     , haskell-src-exts, lens, linear, lucid-svg, mtl, parsec
     , QuickCheck, split, strict, tasty, tasty-quickcheck, text
     , uniplate
     }:
     mkDerivation {
       pname = "diagrams-haddock";
       version = "0.3.0.6";
       sha256 = "32434b0c7b1aeae30827b1b7ae1b7c65542ba27ee8574e6f92d68515da1c485d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring bytestring cautious-file
         containers cpphs diagrams-builder diagrams-lib diagrams-svg
         directory filepath haskell-src-exts lens linear lucid-svg mtl
         parsec split strict text uniplate
       ];
       executableHaskellDepends = [
         base Cabal cmdargs cpphs directory filepath
       ];
       testHaskellDepends = [
         base containers haskell-src-exts lens parsec QuickCheck tasty
         tasty-quickcheck
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Preprocessor for embedding diagrams in Haddock documentation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-haddock_0_3_0_7" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring, bytestring
     , Cabal, cautious-file, cmdargs, containers, cpphs
     , diagrams-builder, diagrams-lib, diagrams-svg, directory, filepath
     , haskell-src-exts, lens, linear, lucid-svg, mtl, parsec
     , QuickCheck, split, strict, tasty, tasty-quickcheck, text
     , uniplate
     }:
     mkDerivation {
       pname = "diagrams-haddock";
       version = "0.3.0.7";
       sha256 = "27899e0fb4e3fc1f230374dfc872ffa658c6d797b6cfe8858f312637e1b694a3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring bytestring cautious-file
         containers cpphs diagrams-builder diagrams-lib diagrams-svg
         directory filepath haskell-src-exts lens linear lucid-svg mtl
         parsec split strict text uniplate
       ];
       executableHaskellDepends = [
         base Cabal cmdargs cpphs directory filepath
       ];
       testHaskellDepends = [
         base containers haskell-src-exts lens parsec QuickCheck tasty
         tasty-quickcheck
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Preprocessor for embedding diagrams in Haddock documentation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-haddock" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring, bytestring
     , Cabal, cautious-file, cmdargs, containers, cpphs
     , diagrams-builder, diagrams-lib, diagrams-svg, directory, filepath
     , haskell-src-exts, lens, linear, lucid-svg, mtl, parsec
     , QuickCheck, split, strict, tasty, tasty-quickcheck, text
     , uniplate
     }:
     mkDerivation {
       pname = "diagrams-haddock";
       version = "0.3.0.10";
       sha256 = "49ed17c49c1aae075892e9992b691867e418944a37141f028a7a2e6220d6f0af";
       revision = "1";
       editedCabalFile = "c77d5d5a908d03ba9fc545f977ced5d393a22e6de5b9d00deb4fb7fddd4a366d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring bytestring cautious-file
         containers cpphs diagrams-builder diagrams-lib diagrams-svg
         directory filepath haskell-src-exts lens linear lucid-svg mtl
         parsec split strict text uniplate
       ];
       executableHaskellDepends = [
         base Cabal cmdargs cpphs directory filepath
       ];
       testHaskellDepends = [
         base containers haskell-src-exts lens parsec QuickCheck tasty
         tasty-quickcheck
       ];
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Preprocessor for embedding diagrams in Haddock documentation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-hsqml" = callPackage
    ({ mkDerivation, base, colour, containers, diagrams-core
     , diagrams-lib, hsqml, lens, text, transformers
     }:
     mkDerivation {
       pname = "diagrams-hsqml";
       version = "0.2.0.0";
       sha256 = "601b3c4a332ce0f4c4af5bc1f85f13fa698cc095698afcbeb523cd0353480439";
       libraryHaskellDepends = [
         base colour containers diagrams-core diagrams-lib hsqml lens text
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/marcinmrotek/diagrams-hsqml";
       description = "HsQML (Qt5) backend for Diagrams";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "diagrams-html5_1_3_0_2" = callPackage
    ({ mkDerivation, base, cmdargs, containers, data-default-class
     , diagrams-core, diagrams-lib, lens, mtl, NumInstances
     , optparse-applicative, split, statestack, static-canvas, text
     }:
     mkDerivation {
       pname = "diagrams-html5";
       version = "1.3.0.2";
       sha256 = "3209ea41b9109af409c1cc6348e42ec34ba1260e39d6d10c6a2ccdd9cbc62ea2";
       libraryHaskellDepends = [
         base cmdargs containers data-default-class diagrams-core
         diagrams-lib lens mtl NumInstances optparse-applicative split
         statestack static-canvas text
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "HTML5 canvas backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-html5_1_3_0_3" = callPackage
    ({ mkDerivation, base, cmdargs, containers, data-default-class
     , diagrams-core, diagrams-lib, lens, mtl, NumInstances
     , optparse-applicative, split, statestack, static-canvas, text
     }:
     mkDerivation {
       pname = "diagrams-html5";
       version = "1.3.0.3";
       sha256 = "319d8a79041abd91030d12a6b04196ed986432d0bd44a7c6f12505d5364b692b";
       libraryHaskellDepends = [
         base cmdargs containers data-default-class diagrams-core
         diagrams-lib lens mtl NumInstances optparse-applicative split
         statestack static-canvas text
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "HTML5 canvas backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-html5" = callPackage
    ({ mkDerivation, base, cmdargs, containers, data-default-class
     , diagrams-core, diagrams-lib, lens, mtl, NumInstances
     , optparse-applicative, split, statestack, static-canvas, text
     }:
     mkDerivation {
       pname = "diagrams-html5";
       version = "1.3.0.4";
       sha256 = "8dcc7134f3b9e3ca7816afe77d6da881e5aee400d91349b0f0af35faac14bfeb";
       libraryHaskellDepends = [
         base cmdargs containers data-default-class diagrams-core
         diagrams-lib lens mtl NumInstances optparse-applicative split
         statestack static-canvas text
       ];
       homepage = "http://projects.haskell.org/diagrams/";
       description = "HTML5 canvas backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-lib_1_2_0_7" = callPackage
    ({ mkDerivation, active, array, base, colour, containers
     , data-default-class, diagrams-core, dual-tree, filepath
     , fingertree, hashable, intervals, JuicyPixels, lens, MemoTrie
     , monoid-extras, optparse-applicative, semigroups, tagged
     , vector-space, vector-space-points
     }:
     mkDerivation {
       pname = "diagrams-lib";
       version = "1.2.0.7";
       sha256 = "2a250887b45fe8a80c2c8d682226e40236e9c4a21144c85dac421e726fa4ad89";
       libraryHaskellDepends = [
         active array base colour containers data-default-class
         diagrams-core dual-tree filepath fingertree hashable intervals
         JuicyPixels lens MemoTrie monoid-extras optparse-applicative
         semigroups tagged vector-space vector-space-points
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Embedded domain-specific language for declarative graphics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-lib_1_2_0_8" = callPackage
    ({ mkDerivation, active, array, base, colour, containers
     , data-default-class, diagrams-core, dual-tree, filepath
     , fingertree, hashable, intervals, JuicyPixels, lens, MemoTrie
     , monoid-extras, optparse-applicative, semigroups, tagged
     , vector-space, vector-space-points
     }:
     mkDerivation {
       pname = "diagrams-lib";
       version = "1.2.0.8";
       sha256 = "0e7d1de4610d0bba49b70a7a655b616218648a30432981117ec60927380f3fbd";
       libraryHaskellDepends = [
         active array base colour containers data-default-class
         diagrams-core dual-tree filepath fingertree hashable intervals
         JuicyPixels lens MemoTrie monoid-extras optparse-applicative
         semigroups tagged vector-space vector-space-points
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Embedded domain-specific language for declarative graphics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-lib_1_2_0_9" = callPackage
    ({ mkDerivation, active, array, base, colour, containers
     , data-default-class, diagrams-core, dual-tree, filepath
     , fingertree, hashable, intervals, JuicyPixels, lens, MemoTrie
     , monoid-extras, optparse-applicative, semigroups, tagged
     , vector-space, vector-space-points
     }:
     mkDerivation {
       pname = "diagrams-lib";
       version = "1.2.0.9";
       sha256 = "69126f1c65771cc2fc645471dce59323e6ea34e4b2fcbc179763a678baac4ad9";
       libraryHaskellDepends = [
         active array base colour containers data-default-class
         diagrams-core dual-tree filepath fingertree hashable intervals
         JuicyPixels lens MemoTrie monoid-extras optparse-applicative
         semigroups tagged vector-space vector-space-points
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Embedded domain-specific language for declarative graphics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-lib_1_3_0_3" = callPackage
    ({ mkDerivation, active, adjunctions, array, base, 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
     , semigroups, tagged, text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "diagrams-lib";
       version = "1.3.0.3";
       sha256 = "0cc9e5131c7eb0061963eac53e58ec91909f606652108515b1f2ca80492a7751";
       libraryHaskellDepends = [
         active adjunctions array base 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 semigroups tagged text transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Embedded domain-specific language for declarative graphics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-lib_1_3_0_8" = callPackage
    ({ mkDerivation, active, adjunctions, array, base, 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
     , semigroups, tagged, text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "diagrams-lib";
       version = "1.3.0.8";
       sha256 = "4d46b91284b3de5bbbf4f0aded5bdbf72670322f47992ad9b868b2a79c4ef53b";
       libraryHaskellDepends = [
         active adjunctions array base 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 semigroups tagged text transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Embedded domain-specific language for declarative graphics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-lib_1_3_0_9" = callPackage
    ({ mkDerivation, active, adjunctions, array, base, 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
     , semigroups, tagged, text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "diagrams-lib";
       version = "1.3.0.9";
       sha256 = "e908935df463b5caaa203205cc98a9163ce8d346ac9cb8bca6fe49630c536c85";
       libraryHaskellDepends = [
         active adjunctions array base 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 semigroups tagged text transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Embedded domain-specific language for declarative graphics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-lib" = callPackage
    ({ mkDerivation, active, adjunctions, array, base, 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
     , semigroups, tagged, tasty, tasty-hunit, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "diagrams-lib";
       version = "1.3.1.1";
       sha256 = "02f2760a413f36fb73a726c1fdc2bfc4100476cbc0850bfe17f90de9ed713e69";
       libraryHaskellDepends = [
         active adjunctions array base 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 semigroups tagged text transformers unordered-containers
       ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       homepage = "http://projects.haskell.org/diagrams";
       description = "Embedded domain-specific language for declarative graphics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-pandoc" = callPackage
    ({ mkDerivation, base, diagrams-builder, diagrams-cairo
     , diagrams-lib, directory, filepath, linear, optparse-applicative
     , pandoc-types
     }:
     mkDerivation {
       pname = "diagrams-pandoc";
       version = "0.2";
       sha256 = "03bc32e95873000bae33d837319367febc2efad073671677afa3fdd59d246459";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base diagrams-builder diagrams-cairo diagrams-lib directory
         filepath linear pandoc-types
       ];
       executableHaskellDepends = [
         base diagrams-builder diagrams-cairo diagrams-lib directory
         filepath linear optparse-applicative pandoc-types
       ];
       jailbreak = true;
       description = "A pandoc filter to express diagrams inline using the haskell EDSL _diagrams_";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-pdf" = callPackage
    ({ mkDerivation, base, cmdargs, colour, diagrams-core, diagrams-lib
     , filepath, HPDF, lens, monoid-extras, mtl, semigroups, split
     , vector-space
     }:
     mkDerivation {
       pname = "diagrams-pdf";
       version = "0.3.1";
       sha256 = "7e9fa1dcaf72e53f7c418b73a3d8e1776c12deab709b9013a93fd89001472372";
       libraryHaskellDepends = [
         base cmdargs colour diagrams-core diagrams-lib filepath HPDF lens
         monoid-extras mtl semigroups split vector-space
       ];
       jailbreak = true;
       homepage = "http://www.alpheccar.org";
       description = "PDF backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-pgf" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-builder, colour
     , containers, diagrams-core, diagrams-lib, directory, filepath
     , hashable, JuicyPixels, mtl, optparse-applicative, process, split
     , texrunner, time, vector, zlib
     }:
     mkDerivation {
       pname = "diagrams-pgf";
       version = "0.1.0.3";
       sha256 = "15148b7e985025fcee125086c13610de1b927b7c4dfcf5d8e6674f6844290641";
       libraryHaskellDepends = [
         base bytestring bytestring-builder colour containers diagrams-core
         diagrams-lib directory filepath hashable JuicyPixels mtl
         optparse-applicative process split texrunner time vector zlib
       ];
       homepage = "http://github.com/cchalmers/diagrams-pgf";
       description = "PGF backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-postscript_1_1_0_3" = callPackage
    ({ mkDerivation, base, containers, data-default-class
     , diagrams-core, diagrams-lib, dlist, filepath, hashable, lens
     , monoid-extras, mtl, semigroups, split, vector-space
     }:
     mkDerivation {
       pname = "diagrams-postscript";
       version = "1.1.0.3";
       sha256 = "1f766977ae09b295e3ede8ee87c0f0fb3eb3f954532dbdca9ec2c32f133e599c";
       libraryHaskellDepends = [
         base containers data-default-class diagrams-core diagrams-lib dlist
         filepath hashable lens monoid-extras mtl semigroups split
         vector-space
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Postscript backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-postscript_1_1_0_4" = callPackage
    ({ mkDerivation, base, containers, data-default-class
     , diagrams-core, diagrams-lib, dlist, filepath, hashable, lens
     , monoid-extras, mtl, semigroups, split, vector-space
     }:
     mkDerivation {
       pname = "diagrams-postscript";
       version = "1.1.0.4";
       sha256 = "b8788fb422a4a9f30cfc49fd2e69e7e3ae182b0205b307ce3b2d16b190594109";
       libraryHaskellDepends = [
         base containers data-default-class diagrams-core diagrams-lib dlist
         filepath hashable lens monoid-extras mtl semigroups split
         vector-space
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Postscript backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-postscript_1_1_0_5" = callPackage
    ({ mkDerivation, base, containers, data-default-class
     , diagrams-core, diagrams-lib, dlist, filepath, hashable, lens
     , monoid-extras, mtl, semigroups, split, vector-space
     }:
     mkDerivation {
       pname = "diagrams-postscript";
       version = "1.1.0.5";
       sha256 = "e566e4da7090652040f0deeb45ac41e7d5a8fb72b98dd5b167f4d74f4cda31db";
       libraryHaskellDepends = [
         base containers data-default-class diagrams-core diagrams-lib dlist
         filepath hashable lens monoid-extras mtl semigroups split
         vector-space
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Postscript backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-postscript_1_3_0_2" = callPackage
    ({ mkDerivation, base, containers, data-default-class
     , diagrams-core, diagrams-lib, dlist, filepath, hashable, lens
     , monoid-extras, mtl, semigroups, split, statestack
     }:
     mkDerivation {
       pname = "diagrams-postscript";
       version = "1.3.0.2";
       sha256 = "fa4caf2c02d001a995dc23700b9ee116cbf9120f15bfbe024ca84aa362d1b031";
       libraryHaskellDepends = [
         base containers data-default-class diagrams-core diagrams-lib dlist
         filepath hashable lens monoid-extras mtl semigroups split
         statestack
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Postscript backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-postscript_1_3_0_3" = callPackage
    ({ mkDerivation, base, containers, data-default-class
     , diagrams-core, diagrams-lib, dlist, filepath, hashable, lens
     , monoid-extras, mtl, semigroups, split, statestack
     }:
     mkDerivation {
       pname = "diagrams-postscript";
       version = "1.3.0.3";
       sha256 = "fd2a98a447a3383be967bbef9ed0262e91d7270b5ce9e2eeed7b2ba4cfebf7e9";
       libraryHaskellDepends = [
         base containers data-default-class diagrams-core diagrams-lib dlist
         filepath hashable lens monoid-extras mtl semigroups split
         statestack
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Postscript backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-postscript" = callPackage
    ({ mkDerivation, base, containers, data-default-class
     , diagrams-core, diagrams-lib, dlist, filepath, hashable, lens
     , monoid-extras, mtl, semigroups, split, statestack
     }:
     mkDerivation {
       pname = "diagrams-postscript";
       version = "1.3.0.4";
       sha256 = "9b1829899a52b53500f415dabb719955e8a468031f91d505b1c2e93221913a35";
       libraryHaskellDepends = [
         base containers data-default-class diagrams-core diagrams-lib dlist
         filepath hashable lens monoid-extras mtl semigroups split
         statestack
       ];
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Postscript backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-qrcode" = callPackage
    ({ mkDerivation, array, base, colour, diagrams-core, diagrams-lib
     }:
     mkDerivation {
       pname = "diagrams-qrcode";
       version = "1.3";
       sha256 = "fd7f571bbdc392b1fb1872546b5980913efde1e3604fd1bc94225e7fd8b2a7dd";
       libraryHaskellDepends = [
         array base colour diagrams-core diagrams-lib
       ];
       homepage = "https://github.com/prowdsponsor/diagrams-qrcode";
       description = "Draw QR codes to SVG, PNG, PDF or PS files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-rasterific_0_1_0_7" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default-class
     , diagrams-core, diagrams-lib, directory, filepath, FontyFruity
     , JuicyPixels, lens, mtl, old-time, optparse-applicative, process
     , Rasterific, split, statestack, time, unix
     }:
     mkDerivation {
       pname = "diagrams-rasterific";
       version = "0.1.0.7";
       sha256 = "08b5dfcdb3865587d98f4db95d14c20e31c7db3d05ebbaf9c1e6c15b44b811a0";
       libraryHaskellDepends = [
         base bytestring containers data-default-class diagrams-core
         diagrams-lib directory filepath FontyFruity JuicyPixels lens mtl
         old-time optparse-applicative process Rasterific split statestack
         time unix
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Rasterific backend for diagrams";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-rasterific_0_1_0_8" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default-class
     , diagrams-core, diagrams-lib, directory, filepath, FontyFruity
     , JuicyPixels, lens, mtl, old-time, optparse-applicative, process
     , Rasterific, split, statestack, time, unix
     }:
     mkDerivation {
       pname = "diagrams-rasterific";
       version = "0.1.0.8";
       sha256 = "f3a0853216e2ad94aee0907c735068738ba623c6be58816e4fe8436308074821";
       libraryHaskellDepends = [
         base bytestring containers data-default-class diagrams-core
         diagrams-lib directory filepath FontyFruity JuicyPixels lens mtl
         old-time optparse-applicative process Rasterific split statestack
         time unix
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Rasterific backend for diagrams";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-rasterific_1_3_1_3" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default-class
     , diagrams-core, diagrams-lib, filepath, FontyFruity, hashable
     , JuicyPixels, lens, mtl, optparse-applicative, Rasterific, split
     , unix
     }:
     mkDerivation {
       pname = "diagrams-rasterific";
       version = "1.3.1.3";
       sha256 = "71b2f992ca563d067f13fd7cdaa62c13ed4df564eba780d408de776187bc6abe";
       libraryHaskellDepends = [
         base bytestring containers data-default-class diagrams-core
         diagrams-lib filepath FontyFruity hashable JuicyPixels lens mtl
         optparse-applicative Rasterific split unix
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Rasterific backend for diagrams";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-rasterific_1_3_1_4" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default-class
     , diagrams-core, diagrams-lib, filepath, FontyFruity, hashable
     , JuicyPixels, lens, mtl, optparse-applicative, Rasterific, split
     , unix
     }:
     mkDerivation {
       pname = "diagrams-rasterific";
       version = "1.3.1.4";
       sha256 = "6fb0d254d7959dd624d5918830601941bed87c4f37f2c625e24107af0560b78d";
       libraryHaskellDepends = [
         base bytestring containers data-default-class diagrams-core
         diagrams-lib filepath FontyFruity hashable JuicyPixels lens mtl
         optparse-applicative Rasterific split unix
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Rasterific backend for diagrams";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-rasterific" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default-class
     , diagrams-core, diagrams-lib, filepath, FontyFruity, hashable
     , JuicyPixels, lens, mtl, optparse-applicative, Rasterific, split
     , unix
     }:
     mkDerivation {
       pname = "diagrams-rasterific";
       version = "1.3.1.5";
       sha256 = "0fe3d7a6b4d5140aece80a35d9cbf54cc7a2712f45b8792758e340cfa4636c10";
       libraryHaskellDepends = [
         base bytestring containers data-default-class diagrams-core
         diagrams-lib filepath FontyFruity hashable JuicyPixels lens mtl
         optparse-applicative Rasterific split unix
       ];
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Rasterific backend for diagrams";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-reflex" = callPackage
    ({ mkDerivation, base, colour, containers, diagrams-core
     , diagrams-lib, lens, monoid-extras, mtl, reflex, reflex-dom
     , reflex-dom-contrib
     }:
     mkDerivation {
       pname = "diagrams-reflex";
       version = "0.1";
       sha256 = "9dd7316c3a65c9f99254f12bd832e72da8af39277ced9ad16e53ee782afad73e";
       libraryHaskellDepends = [
         base colour containers diagrams-core diagrams-lib lens
         monoid-extras mtl reflex reflex-dom reflex-dom-contrib
       ];
       homepage = "http://projects.haskell.org/diagrams/";
       description = "reflex backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-rubiks-cube" = callPackage
    ({ mkDerivation, base, data-default-class, diagrams-lib, lens }:
     mkDerivation {
       pname = "diagrams-rubiks-cube";
       version = "0.2.0.0";
       sha256 = "ab91576655c3f7ca9fa859d8c9fff6bbefe2eb8405d3563cad6734cb71d4d5e7";
       libraryHaskellDepends = [
         base data-default-class diagrams-lib lens
       ];
       homepage = "https://github.com/timjb/rubiks-cube";
       description = "Library for drawing the Rubik's Cube";
       license = stdenv.lib.licenses.mit;
     }) {};

  "diagrams-solve_0_1" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "diagrams-solve";
       version = "0.1";
       sha256 = "4e97355e34d17c23f6dd5ad3bf4e5a9980f85eba4e80c7cf8fe766ae69050c4b";
       libraryHaskellDepends = [ base ];
       homepage = "http://projects.haskell.org/diagrams";
       description = "Pure Haskell solver routines used by diagrams";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-solve" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "diagrams-solve";
       version = "0.1.0.1";
       sha256 = "71e53a4c8c2794719d057e6bf52b996b13d52ac9d62191df134ba05062453bde";
       libraryHaskellDepends = [ base ];
       homepage = "http://projects.haskell.org/diagrams";
       description = "Pure Haskell solver routines used by diagrams";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-svg_1_1_0_3" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-markup, blaze-svg
     , bytestring, colour, containers, diagrams-core, diagrams-lib
     , directory, filepath, hashable, JuicyPixels, lens, monoid-extras
     , mtl, old-time, process, split, time, unix, vector-space
     }:
     mkDerivation {
       pname = "diagrams-svg";
       version = "1.1.0.3";
       sha256 = "98b75b31314a2339a81d58284c121d387d05f613e36f81b3171106983eefd82f";
       libraryHaskellDepends = [
         base base64-bytestring blaze-markup blaze-svg bytestring colour
         containers diagrams-core diagrams-lib directory filepath hashable
         JuicyPixels lens monoid-extras mtl old-time process split time unix
         vector-space
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "SVG backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-svg_1_1_0_4" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-markup, blaze-svg
     , bytestring, colour, containers, diagrams-core, diagrams-lib
     , directory, filepath, hashable, JuicyPixels, lens, monoid-extras
     , mtl, old-time, process, split, time, unix, vector-space
     }:
     mkDerivation {
       pname = "diagrams-svg";
       version = "1.1.0.4";
       sha256 = "f4feaa02b3c0069ea0c93b394777b004a1931f1e83683c17fd1ea922b75b4d85";
       revision = "1";
       editedCabalFile = "2fd35c0f8bb7ba4d17e04ae258addf4a949b91c2b404c0bbac76dbc6dc819c31";
       libraryHaskellDepends = [
         base base64-bytestring blaze-markup blaze-svg bytestring colour
         containers diagrams-core diagrams-lib directory filepath hashable
         JuicyPixels lens monoid-extras mtl old-time process split time unix
         vector-space
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "SVG backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-svg_1_1_0_5" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-markup, blaze-svg
     , bytestring, colour, containers, diagrams-core, diagrams-lib
     , directory, filepath, hashable, JuicyPixels, lens, monoid-extras
     , mtl, old-time, process, split, time, unix, vector-space
     }:
     mkDerivation {
       pname = "diagrams-svg";
       version = "1.1.0.5";
       sha256 = "ae976141ad9fc1e6f1f6a0a7fd5d2c5119916957ac74eb8f2578b1547d939458";
       libraryHaskellDepends = [
         base base64-bytestring blaze-markup blaze-svg bytestring colour
         containers diagrams-core diagrams-lib directory filepath hashable
         JuicyPixels lens monoid-extras mtl old-time process split time unix
         vector-space
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "SVG backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-svg_1_3_1_4" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, colour
     , containers, diagrams-core, diagrams-lib, directory, filepath
     , hashable, JuicyPixels, lens, lucid-svg, monoid-extras, mtl
     , old-time, optparse-applicative, process, semigroups, split, text
     , time
     }:
     mkDerivation {
       pname = "diagrams-svg";
       version = "1.3.1.4";
       sha256 = "bfcac7ff363a8948d722e3d925810e35a498c048a766b0091df1719cb0b13d01";
       libraryHaskellDepends = [
         base base64-bytestring bytestring colour containers diagrams-core
         diagrams-lib directory filepath hashable JuicyPixels lens lucid-svg
         monoid-extras mtl old-time optparse-applicative process semigroups
         split text time
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "SVG backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-svg_1_3_1_5" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, colour
     , containers, diagrams-core, diagrams-lib, directory, filepath
     , hashable, JuicyPixels, lens, lucid-svg, monoid-extras, mtl
     , old-time, optparse-applicative, process, semigroups, split, text
     , time
     }:
     mkDerivation {
       pname = "diagrams-svg";
       version = "1.3.1.5";
       sha256 = "dbb850c21d1df466e1aadc81f74373fb4ec9f774079a27cf9c97aa99bba0ec30";
       libraryHaskellDepends = [
         base base64-bytestring bytestring colour containers diagrams-core
         diagrams-lib directory filepath hashable JuicyPixels lens lucid-svg
         monoid-extras mtl old-time optparse-applicative process semigroups
         split text time
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "SVG backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-svg_1_3_1_6" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, colour
     , containers, diagrams-core, diagrams-lib, directory, filepath
     , hashable, JuicyPixels, lens, lucid-svg, monoid-extras, mtl
     , old-time, optparse-applicative, process, semigroups, split, text
     , time
     }:
     mkDerivation {
       pname = "diagrams-svg";
       version = "1.3.1.6";
       sha256 = "b04dcae8074aea84240dfd8d1776a783c51f46bc372582f025490e95cb88f83f";
       libraryHaskellDepends = [
         base base64-bytestring bytestring colour containers diagrams-core
         diagrams-lib directory filepath hashable JuicyPixels lens lucid-svg
         monoid-extras mtl old-time optparse-applicative process semigroups
         split text time
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "SVG backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-svg_1_3_1_7" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, colour
     , containers, diagrams-core, diagrams-lib, directory, filepath
     , hashable, JuicyPixels, lens, lucid-svg, monoid-extras, mtl
     , old-time, optparse-applicative, process, semigroups, split, text
     , time
     }:
     mkDerivation {
       pname = "diagrams-svg";
       version = "1.3.1.7";
       sha256 = "88929b31c02bfc585613e85e325e707d157cf753de6cc7f2dfca44d2987a6ecc";
       libraryHaskellDepends = [
         base base64-bytestring bytestring colour containers diagrams-core
         diagrams-lib directory filepath hashable JuicyPixels lens lucid-svg
         monoid-extras mtl old-time optparse-applicative process semigroups
         split text time
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams/";
       description = "SVG backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-svg" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, colour
     , containers, diagrams-core, diagrams-lib, directory, filepath
     , hashable, JuicyPixels, lens, lucid-svg, monoid-extras, mtl
     , old-time, optparse-applicative, process, semigroups, split, text
     , time
     }:
     mkDerivation {
       pname = "diagrams-svg";
       version = "1.3.1.10";
       sha256 = "a8293856f359d7d9656bb0b5ca5c97cc13b6ab18eaa71ed30112038cfe0a39a7";
       libraryHaskellDepends = [
         base base64-bytestring bytestring colour containers diagrams-core
         diagrams-lib directory filepath hashable JuicyPixels lens lucid-svg
         monoid-extras mtl old-time optparse-applicative process semigroups
         split text time
       ];
       homepage = "http://projects.haskell.org/diagrams/";
       description = "SVG backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diagrams-svg_1_4" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, colour
     , containers, diagrams-core, diagrams-lib, directory, filepath
     , hashable, JuicyPixels, lens, monoid-extras, mtl, old-time
     , optparse-applicative, process, semigroups, split, svg-builder
     , text, time
     }:
     mkDerivation {
       pname = "diagrams-svg";
       version = "1.4";
       sha256 = "9845b2f999f3fb61bf36c064977d36aea9ad8c5532c2ce80e5e3a85f5f9df900";
       libraryHaskellDepends = [
         base base64-bytestring bytestring colour containers diagrams-core
         diagrams-lib directory filepath hashable JuicyPixels lens
         monoid-extras mtl old-time optparse-applicative process semigroups
         split svg-builder text time
       ];
       homepage = "http://projects.haskell.org/diagrams/";
       description = "SVG backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diagrams-tikz" = callPackage
    ({ mkDerivation, base, diagrams-core, diagrams-lib, dlist, mtl }:
     mkDerivation {
       pname = "diagrams-tikz";
       version = "0.6";
       sha256 = "5bb962177be4f912708cde2018b0fc4f6ccaafe83bddf8e433fb0ae37ba844e3";
       libraryHaskellDepends = [
         base diagrams-core diagrams-lib dlist mtl
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "TikZ backend for diagrams drawing EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dialog" = callPackage
    ({ mkDerivation, base, bytestring, filepath, glib, gtk3
     , open-browser, text, transformers, webkitgtk3
     }:
     mkDerivation {
       pname = "dialog";
       version = "0.3.0.0";
       sha256 = "e47fd86b383a2a7c710219873c916a63cd873ab4b7b67fb204a099f511691ad2";
       libraryHaskellDepends = [
         base bytestring filepath glib gtk3 open-browser text transformers
         webkitgtk3
       ];
       homepage = "https://gitlab.com/lamefun/dialog";
       description = "Simple dialog-based user interfaces";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dice" = callPackage
    ({ mkDerivation, base, parsec, random-fu, transformers }:
     mkDerivation {
       pname = "dice";
       version = "0.1";
       sha256 = "e13fe7dec8394aeddb71fb0e0ac68d8750096bfcc198a80d7bc30d94e01edde5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base parsec random-fu transformers ];
       description = "Simplistic D&D style dice-rolling system";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "dice-entropy-conduit" = callPackage
    ({ mkDerivation, base, bytestring, conduit, entropy, QuickCheck
     , test-framework, test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "dice-entropy-conduit";
       version = "1.0.0.1";
       sha256 = "3ad040fc346586b96311ed44016e785815b075372e26890853666fcfa5eabc07";
       libraryHaskellDepends = [
         base bytestring conduit entropy transformers
       ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       homepage = "http://monoid.at/code";
       description = "Cryptographically secure n-sided dice via rejection sampling";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dicom" = callPackage
    ({ mkDerivation, base, binary, bytestring, pretty, safe, time }:
     mkDerivation {
       pname = "dicom";
       version = "0.3.0.0";
       sha256 = "d616ae5db9863803c7502986925598be9774842e714ed9c4dfecdc5dce9f3d20";
       libraryHaskellDepends = [
         base binary bytestring pretty safe time
       ];
       homepage = "http://github.com/dicomgrid/dicom-haskell-library/";
       description = "A library for reading and writing DICOM files in the Explicit VR Little Endian transfer syntax";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "dictparser" = callPackage
    ({ mkDerivation, base, hspec, parsec, split }:
     mkDerivation {
       pname = "dictparser";
       version = "0.3.0.0";
       sha256 = "11c074f738003e2e00e2f0dd615609c20848b04feb6a6695443727388a655df2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base parsec split ];
       executableHaskellDepends = [ base parsec ];
       testHaskellDepends = [ base hspec parsec ];
       homepage = "http://github.com/mwotton/dictparser";
       description = "Parsec parsers for the DICT format produced by dictfmt -t";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diet" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "diet";
       version = "0.0.1";
       sha256 = "9017825215947e15fb18795eba6456ae031178d51cc5dd4050d4cca27d757e62";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/tonymorris/diet";
       description = "Discrete Interval Encoding Tree";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diff-gestalt" = callPackage
    ({ mkDerivation, base, Diff, KMP, QuickCheck, string-similarity }:
     mkDerivation {
       pname = "diff-gestalt";
       version = "0.2.0.0";
       sha256 = "734d221512635a874d5aa05704e3a101d7472cb0e30ac7f40ff24c7da6f258a9";
       libraryHaskellDepends = [
         base Diff KMP QuickCheck string-similarity
       ];
       testHaskellDepends = [ base Diff ];
       homepage = "http://github.com/chrismwendt/diff-gestalt";
       description = "A diff algorithm based on recursive longest common substrings";
       license = "unknown";
     }) {};

  "diff-parse" = callPackage
    ({ mkDerivation, attoparsec, base, hspec, text }:
     mkDerivation {
       pname = "diff-parse";
       version = "0.2.1";
       sha256 = "55513091b52d114f0a49d85f6ea75fea52415243913f3781d7c5340c7987bc45";
       libraryHaskellDepends = [ attoparsec base text ];
       testHaskellDepends = [ attoparsec base hspec text ];
       jailbreak = true;
       description = "A parser for diff file formats";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "diff3" = callPackage
    ({ mkDerivation, base, Diff, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "diff3";
       version = "0.2.0.3";
       sha256 = "e84c84f03bd100c2ae950b218397fb6af1f838ca1fce8b876817610d65b0ae7d";
       libraryHaskellDepends = [ base Diff ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       homepage = "http://github.com/ocharles/diff3.git";
       description = "Perform a 3-way difference of documents";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diffarray" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "diffarray";
       version = "0.1.1";
       sha256 = "9551b56b586ef7dffaf6bd492cbc38e37bd75d4e87c6963fa86d81fb7b88255d";
       libraryHaskellDepends = [ array base ];
       description = "DiffArray";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diffcabal" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, Diff
     , directory, filepath, pretty, process
     }:
     mkDerivation {
       pname = "diffcabal";
       version = "0.1.1";
       sha256 = "26b23aea4f2693c98cae7cda4265d1005dadc0f9be0bdcf650447049a250f43d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal containers Diff directory filepath pretty
         process
       ];
       homepage = "http://code.haskell.org/~dons/code/diffcabal";
       description = "Diff two .cabal files syntactically";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diffdump" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, cmdargs
     , directory, filemanip, filepath, parallel-io, process
     , process-extras, unix
     }:
     mkDerivation {
       pname = "diffdump";
       version = "0.7.5";
       sha256 = "7067a11970e06c653a64a0cc111cc39b17f0363c3c45041cfcbdc8e1fa80e123";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base bytestring cmdargs directory filemanip filepath
         parallel-io process process-extras unix
       ];
       description = "Tools for diffing stdout";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "digamma" = callPackage
    ({ mkDerivation, base, polynomial }:
     mkDerivation {
       pname = "digamma";
       version = "0.1";
       sha256 = "ed1a3072c3e59d2628d63e6df85cbaaef264e8392de744735aae1d10ec153262";
       libraryHaskellDepends = [ base polynomial ];
       jailbreak = true;
       homepage = "https://github.com/bgamari/digamma";
       description = "A robust implementation of the digamma function";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "digest" = callPackage
    ({ mkDerivation, base, bytestring, zlib }:
     mkDerivation {
       pname = "digest";
       version = "0.0.1.2";
       sha256 = "641717eb16392abf8965986a9e8dc21eebf1d97775bbb6923c7b7f8fee17fe11";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ zlib ];
       description = "Various cryptographic hashes for bytestrings; CRC32 and Adler32 for now";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) zlib;};

  "digest-pure" = callPackage
    ({ mkDerivation, array, base, bytestring, digest, QuickCheck }:
     mkDerivation {
       pname = "digest-pure";
       version = "0.0.3";
       sha256 = "bc24ef45e1bbd923afc3c36106e4e62059e22a4a101fd220489fb460ff946565";
       libraryHaskellDepends = [ array base bytestring ];
       testHaskellDepends = [ array base bytestring digest QuickCheck ];
       homepage = "http://github.com/danieldk/digest-pure";
       description = "Pure hash functions for bytestrings";
       license = "unknown";
     }) {};

  "digestive-bootstrap" = callPackage
    ({ mkDerivation, base, blaze-bootstrap, blaze-html
     , digestive-functors, digestive-functors-blaze, http-types, text
     }:
     mkDerivation {
       pname = "digestive-bootstrap";
       version = "0.1.0.1";
       sha256 = "eb7d7586903f07c4519c4ff862923344e912268f686394cb4f550bd9ef0418f7";
       libraryHaskellDepends = [
         base blaze-bootstrap blaze-html digestive-functors
         digestive-functors-blaze http-types text
       ];
       description = "Speed up form designing using digestive functors and bootstrap";
       license = stdenv.lib.licenses.mit;
     }) {};

  "digestive-foundation-lucid" = callPackage
    ({ mkDerivation, base, digestive-functors, digestive-functors-lucid
     , http-types, lucid, lucid-foundation, text
     }:
     mkDerivation {
       pname = "digestive-foundation-lucid";
       version = "0.0.0.1";
       sha256 = "71199b130d9d216769379562e155ca730e5b9641c0c1057b727d125ddcaaf5be";
       libraryHaskellDepends = [
         base digestive-functors digestive-functors-lucid http-types lucid
         lucid-foundation text
       ];
       jailbreak = true;
       description = "Speed up form designing using digestive functors and foundation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "digestive-functors_0_7_1_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, HUnit, mtl
     , old-locale, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time
     }:
     mkDerivation {
       pname = "digestive-functors";
       version = "0.7.1.1";
       sha256 = "89a11014407ff3ec01edf391336d9adc83f252616d9afe844882c6877c302498";
       libraryHaskellDepends = [
         base bytestring containers mtl old-locale text time
       ];
       testHaskellDepends = [
         base bytestring containers HUnit mtl old-locale QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time
       ];
       jailbreak = true;
       homepage = "http://github.com/jaspervdj/digestive-functors";
       description = "A practical formlet library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "digestive-functors_0_7_1_3" = callPackage
    ({ mkDerivation, base, bytestring, containers, HUnit, mtl
     , old-locale, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time
     }:
     mkDerivation {
       pname = "digestive-functors";
       version = "0.7.1.3";
       sha256 = "74cfc734a11cc0f4ac897b06c45b63665733f1e82fdb5822dbd4ebf95ba10f79";
       libraryHaskellDepends = [
         base bytestring containers mtl old-locale text time
       ];
       testHaskellDepends = [
         base bytestring containers HUnit mtl old-locale QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time
       ];
       jailbreak = true;
       homepage = "http://github.com/jaspervdj/digestive-functors";
       description = "A practical formlet library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "digestive-functors_0_7_1_4" = callPackage
    ({ mkDerivation, base, bytestring, containers, HUnit, mtl
     , old-locale, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time
     }:
     mkDerivation {
       pname = "digestive-functors";
       version = "0.7.1.4";
       sha256 = "aba7dd72772c2a892424f6ad9be01773c4099559cf56f6f7577f57f7378a5340";
       revision = "1";
       editedCabalFile = "509709b7a7e4e999fc2303cd8225bb43479dfb6605307d39b4bbee0d000bfc60";
       libraryHaskellDepends = [
         base bytestring containers mtl old-locale text time
       ];
       testHaskellDepends = [
         base bytestring containers HUnit mtl old-locale QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time
       ];
       jailbreak = true;
       homepage = "http://github.com/jaspervdj/digestive-functors";
       description = "A practical formlet library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "digestive-functors_0_7_1_5" = callPackage
    ({ mkDerivation, base, bytestring, containers, HUnit, mtl
     , old-locale, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time
     }:
     mkDerivation {
       pname = "digestive-functors";
       version = "0.7.1.5";
       sha256 = "9a56ec5dc7d41f848992b593418d3e2e154b24ec83c5fe4b2e8a5b3698eacde5";
       revision = "1";
       editedCabalFile = "a39a3b9d3c0a724604ce406543150e75c3298af1981e9af67d9701a66b6f770a";
       libraryHaskellDepends = [
         base bytestring containers mtl old-locale text time
       ];
       testHaskellDepends = [
         base bytestring containers HUnit mtl old-locale QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time
       ];
       jailbreak = true;
       homepage = "http://github.com/jaspervdj/digestive-functors";
       description = "A practical formlet library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "digestive-functors_0_8_0_0" = callPackage
    ({ mkDerivation, base, bytestring, containers, HUnit, mtl
     , old-locale, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time
     }:
     mkDerivation {
       pname = "digestive-functors";
       version = "0.8.0.0";
       sha256 = "03fb41b756472c9126a3df33c65e13438cdf861b12586a786c60df4640219772";
       libraryHaskellDepends = [
         base bytestring containers mtl old-locale text time
       ];
       testHaskellDepends = [
         base bytestring containers HUnit mtl old-locale QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time
       ];
       jailbreak = true;
       homepage = "http://github.com/jaspervdj/digestive-functors";
       description = "A practical formlet library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "digestive-functors" = callPackage
    ({ mkDerivation, base, bytestring, containers, HUnit, mtl
     , old-locale, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time
     }:
     mkDerivation {
       pname = "digestive-functors";
       version = "0.8.0.1";
       sha256 = "ae3d5cb376c0065a59313424c408f3a81a1d4a1839214d1a60764e3708abf3c6";
       libraryHaskellDepends = [
         base bytestring containers mtl old-locale text time
       ];
       testHaskellDepends = [
         base bytestring containers HUnit mtl old-locale QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time
       ];
       homepage = "http://github.com/jaspervdj/digestive-functors";
       description = "A practical formlet library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "digestive-functors-aeson_1_1_16" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , digestive-functors, HUnit, lens, lens-aeson, mtl, safe
     , scientific, tasty, tasty-hunit, text, vector
     }:
     mkDerivation {
       pname = "digestive-functors-aeson";
       version = "1.1.16";
       sha256 = "3ee91a06d4c152d642142a067d690d34bc885768b999ec47ac51244eef55016c";
       libraryHaskellDepends = [
         aeson base containers digestive-functors lens lens-aeson safe text
         vector
       ];
       testHaskellDepends = [
         aeson base bytestring digestive-functors HUnit mtl scientific tasty
         tasty-hunit text
       ];
       jailbreak = true;
       homepage = "http://github.com/ocharles/digestive-functors-aeson";
       description = "Run digestive-functors forms against JSON";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "digestive-functors-aeson_1_1_18" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , digestive-functors, HUnit, lens, lens-aeson, mtl, safe
     , scientific, tasty, tasty-hunit, text, vector
     }:
     mkDerivation {
       pname = "digestive-functors-aeson";
       version = "1.1.18";
       sha256 = "125cc4e14f3b9f67163b66f7ebf05c88137e4446ee79085d0ea550614ab483ad";
       libraryHaskellDepends = [
         aeson base containers digestive-functors lens lens-aeson safe text
         vector
       ];
       testHaskellDepends = [
         aeson base bytestring digestive-functors HUnit mtl scientific tasty
         tasty-hunit text
       ];
       homepage = "http://github.com/ocharles/digestive-functors-aeson";
       description = "Run digestive-functors forms against JSON";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "digestive-functors-aeson" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , digestive-functors, HUnit, lens, lens-aeson, mtl, safe
     , scientific, tasty, tasty-hunit, text, vector
     }:
     mkDerivation {
       pname = "digestive-functors-aeson";
       version = "1.1.19";
       sha256 = "eb58a68fee918486e6ef884e946898427a75ddc6c3d1d509dd9a475341b6daa7";
       libraryHaskellDepends = [
         aeson base containers digestive-functors lens lens-aeson safe text
         vector
       ];
       testHaskellDepends = [
         aeson base bytestring digestive-functors HUnit mtl scientific tasty
         tasty-hunit text
       ];
       homepage = "http://github.com/ocharles/digestive-functors-aeson";
       description = "Run digestive-functors forms against JSON";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "digestive-functors-blaze" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, digestive-functors
     , text
     }:
     mkDerivation {
       pname = "digestive-functors-blaze";
       version = "0.6.0.6";
       sha256 = "b11b6c0268a31353b915894452d0a78162e0ead933baeb4e6e49b384b869a8cf";
       libraryHaskellDepends = [
         base blaze-html blaze-markup digestive-functors text
       ];
       homepage = "http://github.com/jaspervdj/digestive-functors";
       description = "Blaze frontend for the digestive-functors library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "digestive-functors-happstack" = callPackage
    ({ mkDerivation, base, bytestring, digestive-functors
     , happstack-server, text
     }:
     mkDerivation {
       pname = "digestive-functors-happstack";
       version = "0.6.1.1";
       sha256 = "e5a9e9216372f0977f279005865e25eac25d0aece9d426963b6228c97b1ec134";
       libraryHaskellDepends = [
         base bytestring digestive-functors happstack-server text
       ];
       homepage = "http://github.com/jaspervdj/digestive-functors";
       description = "Happstack backend for the digestive-functors library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "digestive-functors-heist" = callPackage
    ({ mkDerivation, base, blaze-builder, digestive-functors, heist
     , mtl, text, xmlhtml
     }:
     mkDerivation {
       pname = "digestive-functors-heist";
       version = "0.8.6.2";
       sha256 = "29009a85d77d904115a3ef64659b0e56b8402c8140fd228b5194edcfb3874d5a";
       libraryHaskellDepends = [
         base blaze-builder digestive-functors heist mtl text xmlhtml
       ];
       homepage = "http://github.com/jaspervdj/digestive-functors";
       description = "Heist frontend for the digestive-functors library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "digestive-functors-hsp" = callPackage
    ({ mkDerivation, base, digestive-functors, hsp, hsx, text, trhsx }:
     mkDerivation {
       pname = "digestive-functors-hsp";
       version = "0.5.0";
       sha256 = "ac7d4e7e5eaa21079cb596ba8ff5c59c7dd3bd3df99a7b0ff56ab4996767c102";
       libraryHaskellDepends = [ base digestive-functors hsp hsx text ];
       libraryToolDepends = [ trhsx ];
       jailbreak = true;
       homepage = "http://src.seereason.com/digestive-functors-hsp";
       description = "HSP support for digestive-functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "digestive-functors-lucid" = callPackage
    ({ mkDerivation, base, digestive-functors, lucid, text }:
     mkDerivation {
       pname = "digestive-functors-lucid";
       version = "0.0.0.3";
       sha256 = "15fa8c7a0fb6e8d230cfe9d008101cd72d7eecbcbd1231f0c9982c20a0a73bb9";
       libraryHaskellDepends = [ base digestive-functors lucid text ];
       homepage = "http://github.com/jaspervdj/digestive-functors";
       description = "Lucid frontend for the digestive-functors library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "digestive-functors-scotty" = callPackage
    ({ mkDerivation, base, bytestring, digestive-functors, http-types
     , scotty, text, wai, wai-extra
     }:
     mkDerivation {
       pname = "digestive-functors-scotty";
       version = "0.2.0.2";
       sha256 = "9732a545196767e24697297da75275ec40a5d5d1e9db11e945d28d0ea70a953a";
       revision = "1";
       editedCabalFile = "5d7d94c850207910683a4ac60426bf3fb0d62ba2d15cd0bfb758cbee51417580";
       libraryHaskellDepends = [
         base bytestring digestive-functors http-types scotty text wai
         wai-extra
       ];
       homepage = "https://github.com/mmartin/digestive-functors-scotty";
       description = "Scotty backend for the digestive-functors library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "digestive-functors-snap" = callPackage
    ({ mkDerivation, base, bytestring, containers, digestive-functors
     , directory, filepath, mtl, snap-core, text
     }:
     mkDerivation {
       pname = "digestive-functors-snap";
       version = "0.6.1.3";
       sha256 = "f0455512104e2a843621d2421283ff31627134301570f9a5dc49ba1277265085";
       libraryHaskellDepends = [
         base bytestring containers digestive-functors directory filepath
         mtl snap-core text
       ];
       homepage = "http://github.com/jaspervdj/digestive-functors";
       description = "Snap backend for the digestive-functors library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "digit" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, lens
     , QuickCheck, template-haskell
     }:
     mkDerivation {
       pname = "digit";
       version = "0.1.2";
       sha256 = "61b56e10673dd3e3ca7fb6bdcd9fc07bd79a38fe75fd3554c5b2598caa51ff6f";
       libraryHaskellDepends = [ base lens template-haskell ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck
       ];
       homepage = "https://github.com/NICTA/digit";
       description = "A data-type representing digits 0-9 and other combinations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "digitalocean-kzs" = callPackage
    ({ mkDerivation, aeson, base, bytestring, doctest, hspec, HTTP
     , http-conduit, http-types, text, transformers
     }:
     mkDerivation {
       pname = "digitalocean-kzs";
       version = "0.1.0.3";
       sha256 = "cffe351e522de02dc4c3b8fb2616d83f27d178c572ab641f594a2d4d105c2f70";
       libraryHaskellDepends = [
         aeson base bytestring HTTP http-conduit http-types text
         transformers
       ];
       testHaskellDepends = [ base doctest hspec ];
       jailbreak = true;
       homepage = "https://github.com/KazumaSATO/digitalocean-kzs";
       description = "digitalocean api for haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "digits" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "digits";
       version = "0.2";
       sha256 = "f40437896a7866b210cdb45bfe025d65391ebf9980ea7a92206d6320e79949a3";
       libraryHaskellDepends = [ base QuickCheck ];
       description = "Converts integers to lists of digits and back";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dimensional_0_13_0_1" = callPackage
    ({ mkDerivation, base, numtype, time }:
     mkDerivation {
       pname = "dimensional";
       version = "0.13.0.1";
       sha256 = "26ee806eaded39629ac7610209bdcc1106432e36b780592a2d5d813bb57fc7b2";
       libraryHaskellDepends = [ base numtype time ];
       homepage = "http://dimensional.googlecode.com/";
       description = "Statically checked physical dimensions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dimensional_0_13_0_2" = callPackage
    ({ mkDerivation, base, numtype, time }:
     mkDerivation {
       pname = "dimensional";
       version = "0.13.0.2";
       sha256 = "9762c214f036891299a766aa2e294d1295ec81e4ba806d0e5bb6cf80114928be";
       libraryHaskellDepends = [ base numtype time ];
       homepage = "http://dimensional.googlecode.com/";
       description = "Statically checked physical dimensions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dimensional" = callPackage
    ({ mkDerivation, base, deepseq, exact-pi, HUnit, numtype-dk, vector
     }:
     mkDerivation {
       pname = "dimensional";
       version = "1.0.1.1";
       sha256 = "d876eea43341b597959e3244673817dcb23c350c06549158e04a6c632243692e";
       libraryHaskellDepends = [
         base deepseq exact-pi numtype-dk vector
       ];
       testHaskellDepends = [ base HUnit ];
       homepage = "https://github.com/bjornbm/dimensional/";
       description = "Statically checked physical dimensions, using Type Families and Data Kinds";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dimensional-codata" = callPackage
    ({ mkDerivation, base, dimensional, numtype-dk }:
     mkDerivation {
       pname = "dimensional-codata";
       version = "2014.0.0.0";
       sha256 = "45a4eac9e27997493f2bcb2977098ede8443c6eda263a447125446e203a7cae3";
       libraryHaskellDepends = [ base dimensional numtype-dk ];
       homepage = "https://github.com/dmcclean/dimensional-codata";
       description = "CODATA Recommended Physical Constants with Dimensional Types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dimensional-tf" = callPackage
    ({ mkDerivation, base, numtype-tf, time }:
     mkDerivation {
       pname = "dimensional-tf";
       version = "0.3.0.3";
       sha256 = "50081bf621515ee7fbe54f7aac45b0f3df7433dcc6ba681e0ca418f0cd17b110";
       libraryHaskellDepends = [ base numtype-tf time ];
       homepage = "http://dimensional.googlecode.com/";
       description = "Statically checked physical dimensions, implemented using type families";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dingo-core" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-builder, blaze-html, blaze-textual, bytestring, conduit
     , containers, cookie, deepseq, fclabels, file-embed, hashable
     , http-types, random, SHA, shakespeare-js, strict-concurrency
     , template-haskell, text, transformers, unordered-containers, wai
     , wai-eventsource, wai-extra, warp, web-css
     }:
     mkDerivation {
       pname = "dingo-core";
       version = "0.2.0";
       sha256 = "c5e17ac151f2a792f4ed8c8ae8a1f2f1f57a50546ce54826464c606b60c911c0";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-builder blaze-html
         blaze-textual bytestring conduit containers cookie deepseq fclabels
         file-embed hashable http-types random SHA shakespeare-js
         strict-concurrency template-haskell text transformers
         unordered-containers wai wai-eventsource wai-extra warp web-css
       ];
       jailbreak = true;
       description = "Dingo is a Rich Internet Application platform based on the Warp web server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dingo-example" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, bytestring, dingo-core
     , dingo-widgets, fclabels, shakespeare-js, template-haskell, text
     , transformers
     }:
     mkDerivation {
       pname = "dingo-example";
       version = "0.2.0";
       sha256 = "8bb87cc6f78f723d0f7794ba15244166a3ecd7d6396513fa3a073819d7408a56";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base blaze-html bytestring dingo-core dingo-widgets fclabels
         shakespeare-js template-haskell text transformers
       ];
       jailbreak = true;
       description = "Dingo Example";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dingo-widgets" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, bytestring, containers
     , dingo-core, fclabels, file-embed, shakespeare-js
     , template-haskell, text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "dingo-widgets";
       version = "0.2.0";
       sha256 = "17d9b62bd0a824dc280aef8faadf4f5a1dbbf31fd5fa929d7bf6f26d98a0c1b4";
       libraryHaskellDepends = [
         aeson base blaze-html bytestring containers dingo-core fclabels
         file-embed shakespeare-js template-haskell text transformers
         unordered-containers
       ];
       jailbreak = true;
       description = "Dingo Widgets";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diophantine" = callPackage
    ({ mkDerivation, array, base, happy }:
     mkDerivation {
       pname = "diophantine";
       version = "0.2.1.0";
       sha256 = "492a1f57732c0cbc55e9b04939d64153e26ddb251d8cd2a4c61fc6cd6b2a1985";
       libraryHaskellDepends = [ array base ];
       libraryToolDepends = [ happy ];
       homepage = "https://github.com/llllllllll/Math.Diophantine";
       description = "A quadratic diophantine equation solving library";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diplomacy" = callPackage
    ({ mkDerivation, base, containers, HUnit, parsec, transformers
     , TypeNat
     }:
     mkDerivation {
       pname = "diplomacy";
       version = "0.1.0.0";
       sha256 = "87bcb1b15d7470947a66f19a534ab145c185d928a3ade828fe2af2cee11cd87a";
       libraryHaskellDepends = [
         base containers HUnit parsec transformers TypeNat
       ];
       jailbreak = true;
       homepage = "https://github.com/avieth/diplomacy";
       description = "The board game Diplomacy, spoken in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diplomacy-server" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, containers
     , deepseq, diplomacy, filepath, hourglass, json-schema, mtl
     , optparse-applicative, parsec, random, rest-core, rest-wai, stm
     , Stream, text, transformers, transformers-compat, TypeNat, wai
     , warp, warp-tls
     }:
     mkDerivation {
       pname = "diplomacy-server";
       version = "0.1.0.0";
       sha256 = "36de8e6754843331fa36f1da296dd467dc6267a80bce3d907e4f73f4f2e4dcf6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson async base bytestring containers deepseq diplomacy filepath
         hourglass json-schema mtl optparse-applicative parsec random
         rest-core rest-wai stm Stream text transformers transformers-compat
         TypeNat wai warp warp-tls
       ];
       jailbreak = true;
       homepage = "https://github.com/avieth/diplomacy-server";
       description = "Play Diplomacy over HTTP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "direct-binary-files" = callPackage
    ({ mkDerivation, base, bytestring, mtl }:
     mkDerivation {
       pname = "direct-binary-files";
       version = "1.0";
       sha256 = "b9c5b6373027c177be13d7164a458581275ce37078dfd544b09ae6a7d1562632";
       libraryHaskellDepends = [ base bytestring mtl ];
       homepage = "http://ireneknapp.com/software/";
       description = "Serialization and deserialization monads for streams and ByteStrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "direct-daemonize" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "direct-daemonize";
       version = "3.1";
       sha256 = "b0ef75dbdc491fe355837415d16cf654e06cbef62c86f45077ea4dea3fa22819";
       libraryHaskellDepends = [ base unix ];
       homepage = "http://dankna.com/software/";
       description = "Library to switch to daemon mode using built-in OS facilities";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "direct-fastcgi" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, network
     , utf8-string
     }:
     mkDerivation {
       pname = "direct-fastcgi";
       version = "1.0.3";
       sha256 = "e86887fc2456ccb5eb9fe97ee1a667e5c361a95a23f7d43582636a3ddf103f11";
       libraryHaskellDepends = [
         base bytestring containers mtl network utf8-string
       ];
       jailbreak = true;
       homepage = "http://dankna.com/software/";
       description = "Native implementation of the FastCGI protocol";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "direct-http" = callPackage
    ({ mkDerivation, base, bytestring, containers, direct-daemonize
     , lifted-base, monad-control, mtl, network, old-locale
     , SafeSemaphore, time, transformers-base, unix, utf8-string
     }:
     mkDerivation {
       pname = "direct-http";
       version = "0.6";
       sha256 = "ef6ed7385416fa2702bed89b61618c7f49dbb1b5b070664ac44b740b1e74f029";
       libraryHaskellDepends = [
         base bytestring containers direct-daemonize lifted-base
         monad-control mtl network old-locale SafeSemaphore time
         transformers-base unix utf8-string
       ];
       jailbreak = true;
       homepage = "http://ireneknapp.com/software/";
       description = "Native webserver that acts as a library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "direct-murmur-hash" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "direct-murmur-hash";
       version = "1.0.1";
       sha256 = "5810a52223263de42859aa4b81b6bb879a489e5b66f7eef07d037daaa1011b26";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://ireneknapp.com/software/";
       description = "An implementation of the MurmurHash3 algorithm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "direct-plugins" = callPackage
    ({ mkDerivation, base, ghc, ghc-paths }:
     mkDerivation {
       pname = "direct-plugins";
       version = "1.1";
       sha256 = "9941ed355917ef7fb92d12ed7fbbb44a36cef99853fd7f778e114f0d7a96c70d";
       libraryHaskellDepends = [ base ghc ghc-paths ];
       homepage = "http://dankna.com/software/";
       description = "Lightweight replacement for Plugins, specific to GHC";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "direct-sqlite_2_3_14" = callPackage
    ({ mkDerivation, base, base16-bytestring, bytestring, directory
     , HUnit, text
     }:
     mkDerivation {
       pname = "direct-sqlite";
       version = "2.3.14";
       sha256 = "bcf4801e7a55616737209c3fa7443415fa63e7748664a1f7b49a144bb9c8bb77";
       libraryHaskellDepends = [ base bytestring text ];
       testHaskellDepends = [
         base base16-bytestring bytestring directory HUnit text
       ];
       homepage = "https://github.com/IreneKnapp/direct-sqlite";
       description = "Low-level binding to SQLite3. Includes UTF8 and BLOB support.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "direct-sqlite_2_3_15" = callPackage
    ({ mkDerivation, base, base16-bytestring, bytestring, directory
     , HUnit, text
     }:
     mkDerivation {
       pname = "direct-sqlite";
       version = "2.3.15";
       sha256 = "22ecc3d9962ae0d20da9542f13926d2d611d6375e65ed6bc85096646e4609742";
       libraryHaskellDepends = [ base bytestring text ];
       testHaskellDepends = [
         base base16-bytestring bytestring directory HUnit text
       ];
       homepage = "https://github.com/IreneKnapp/direct-sqlite";
       description = "Low-level binding to SQLite3. Includes UTF8 and BLOB support.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "direct-sqlite_2_3_16" = callPackage
    ({ mkDerivation, base, base16-bytestring, bytestring, directory
     , HUnit, text
     }:
     mkDerivation {
       pname = "direct-sqlite";
       version = "2.3.16";
       sha256 = "10592458a5a90ae84c7005849924576c31a90422349b4b7ac762a230a056816f";
       libraryHaskellDepends = [ base bytestring text ];
       testHaskellDepends = [
         base base16-bytestring bytestring directory HUnit text
       ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "direct-sqlite" = callPackage
    ({ mkDerivation, base, base16-bytestring, bytestring, directory
     , HUnit, temporary, text
     }:
     mkDerivation {
       pname = "direct-sqlite";
       version = "2.3.17";
       sha256 = "fade7c52d157cf145380a4818fa2e03163fa104fadf43d580c1d475b6b6fffc4";
       libraryHaskellDepends = [ base bytestring text ];
       testHaskellDepends = [
         base base16-bytestring bytestring directory HUnit temporary text
       ];
       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;
     }) {};

  "directed-cubical" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, hashable
     , parallel, QuickCheck, unordered-containers, vector
     }:
     mkDerivation {
       pname = "directed-cubical";
       version = "0.1.2.0";
       sha256 = "7fd8ebe301af3355b3c4abc5cb45fe9559e2d3228319d668a027e6ea6db9c673";
       libraryHaskellDepends = [
         base bytestring containers deepseq hashable parallel QuickCheck
         unordered-containers vector
       ];
       jailbreak = true;
       description = "Finite directed cubical complexes and associated algorithms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "directory_1_2_5_1" = callPackage
    ({ mkDerivation, base, filepath, time, unix }:
     mkDerivation {
       pname = "directory";
       version = "1.2.5.1";
       sha256 = "15f6d6c403755196617933ed165e6abd82340fcf172582577bb7ced86700ed7d";
       libraryHaskellDepends = [ base filepath time unix ];
       testHaskellDepends = [ base filepath time unix ];
       description = "Platform-agnostic library for filesystem operations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "directory-layout" = callPackage
    ({ mkDerivation, base, bytestring, command-qq, containers
     , directory, doctest, filepath, free, hspec, lens, semigroups
     , template-haskell, temporary, text, transformers, unix
     , unordered-containers
     }:
     mkDerivation {
       pname = "directory-layout";
       version = "0.7.4.1";
       sha256 = "2ba10ddd9a1c1a35ce70c8e0bcdf0cbfdfcc087a4e689ec16c418b58b66b4742";
       libraryHaskellDepends = [
         base bytestring command-qq containers directory filepath free hspec
         lens semigroups template-haskell text transformers unix
         unordered-containers
       ];
       testHaskellDepends = [
         base bytestring command-qq containers directory doctest filepath
         free hspec lens semigroups template-haskell temporary text
         transformers unix unordered-containers
       ];
       description = "Directory layout DSL";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "directory-tree" = callPackage
    ({ mkDerivation, base, directory, filepath, process }:
     mkDerivation {
       pname = "directory-tree";
       version = "0.12.0";
       sha256 = "ff09c6e66a5038f905ea423700d60e538286c12b83fecda70b2932ee4eb5b3c5";
       libraryHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [ base directory filepath process ];
       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;
     }) {};

  "dirfiles" = callPackage
    ({ mkDerivation, aeson, base, containers, hblock, safecopy, text
     , time, unordered-containers
     }:
     mkDerivation {
       pname = "dirfiles";
       version = "0.1.0.9";
       sha256 = "262d20f56c1e4b32465122e76836d80b3c8754d7eab13a2856ce21a185dc0a4b";
       libraryHaskellDepends = [
         aeson base containers hblock safecopy text time
         unordered-containers
       ];
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dirstream" = callPackage
    ({ mkDerivation, base, directory, pipes, pipes-safe, system-fileio
     , system-filepath, unix
     }:
     mkDerivation {
       pname = "dirstream";
       version = "1.0.0";
       sha256 = "7c1f944d519b8b56ccb855486482be8fed83492335d5b78ad73f08280c63b5c3";
       libraryHaskellDepends = [
         base directory pipes pipes-safe system-fileio system-filepath unix
       ];
       description = "Easily stream directory contents in constant memory";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "disassembler" = callPackage
    ({ mkDerivation, array, base, containers, mtl, parsec }:
     mkDerivation {
       pname = "disassembler";
       version = "0.2.0.1";
       sha256 = "2c8dcc423defcd6da7b0bb11d54cd148df809f89a267406b0c351dc3d3aae1f9";
       libraryHaskellDepends = [ array base containers mtl parsec ];
       homepage = "https://github.com/mgrabmueller/disassembler";
       description = "Disassembler for X86 & AMD64 machine code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "discordian-calendar" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "discordian-calendar";
       version = "0.1";
       sha256 = "4d88f65d97f04b11e03082e20a4b3044920f644a7babd2b1de689a9575746b7a";
       libraryHaskellDepends = [ base time ];
       jailbreak = true;
       homepage = "https://github.com/kallisti-dev/discordian-calendar";
       description = "library for handling Discordian calendar dates";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "discount" = callPackage
    ({ mkDerivation, base, bytestring, markdown, text }:
     mkDerivation {
       pname = "discount";
       version = "0.1.1";
       sha256 = "e99cb7fdd1896dd1e525616597f936c1305a657cea1ef82cc0b3dcfe5afa34e0";
       libraryHaskellDepends = [ base bytestring text ];
       librarySystemDepends = [ markdown ];
       homepage = "http://github.com/lightquake/discount";
       description = "Haskell bindings to the discount Markdown library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {markdown = null;};

  "discrete-space-map" = callPackage
    ({ mkDerivation, adjunctions, base, comonad, distributive, keys
     , semigroupoids
     }:
     mkDerivation {
       pname = "discrete-space-map";
       version = "0.0.5";
       sha256 = "18c12b0b2bc2796e60f5b4e8d8e10ce3c788f4723161ab0f348e53eb72cd8268";
       libraryHaskellDepends = [
         adjunctions base comonad distributive keys semigroupoids
       ];
       homepage = "https://github.com/sjoerdvisscher/discrete-space-map";
       description = "A discrete space map";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "discrimination" = callPackage
    ({ mkDerivation, array, base, containers, contravariant, deepseq
     , ghc-prim, hashable, primitive, profunctors, promises, semigroups
     , transformers, transformers-compat, vector, void
     }:
     mkDerivation {
       pname = "discrimination";
       version = "0.2.1";
       sha256 = "b431a43f635af98df8677a44c0e76726b95d12ea338e47db248aa3bbc3be2ccf";
       revision = "1";
       editedCabalFile = "6adf13db8d07059ac4f484c51fc13a7a3ab00e0a2a9c02899a44fedd24b550f3";
       libraryHaskellDepends = [
         array base containers contravariant deepseq ghc-prim hashable
         primitive profunctors promises semigroups transformers
         transformers-compat vector void
       ];
       homepage = "http://github.com/ekmett/discrimination/";
       description = "Fast generic linear-time sorting, joins and container construction";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "disjoint-set" = callPackage
    ({ mkDerivation, base, containers, HUnit, mtl, QuickCheck
     , transformers
     }:
     mkDerivation {
       pname = "disjoint-set";
       version = "0.2";
       sha256 = "7f30afba02f282e1d3c9f163833ed65f665361400329c469e1cd916663a4a716";
       libraryHaskellDepends = [ base containers mtl transformers ];
       testHaskellDepends = [
         base containers HUnit mtl QuickCheck transformers
       ];
       homepage = "https://github.com/maxwellsayles/disjoint-set";
       description = "Persistent disjoint-sets, a.k.a union-find.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "disjoint-sets-st" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "disjoint-sets-st";
       version = "0.1";
       sha256 = "55b09b9c336493ec38b990114473d5aef7d9e9f503be33d71b523b28cb7dc47b";
       libraryHaskellDepends = [ array base ];
       homepage = "http://github.com/ppetr/disjoint-sets-st/";
       description = "Imperative ST/IO based disjoint set data structure";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "disk-free-space" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "disk-free-space";
       version = "0.1.0.1";
       sha256 = "f17a4f9c3b41083ccbb6c11b2debdbc705f86097b7459ff0f46cc01d2692381f";
       revision = "3";
       editedCabalFile = "71ac4e0b1a2917e1c5d9dc43c84fdfac1ec7d0d7648582d94e1ce69199971c74";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/redneb/disk-free-space";
       description = "Retrieve information about disk space usage";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dist-upload" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, process }:
     mkDerivation {
       pname = "dist-upload";
       version = "0.0.4";
       sha256 = "e16850986695d826a7357270dacc527dcfb2bc99e8a003e266cdcb5ab1242fc5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base Cabal directory filepath process ];
       doHaddock = false;
       description = "Generate/Upload cabal package to Hackage";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "distributed-closure" = callPackage
    ({ mkDerivation, base, binary, bytestring, constraints, hspec
     , QuickCheck, template-haskell
     }:
     mkDerivation {
       pname = "distributed-closure";
       version = "0.2.1.0";
       sha256 = "345140293e28e6feaae46e2e3e275e892d72029dbd57617ba8fc1b7251ae902f";
       libraryHaskellDepends = [
         base binary bytestring constraints template-haskell
       ];
       testHaskellDepends = [ base binary hspec QuickCheck ];
       homepage = "https://github.com/tweag/distributed-closure";
       description = "Serializable closures for distributed programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process_0_5_2" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , data-accessor, deepseq, distributed-static, ghc-prim, hashable
     , mtl, network-transport, old-locale, random, rank1dynamic, stm
     , syb, template-haskell, time, transformers
     }:
     mkDerivation {
       pname = "distributed-process";
       version = "0.5.2";
       sha256 = "f43c70f268657213c889c94358cdc6fca37427877004f95a2c6620f1d3879412";
       libraryHaskellDepends = [
         base binary bytestring containers data-accessor deepseq
         distributed-static ghc-prim hashable mtl network-transport
         old-locale random rank1dynamic stm syb template-haskell time
         transformers
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://haskell-distributed.github.com/";
       description = "Cloud Haskell: Erlang-style concurrency in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process_0_5_3" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , data-accessor, deepseq, distributed-static, ghc-prim, hashable
     , mtl, network-transport, old-locale, random, rank1dynamic, stm
     , syb, template-haskell, time, transformers
     }:
     mkDerivation {
       pname = "distributed-process";
       version = "0.5.3";
       sha256 = "df965db9ac43f6710a8685fab4b3a0651c4f557d2b53cd06d03f327d5a2be8ca";
       libraryHaskellDepends = [
         base binary bytestring containers data-accessor deepseq
         distributed-static ghc-prim hashable mtl network-transport
         old-locale random rank1dynamic stm syb template-haskell time
         transformers
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://haskell-distributed.github.com/";
       description = "Cloud Haskell: Erlang-style concurrency in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process_0_5_4" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , data-accessor, deepseq, distributed-static, ghc-prim, hashable
     , mtl, network-transport, old-locale, random, rank1dynamic, stm
     , syb, template-haskell, time, transformers
     }:
     mkDerivation {
       pname = "distributed-process";
       version = "0.5.4";
       sha256 = "5adc5e2d689a985a072d2995bc781fe4836eaa8951207bec4287a86bafdea2fb";
       libraryHaskellDepends = [
         base binary bytestring containers data-accessor deepseq
         distributed-static ghc-prim hashable mtl network-transport
         old-locale random rank1dynamic stm syb template-haskell time
         transformers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://haskell-distributed.github.com/";
       description = "Cloud Haskell: Erlang-style concurrency in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process_0_5_5_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , data-accessor, deepseq, distributed-static, ghc-prim, hashable
     , mtl, network-transport, random, rank1dynamic, stm, syb
     , template-haskell, time, transformers
     }:
     mkDerivation {
       pname = "distributed-process";
       version = "0.5.5.1";
       sha256 = "63a196d159ab18988c245b537b2099d5d7f85611b17593ef02271a478de34955";
       libraryHaskellDepends = [
         base binary bytestring containers data-accessor deepseq
         distributed-static ghc-prim hashable mtl network-transport random
         rank1dynamic stm syb template-haskell time transformers
       ];
       doCheck = false;
       homepage = "http://haskell-distributed.github.com/";
       description = "Cloud Haskell: Erlang-style concurrency in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , data-accessor, deepseq, distributed-static, ghc-prim, hashable
     , mtl, network-transport, random, rank1dynamic, stm, syb
     , template-haskell, time, transformers
     }:
     mkDerivation {
       pname = "distributed-process";
       version = "0.6.0";
       sha256 = "d79f7e24e7b2896681f9f4b798da0e987742caab4c34917a0d04f40f9aef6b5b";
       libraryHaskellDepends = [
         base binary bytestring containers data-accessor deepseq
         distributed-static ghc-prim hashable mtl network-transport random
         rank1dynamic stm syb template-haskell time transformers
       ];
       doCheck = false;
       homepage = "http://haskell-distributed.github.com/";
       description = "Cloud Haskell: Erlang-style concurrency in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "distributed-process-async_0_2_1" = callPackage
    ({ mkDerivation, ansi-terminal, base, binary, containers
     , data-accessor, deepseq, distributed-process
     , distributed-process-extras, distributed-process-tests, fingertree
     , hashable, HUnit, mtl, network, network-transport
     , network-transport-tcp, rematch, stm, test-framework
     , test-framework-hunit, time, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "distributed-process-async";
       version = "0.2.1";
       sha256 = "2bd6754b12bc2bb0ec0024d6ed89beb8670315553ea56a5f501989559c70483c";
       libraryHaskellDepends = [
         base binary containers data-accessor deepseq distributed-process
         distributed-process-extras fingertree hashable mtl stm time
         transformers unordered-containers
       ];
       testHaskellDepends = [
         ansi-terminal base binary deepseq distributed-process
         distributed-process-extras distributed-process-tests HUnit network
         network-transport network-transport-tcp rematch stm test-framework
         test-framework-hunit transformers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/haskell-distributed/distributed-process-async";
       description = "Cloud Haskell Async API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process-async" = callPackage
    ({ mkDerivation, ansi-terminal, base, binary, containers
     , data-accessor, deepseq, distributed-process
     , distributed-process-extras, distributed-process-tests, fingertree
     , hashable, HUnit, mtl, network, network-transport
     , network-transport-tcp, rematch, stm, test-framework
     , test-framework-hunit, time, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "distributed-process-async";
       version = "0.2.3";
       sha256 = "d3031457c36bb3c35496031c185354417b54ce253e1878f35072d04e8161ad95";
       libraryHaskellDepends = [
         base binary containers data-accessor deepseq distributed-process
         distributed-process-extras fingertree hashable mtl stm time
         transformers unordered-containers
       ];
       testHaskellDepends = [
         ansi-terminal base binary deepseq distributed-process
         distributed-process-extras distributed-process-tests HUnit network
         network-transport network-transport-tcp rematch stm test-framework
         test-framework-hunit transformers
       ];
       homepage = "http://github.com/haskell-distributed/distributed-process-async";
       description = "Cloud Haskell Async API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "distributed-process-azure" = callPackage
    ({ mkDerivation, azure-service-api, base, binary, bytestring
     , certificate, distributed-process, distributed-static
     , executable-path, filepath, libssh2, mtl, network-transport
     , network-transport-tcp, pureMD5, rank1dynamic, transformers, unix
     }:
     mkDerivation {
       pname = "distributed-process-azure";
       version = "0.1.0";
       sha256 = "4f64d22e0ff0dc94e6ecfd99cc7133ab5c5df4dbbe3415bd2c99fdaee98f8035";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         azure-service-api base binary bytestring certificate
         distributed-process distributed-static executable-path filepath
         libssh2 mtl network-transport network-transport-tcp pureMD5
         rank1dynamic transformers unix
       ];
       jailbreak = true;
       homepage = "http://github.com/haskell-distributed/distributed-process";
       description = "Microsoft Azure backend for Cloud Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process-client-server_0_1_2" = callPackage
    ({ mkDerivation, ansi-terminal, base, binary, containers
     , data-accessor, deepseq, distributed-process
     , distributed-process-async, distributed-process-extras
     , distributed-process-tests, fingertree, ghc-prim, hashable, HUnit
     , mtl, network, network-transport, network-transport-tcp, rematch
     , stm, test-framework, test-framework-hunit, time, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "distributed-process-client-server";
       version = "0.1.2";
       sha256 = "5accb15a6f88c9c2799059c16476f70c43ada6cc945c8042932484f45a772073";
       libraryHaskellDepends = [
         base binary containers data-accessor deepseq distributed-process
         distributed-process-async distributed-process-extras fingertree
         hashable mtl stm time transformers unordered-containers
       ];
       testHaskellDepends = [
         ansi-terminal base binary containers deepseq distributed-process
         distributed-process-async distributed-process-extras
         distributed-process-tests fingertree ghc-prim HUnit mtl network
         network-transport network-transport-tcp rematch stm test-framework
         test-framework-hunit transformers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/haskell-distributed/distributed-process-client-server";
       description = "The Cloud Haskell Application Platform";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process-client-server" = callPackage
    ({ mkDerivation, ansi-terminal, base, binary, containers
     , data-accessor, deepseq, distributed-process
     , distributed-process-async, distributed-process-extras
     , distributed-process-tests, fingertree, ghc-prim, hashable, HUnit
     , mtl, network, network-transport, network-transport-tcp, rematch
     , stm, test-framework, test-framework-hunit, time, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "distributed-process-client-server";
       version = "0.1.3.2";
       sha256 = "2c905624d5486b7bc8bd1a4763b139e7eb364b20467c9abddd553f9afbd3601f";
       libraryHaskellDepends = [
         base binary containers data-accessor deepseq distributed-process
         distributed-process-async distributed-process-extras fingertree
         hashable mtl stm time transformers unordered-containers
       ];
       testHaskellDepends = [
         ansi-terminal base binary containers deepseq distributed-process
         distributed-process-async distributed-process-extras
         distributed-process-tests fingertree ghc-prim HUnit mtl network
         network-transport network-transport-tcp rematch stm test-framework
         test-framework-hunit transformers
       ];
       doCheck = false;
       homepage = "http://github.com/haskell-distributed/distributed-process-client-server";
       description = "The Cloud Haskell Application Platform";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process-execution_0_1_1" = callPackage
    ({ mkDerivation, ansi-terminal, base, binary, bytestring
     , containers, data-accessor, deepseq, distributed-process
     , distributed-process-client-server, distributed-process-extras
     , distributed-process-supervisor, distributed-static, fingertree
     , ghc-prim, hashable, HUnit, mtl, network, network-transport
     , network-transport-tcp, QuickCheck, rematch, stm, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "distributed-process-execution";
       version = "0.1.1";
       sha256 = "4a9e37d76530db2a3e9559195b75fd544572e1a942b1ff874ec569c522aba4fe";
       libraryHaskellDepends = [
         base binary containers data-accessor deepseq distributed-process
         distributed-process-client-server distributed-process-extras
         distributed-process-supervisor fingertree hashable mtl stm time
         transformers unordered-containers
       ];
       testHaskellDepends = [
         ansi-terminal base binary bytestring containers data-accessor
         deepseq distributed-process distributed-process-extras
         distributed-static fingertree ghc-prim hashable HUnit mtl network
         network-transport network-transport-tcp QuickCheck rematch stm
         test-framework test-framework-hunit test-framework-quickcheck2 time
         transformers unordered-containers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/haskell-distributed/distributed-process-execution";
       description = "Execution Framework for The Cloud Haskell Application Platform";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process-execution" = callPackage
    ({ mkDerivation, ansi-terminal, base, binary, bytestring
     , containers, data-accessor, deepseq, distributed-process
     , distributed-process-client-server, distributed-process-extras
     , distributed-process-supervisor, distributed-process-tests
     , distributed-static, fingertree, ghc-prim, hashable, HUnit, mtl
     , network, network-transport, network-transport-tcp, QuickCheck
     , rematch, stm, test-framework, test-framework-hunit
     , test-framework-quickcheck2, time, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "distributed-process-execution";
       version = "0.1.2.2";
       sha256 = "9fbfca6b394e52af462586127a0edc2efc2a160ae8f69a9d34234a71e3dbf7b5";
       libraryHaskellDepends = [
         base binary containers data-accessor deepseq distributed-process
         distributed-process-client-server distributed-process-extras
         distributed-process-supervisor fingertree hashable mtl stm time
         transformers unordered-containers
       ];
       testHaskellDepends = [
         ansi-terminal base binary bytestring containers data-accessor
         deepseq distributed-process distributed-process-extras
         distributed-process-tests distributed-static fingertree ghc-prim
         hashable HUnit mtl network network-transport network-transport-tcp
         QuickCheck rematch stm test-framework test-framework-hunit
         test-framework-quickcheck2 time transformers unordered-containers
       ];
       doCheck = false;
       homepage = "http://github.com/haskell-distributed/distributed-process-execution";
       description = "Execution Framework for The Cloud Haskell Application Platform";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process-extras_0_2_0" = callPackage
    ({ mkDerivation, ansi-terminal, base, binary, bytestring
     , containers, data-accessor, deepseq, distributed-process
     , distributed-process-tests, distributed-static, fingertree
     , ghc-prim, hashable, HUnit, mtl, network, network-transport
     , network-transport-tcp, QuickCheck, rematch, stm, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "distributed-process-extras";
       version = "0.2.0";
       sha256 = "9ee22b6d5570e4cddd7fafe505e11e1c233697d4df372f907df18a6e010c1351";
       libraryHaskellDepends = [
         base binary containers data-accessor deepseq distributed-process
         fingertree hashable mtl stm time transformers unordered-containers
       ];
       testHaskellDepends = [
         ansi-terminal base binary bytestring containers data-accessor
         deepseq distributed-process distributed-process-tests
         distributed-static fingertree ghc-prim hashable HUnit mtl network
         network-transport network-transport-tcp QuickCheck rematch stm
         test-framework test-framework-hunit test-framework-quickcheck2 time
         transformers unordered-containers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/haskell-distributed/distributed-process-extras";
       description = "Cloud Haskell Extras";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process-extras" = callPackage
    ({ mkDerivation, ansi-terminal, base, binary, bytestring
     , containers, data-accessor, deepseq, distributed-process
     , distributed-process-tests, distributed-static, fingertree
     , ghc-prim, hashable, HUnit, mtl, network, network-transport
     , network-transport-tcp, QuickCheck, rematch, stm, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "distributed-process-extras";
       version = "0.2.1.2";
       sha256 = "c1a4e1a5e3ec30089251db40fd479b19c5fd74c9dd8ca50f8eb32aaf9747a048";
       libraryHaskellDepends = [
         base binary containers data-accessor deepseq distributed-process
         fingertree hashable mtl stm time transformers unordered-containers
       ];
       testHaskellDepends = [
         ansi-terminal base binary bytestring containers data-accessor
         deepseq distributed-process distributed-process-tests
         distributed-static fingertree ghc-prim hashable HUnit mtl network
         network-transport network-transport-tcp QuickCheck rematch stm
         test-framework test-framework-hunit test-framework-quickcheck2 time
         transformers unordered-containers
       ];
       doCheck = false;
       homepage = "http://github.com/haskell-distributed/distributed-process-extras";
       description = "Cloud Haskell Extras";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "distributed-process-lifted" = callPackage
    ({ mkDerivation, base, binary, deepseq, distributed-process
     , distributed-process-monad-control, HUnit, lifted-base
     , monad-control, mtl, network, network-transport
     , network-transport-tcp, rematch, test-framework
     , test-framework-hunit, transformers, transformers-base
     }:
     mkDerivation {
       pname = "distributed-process-lifted";
       version = "0.2.0.0";
       sha256 = "c0c323de903c6f6770c9e95e4c3dbbfc9295f55ad309220fd64710dae3a5e27f";
       libraryHaskellDepends = [
         base deepseq distributed-process distributed-process-monad-control
         lifted-base monad-control mtl network-transport transformers
         transformers-base
       ];
       testHaskellDepends = [
         base binary distributed-process HUnit lifted-base mtl network
         network-transport network-transport-tcp rematch test-framework
         test-framework-hunit transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/jeremyjh/distributed-process-lifted";
       description = "monad-control style typeclass and transformer instances for Process monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "distributed-process-monad-control" = callPackage
    ({ mkDerivation, base, distributed-process, monad-control
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "distributed-process-monad-control";
       version = "0.5.1.1";
       sha256 = "dab2eb3396e4afa5fdf9f84dd51a3e6bf634c2971a28c782946cc9f4b0e7fa43";
       libraryHaskellDepends = [
         base distributed-process monad-control transformers
         transformers-base
       ];
       jailbreak = true;
       homepage = "http://haskell-distributed.github.io";
       description = "Orphan instances for MonadBase and MonadBaseControl";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "distributed-process-p2p" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , distributed-process, mtl, network, network-transport
     , network-transport-tcp
     }:
     mkDerivation {
       pname = "distributed-process-p2p";
       version = "0.1.3.2";
       sha256 = "613c65aa986085e61cf65b55bf174cc2f31a79e5b666daf1ef402bcad940a28e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers distributed-process mtl network
         network-transport network-transport-tcp
       ];
       executableHaskellDepends = [ base distributed-process mtl ];
       homepage = "https://bitbucket.org/dpwiz/distributed-process-p2p/";
       description = "Peer-to-peer node discovery for Cloud Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "distributed-process-platform" = callPackage
    ({ mkDerivation, ansi-terminal, base, binary, bytestring
     , containers, data-accessor, deepseq, distributed-process
     , distributed-static, fingertree, ghc-prim, hashable, HUnit, mtl
     , network, network-transport, network-transport-tcp, QuickCheck
     , rematch, stm, test-framework, test-framework-hunit
     , test-framework-quickcheck2, time, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "distributed-process-platform";
       version = "0.1.0";
       sha256 = "752980d006aaa5319b91da7b5bd5124322552fff9e9cb7de816aff89b7f5ae2f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary containers data-accessor deepseq distributed-process
         fingertree hashable mtl stm time transformers unordered-containers
       ];
       testHaskellDepends = [
         ansi-terminal base binary bytestring containers data-accessor
         deepseq distributed-process distributed-static fingertree ghc-prim
         hashable HUnit mtl network network-transport network-transport-tcp
         QuickCheck rematch stm test-framework test-framework-hunit
         test-framework-quickcheck2 time transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/haskell-distributed/distributed-process-platform";
       description = "The Cloud Haskell Application Platform";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process-registry" = callPackage
    ({ mkDerivation, ansi-terminal, base, binary, bytestring
     , containers, data-accessor, deepseq, distributed-process
     , distributed-process-client-server, distributed-process-extras
     , distributed-process-supervisor, distributed-process-tests
     , distributed-static, fingertree, hashable, HUnit, mtl, network
     , network-transport, network-transport-tcp, rematch, stm
     , test-framework, test-framework-hunit, time, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "distributed-process-registry";
       version = "0.1.0.2";
       sha256 = "ae2e6ec9de83344cbf33db09073343faba2f8e990e20e98dfebe80a9560875d2";
       libraryHaskellDepends = [
         base binary containers data-accessor deepseq distributed-process
         distributed-process-client-server distributed-process-extras
         distributed-process-supervisor fingertree hashable mtl stm time
         transformers unordered-containers
       ];
       testHaskellDepends = [
         ansi-terminal base binary bytestring containers data-accessor
         deepseq distributed-process distributed-process-extras
         distributed-process-tests distributed-static fingertree hashable
         HUnit mtl network network-transport network-transport-tcp rematch
         stm test-framework test-framework-hunit time transformers
         unordered-containers
       ];
       homepage = "http://github.com/haskell-distributed/distributed-process-registry";
       description = "Cloud Haskell Extended Process Registry";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process-simplelocalnet_0_2_2_0" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , data-accessor, distributed-process, network, network-multicast
     , network-transport, network-transport-tcp, transformers
     }:
     mkDerivation {
       pname = "distributed-process-simplelocalnet";
       version = "0.2.2.0";
       sha256 = "219d7137acc4633728bec1708e4408d29ce7f1e8277551c988a788cfbc2c9508";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers data-accessor distributed-process
         network network-multicast network-transport network-transport-tcp
         transformers
       ];
       jailbreak = true;
       homepage = "http://haskell-distributed.github.com";
       description = "Simple zero-configuration backend for Cloud Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process-simplelocalnet_0_2_3_0" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , data-accessor, distributed-process, network, network-multicast
     , network-transport, network-transport-tcp, transformers
     }:
     mkDerivation {
       pname = "distributed-process-simplelocalnet";
       version = "0.2.3.0";
       sha256 = "5ece5c8cf825c6b0fbdd7c0c499d95ae77008530b1a43acc66fc17c9480e0705";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers data-accessor distributed-process
         network network-multicast network-transport network-transport-tcp
         transformers
       ];
       jailbreak = true;
       homepage = "http://haskell-distributed.github.com";
       description = "Simple zero-configuration backend for Cloud Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process-simplelocalnet" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , data-accessor, distributed-process, network, network-multicast
     , network-transport, network-transport-tcp, transformers
     }:
     mkDerivation {
       pname = "distributed-process-simplelocalnet";
       version = "0.2.3.2";
       sha256 = "c3351cf8a782dda756689b3747ede1e3879dcb913a07065eb4ec0052a963825f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers data-accessor distributed-process
         network network-multicast network-transport network-transport-tcp
         transformers
       ];
       homepage = "http://haskell-distributed.github.com";
       description = "Simple zero-configuration backend for Cloud Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "distributed-process-supervisor_0_1_2" = callPackage
    ({ mkDerivation, ansi-terminal, base, binary, bytestring
     , containers, data-accessor, deepseq, distributed-process
     , distributed-process-client-server, distributed-process-extras
     , distributed-static, fingertree, ghc-prim, hashable, HUnit, mtl
     , network, network-transport, network-transport-tcp, rematch, stm
     , test-framework, test-framework-hunit, time, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "distributed-process-supervisor";
       version = "0.1.2";
       sha256 = "417e183e57d0d4548267abf8cebc95d282c006263b929f3bd262d528ffd459ac";
       libraryHaskellDepends = [
         base binary containers data-accessor deepseq distributed-process
         distributed-process-client-server distributed-process-extras
         fingertree hashable mtl stm time transformers unordered-containers
       ];
       testHaskellDepends = [
         ansi-terminal base binary bytestring containers data-accessor
         deepseq distributed-process distributed-process-client-server
         distributed-process-extras distributed-static fingertree ghc-prim
         hashable HUnit mtl network network-transport network-transport-tcp
         rematch stm test-framework test-framework-hunit time transformers
         unordered-containers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/haskell-distributed/distributed-process-supervisor";
       description = "Supervisors for The Cloud Haskell Application Platform";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process-supervisor" = callPackage
    ({ mkDerivation, ansi-terminal, base, binary, bytestring
     , containers, data-accessor, deepseq, distributed-process
     , distributed-process-client-server, distributed-process-extras
     , distributed-static, fingertree, ghc-prim, hashable, HUnit, mtl
     , network, network-transport, network-transport-tcp, rematch, stm
     , test-framework, test-framework-hunit, time, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "distributed-process-supervisor";
       version = "0.1.3.2";
       sha256 = "3e9b9c940afb67d41bb3ec50229ea972ffd386a2e424007b9cbacc361f053df4";
       libraryHaskellDepends = [
         base binary containers data-accessor deepseq distributed-process
         distributed-process-client-server distributed-process-extras
         fingertree hashable mtl stm time transformers unordered-containers
       ];
       testHaskellDepends = [
         ansi-terminal base binary bytestring containers data-accessor
         deepseq distributed-process distributed-process-client-server
         distributed-process-extras distributed-static fingertree ghc-prim
         hashable HUnit mtl network network-transport network-transport-tcp
         rematch stm test-framework test-framework-hunit time transformers
         unordered-containers
       ];
       doCheck = false;
       homepage = "http://github.com/haskell-distributed/distributed-process-supervisor";
       description = "Supervisors for The Cloud Haskell Application Platform";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process-task_0_1_1" = callPackage
    ({ mkDerivation, ansi-terminal, base, binary, bytestring
     , containers, data-accessor, deepseq, distributed-process
     , distributed-process-async, distributed-process-client-server
     , distributed-process-extras, distributed-static, fingertree
     , ghc-prim, hashable, HUnit, mtl, network, network-transport
     , network-transport-tcp, QuickCheck, rematch, stm, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "distributed-process-task";
       version = "0.1.1";
       sha256 = "35f8ef2af1dc30ace7d003735d3fb09adde27cae0045c7eb5f26a6a218b48113";
       libraryHaskellDepends = [
         base binary containers data-accessor deepseq distributed-process
         distributed-process-async distributed-process-client-server
         distributed-process-extras fingertree hashable mtl stm time
         transformers unordered-containers
       ];
       testHaskellDepends = [
         ansi-terminal base binary bytestring containers data-accessor
         deepseq distributed-process distributed-process-async
         distributed-process-client-server distributed-process-extras
         distributed-static fingertree ghc-prim hashable HUnit mtl network
         network-transport network-transport-tcp QuickCheck rematch stm
         test-framework test-framework-hunit test-framework-quickcheck2 time
         transformers unordered-containers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/haskell-distributed/distributed-process-task";
       description = "Task Framework for The Cloud Haskell Application Platform";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process-task" = callPackage
    ({ mkDerivation, ansi-terminal, base, binary, bytestring
     , containers, data-accessor, deepseq, distributed-process
     , distributed-process-async, distributed-process-client-server
     , distributed-process-extras, distributed-process-tests
     , distributed-static, fingertree, ghc-prim, hashable, HUnit, mtl
     , network, network-transport, network-transport-tcp, QuickCheck
     , rematch, stm, test-framework, test-framework-hunit
     , test-framework-quickcheck2, time, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "distributed-process-task";
       version = "0.1.2.2";
       sha256 = "ec25caf01b9185d166433246210be688a9733e73f54b03f91a910eaf2cd05c23";
       libraryHaskellDepends = [
         base binary containers data-accessor deepseq distributed-process
         distributed-process-async distributed-process-client-server
         distributed-process-extras fingertree hashable mtl stm time
         transformers unordered-containers
       ];
       testHaskellDepends = [
         ansi-terminal base binary bytestring containers data-accessor
         deepseq distributed-process distributed-process-async
         distributed-process-client-server distributed-process-extras
         distributed-process-tests distributed-static fingertree ghc-prim
         hashable HUnit mtl network network-transport network-transport-tcp
         QuickCheck rematch stm test-framework test-framework-hunit
         test-framework-quickcheck2 time transformers unordered-containers
       ];
       doCheck = false;
       homepage = "http://github.com/haskell-distributed/distributed-process-task";
       description = "Task Framework for The Cloud Haskell Application Platform";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-process-tests" = callPackage
    ({ mkDerivation, ansi-terminal, base, binary, bytestring
     , distributed-process, distributed-static, HUnit, network
     , network-transport, network-transport-inmemory, random, rematch
     , setenv, stm, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "distributed-process-tests";
       version = "0.4.4";
       sha256 = "e53f39304100179bbd4e6944348578fe252940170f5ae20ab2ae1c63f8a69169";
       libraryHaskellDepends = [
         ansi-terminal base binary bytestring distributed-process
         distributed-static HUnit network network-transport random rematch
         setenv stm test-framework test-framework-hunit
       ];
       testHaskellDepends = [
         base network network-transport network-transport-inmemory
         test-framework
       ];
       homepage = "http://github.com/haskell-distributed/distributed-process-tests";
       description = "Tests and test support tools for distributed-process";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "distributed-process-zookeeper" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , distributed-process, distributed-process-monad-control
     , enclosed-exceptions, hspec, hzk, lifted-base, monad-control, mtl
     , network, network-transport, network-transport-tcp, transformers
     }:
     mkDerivation {
       pname = "distributed-process-zookeeper";
       version = "0.2.0.0";
       sha256 = "b14f2f6a6f8f0e37bee40fd57a6e4c3491cf687a1de65f593fbac94962a912ed";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers deepseq distributed-process hzk
         mtl network network-transport network-transport-tcp transformers
       ];
       executableHaskellDepends = [ base distributed-process ];
       testHaskellDepends = [
         base bytestring deepseq distributed-process
         distributed-process-monad-control enclosed-exceptions hspec hzk
         lifted-base monad-control network network-transport
         network-transport-tcp transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/jeremyjh/distributed-process-zookeeper";
       description = "A Zookeeper back-end for Cloud Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-static_0_3_1_0" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, rank1dynamic
     }:
     mkDerivation {
       pname = "distributed-static";
       version = "0.3.1.0";
       sha256 = "084818ed677210f0f8f67c26ee9e00ea6786b8d68089439dddf9ddc8e4360ba4";
       libraryHaskellDepends = [
         base binary bytestring containers rank1dynamic
       ];
       jailbreak = true;
       homepage = "http://haskell-distributed.github.com";
       description = "Compositional, type-safe, polymorphic static values and closures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-static_0_3_2_0" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , rank1dynamic
     }:
     mkDerivation {
       pname = "distributed-static";
       version = "0.3.2.0";
       sha256 = "95bced7a81ccde6e2351a97be5019ea1b2c8cc62aae313b85528a6e11e45e1ff";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq rank1dynamic
       ];
       homepage = "http://haskell-distributed.github.com";
       description = "Compositional, type-safe, polymorphic static values and closures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-static_0_3_3_0" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , rank1dynamic
     }:
     mkDerivation {
       pname = "distributed-static";
       version = "0.3.3.0";
       sha256 = "57ac042377d0cf0ca0dca3952b92ddd4a9c1f5a3b1ddf3cab0b59c212489a1c9";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq rank1dynamic
       ];
       homepage = "http://haskell-distributed.github.com";
       description = "Compositional, type-safe, polymorphic static values and closures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributed-static" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , rank1dynamic
     }:
     mkDerivation {
       pname = "distributed-static";
       version = "0.3.4.0";
       sha256 = "f3d522537946c2e89382f8549674b7abe7adc9aab22acafdf89570f44c508d51";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq rank1dynamic
       ];
       homepage = "http://haskell-distributed.github.com";
       description = "Compositional, type-safe, polymorphic static values and closures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "distribution" = callPackage
    ({ mkDerivation, array, base, containers, MonadRandom, random }:
     mkDerivation {
       pname = "distribution";
       version = "1.0.0.0";
       sha256 = "9ed0b100f62fda5e9bb7e7e952f7470ef5225faa9094abd799977a08c755097e";
       libraryHaskellDepends = [
         array base containers MonadRandom random
       ];
       jailbreak = true;
       homepage = "https://github.com/redelmann/haskell-distribution";
       description = "Finite discrete probability distributions";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distribution-plot" = callPackage
    ({ mkDerivation, base, Chart, Chart-cairo, colour, containers
     , data-default-class, distribution, lens
     }:
     mkDerivation {
       pname = "distribution-plot";
       version = "1.0.0.0";
       sha256 = "361def9caab9df2ca5ba222c807ab1649347e430c05261e489a3a7f37a3b659a";
       libraryHaskellDepends = [
         base Chart Chart-cairo colour containers data-default-class
         distribution lens
       ];
       jailbreak = true;
       homepage = "https://github.com/redelmann/haskell-distribution-plot";
       description = "Easily plot distributions from the distribution package..";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributive_0_4_4" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, ghc-prim
     , tagged, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "distributive";
       version = "0.4.4";
       sha256 = "82d1f53495fe9c25e4e974825666b4a6232af7452784e145cc04aeb365b25468";
       libraryHaskellDepends = [
         base ghc-prim tagged transformers transformers-compat
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/ekmett/distributive/";
       description = "Distributive functors -- Dual to Traversable";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "distributive" = callPackage
    ({ mkDerivation, base, base-orphans, directory, doctest, filepath
     , tagged, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "distributive";
       version = "0.5.0.2";
       sha256 = "f884996f491fe5b275b7dda2cebdadfecea0d7788a142546e0271e9575cc1609";
       libraryHaskellDepends = [
         base base-orphans tagged transformers transformers-compat
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/ekmett/distributive/";
       description = "Distributive functors -- Dual to Traversable";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "diversity_0_7_1_1" = callPackage
    ({ mkDerivation, base, containers, data-ordlist, fasta
     , math-functions, MonadRandom, optparse-applicative, parsec, pipes
     , random-shuffle, scientific, split
     }:
     mkDerivation {
       pname = "diversity";
       version = "0.7.1.1";
       sha256 = "c59302a3b4e0d4a6d7d4536d50c0a8b0e5676b569b0439df215607ce29e713a9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers data-ordlist fasta math-functions MonadRandom
         parsec random-shuffle scientific split
       ];
       executableHaskellDepends = [
         base containers fasta optparse-applicative pipes
       ];
       homepage = "https://github.com/GregorySchwartz/diversity";
       description = "Return the diversity at each position by default for all sequences in a fasta file";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "diversity" = callPackage
    ({ mkDerivation, base, containers, data-ordlist, fasta
     , math-functions, MonadRandom, optparse-applicative, parsec, pipes
     , random-shuffle, scientific, split
     }:
     mkDerivation {
       pname = "diversity";
       version = "0.8.0.0";
       sha256 = "0ebba59c35fdc1b1fe54255fe18b7d1f808b3750cc6b2a5425456b622277e51d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers data-ordlist fasta math-functions MonadRandom
         parsec random-shuffle scientific split
       ];
       executableHaskellDepends = [
         base containers fasta optparse-applicative pipes
       ];
       homepage = "https://github.com/GregorySchwartz/diversity";
       description = "Quantify the diversity of a population";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "dixi_0_6_0_2" = callPackage
    ({ mkDerivation, acid-state, aeson, aeson-pretty, attoparsec, base
     , blaze-html, blaze-markup, bytestring, composition-tree
     , containers, data-default, directory, either, filepath, heredoc
     , lens, network-uri, pandoc, pandoc-types, patches-vector, safecopy
     , servant, servant-blaze, servant-docs, servant-server, shakespeare
     , template-haskell, text, time, time-locale-compat, timezone-olson
     , timezone-series, transformers, vector, warp, yaml
     }:
     mkDerivation {
       pname = "dixi";
       version = "0.6.0.2";
       sha256 = "01734a92055e31e4c52fd1d31f7e30977fd1a7c8274b6b8ff69b338f0f675675";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         acid-state aeson base blaze-html blaze-markup bytestring
         composition-tree containers data-default either heredoc lens
         network-uri pandoc pandoc-types patches-vector safecopy servant
         servant-blaze servant-server shakespeare template-haskell text time
         time-locale-compat timezone-olson timezone-series transformers
         vector
       ];
       executableHaskellDepends = [
         acid-state base directory filepath servant-server text warp yaml
       ];
       testHaskellDepends = [
         aeson aeson-pretty attoparsec base bytestring lens patches-vector
         servant servant-blaze servant-docs shakespeare text time vector
       ];
       jailbreak = true;
       homepage = "https://github.com/liamoc/dixi";
       description = "A wiki implemented with a firm theoretical foundation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dixi_0_6_0_3" = callPackage
    ({ mkDerivation, acid-state, aeson, aeson-pretty, attoparsec, base
     , blaze-html, blaze-markup, bytestring, composition-tree
     , containers, data-default, directory, either, filepath, heredoc
     , lens, network-uri, pandoc, pandoc-types, patches-vector, safecopy
     , servant, servant-blaze, servant-docs, servant-server, shakespeare
     , template-haskell, text, time, time-locale-compat, timezone-olson
     , timezone-series, transformers, vector, warp, yaml
     }:
     mkDerivation {
       pname = "dixi";
       version = "0.6.0.3";
       sha256 = "20321780dd63d08ee7c09d6eb15704870351205bf85751f8ac49ea1a9811dc52";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         acid-state aeson base blaze-html blaze-markup bytestring
         composition-tree containers data-default either heredoc lens
         network-uri pandoc pandoc-types patches-vector safecopy servant
         servant-blaze servant-server shakespeare template-haskell text time
         time-locale-compat timezone-olson timezone-series transformers
         vector
       ];
       executableHaskellDepends = [
         acid-state base directory filepath servant-server text warp yaml
       ];
       testHaskellDepends = [
         aeson aeson-pretty attoparsec base bytestring lens patches-vector
         servant servant-blaze servant-docs shakespeare text time vector
       ];
       homepage = "https://github.com/liamoc/dixi";
       description = "A wiki implemented with a firm theoretical foundation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dixi" = callPackage
    ({ mkDerivation, acid-state, aeson, aeson-pretty, attoparsec, base
     , base-orphans, blaze-html, blaze-markup, bytestring
     , composition-tree, containers, data-default, directory, either
     , filepath, heredoc, lens, network-uri, pandoc, pandoc-types
     , patches-vector, safecopy, servant, servant-blaze, servant-docs
     , servant-server, shakespeare, template-haskell, text, time
     , time-locale-compat, timezone-olson, timezone-series, transformers
     , vector, warp, yaml
     }:
     mkDerivation {
       pname = "dixi";
       version = "0.6.0.5";
       sha256 = "2702e771c2c2af3157c5fc6b6ae8001a46ece8b2e23a2c6cd96fdfcc2f9f22c5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         acid-state aeson base base-orphans blaze-html blaze-markup
         bytestring composition-tree containers data-default either heredoc
         lens network-uri pandoc pandoc-types patches-vector safecopy
         servant servant-blaze servant-server shakespeare template-haskell
         text time time-locale-compat timezone-olson timezone-series
         transformers vector
       ];
       executableHaskellDepends = [
         acid-state base base-orphans directory filepath servant-server text
         warp yaml
       ];
       testHaskellDepends = [
         aeson aeson-pretty attoparsec base base-orphans bytestring lens
         patches-vector servant servant-blaze servant-docs shakespeare text
         time vector
       ];
       homepage = "https://github.com/liamoc/dixi";
       description = "A wiki implemented with a firm theoretical foundation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "djembe" = callPackage
    ({ mkDerivation, base, hmidi, hspec, lens, mtl, QuickCheck, random
     }:
     mkDerivation {
       pname = "djembe";
       version = "0.1.1.2";
       sha256 = "522a89f1f9c29dfaf17b4dd0a0dcb7e88eba511948e8fd94ea618a4757eb7a28";
       libraryHaskellDepends = [
         base hmidi hspec lens mtl QuickCheck random
       ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "https://github.com/reedrosenbluth/Djembe";
       description = "Hit drums with haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "djinn" = callPackage
    ({ mkDerivation, array, base, containers, haskeline, mtl, pretty }:
     mkDerivation {
       pname = "djinn";
       version = "2014.9.7";
       sha256 = "4ff8346fb9e93055b93db16a283312ee8bda122db8e54520c299da81d6df2ddd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers haskeline mtl pretty
       ];
       description = "Generate Haskell code from a type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "djinn-ghc_0_0_2_2" = callPackage
    ({ mkDerivation, async, base, containers, djinn-lib, ghc, mtl
     , transformers
     }:
     mkDerivation {
       pname = "djinn-ghc";
       version = "0.0.2.2";
       sha256 = "e0d0046797d9eeda7c904d8b7558cc3f013f7fed59042102d32e458dca93e537";
       libraryHaskellDepends = [
         async base containers djinn-lib ghc mtl transformers
       ];
       description = "Generate Haskell code from a type. Bridge from Djinn to GHC API.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "djinn-ghc" = callPackage
    ({ mkDerivation, async, base, containers, djinn-lib, ghc, mtl
     , transformers
     }:
     mkDerivation {
       pname = "djinn-ghc";
       version = "0.0.2.3";
       sha256 = "cb956aed69bc5c342b45ef1b1142b6555fd2865dde1a80ac6ab3ef86aca314a4";
       libraryHaskellDepends = [
         async base containers djinn-lib ghc mtl transformers
       ];
       description = "Generate Haskell code from a type. Bridge from Djinn to GHC API.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "djinn-lib" = callPackage
    ({ mkDerivation, base, containers, mtl, pretty }:
     mkDerivation {
       pname = "djinn-lib";
       version = "0.0.1.2";
       sha256 = "c0fe10b7aa5cb39f828e933925fc5bbf86c290bb7661021e4d9250ae8ed01011";
       libraryHaskellDepends = [ base containers mtl pretty ];
       homepage = "http://www.augustsson.net/Darcs/Djinn/";
       description = "Generate Haskell code from a type. Library extracted from djinn package.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "djinn-th" = callPackage
    ({ mkDerivation, base, containers, logict, template-haskell }:
     mkDerivation {
       pname = "djinn-th";
       version = "0.0.1";
       sha256 = "3ddec6df9153059aeef2153857ff642103c0a84915f97f8e4fd86c06d1372b21";
       libraryHaskellDepends = [
         base containers logict template-haskell
       ];
       jailbreak = true;
       homepage = "http://gitorious.org/djinn-th";
       description = "Generate executable Haskell code from a type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dlist_0_7_1" = callPackage
    ({ mkDerivation, base, Cabal, deepseq, QuickCheck }:
     mkDerivation {
       pname = "dlist";
       version = "0.7.1";
       sha256 = "d9f5609dc1aa9756372a43f8f8414be6380e778754c8e7986a54906317186a8e";
       libraryHaskellDepends = [ base deepseq ];
       testHaskellDepends = [ base Cabal QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/spl/dlist";
       description = "Difference lists";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dlist_0_7_1_1" = callPackage
    ({ mkDerivation, base, Cabal, deepseq, QuickCheck }:
     mkDerivation {
       pname = "dlist";
       version = "0.7.1.1";
       sha256 = "08b07f28e01f4a7e17239c33b37fbef0bf6073712337a97a145a583577df5efd";
       libraryHaskellDepends = [ base deepseq ];
       testHaskellDepends = [ base Cabal QuickCheck ];
       homepage = "https://github.com/spl/dlist";
       description = "Difference lists";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dlist" = callPackage
    ({ mkDerivation, base, Cabal, deepseq, QuickCheck }:
     mkDerivation {
       pname = "dlist";
       version = "0.7.1.2";
       sha256 = "332d21f16fd30d2534b6ab96c98830a14266d8f368cff21f6a47469fb3493783";
       libraryHaskellDepends = [ base deepseq ];
       testHaskellDepends = [ base Cabal QuickCheck ];
       homepage = "https://github.com/spl/dlist";
       description = "Difference lists";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dlist-instances" = callPackage
    ({ mkDerivation, base, dlist, semigroups }:
     mkDerivation {
       pname = "dlist-instances";
       version = "0.1";
       sha256 = "2598aae775532829923d2a8f99dcaaa20e49efec31314e8460a761ee653b3264";
       libraryHaskellDepends = [ base dlist semigroups ];
       homepage = "https://github.com/gregwebs/dlist-instances";
       description = "Difference lists instances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dns_2_0_0" = callPackage
    ({ mkDerivation, attoparsec, base, binary, blaze-builder
     , bytestring, conduit, conduit-extra, containers, doctest, hspec
     , iproute, mtl, network, random, resourcet, word8
     }:
     mkDerivation {
       pname = "dns";
       version = "2.0.0";
       sha256 = "5ec9e58f71022bbc50888ec8b34be3be6f9e8d1566647b59b6e9bf169b1401cb";
       libraryHaskellDepends = [
         attoparsec base binary blaze-builder bytestring conduit
         conduit-extra containers iproute mtl network random resourcet
       ];
       testHaskellDepends = [
         attoparsec base binary blaze-builder bytestring conduit
         conduit-extra containers doctest hspec iproute mtl network random
         resourcet word8
       ];
       doCheck = false;
       testTarget = "spec";
       description = "DNS library in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dns" = callPackage
    ({ mkDerivation, attoparsec, base, binary, blaze-builder
     , bytestring, conduit, conduit-extra, containers, doctest, hspec
     , iproute, mtl, network, random, resourcet, word8
     }:
     mkDerivation {
       pname = "dns";
       version = "2.0.1";
       sha256 = "3d11e14bbfd07b46bba9c676dd970731be190d6dc9c5e95089c4da60565e47d2";
       libraryHaskellDepends = [
         attoparsec base binary blaze-builder bytestring conduit
         conduit-extra containers iproute mtl network random resourcet
       ];
       testHaskellDepends = [
         attoparsec base binary blaze-builder bytestring conduit
         conduit-extra containers doctest hspec iproute mtl network random
         resourcet word8
       ];
       doCheck = false;
       testTarget = "spec";
       description = "DNS library in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dnscache" = callPackage
    ({ mkDerivation, base, bytestring, containers, contstuff, dns
     , iproute, time
     }:
     mkDerivation {
       pname = "dnscache";
       version = "1.1.0";
       sha256 = "ab7fd38ca9b162299f9269a5d94565f504455d1c81bf8c2dd64047ed0e77972f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers contstuff dns iproute time
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       description = "Caching DNS resolver library and mass DNS resolver utility";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dnsrbl" = callPackage
    ({ mkDerivation, base, containers, hsdns, HUnit, network }:
     mkDerivation {
       pname = "dnsrbl";
       version = "0.0.3";
       sha256 = "b5a76d7f04b5d3393aa905d6b4afc50c74e5ddc957a38a8c0bf8578c9528b81f";
       libraryHaskellDepends = [ base containers hsdns HUnit network ];
       homepage = "http://www.pigscanfly.ca/~holden/dnsrbl/";
       description = "Asynchronous DNS RBL lookup";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dnssd" = callPackage
    ({ mkDerivation, base, dns_sd, transformers }:
     mkDerivation {
       pname = "dnssd";
       version = "0.1.0.0";
       sha256 = "56cc66b4ba20bc2f554d9153c63706713fb3eba4c6b5944106d176c643f6de3d";
       libraryHaskellDepends = [ base transformers ];
       librarySystemDepends = [ dns_sd ];
       jailbreak = true;
       homepage = "https://github.com/maxpow4h/dnssd";
       description = "DNS service discovery bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {dns_sd = null;};

  "doc-review" = callPackage
    ({ mkDerivation, base, base64-bytestring, binary, bytestring
     , containers, directory, feed, filepath, haskell98, heist, hexpat
     , json, MonadCatchIO-transformers, MonadRandom, monads-fd, network
     , old-locale, snap-core, snap-server, sqlite, tagchup, text, time
     , transformers, unix, xhtml-combinators, xml, xml-basic
     }:
     mkDerivation {
       pname = "doc-review";
       version = "0.7.1";
       sha256 = "ce46c33676f61e6dbf715d2549e440ba2eb8a7268d81ab173a593e68ea7d0900";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base base64-bytestring binary bytestring containers directory feed
         filepath haskell98 heist hexpat json MonadCatchIO-transformers
         MonadRandom monads-fd network old-locale snap-core snap-server
         sqlite tagchup text time transformers unix xhtml-combinators xml
         xml-basic
       ];
       jailbreak = true;
       homepage = "https://github.com/j3h/doc-review";
       description = "Document review Web application, like http://book.realworldhaskell.org/";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "doccheck" = callPackage
    ({ mkDerivation, attoparsec, base, directory, directory-tree
     , filepath, ghc, ghc-paths, text
     }:
     mkDerivation {
       pname = "doccheck";
       version = "0.1.0.0";
       sha256 = "8b8631b0a3162395bbeeaa2cd73969afdaddd73b2dd534dff711149d80b6b214";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base directory directory-tree filepath ghc ghc-paths
         text
       ];
       homepage = "https://github.com/Fuuzetsu/doccheck";
       description = "Checks Haddock comments for pitfalls and version changes";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "docidx" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, filepath, html
     , MissingH, mtl, old-locale, tagsoup, time
     }:
     mkDerivation {
       pname = "docidx";
       version = "1.1.0";
       sha256 = "68e91713c5bc9167b4bc0363e31b62bc45995c890afe06cddacc585049bc4000";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers directory filepath html MissingH mtl
         old-locale tagsoup time
       ];
       homepage = "http://github.com/gimbo/docidx.hs";
       description = "Generate an HTML index of installed Haskell packages and their documentation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "docker" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, data-default
     , HsOpenSSL, http-client-openssl, http-types, lens, lens-aeson
     , network-uri, pipes, pipes-bytestring, pipes-http, pipes-text
     , process, QuickCheck, tasty, tasty-hunit, tasty-quickcheck, text
     , wreq
     }:
     mkDerivation {
       pname = "docker";
       version = "0.2.0.4";
       sha256 = "66821e0315b1016fa3c70c6760763134b5ddbde23f644410ed12975d67b94096";
       libraryHaskellDepends = [
         aeson base bytestring containers data-default HsOpenSSL
         http-client-openssl lens lens-aeson network-uri pipes
         pipes-bytestring pipes-http pipes-text text wreq
       ];
       testHaskellDepends = [
         aeson base bytestring containers data-default HsOpenSSL
         http-client-openssl http-types lens lens-aeson pipes
         pipes-bytestring pipes-http pipes-text process QuickCheck tasty
         tasty-hunit tasty-quickcheck text wreq
       ];
       homepage = "https://github.com/denibertovic/docker-hs";
       description = "Haskell wrapper for Docker Remote API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dockercook" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, bytestring
     , conduit, conduit-combinators, conduit-extra, cryptohash
     , directory, filepath, hashable, hslogger, HTF, lens, monad-logger
     , mtl, optparse-applicative, persistent-sqlite, persistent-template
     , process, regex-compat, resourcet, retry, stm, streaming-commons
     , system-filepath, temporary, text, time, transformers, unix
     , unordered-containers, vector, wreq
     }:
     mkDerivation {
       pname = "dockercook";
       version = "0.4.3.0";
       sha256 = "6c23a3e4090a0de6a0594353c4449cfd79b073dd1c0ac44f006ab4b530e04a3f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base base16-bytestring bytestring conduit
         conduit-combinators conduit-extra cryptohash directory filepath
         hashable hslogger lens monad-logger mtl persistent-sqlite
         persistent-template process regex-compat resourcet retry stm
         streaming-commons system-filepath temporary text time transformers
         unix unordered-containers vector wreq
       ];
       executableHaskellDepends = [
         base directory filepath hslogger optparse-applicative process
       ];
       testHaskellDepends = [ base HTF text vector ];
       jailbreak = true;
       homepage = "https://github.com/factisresearch/dockercook";
       description = "A build tool for multiple docker image layers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dockerfile" = callPackage
    ({ mkDerivation, base, hspec }:
     mkDerivation {
       pname = "dockerfile";
       version = "0.1.0.1";
       sha256 = "294ac0b6c0546da15bf5453d6006979aeb6f6b36f0566be75767f5021de00025";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec ];
       description = "A simple DSL for describing and generating Dockerfile containers in Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "docopt" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, containers
     , HUnit, parsec, split, template-haskell, th-lift
     }:
     mkDerivation {
       pname = "docopt";
       version = "0.7.0.4";
       sha256 = "3470cd9de7b1731a0b2c0a3fe8b9ea1bfdcfbebeffa5ed77831572f50f01e480";
       libraryHaskellDepends = [
         base containers parsec template-haskell th-lift
       ];
       testHaskellDepends = [
         aeson ansi-terminal base bytestring containers HUnit parsec split
         template-haskell th-lift
       ];
       homepage = "https://github.com/docopt/docopt.hs";
       description = "A command-line interface parser that will make you smile";
       license = stdenv.lib.licenses.mit;
     }) {};

  "doctest_0_9_11_1" = callPackage
    ({ mkDerivation, base, base-compat, deepseq, directory, filepath
     , ghc, ghc-paths, hspec, HUnit, process, QuickCheck, setenv
     , silently, stringbuilder, syb, transformers
     }:
     mkDerivation {
       pname = "doctest";
       version = "0.9.11.1";
       sha256 = "aba544bfea066cd19dec4473e53805872291bb25672eb7680d481c7732ffffbf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base deepseq directory filepath ghc ghc-paths process syb
         transformers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base base-compat deepseq directory filepath ghc ghc-paths hspec
         HUnit process QuickCheck setenv silently stringbuilder syb
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/sol/doctest#readme";
       description = "Test interactive Haskell examples";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "doctest_0_9_12" = callPackage
    ({ mkDerivation, base, base-compat, deepseq, directory, filepath
     , ghc, ghc-paths, hspec, HUnit, process, QuickCheck, setenv
     , silently, stringbuilder, syb, transformers
     }:
     mkDerivation {
       pname = "doctest";
       version = "0.9.12";
       sha256 = "a3e0e67d7f18572128d7de9b2c55e1559b689e77f6b254c659cc5cb47029756b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base deepseq directory filepath ghc ghc-paths process syb
         transformers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base base-compat deepseq directory filepath ghc ghc-paths hspec
         HUnit process QuickCheck setenv silently stringbuilder syb
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/sol/doctest#readme";
       description = "Test interactive Haskell examples";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "doctest_0_9_13" = callPackage
    ({ mkDerivation, base, base-compat, deepseq, directory, filepath
     , ghc, ghc-paths, hspec, HUnit, process, QuickCheck, setenv
     , silently, stringbuilder, syb, transformers
     }:
     mkDerivation {
       pname = "doctest";
       version = "0.9.13";
       sha256 = "00bc8aee18836edf2fcc024e8fd35d92db2c1260a97015dacd81afe215388576";
       revision = "1";
       editedCabalFile = "592ab6d62eca8a0b43930f15c8fb653c54d60983bd232ecc505bd5a5aebe6f7f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base deepseq directory filepath ghc ghc-paths process syb
         transformers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base base-compat deepseq directory filepath ghc ghc-paths hspec
         HUnit process QuickCheck setenv silently stringbuilder syb
         transformers
       ];
       homepage = "https://github.com/sol/doctest#readme";
       description = "Test interactive Haskell examples";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "doctest" = callPackage
    ({ mkDerivation, base, base-compat, deepseq, directory, filepath
     , ghc, ghc-paths, hspec, HUnit, process, QuickCheck, setenv
     , silently, stringbuilder, syb, transformers
     }:
     mkDerivation {
       pname = "doctest";
       version = "0.10.1";
       sha256 = "357b99c0975171a61de3bf5a9b9265e82a15f336f2ceb5cf73d94111d7877ec9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base deepseq directory filepath ghc ghc-paths process syb
         transformers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base base-compat deepseq directory filepath ghc ghc-paths hspec
         HUnit process QuickCheck setenv silently stringbuilder syb
         transformers
       ];
       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
     }:
     mkDerivation {
       pname = "doctest-discover";
       version = "0.1.0.7";
       sha256 = "ac6a65da517db7f264e65607a50b080b54f008ba592746ac11b7bb40107fbd70";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring directory doctest filepath
       ];
       executableHaskellDepends = [
         aeson base bytestring directory doctest filepath
       ];
       testHaskellDepends = [ base doctest ];
       doHaddock = false;
       homepage = "http://github.com/karun012/doctest-discover";
       description = "Easy way to run doctests via cabal";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "doctest-discover-configurator" = callPackage
    ({ mkDerivation, base, bytestring, configurator, directory, doctest
     , filepath
     }:
     mkDerivation {
       pname = "doctest-discover-configurator";
       version = "0.1.0.6";
       sha256 = "289f1b5dae7b8ae7cf1fe1f5450552988492cf04deb20e9577b1b5636e465dd8";
       revision = "1";
       editedCabalFile = "79f62a00ff10acba4f850730ed2ffe99d5637bdfdb48f6fc4b92f03fbbb20a45";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring configurator directory doctest filepath
       ];
       executableHaskellDepends = [
         base bytestring configurator directory doctest filepath
       ];
       testHaskellDepends = [ base doctest ];
       doHaddock = false;
       jailbreak = true;
       homepage = "http://github.com/relrod/doctest-discover-noaeson";
       description = "Easy way to run doctests via cabal (no aeson dependency, uses configurator instead)";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "doctest-prop" = callPackage
    ({ mkDerivation, base, doctest, HUnit, QuickCheck }:
     mkDerivation {
       pname = "doctest-prop";
       version = "0.2.0.1";
       sha256 = "4ab056cc370c320536976ce3c1648098ee60d7d60b9e770e556f013d0ad6aeaa";
       libraryHaskellDepends = [ base HUnit QuickCheck ];
       testHaskellDepends = [ base doctest HUnit QuickCheck ];
       description = "Allow QuickCheck-style property testing within doctest";
       license = stdenv.lib.licenses.mit;
     }) {};

  "dom-lt" = callPackage
    ({ mkDerivation, array, base, containers }:
     mkDerivation {
       pname = "dom-lt";
       version = "0.1.3";
       sha256 = "ea652b765850150b0da96a12573a807593564c214a3043613deeca441a6aa144";
       libraryHaskellDepends = [ array base containers ];
       description = "The Lengauer-Tarjan graph dominators algorithm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dom-parser" = callPackage
    ({ mkDerivation, base, data-default, hspec, lens, mtl, semigroups
     , shakespeare, text, transformers, xml-conduit
     }:
     mkDerivation {
       pname = "dom-parser";
       version = "0.0.1";
       sha256 = "5ade4315c5e59bfbaf1e078a1171c6f3109d4f3bd3c394d7ef923140e253f86b";
       revision = "1";
       editedCabalFile = "1157c5f603c43f5a4bd0ea7f45da822b989db065324bbecb2e14659473eb766f";
       libraryHaskellDepends = [
         base lens mtl semigroups shakespeare text transformers xml-conduit
       ];
       testHaskellDepends = [
         base data-default hspec shakespeare text xml-conduit
       ];
       homepage = "https://github.com/s9gf4ult/dom-parser";
       description = "Simple monad for parsing DOM";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dom-selector" = callPackage
    ({ mkDerivation, base, blaze-html, containers, html-conduit, parsec
     , QuickCheck, template-haskell, text, th-lift, xml-conduit
     }:
     mkDerivation {
       pname = "dom-selector";
       version = "0.2.0.1";
       sha256 = "42ac991bfc11576838c841b4712f2c162cb841389b28eb0aa4454732d3c9a3da";
       libraryHaskellDepends = [
         base blaze-html containers html-conduit parsec QuickCheck
         template-haskell text th-lift xml-conduit
       ];
       testHaskellDepends = [
         base blaze-html containers html-conduit parsec QuickCheck
         template-haskell text th-lift xml-conduit
       ];
       homepage = "https://github.com/nebuta/";
       description = "DOM traversal by CSS selectors for xml-conduit package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "domain-auth" = callPackage
    ({ mkDerivation, appar, base, binary, blaze-builder, bytestring
     , containers, crypto-pubkey-types, dns, iproute, network, RSA, SHA
     }:
     mkDerivation {
       pname = "domain-auth";
       version = "0.2.1";
       sha256 = "8ac8691b4a23352656fda46fb14e24f16399cbbcf73acf71f9c5853a2fe133ac";
       libraryHaskellDepends = [
         appar base binary blaze-builder bytestring containers
         crypto-pubkey-types dns iproute network RSA SHA
       ];
       description = "Domain authentication library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dominion" = callPackage
    ({ mkDerivation, base, hscolour, hspec, lens, mtl, random
     , random-extras, random-fu, transformers
     }:
     mkDerivation {
       pname = "dominion";
       version = "0.1.0.4";
       sha256 = "be25f1fb393288603a619b5fd26b25b05c756726c8f5ee69f447cea61250d78f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base hscolour lens mtl random random-extras random-fu transformers
       ];
       executableHaskellDepends = [
         base hscolour lens mtl random random-extras random-fu transformers
       ];
       testHaskellDepends = [
         base hscolour hspec lens mtl random random-extras random-fu
         transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/egonschiele/dominion";
       description = "A simulator for the board game Dominion";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "domplate" = callPackage
    ({ mkDerivation, base, bytestring, containers, tagsoup, text
     , unordered-containers, vector, yaml
     }:
     mkDerivation {
       pname = "domplate";
       version = "0.1.0.1";
       sha256 = "645d9d390d9507ffe4fa3aead56c7ca012b1f0ec19ed5a7574b2fa7a7e975fda";
       libraryHaskellDepends = [
         base bytestring containers tagsoup text unordered-containers vector
         yaml
       ];
       homepage = "https://github.com/valderman/domplate";
       description = "A simple templating library using HTML5 as its template language";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dot2graphml" = callPackage
    ({ mkDerivation, base, containers, graphviz, hxt, text }:
     mkDerivation {
       pname = "dot2graphml";
       version = "0.1.0.2";
       sha256 = "31e20e5aa13bd4735b7f21078dbcf8703e147b008805712ac8f13547c4e58ebb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers graphviz hxt text ];
       homepage = "http://redmine.iportnov.ru/projects/dot2graphml";
       description = "Converter from GraphViz .dot format to yEd GraphML";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dotenv" = callPackage
    ({ mkDerivation, base, base-compat, hspec, optparse-applicative
     , parsec, parseerror-eq, process
     }:
     mkDerivation {
       pname = "dotenv";
       version = "0.1.0.9";
       sha256 = "7e6546de1969bd0e3fcb8be864da3f103d19c4b10b173a807381969729cbed6c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base base-compat parsec ];
       executableHaskellDepends = [
         base base-compat optparse-applicative parsec process
       ];
       testHaskellDepends = [
         base base-compat hspec parsec parseerror-eq
       ];
       homepage = "https://github.com/stackbuilders/dotenv-hs";
       description = "Loads environment variables from dotenv files";
       license = stdenv.lib.licenses.mit;
     }) {};

  "dotfs" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , haskell-src, HFuse, HUnit, parsec, process, QuickCheck
     , template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, transformers, unix
     }:
     mkDerivation {
       pname = "dotfs";
       version = "0.1.1.3";
       sha256 = "2e112a0c1fbccb3a11cf82c3ef256ae5c853722c421037c7aa10d925770e4242";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers directory filepath haskell-src HFuse
         HUnit parsec process QuickCheck template-haskell test-framework
         test-framework-hunit test-framework-quickcheck2 transformers unix
       ];
       executableHaskellDepends = [
         base bytestring containers directory filepath HFuse parsec process
         transformers unix
       ];
       testHaskellDepends = [
         base containers haskell-src HUnit parsec QuickCheck
         template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2 transformers
       ];
       doHaddock = false;
       homepage = "http://github.com/toothbrush/dotfs";
       description = "Filesystem to manage and parse dotfiles";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "dotgen" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "dotgen";
       version = "0.4.2";
       sha256 = "cf0de20a435d74aeb9a32b8bcb3ebfa1b6659ac3f26edefe2df9e1aaf1481891";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/ku-fpg/dotgen";
       description = "A simple interface for building .dot graph files.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "double-conversion" = callPackage
    ({ mkDerivation, base, bytestring, ghc-prim, integer-gmp
     , test-framework, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "double-conversion";
       version = "2.0.1.0";
       sha256 = "0072b5b05631081c2eb73cda9dd660e384a7e988d3867b8b05540ef7648a920c";
       libraryHaskellDepends = [
         base bytestring ghc-prim integer-gmp text
       ];
       testHaskellDepends = [
         base bytestring test-framework test-framework-quickcheck2 text
       ];
       homepage = "https://github.com/bos/double-conversion";
       description = "Fast conversion between double precision floating point and text";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "double-metaphone" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "double-metaphone";
       version = "0.0.1";
       sha256 = "7a73926453e670475b350a7a4474fc871efacec42b150cd767c3ea34426be5d1";
       revision = "1";
       editedCabalFile = "bd8a01ddbe3c8ed20556e0f16f3bced93c6867ac51b859bd91ff8c04bf5fddde";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "https://github.com/christian-marie/double-metaphone";
       description = "Haskell bindings to a C double-metaphone implementation";
       license = "GPL";
     }) {};

  "dove" = callPackage
    ({ mkDerivation, acl2, base }:
     mkDerivation {
       pname = "dove";
       version = "0.0.0";
       sha256 = "8dcb014191b11835b56523b0940cc3c83cf4205d75a43ad5d274b1debb8d03a6";
       libraryHaskellDepends = [ acl2 base ];
       description = "The Dove verification language";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dow" = callPackage
    ({ mkDerivation, array, base, directory, elerea, GLFW
     , mersenne-random, OpenGL
     }:
     mkDerivation {
       pname = "dow";
       version = "0.2.5";
       sha256 = "34ddcc6606724c54ece1a98b6131ecde4ac5adefec83a4a04c847bc05df37497";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base directory elerea GLFW mersenne-random OpenGL
       ];
       description = "Dungeons of Wor";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "download" = callPackage
    ({ mkDerivation, base, bytestring, feed, tagsoup, xml }:
     mkDerivation {
       pname = "download";
       version = "0.3.2";
       sha256 = "839f46eae433b824e7013b84cfd253134a718319949447ad2b6cb28411760b5a";
       libraryHaskellDepends = [ base bytestring feed tagsoup xml ];
       homepage = "http://code.haskell.org/~dons/code/download";
       description = "High-level file download based on URLs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "download-curl" = callPackage
    ({ mkDerivation, base, bytestring, curl, feed, tagsoup, xml }:
     mkDerivation {
       pname = "download-curl";
       version = "0.1.4";
       sha256 = "950ede497ff41d72875337861fa41ca3e151b691ad53a9ddddd2443285bbc3f1";
       revision = "1";
       editedCabalFile = "7e6df1d4f39879e9b031c8ff5e2f6fd5be3729cc40f7515e117ac0b47ed3f675";
       libraryHaskellDepends = [ base bytestring curl feed tagsoup xml ];
       homepage = "http://code.haskell.org/~dons/code/download-curl";
       description = "High-level file download based on URLs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "download-media-content" = callPackage
    ({ mkDerivation, base, bytestring, filepath, http-enumerator
     , tagsoup, text
     }:
     mkDerivation {
       pname = "download-media-content";
       version = "0.0.0.1";
       sha256 = "e69bec8d560efd1f66de7c391af9b5214dda0812151a1649eb46e821411844ae";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring filepath http-enumerator tagsoup text
       ];
       jailbreak = true;
       homepage = "http://github.com/jaspervdj/download-media-content";
       description = "Simple tool to download images from RSS feeds (e.g. Flickr, Picasa)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dozenal" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "dozenal";
       version = "0.1.0.0";
       sha256 = "3448b747cb22e61f7939a56a3f238e72ed702d1d49899fa9dc787935a4ef1b6b";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/siddhanathan/dozenal";
       description = "A Haskell library for using Dozenal (Duodecimal - Base 12) numbers";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "dozens" = callPackage
    ({ mkDerivation, aeson, base, bytestring, data-default-class
     , http-client, http-types, reflection, scientific, text
     , transformers
     }:
     mkDerivation {
       pname = "dozens";
       version = "0.1.1";
       sha256 = "7e16121b2ee5e4bbdda47c11d956828ed0e5646723ff2b6e469d3c950c6b7ac3";
       revision = "1";
       editedCabalFile = "08e6297d7be6ec753261aa5cb8f265a6ba6c369f44d25f46f9784ae1d8a88e52";
       libraryHaskellDepends = [
         aeson base bytestring data-default-class http-client http-types
         reflection scientific text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/philopon/dozens-hs";
       description = "dozens api library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "dph-base" = callPackage
    ({ mkDerivation, array, base, ghc-prim, pretty, random, vector }:
     mkDerivation {
       pname = "dph-base";
       version = "0.7.0.1";
       sha256 = "be0477927fdbafb392d5d89a08d0a1cef17c01b38f07c255b3be3f4a12042ca7";
       libraryHaskellDepends = [
         array base ghc-prim pretty random vector
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell";
       description = "Data Parallel Haskell common config and debugging functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dph-examples" = callPackage
    ({ mkDerivation, base, containers, dph-base, dph-lifted-vseg
     , dph-prim-par, HUnit, old-time, parseargs, random, vector
     }:
     mkDerivation {
       pname = "dph-examples";
       version = "0.7.0.5";
       sha256 = "7fb2eddf79c9410126c15e063e609a6e97e52c338b79ac71499dd5fb344472e1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers dph-base dph-lifted-vseg dph-prim-par HUnit
         old-time parseargs random vector
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell";
       description = "Data Parallel Haskell example programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dph-lifted-base" = callPackage
    ({ mkDerivation, array, base, containers, dph-base, dph-prim-par
     , ghc, pretty, random, template-haskell, vector
     }:
     mkDerivation {
       pname = "dph-lifted-base";
       version = "0.7.0.1";
       sha256 = "138809530026ac8089510c008442ca64a3eafc88dd79480e1c9ed6fb56a2e3be";
       libraryHaskellDepends = [
         array base containers dph-base dph-prim-par ghc pretty random
         template-haskell vector
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell";
       description = "Data Parallel Haskell common definitions used by other dph-lifted packages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dph-lifted-copy" = callPackage
    ({ mkDerivation, array, base, dph-base, dph-prim-par, ghc, random
     , template-haskell, vector
     }:
     mkDerivation {
       pname = "dph-lifted-copy";
       version = "0.7.0.1";
       sha256 = "b89ca3641c34a3366a5c67caabd04b235f74788d52e473d630a4d4bcb38a4a85";
       libraryHaskellDepends = [
         array base dph-base dph-prim-par ghc random template-haskell vector
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell";
       description = "Data Parallel Haskell lifted array combinators. (deprecated version)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dph-lifted-vseg" = callPackage
    ({ mkDerivation, array, base, containers, dph-base, dph-lifted-base
     , dph-prim-par, ghc, pretty, random, template-haskell, vector
     }:
     mkDerivation {
       pname = "dph-lifted-vseg";
       version = "0.7.0.1";
       sha256 = "852823874c3869041e7ad2ae823c0f6f83513315148b013bfef617d3fc3c786e";
       libraryHaskellDepends = [
         array base containers dph-base dph-lifted-base dph-prim-par ghc
         pretty random template-haskell vector
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell";
       description = "Data Parallel Haskell lifted array combinators";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dph-par" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "dph-par";
       version = "0.5.1.99";
       sha256 = "274584ca29e8c9bac8113255e75c1202dd1f3646c9b6922edf61f7051f6a4f33";
       doHaddock = false;
       homepage = "http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell";
       description = "(deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dph-prim-interface" = callPackage
    ({ mkDerivation, base, dph-base, random, vector }:
     mkDerivation {
       pname = "dph-prim-interface";
       version = "0.7.0.1";
       sha256 = "12c112d93d6705a5f21ec890f0c2ce248058f904e767237a3d2d1846fd1ba09e";
       libraryHaskellDepends = [ base dph-base random vector ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell";
       description = "Data Parallel Haskell segmented arrays. (abstract interface)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dph-prim-par" = callPackage
    ({ mkDerivation, base, dph-base, dph-prim-interface, dph-prim-seq
     , old-time, random, vector
     }:
     mkDerivation {
       pname = "dph-prim-par";
       version = "0.7.0.1";
       sha256 = "f786940755f304f5c3e047fff01470259f30390352ebf8ed2d2655b657cca78f";
       libraryHaskellDepends = [
         base dph-base dph-prim-interface dph-prim-seq old-time random
         vector
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell";
       description = "Data Parallel Haskell segmented arrays. (production version)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dph-prim-seq" = callPackage
    ({ mkDerivation, base, dph-base, dph-prim-interface, ghc-prim
     , primitive, random, vector
     }:
     mkDerivation {
       pname = "dph-prim-seq";
       version = "0.7.0.1";
       sha256 = "195b86f6221adc186f3affaaed3610445712e66a7b9caad0fbc789b93f2ee9bb";
       libraryHaskellDepends = [
         base dph-base dph-prim-interface ghc-prim primitive random vector
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell";
       description = "Data Parallel Haskell segmented arrays. (sequential implementation)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dph-seq" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "dph-seq";
       version = "0.5.1.99";
       sha256 = "f7f9940a42e945c4390d470ff4768ee628717273ed506fe1e60541af08c64683";
       doHaddock = false;
       homepage = "http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell";
       description = "(deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dpkg" = callPackage
    ({ mkDerivation, base, bindings-DSL, bytestring, dpkg, HUnit
     , libdpkg, monad-loops
     }:
     mkDerivation {
       pname = "dpkg";
       version = "0.0.3";
       sha256 = "b37c65b1df2b828d3f20c34498fb7725f9fc3d5ff4e8a0191edb4a8c779019af";
       libraryHaskellDepends = [
         base bindings-DSL bytestring monad-loops
       ];
       libraryPkgconfigDepends = [ libdpkg ];
       testHaskellDepends = [ base bytestring HUnit ];
       testSystemDepends = [ dpkg ];
       testPkgconfigDepends = [ libdpkg ];
       description = "libdpkg bindings";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) dpkg; libdpkg = null;};

  "drClickOn" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "drClickOn";
       version = "0.1";
       sha256 = "232bf1b01f9af4b13f9d7ff8b504e3b952e19e6ae969876f81b4972e14ae2c83";
       libraryHaskellDepends = [ base containers ];
       homepage = "https://github.com/cwi-swat/monadic-frp";
       description = "Monadic FRP";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "draw-poker" = callPackage
    ({ mkDerivation, base, random-shuffle, safe }:
     mkDerivation {
       pname = "draw-poker";
       version = "0.1.0.1";
       sha256 = "a78832b02fe72bcf83ce1970ecb7a863500fb3987a6a0c912150ad211d3e6199";
       revision = "1";
       editedCabalFile = "62a11039e0b634f0b372c28d87f6fe84f40a33981211c9f2bc077135abcef629";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base random-shuffle safe ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       homepage = "http://tune.hateblo.jp/entry/2015/05/12/023112";
       description = "playing draw poker";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "drawille" = callPackage
    ({ mkDerivation, base, containers, hspec, QuickCheck }:
     mkDerivation {
       pname = "drawille";
       version = "0.1.0.6";
       sha256 = "3282ca7d783580f95349ffd85b6f668f57a354aad74a84c37406fc8ef2636c09";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [ base containers hspec QuickCheck ];
       homepage = "https://github.com/yamadapc/haskell-drawille";
       description = "A port of asciimoo's drawille to haskell";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "dresdner-verkehrsbetriebe" = callPackage
    ({ mkDerivation, aeson, base, bytestring, HTTP, old-locale
     , optparse-applicative, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "dresdner-verkehrsbetriebe";
       version = "0.1.1";
       sha256 = "380af7c7a9181b3d8b3a9e1bce271a71071781d3055a669b31492217f6c8babf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring HTTP old-locale time unordered-containers
         vector
       ];
       executableHaskellDepends = [
         aeson base bytestring HTTP old-locale optparse-applicative time
         unordered-containers vector
       ];
       jailbreak = true;
       description = "Library and program for querying DVB (Dresdner Verkehrsbetriebe AG)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "drifter" = callPackage
    ({ mkDerivation, base, containers, fgl, tasty, tasty-hunit
     , tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "drifter";
       version = "0.2.2";
       sha256 = "e47e0ceff7ff4e33c681719c6a1af3052f0c123c847dae2cb1fb73e08d3311e1";
       libraryHaskellDepends = [ base containers fgl text ];
       testHaskellDepends = [
         base tasty tasty-hunit tasty-quickcheck text
       ];
       homepage = "https://github.com/AndrewRademacher/drifter";
       description = "Simple schema management for arbitrary databases";
       license = stdenv.lib.licenses.mit;
     }) {};

  "drifter-postgresql" = callPackage
    ({ mkDerivation, base, drifter, either, mtl, postgresql-simple
     , tasty, tasty-hunit, text, time
     }:
     mkDerivation {
       pname = "drifter-postgresql";
       version = "0.0.2";
       sha256 = "07fbd1e08b517d2fde939657237c7a05f2b1d1abe276681ab7254b1ab8415190";
       libraryHaskellDepends = [
         base drifter either mtl postgresql-simple time
       ];
       testHaskellDepends = [
         base drifter either postgresql-simple tasty tasty-hunit text
       ];
       doCheck = false;
       description = "PostgreSQL support for the drifter schema migration tool";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dropbox-sdk" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , certificate, conduit, HTTP, http-conduit, http-types, json
     , monad-control, network, old-locale, pem, resourcet
     , template-haskell, time, tls, tls-extra, transformers, urlencoded
     , utf8-string
     }:
     mkDerivation {
       pname = "dropbox-sdk";
       version = "0.3.1";
       sha256 = "c2f7531f7aa2e2026e92de784ec43e4534fbd06035d8cae79c2c4aaf429c0ae8";
       libraryHaskellDepends = [
         base blaze-builder bytestring case-insensitive certificate conduit
         HTTP http-conduit http-types json monad-control network old-locale
         pem resourcet template-haskell time tls tls-extra transformers
         urlencoded utf8-string
       ];
       jailbreak = true;
       homepage = "http://github.com/cakoose/dropbox-sdk-haskell";
       description = "A library to access the Dropbox HTTP API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dropsolve" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, haskell98
     , process, regex-posix, time
     }:
     mkDerivation {
       pname = "dropsolve";
       version = "0.1.2.1";
       sha256 = "f72dc80151190d4dc42fa0698ec383f9e5e2c7a234db85e12ebec9501ccb3bdb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath haskell98 process regex-posix
         time
       ];
       jailbreak = true;
       description = "A command line tool for resolving dropbox conflicts. Deprecated! Please use confsolve.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ds-kanren" = callPackage
    ({ mkDerivation, base, containers, logict, QuickCheck, tasty
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "ds-kanren";
       version = "0.2.0.1";
       sha256 = "d31d29f938bae1f4fccc8e66269c90760d908a32a49358c1850a5b594ac34f93";
       libraryHaskellDepends = [ base containers logict ];
       testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
       description = "A subset of the miniKanren language";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dsh-sql" = callPackage
    ({ mkDerivation, aeson, algebra-dag, algebra-sql, base, bytestring
     , bytestring-lexing, containers, Decimal, DSH, either, HDBC
     , HDBC-odbc, HUnit, mtl, process, QuickCheck, random, semigroups
     , set-monad, template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, vector
     }:
     mkDerivation {
       pname = "dsh-sql";
       version = "0.2.0.2";
       sha256 = "a8e0b26973d9154517e973477fbe85d33d0e49c69b84266550dfdeb9dee22103";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson algebra-dag algebra-sql base bytestring bytestring-lexing
         containers Decimal DSH either HDBC HDBC-odbc mtl process random
         semigroups set-monad template-haskell text vector
       ];
       executableHaskellDepends = [
         base bytestring bytestring-lexing containers DSH HDBC HDBC-odbc
         HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 text vector
       ];
       description = "SQL backend for Database Supported Haskell (DSH)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dsmc" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, entropy
     , hslogger, mwc-random, parallel, primitive, repa, strict
     , transformers, vector
     }:
     mkDerivation {
       pname = "dsmc";
       version = "0.1.0.1";
       sha256 = "45a9ff4df48bc5e887f41da37b03e96acaa637b777ec3a00cd004937fa12426d";
       libraryHaskellDepends = [
         attoparsec base bytestring containers entropy hslogger mwc-random
         parallel primitive repa strict transformers vector
       ];
       jailbreak = true;
       description = "DSMC library for rarefied gas dynamics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dsmc-tools" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, ConfigFile, dsmc, gloss
     , gloss-raster, hslogger, mtl, repa, strict, transformers, vector
     }:
     mkDerivation {
       pname = "dsmc-tools";
       version = "0.1.0.1";
       sha256 = "204badac3a0c1d2550c939f0c874a657b64ca5d9834505d069bc0dc7780b3e73";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs ConfigFile dsmc gloss gloss-raster hslogger
         mtl repa strict transformers vector
       ];
       jailbreak = true;
       description = "DSMC toolkit for rarefied gas dynamics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dson" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "dson";
       version = "0.3.0.0";
       sha256 = "2d81d82fae1094ca89e098e94f28f8a196e7186d68f612fba92ad3808192f896";
       libraryHaskellDepends = [ base parsec ];
       jailbreak = true;
       homepage = "https://github.com/lcycon/hs-dson";
       description = "Haskell DogeScript Object Notation Parser";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "dson-parsec" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "dson-parsec";
       version = "0.4.1.1";
       sha256 = "3ea53b41913dd9e0cc44c4000afb5377e7da78fd314363b5d6f77c0677fad4fd";
       libraryHaskellDepends = [ base parsec ];
       jailbreak = true;
       homepage = "https://github.com/alvare/dson-parsec";
       description = "DSON parser";
       license = stdenv.lib.licenses.mit;
     }) {};

  "dsp" = callPackage
    ({ mkDerivation, array, base, random }:
     mkDerivation {
       pname = "dsp";
       version = "0.2.3.1";
       sha256 = "d5c21c9bf0a7c40b4a7f1bfed04250251a770d3a3c1935ba0b358bc43191dda2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base random ];
       executableHaskellDepends = [ array base ];
       homepage = "http://www.haskell.org/haskellwiki/DSP";
       description = "Haskell Digital Signal Processing";
       license = "GPL";
     }) {};

  "dstring" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, dlist }:
     mkDerivation {
       pname = "dstring";
       version = "0.4.0.4";
       sha256 = "152b48970e4b4fdb0cf0c5ef53cda1e76dd82ea89e948a03eef020ed600bfe97";
       libraryHaskellDepends = [ base base-unicode-symbols dlist ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/dstring";
       description = "Difference strings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dtab" = callPackage
    ({ mkDerivation, alex, array, base, binary, bytestring, containers
     , data-binary-ieee754, happy, pretty, transformers
     }:
     mkDerivation {
       pname = "dtab";
       version = "1.0.0.1";
       sha256 = "d696fd2a9019c9b4916831f88217f92f809dc4341b5ffc506f8e786d91bbe069";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers data-binary-ieee754 pretty
         transformers
       ];
       libraryToolDepends = [ alex happy ];
       executableHaskellDepends = [ base bytestring ];
       description = "Harmonix (Guitar Hero, Rock Band) DTA/DTB metadata library";
       license = "GPL";
     }) {};

  "dtd" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-conduit, base
     , blaze-builder, conduit, containers, lifted-base, monad-control
     , network, resourcet, text, transformers, uri-conduit, xml-catalog
     , xml-conduit, xml-types
     }:
     mkDerivation {
       pname = "dtd";
       version = "1.1.0.2";
       sha256 = "d767ac62a1435a661d93bab3f0811ceccaf86fcdff64c66617369bc1bbae5887";
       libraryHaskellDepends = [
         attoparsec attoparsec-conduit base blaze-builder conduit containers
         lifted-base monad-control network resourcet text transformers
         uri-conduit xml-catalog xml-conduit xml-types
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/xml";
       description = "Parse and render DTD files (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dtd-text" = callPackage
    ({ mkDerivation, attoparsec, base, containers, dtd-types, text
     , xml-types
     }:
     mkDerivation {
       pname = "dtd-text";
       version = "0.1.2.0";
       sha256 = "48ab2001214d9876a035c64ac66ecb919786539d5abbb930a9595d25ca7ffeb3";
       libraryHaskellDepends = [
         attoparsec base containers dtd-types text xml-types
       ];
       homepage = "http://github.com/m15k/hs-dtd-text";
       description = "Parse and render XML DTDs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dtd-types" = callPackage
    ({ mkDerivation, base, text, xml-types }:
     mkDerivation {
       pname = "dtd-types";
       version = "0.3.0.1";
       sha256 = "4783851e854f163a863da519e371ba775edcdfee9c2cdcf21344d889568a56f0";
       libraryHaskellDepends = [ base text xml-types ];
       homepage = "http://projects.haskell.org/dtd/";
       description = "Basic types for representing XML DTDs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dtrace" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "dtrace";
       version = "0.1";
       sha256 = "393b9e0f3ed92d2b817ae162ad5478116d001ec8e05ddf3c65a0334029a45f63";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       description = "Haskell interface to the DTrace system tracing utility";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dtw" = callPackage
    ({ mkDerivation, base, containers, QuickCheck, test-framework
     , test-framework-quickcheck2, thyme, vector, vector-space
     }:
     mkDerivation {
       pname = "dtw";
       version = "1.0.1.0";
       sha256 = "13fe55aa1ecb667ad5d56967e578dafbae527721dcb90e317f5a5f5452461397";
       libraryHaskellDepends = [ base containers vector vector-space ];
       testHaskellDepends = [
         base containers QuickCheck test-framework
         test-framework-quickcheck2 thyme vector vector-space
       ];
       jailbreak = true;
       description = "(Fast) Dynamic Time Warping";
       license = stdenv.lib.licenses.mit;
     }) {};

  "dual-tree_0_2_0_5" = callPackage
    ({ mkDerivation, base, monoid-extras, newtype, semigroups }:
     mkDerivation {
       pname = "dual-tree";
       version = "0.2.0.5";
       sha256 = "e5494ad416e5da396fd2aa66a8fbb669f14eb6b13905025a143675535396f61c";
       libraryHaskellDepends = [ base monoid-extras newtype semigroups ];
       jailbreak = true;
       description = "Rose trees with cached and accumulating monoidal annotations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dual-tree_0_2_0_6" = callPackage
    ({ mkDerivation, base, monoid-extras, newtype, semigroups }:
     mkDerivation {
       pname = "dual-tree";
       version = "0.2.0.6";
       sha256 = "9ba928efb967f180c7a8319d3f76faf072cf20f588709187714fac931df3b57d";
       libraryHaskellDepends = [ base monoid-extras newtype semigroups ];
       jailbreak = true;
       description = "Rose trees with cached and accumulating monoidal annotations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dual-tree_0_2_0_7" = callPackage
    ({ mkDerivation, base, monoid-extras, newtype, semigroups }:
     mkDerivation {
       pname = "dual-tree";
       version = "0.2.0.7";
       sha256 = "2b7e99ead18f1b42968c29717ed83b8a342aec1ab96030909de7e2071fb8df36";
       libraryHaskellDepends = [ base monoid-extras newtype semigroups ];
       jailbreak = true;
       description = "Rose trees with cached and accumulating monoidal annotations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dual-tree_0_2_0_8" = callPackage
    ({ mkDerivation, base, monoid-extras, newtype, semigroups }:
     mkDerivation {
       pname = "dual-tree";
       version = "0.2.0.8";
       sha256 = "53c5829fc5567f6e76adc3666c9db2755d17f606e0c5789bc00e0d6b7b97c273";
       libraryHaskellDepends = [ base monoid-extras newtype semigroups ];
       description = "Rose trees with cached and accumulating monoidal annotations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dual-tree" = callPackage
    ({ mkDerivation, base, monoid-extras, newtype, semigroups }:
     mkDerivation {
       pname = "dual-tree";
       version = "0.2.0.9";
       sha256 = "5e7d0abb471962df00c5adc53fa9a48f70c9695d5fdf225deecfa040116576a4";
       libraryHaskellDepends = [ base monoid-extras newtype semigroups ];
       description = "Rose trees with cached and accumulating monoidal annotations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dump" = callPackage
    ({ mkDerivation, base, haskell-src-meta, hspec
     , interpolatedstring-perl6, QuickCheck, template-haskell, text
     }:
     mkDerivation {
       pname = "dump";
       version = "0.2.8";
       sha256 = "043eb0a2695b97df6a9feada6caf114561d4f26d46082d505fee51513be31c5c";
       libraryHaskellDepends = [
         base haskell-src-meta interpolatedstring-perl6 template-haskell
         text
       ];
       testHaskellDepends = [
         base haskell-src-meta hspec interpolatedstring-perl6 QuickCheck
         template-haskell text
       ];
       homepage = "https://github.com/Wizek/dump";
       description = "Dumps the names and values of expressions to ease debugging";
       license = stdenv.lib.licenses.mit;
     }) {};

  "duplo" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, ansi-terminal, base
     , base64-bytestring, bytestring, containers, directory
     , executable-path, filepath, fsnotify, http-types, HUnit
     , language-javascript, lens, MissingH, mtl, process, QuickCheck
     , regex-compat, scotty, shake, system-fileio, system-filepath
     , tasty, tasty-hunit, tasty-quickcheck, text, text-format
     , transformers, unordered-containers, utf8-string, wai, warp
     }:
     mkDerivation {
       pname = "duplo";
       version = "1.8.1";
       sha256 = "71106816e0d59f4e2e4cab27da8a47da5745ba07dae36d52e7f878aa0848c3cc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty ansi-terminal base bytestring containers
         directory executable-path filepath fsnotify http-types
         language-javascript lens MissingH mtl regex-compat scotty shake
         system-fileio text text-format transformers unordered-containers
         utf8-string wai warp
       ];
       executableHaskellDepends = [
         aeson aeson-pretty ansi-terminal base base64-bytestring bytestring
         containers directory filepath fsnotify http-types
         language-javascript lens MissingH mtl process regex-compat scotty
         shake system-filepath text text-format transformers
         unordered-containers wai warp
       ];
       testHaskellDepends = [
         base HUnit MissingH QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       jailbreak = true;
       description = "Frontend development build tool";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dvda" = callPackage
    ({ mkDerivation, ad, base, containers, directory, fgl
     , file-location, graphviz, hashable, hashtables, mtl, process
     , QuickCheck, test-framework, test-framework-quickcheck2
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "dvda";
       version = "0.4";
       sha256 = "e87ac199fbfbe858913031525cf3c443b0cd8835364430d530d976fc6bdb0ae1";
       libraryHaskellDepends = [
         base containers hashable hashtables mtl unordered-containers vector
       ];
       testHaskellDepends = [
         ad base containers directory fgl file-location graphviz hashable
         hashtables mtl process QuickCheck test-framework
         test-framework-quickcheck2 unordered-containers
       ];
       description = "Efficient automatic differentiation and code generation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dvdread" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, dvdread, mtl }:
     mkDerivation {
       pname = "dvdread";
       version = "0.1";
       sha256 = "1574e74c078841177b3ca2284e3742b628992d714ae1fb3d3183b34f72aab8d3";
       libraryHaskellDepends = [ base bytestring mtl ];
       libraryPkgconfigDepends = [ dvdread ];
       libraryToolDepends = [ c2hs ];
       description = "A monadic interface to libdvdread";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {dvdread = null;};

  "dvi-processing" = callPackage
    ({ mkDerivation, base, bytestring, filepath, transformers }:
     mkDerivation {
       pname = "dvi-processing";
       version = "0.3.1";
       sha256 = "8328acb050181a69e64aadcf102001554967da2e06aef56d41dad29d2b53e636";
       libraryHaskellDepends = [ base bytestring filepath transformers ];
       jailbreak = true;
       description = "Read/write DVI and TFM file";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "dvorak" = callPackage
    ({ mkDerivation, base, containers, hspec, QuickCheck }:
     mkDerivation {
       pname = "dvorak";
       version = "0.1.0.0";
       sha256 = "afc8ba89415a01039ccdc719b875826b6b12befb4a6a97bcd7544f22eaffb6cf";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "https://github.com/kvanberendonck/codec-dvorak";
       description = "Dvorak encoding for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dwarf" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers }:
     mkDerivation {
       pname = "dwarf";
       version = "0.23";
       sha256 = "f4eb66aa1d9607bd3f5f4c1f30704a6aa79c0a2a3f2a3297c5e033240cfccb40";
       libraryHaskellDepends = [ base binary bytestring containers ];
       description = "Parser for DWARF debug format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dwarf-el" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, transformers
     , utf8-string
     }:
     mkDerivation {
       pname = "dwarf-el";
       version = "0.2.1.1";
       sha256 = "3c24b3f26b2cde8837ac008c91691050b9c352fed93df9fcd3ab9f1af6006aa1";
       libraryHaskellDepends = [
         base binary bytestring containers transformers utf8-string
       ];
       description = "Parser for DWARF debug format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dwarfadt" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-mmap, containers
     , dwarf-el, elf, lens, pretty, transformers
     }:
     mkDerivation {
       pname = "dwarfadt";
       version = "0.4";
       sha256 = "1106b9c4bfc88dd4272c927f373a610bd341cb9091603e757ac061a1b4d9bf96";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring bytestring-mmap containers dwarf-el elf lens pretty
         transformers
       ];
       executableHaskellDepends = [ base containers dwarf-el ];
       jailbreak = true;
       description = "High-level wrapper around the dwarf library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dx9base" = callPackage
    ({ mkDerivation, base, Win32 }:
     mkDerivation {
       pname = "dx9base";
       version = "0.1.1";
       sha256 = "71f8e2a11508bc6c1a3042d550268755970fe9c43e8bc54ed7e8c0e7faa5fc99";
       libraryHaskellDepends = [ base Win32 ];
       description = "Backend for a binding to the Microsoft DirectX 9 API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dx9d3d" = callPackage
    ({ mkDerivation, base, d3d9, dx9base, Win32 }:
     mkDerivation {
       pname = "dx9d3d";
       version = "0.1.1.1";
       sha256 = "325f9edb6cf6190d095824aa6ed29829c69ac4e8efeff2fecfd43ea9e4282ff9";
       libraryHaskellDepends = [ base dx9base Win32 ];
       librarySystemDepends = [ d3d9 ];
       description = "A binding to the Microsoft DirectX 9 API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {d3d9 = null;};

  "dx9d3dx" = callPackage
    ({ mkDerivation, base, d3dx9, dx9base, dx9d3d, Win32 }:
     mkDerivation {
       pname = "dx9d3dx";
       version = "0.1.1";
       sha256 = "c7b8bdb1950326178356bad5b845773a45a5a7bbbea9b98b4fb4bc300f5eb9d8";
       libraryHaskellDepends = [ base dx9base dx9d3d Win32 ];
       librarySystemDepends = [ d3dx9 ];
       description = "A binding to the Microsoft DirectX 9 D3DX API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {d3dx9 = null;};

  "dynamic-cabal" = callPackage
    ({ mkDerivation, base, containers, data-default, directory, doctest
     , filepath, ghc, ghc-paths, haskell-generate, haskell-src-exts
     , HUnit, tasty, tasty-hunit, tasty-th, time, void
     }:
     mkDerivation {
       pname = "dynamic-cabal";
       version = "0.3.5";
       sha256 = "bcf32d088006ed4f69566bed68279119d4ee3c76ff3602157b1eeca12f1c793a";
       libraryHaskellDepends = [
         base containers data-default directory filepath ghc ghc-paths
         haskell-generate haskell-src-exts time void
       ];
       testHaskellDepends = [
         base containers directory doctest filepath ghc HUnit tasty
         tasty-hunit tasty-th
       ];
       homepage = "http://github.com/bennofs/dynamic-cabal/";
       description = "Access the functions from the Cabal library without depending on it";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dynamic-graph" = callPackage
    ({ mkDerivation, base, cairo, colour, either, GLFW-b, GLUtil
     , OpenGL, pango, pipes, transformers
     }:
     mkDerivation {
       pname = "dynamic-graph";
       version = "0.1.0.8";
       sha256 = "b32c42edb14b0c0e4e112981ebd7169bbce9bc546c4275fc5fda865a3fe507d2";
       libraryHaskellDepends = [
         base cairo colour either GLFW-b GLUtil OpenGL pango pipes
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/adamwalker/dynamic-graph";
       description = "Draw and update graphs in real time with OpenGL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dynamic-linker-template" = callPackage
    ({ mkDerivation, base, containers, template-haskell, unix }:
     mkDerivation {
       pname = "dynamic-linker-template";
       version = "0.1.0.4";
       sha256 = "f865165fccac573099181bb1fd5f834c261894a2a7c2f8bd9bfa1645ee446d10";
       libraryHaskellDepends = [ base containers template-haskell unix ];
       homepage = "http://github.com/hsyl20/dynamic-linker-template";
       description = "Automatically derive dynamic linking methods from a data type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dynamic-loader" = callPackage
    ({ mkDerivation, base, directory, ghc-prim, hashable, hashtables
     , time, transformers
     }:
     mkDerivation {
       pname = "dynamic-loader";
       version = "0.0";
       sha256 = "20e23ae42814f96ffebc44d6091ae3edf6eec041dfa7be7e0f8bb9078ce39533";
       libraryHaskellDepends = [
         base directory ghc-prim hashable hashtables time transformers
       ];
       homepage = "https://github.com/ggreif/dynamic-loader";
       description = "lightweight loader of GHC-based modules or packages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dynamic-mvector" = callPackage
    ({ mkDerivation, base, primitive, vector }:
     mkDerivation {
       pname = "dynamic-mvector";
       version = "0.1.0.4";
       sha256 = "a36fc29ba4b91d52beb1f2df6ba8a837c6f112ef31358b20f5d0056f20d788a6";
       libraryHaskellDepends = [ base primitive vector ];
       homepage = "https://github.com/AndrasKovacs/dynamic-mvector";
       description = "A wrapper around MVector that enables pushing, popping and extending";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dynamic-object" = callPackage
    ({ mkDerivation, base, containers, doctest, ghc, hspec, lens, mtl
     , QuickCheck, text, transformers
     }:
     mkDerivation {
       pname = "dynamic-object";
       version = "0.2.1";
       sha256 = "8bbaad97cfa7d31507accfdf12ed9ef8c4a88f8101c14b8da9086c829be6f2f7";
       libraryHaskellDepends = [
         base containers lens mtl QuickCheck text transformers
       ];
       testHaskellDepends = [
         base doctest ghc hspec lens QuickCheck transformers
       ];
       description = "Object-oriented programming with duck typing and singleton classes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dynamic-plot" = callPackage
    ({ mkDerivation, async, base, colour, constrained-categories
     , containers, data-default, deepseq, diagrams-cairo, diagrams-core
     , diagrams-gtk, diagrams-lib, glib, gtk, lens, manifolds, MemoTrie
     , MonadRandom, mtl, process, random, semigroups, tagged, time
     , transformers, vector, vector-space
     }:
     mkDerivation {
       pname = "dynamic-plot";
       version = "0.1.2.0";
       sha256 = "9afd0f1a29dd23036d7f7a8da943ea1a015e8c2ceec628f0ffc946203689878f";
       libraryHaskellDepends = [
         async base colour constrained-categories containers data-default
         deepseq diagrams-cairo diagrams-core diagrams-gtk diagrams-lib glib
         gtk lens manifolds MemoTrie MonadRandom mtl process random
         semigroups tagged time transformers vector vector-space
       ];
       jailbreak = true;
       homepage = "https://github.com/leftaroundabout/dynamic-plot";
       description = "Interactive diagram windows";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dynamic-pp" = callPackage
    ({ mkDerivation, ansi-terminal, base, blaze-builder, bytestring
     , Cabal, hashable, HUnit-Plus, unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "dynamic-pp";
       version = "0.2.0";
       sha256 = "adad65d29f722f34b4c49764b0ec766f8996dd5121024f628fe15ad607d5c90f";
       libraryHaskellDepends = [
         ansi-terminal base blaze-builder bytestring Cabal hashable
         unordered-containers utf8-string
       ];
       testHaskellDepends = [
         ansi-terminal base blaze-builder bytestring Cabal hashable
         HUnit-Plus unordered-containers utf8-string
       ];
       homepage = "https://github.com/emc2/dynamic-pp";
       description = "A pretty-print library that employs a dynamic programming algorithm for optimal rendering";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dynamic-state_0_2_0_0" = callPackage
    ({ mkDerivation, base, binary, bytestring, hashable
     , unordered-containers
     }:
     mkDerivation {
       pname = "dynamic-state";
       version = "0.2.0.0";
       sha256 = "53a09c16380012b35079a7d41fca332fc94b55a0b0c929937af94cc9cad5e0b6";
       revision = "1";
       editedCabalFile = "640601c8531dae847d624eac78db22ce0343c1607040a7158454635f486e477c";
       libraryHaskellDepends = [
         base binary bytestring hashable unordered-containers
       ];
       description = "Optionally serializable dynamic state keyed by type";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dynamic-state" = callPackage
    ({ mkDerivation, base, binary, bytestring, hashable
     , unordered-containers
     }:
     mkDerivation {
       pname = "dynamic-state";
       version = "0.2.1.0";
       sha256 = "16094496ec20cddadce64491196000483e757d9011ce756447584a85adf1de05";
       libraryHaskellDepends = [
         base binary bytestring hashable unordered-containers
       ];
       description = "Optionally serializable dynamic state keyed by type";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "dynobud" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, casadi-bindings
     , casadi-bindings-core, cereal, Chart, Chart-gtk, cmdargs, colour
     , containers, data-default-class, directory, distributive, doctest
     , generic-accessors, hmatrix, hmatrix-gsl, HUnit, jacobi-roots
     , lens, linear, mtl, mwc-random, not-gloss, Plot-ho-matic, process
     , QuickCheck, reflection, semigroups, spatial-math, stm
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , time, unordered-containers, vector, vector-binary-instances
     , zeromq4-haskell
     }:
     mkDerivation {
       pname = "dynobud";
       version = "1.9.1.0";
       sha256 = "3995a1186ca493ae30fc38b72fbfa49b8f4b5858e266a9b6b24135267deedde5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base binary casadi-bindings casadi-bindings-core cereal
         containers data-default-class directory distributive
         generic-accessors hmatrix hmatrix-gsl jacobi-roots lens linear mtl
         mwc-random Plot-ho-matic process reflection spatial-math time
         vector vector-binary-instances
       ];
       executableHaskellDepends = [
         base bytestring casadi-bindings casadi-bindings-core cereal Chart
         Chart-gtk cmdargs colour containers data-default-class
         generic-accessors lens linear mtl not-gloss Plot-ho-matic
         semigroups stm time unordered-containers vector zeromq4-haskell
       ];
       testHaskellDepends = [
         base binary casadi-bindings cereal containers doctest hmatrix
         hmatrix-gsl HUnit linear QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 vector
       ];
       description = "your dynamic optimization buddy";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "dyre" = callPackage
    ({ mkDerivation, base, binary, directory, executable-path, filepath
     , ghc-paths, io-storage, process, 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
       ];
       homepage = "http://github.com/willdonnelly/dyre";
       description = "Dynamic reconfiguration in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "dywapitchtrack" = callPackage
    ({ mkDerivation, base, bytestring, transformers }:
     mkDerivation {
       pname = "dywapitchtrack";
       version = "0.1.0.1";
       sha256 = "ee7d3dab776e190aa16c9403580597e5128ca7f32837a0dd5d75b377bd42b6ba";
       libraryHaskellDepends = [ base bytestring transformers ];
       description = "Bindings to the dywapitchtrack pitch tracking library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "dzen-utils" = callPackage
    ({ mkDerivation, base, colour, process }:
     mkDerivation {
       pname = "dzen-utils";
       version = "0.1.1";
       sha256 = "c0e98d2d6f0ee80e3abac8987eb5885874ab9eb2b91cd64ce3cd5705883e4417";
       libraryHaskellDepends = [ base colour process ];
       description = "Utilities for creating inputs for dzen";
       license = "GPL";
     }) {};

  "eager-sockets" = callPackage
    ({ mkDerivation, base, bytestring, network }:
     mkDerivation {
       pname = "eager-sockets";
       version = "0.1";
       sha256 = "abbd5f7565685d756de895600b3f977863e56abd2a6dbda9b90a710841e1e881";
       revision = "1";
       editedCabalFile = "2bf99bcdc9b979fbe9394e8b77bd1fa9b713da8e04981939cb0ae41b0b2a1963";
       libraryHaskellDepends = [ base bytestring network ];
       jailbreak = true;
       description = "Socket operations with timeouts";
       license = "unknown";
     }) {};

  "easy-api" = callPackage
    ({ mkDerivation, aeson, base, bytestring, either, http-conduit, mtl
     , resourcet, text
     }:
     mkDerivation {
       pname = "easy-api";
       version = "0.1.0.0";
       sha256 = "2bd01b47d430c6eacd7842709866467a386282fcee012305732f2502cfda0432";
       libraryHaskellDepends = [
         aeson base bytestring either http-conduit mtl resourcet text
       ];
       jailbreak = true;
       homepage = "http://github.com/sanetracker/easy-api";
       description = "Utility code for building HTTP API bindings more quickly";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "easy-bitcoin" = callPackage
    ({ mkDerivation, aeson, base, base16-bytestring, binary, byteable
     , bytestring, cryptohash, deepseq, lens, postgresql-simple, safe
     , text
     }:
     mkDerivation {
       pname = "easy-bitcoin";
       version = "0.0.0.2";
       sha256 = "3b20ddd3f268e379bcf2a5c07f70de88ad5d936b59743caad10403f0e932f7b5";
       libraryHaskellDepends = [
         aeson base base16-bytestring binary byteable bytestring cryptohash
         deepseq lens postgresql-simple safe text
       ];
       homepage = "https://github.com/vwwv/easy-bitcoin";
       description = "types and functions for bitcoin applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "easy-file_0_2_0" = callPackage
    ({ mkDerivation, base, directory, filepath, time, unix }:
     mkDerivation {
       pname = "easy-file";
       version = "0.2.0";
       sha256 = "4a548fd47953f81ec2b528aa5d4e5cf36799a8cbac053f7df43b97807b9c1a6d";
       libraryHaskellDepends = [ base directory filepath time unix ];
       homepage = "http://github.com/kazu-yamamoto/easy-file";
       description = "Cross-platform File handling";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "easy-file" = callPackage
    ({ mkDerivation, base, directory, filepath, time, unix }:
     mkDerivation {
       pname = "easy-file";
       version = "0.2.1";
       sha256 = "ff86e1b29284499bea5f1d0ff539b3ed64fa6d1a06c2243ca61f93be0202e56c";
       libraryHaskellDepends = [ base directory filepath time unix ];
       homepage = "http://github.com/kazu-yamamoto/easy-file";
       description = "Cross-platform File handling";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "easyjson" = callPackage
    ({ mkDerivation, base, mtl, parsec, text, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "easyjson";
       version = "0.1.0.1";
       sha256 = "e2e9f5f68b94b89e766bc47bf81b0006a47852f524dde1960cf30ed6012686a4";
       libraryHaskellDepends = [
         base mtl parsec text unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/thinkpad20/easyjson";
       description = "Haskell JSON library with an emphasis on simplicity, minimal dependencies, and ease of use";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "easyplot" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "easyplot";
       version = "1.0";
       sha256 = "1347b6a5d9a4eb01a4db858dcbf347fd056f423dd719f5dc955709d9f66b76a2";
       libraryHaskellDepends = [ base process ];
       homepage = "http://hub.darcs.net/scravy/easyplot";
       description = "A tiny plotting library, utilizes gnuplot for plotting";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "easyrender" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, superdoc, zlib
     }:
     mkDerivation {
       pname = "easyrender";
       version = "0.1.1.0";
       sha256 = "eb0ca0d7622c7aed65787e92eb2c627a9e7153aaa4afc9f9981f6d4b7c020ec4";
       libraryHaskellDepends = [
         base bytestring containers mtl superdoc zlib
       ];
       homepage = "http://www.mathstat.dal.ca/~selinger/easyrender/";
       description = "User-friendly creation of EPS, PostScript, and PDF files";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ebeats" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "ebeats";
       version = "0.1.0";
       sha256 = "13978e3478583df04499345586b124eb1ec200ec219d71b9532ee7ee86a17764";
       libraryHaskellDepends = [ base time ];
       jailbreak = true;
       description = "Time in ebeats";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ebnf-bff" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cond, directory, parsec
     , text
     }:
     mkDerivation {
       pname = "ebnf-bff";
       version = "0.1.1.0";
       sha256 = "683ce685b605b83feb795ec3a832e4e83c284ad7daa0bb8cb2a7d9c96bd27d80";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ aeson base parsec text ];
       executableHaskellDepends = [
         aeson base bytestring cond directory parsec
       ];
       jailbreak = true;
       description = "Parser combinators & EBNF, BFFs!";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ec2-signature" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, doctest
     , hspec, http-types, HUnit, QuickCheck, SHA
     }:
     mkDerivation {
       pname = "ec2-signature";
       version = "3.1";
       sha256 = "e019622a3b773407757aaf215cc3a07029476a95583a6a473658544794f8fefb";
       libraryHaskellDepends = [
         base base64-bytestring bytestring http-types SHA
       ];
       testHaskellDepends = [
         base base64-bytestring bytestring doctest hspec http-types HUnit
         QuickCheck SHA
       ];
       homepage = "https://github.com/worksap-ate/ec2-signature";
       description = "The Amazon EC2 style signature calculator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ecdsa" = callPackage
    ({ mkDerivation, base, bytestring, crypto-api, crypto-pubkey-types
     , hecc
     }:
     mkDerivation {
       pname = "ecdsa";
       version = "0.2";
       sha256 = "16095f715c1fd26bb2381c0d9d147f1c0f6f1e65a99f8517e655baaf73aa008c";
       libraryHaskellDepends = [
         base bytestring crypto-api crypto-pubkey-types hecc
       ];
       homepage = "https://github.com/singpolyma/ecdsa-haskell";
       description = "Basic ECDSA signing implementation";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ecma262" = callPackage
    ({ mkDerivation, base, containers, data-default, lens, parsec, safe
     , transformers
     }:
     mkDerivation {
       pname = "ecma262";
       version = "0.0.0";
       sha256 = "f5216829a58e8490c074b4befc2a9cc34402d3c8f234107cc07d4afc9a2a71c3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers data-default lens parsec safe transformers
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/fabianbergmark/ECMA-262";
       description = "A ECMA-262 interpreter library";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ecu" = callPackage
    ({ mkDerivation, base, bytestring, canlib, digest, directory
     , process, vcd
     }:
     mkDerivation {
       pname = "ecu";
       version = "0.0.8";
       sha256 = "9203ab55db7e001e65286082a60b0cf6118e8b90dceffa93f0c25fee0f28cba9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring digest directory process vcd
       ];
       executableSystemDepends = [ canlib ];
       jailbreak = true;
       description = "Tools for automotive ECU development";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {canlib = null;};

  "ed25519" = callPackage
    ({ mkDerivation, base, bytestring, directory, doctest, filepath
     , ghc-prim, hlint, QuickCheck
     }:
     mkDerivation {
       pname = "ed25519";
       version = "0.0.5.0";
       sha256 = "d8a5958ebfa9309790efade64275dc5c441b568645c45ceed1b0c6ff36d6156d";
       revision = "1";
       editedCabalFile = "4e8742cc8e8bf5d078c68c9f550b06566c7a94df3ff3070cfe4c91cbee664f06";
       libraryHaskellDepends = [ base bytestring ghc-prim ];
       testHaskellDepends = [
         base bytestring directory doctest filepath hlint QuickCheck
       ];
       homepage = "http://thoughtpolice.github.com/hs-ed25519";
       description = "Ed25519 cryptographic signatures";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ed25519-donna" = callPackage
    ({ mkDerivation, base, bytestring, crypto-api }:
     mkDerivation {
       pname = "ed25519-donna";
       version = "0.1.1";
       sha256 = "6ddb25e72cb18b18e70ab9727a028c26acb0ffaa9dafafb42821c9f81d81f84e";
       libraryHaskellDepends = [ base bytestring crypto-api ];
       homepage = "github.com/tommd/hs-ed25519-donna";
       description = "Haskell bindings to ed25519-donna (Elliptical Curve Signature Scheme)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "eddie" = callPackage
    ({ mkDerivation, base, bifunctors, classy-prelude, hint
     , optparse-applicative, safe
     }:
     mkDerivation {
       pname = "eddie";
       version = "1.0.0";
       sha256 = "bd7f3cd868a32738e650f74c0a78f1f761ce742e35aa946ceb750c7a9bea02ff";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bifunctors classy-prelude hint optparse-applicative safe
       ];
       homepage = "http://chiselapp.com/user/mwm/repository/eddie/";
       description = "Command line file filtering with haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ede_0_2_8" = callPackage
    ({ mkDerivation, aeson, ansi-wl-pprint, base, bifunctors
     , bytestring, comonad, directory, filepath, free, lens, mtl
     , parsers, scientific, semigroups, tasty, tasty-golden, text
     , text-format, text-manipulate, trifecta, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "ede";
       version = "0.2.8";
       sha256 = "d0677fc67ce9e8b6a9b28e785998d1dd6affb4a93b5eac42e1b303538e96f8df";
       libraryHaskellDepends = [
         aeson ansi-wl-pprint base bifunctors bytestring comonad directory
         filepath free lens mtl parsers scientific semigroups text
         text-format text-manipulate trifecta unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bifunctors bytestring directory tasty tasty-golden text
       ];
       homepage = "http://github.com/brendanhay/ede";
       description = "Templating language with similar syntax and features to Liquid or Jinja2";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ede_0_2_8_2" = callPackage
    ({ mkDerivation, aeson, ansi-wl-pprint, base, bifunctors
     , bytestring, comonad, directory, filepath, free, lens, mtl
     , parsers, scientific, semigroups, tasty, tasty-golden, text
     , text-format, text-manipulate, trifecta, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "ede";
       version = "0.2.8.2";
       sha256 = "38bcc0b496a97460655ad2123fe521ac8bf142b9bddb0756c7775f95ec050b48";
       libraryHaskellDepends = [
         aeson ansi-wl-pprint base bifunctors bytestring comonad directory
         filepath free lens mtl parsers scientific semigroups text
         text-format text-manipulate trifecta unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bifunctors bytestring directory tasty tasty-golden text
       ];
       homepage = "http://github.com/brendanhay/ede";
       description = "Templating language with similar syntax and features to Liquid or Jinja2";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ede_0_2_8_3" = callPackage
    ({ mkDerivation, aeson, ansi-wl-pprint, base, bifunctors
     , bytestring, comonad, directory, filepath, free, lens, mtl
     , parsers, scientific, semigroups, tasty, tasty-golden, text
     , text-format, text-manipulate, trifecta, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "ede";
       version = "0.2.8.3";
       sha256 = "3433a901fc1fe54d14690a65366f3edcab9cff8934557fef29bdd520c3083ad7";
       libraryHaskellDepends = [
         aeson ansi-wl-pprint base bifunctors bytestring comonad directory
         filepath free lens mtl parsers scientific semigroups text
         text-format text-manipulate trifecta unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bifunctors bytestring directory tasty tasty-golden text
       ];
       homepage = "http://github.com/brendanhay/ede";
       description = "Templating language with similar syntax and features to Liquid or Jinja2";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ede" = callPackage
    ({ mkDerivation, aeson, ansi-wl-pprint, base, bifunctors
     , bytestring, comonad, directory, filepath, free, lens, mtl
     , parsers, scientific, semigroups, tasty, tasty-golden, text
     , text-format, text-manipulate, trifecta, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "ede";
       version = "0.2.8.4";
       sha256 = "f7fda7bc2d28b87fe7042adfca9fa9f7484c546142ad649dcae1d2ad4af5ae72";
       libraryHaskellDepends = [
         aeson ansi-wl-pprint base bifunctors bytestring comonad directory
         filepath free lens mtl parsers scientific semigroups text
         text-format text-manipulate trifecta unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bifunctors bytestring directory tasty tasty-golden text
       ];
       homepage = "http://github.com/brendanhay/ede";
       description = "Templating language with similar syntax and features to Liquid or Jinja2";
       license = "unknown";
     }) {};

  "edenmodules" = callPackage
    ({ mkDerivation, base, containers, deepseq, parallel }:
     mkDerivation {
       pname = "edenmodules";
       version = "1.2.0.0";
       sha256 = "b2532f00ead8fe8198c6208d72da43b4a5366ecaa8ad2828f359704dd3d26af1";
       libraryHaskellDepends = [ base containers deepseq parallel ];
       jailbreak = true;
       homepage = "http://www.mathematik.uni-marburg.de/~eden";
       description = "Semi-explicit parallel programming library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "edenskel" = callPackage
    ({ mkDerivation, base, edenmodules, parallel }:
     mkDerivation {
       pname = "edenskel";
       version = "2.1.0.0";
       sha256 = "38c9f12163d2a58d429d8f0064b502b7da35095a6889170340ca38d203ffc5ad";
       libraryHaskellDepends = [ base edenmodules parallel ];
       description = "Semi-explicit parallel programming skeleton library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "edentv" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, cairo, containers
     , directory, filepath, ghc-events-parallel, gtk, mtl, text
     , zip-archive
     }:
     mkDerivation {
       pname = "edentv";
       version = "4.10.0";
       sha256 = "6258569b18219f897ce62c9494ac4e707ea190aefd90f4cda914d53d8ada6c4a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base binary bytestring cairo containers directory filepath
         ghc-events-parallel gtk mtl text zip-archive
       ];
       homepage = "http://www.mathematik.uni-marburg.de/~eden";
       description = "A Tool to Visualize Parallel Functional Program Executions";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "edge" = callPackage
    ({ mkDerivation, ALUT, base, cmdtheline, containers, gloss, random
     , wraparound
     }:
     mkDerivation {
       pname = "edge";
       version = "0.9.0.2";
       sha256 = "7bfeedfc9db97e0d61c8650f9a542ddf3602f15ee6251141797fa035f82da965";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ALUT base cmdtheline containers gloss random wraparound
       ];
       jailbreak = true;
       homepage = "http://frigidcode.com/code/edge";
       description = "Top view space combat arcade game";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "edis" = callPackage
    ({ mkDerivation, base, bytestring, cereal, hedis }:
     mkDerivation {
       pname = "edis";
       version = "0.0.1.0";
       sha256 = "b21590a3ce7cc3314e9cf4b5bfba0f4997f050fe2087ab4b1852554914b6f6af";
       libraryHaskellDepends = [ base bytestring cereal hedis ];
       description = "Statically typechecked client for Redis";
       license = stdenv.lib.licenses.mit;
     }) {};

  "edit-distance_0_2_1_2" = callPackage
    ({ mkDerivation, array, base, containers, random }:
     mkDerivation {
       pname = "edit-distance";
       version = "0.2.1.2";
       sha256 = "84bcc319f4b7dc48994de082819bc656e6a001fdf40c2f7327b9a2acc2d5bd21";
       revision = "1";
       editedCabalFile = "27d6fb19e1707aa05883ca4ffd6715dcc81db287c71508d6aaa420cefc8f29c1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base containers random ];
       jailbreak = true;
       homepage = "http://github.com/batterseapower/edit-distance";
       description = "Levenshtein and restricted Damerau-Levenshtein edit distances";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "edit-distance_0_2_1_3" = callPackage
    ({ mkDerivation, array, base, containers, random }:
     mkDerivation {
       pname = "edit-distance";
       version = "0.2.1.3";
       sha256 = "a0b2e59ab50b30af604681eba822b15bbb90d9b477b8d233a6f12b1fd4c9dac6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base containers random ];
       homepage = "http://github.com/batterseapower/edit-distance";
       description = "Levenshtein and restricted Damerau-Levenshtein edit distances";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "edit-distance" = callPackage
    ({ mkDerivation, array, base, containers, QuickCheck, random
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "edit-distance";
       version = "0.2.2.1";
       sha256 = "3e8885ee2f56ad4da940f043ae8f981ee2fe336b5e8e4ba3f7436cff4f526c4a";
       libraryHaskellDepends = [ array base containers random ];
       testHaskellDepends = [
         array base containers QuickCheck random test-framework
         test-framework-quickcheck2
       ];
       homepage = "http://github.com/phadej/edit-distance";
       description = "Levenshtein and restricted Damerau-Levenshtein edit distances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "edit-distance-vector_1_0_0_2" = callPackage
    ({ mkDerivation, base, QuickCheck, quickcheck-instances, vector }:
     mkDerivation {
       pname = "edit-distance-vector";
       version = "1.0.0.2";
       sha256 = "0575644e8a1c37135a59da0b3665a5d9dee0aa5a63834d7ea9ab7c7e64a54002";
       libraryHaskellDepends = [ base vector ];
       testHaskellDepends = [
         base QuickCheck quickcheck-instances vector
       ];
       homepage = "https://github.com/thsutton/edit-distance-vector";
       description = "Calculate edit distances and edit scripts between vectors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "edit-distance-vector" = callPackage
    ({ mkDerivation, base, QuickCheck, quickcheck-instances, vector }:
     mkDerivation {
       pname = "edit-distance-vector";
       version = "1.0.0.3";
       sha256 = "a52670b6887d9cc852243fdd2adbb89e7cf152188f4b698d67d9825cef8d375b";
       libraryHaskellDepends = [ base vector ];
       testHaskellDepends = [
         base QuickCheck quickcheck-instances vector
       ];
       homepage = "https://github.com/thsutton/edit-distance-vector";
       description = "Calculate edit distances and edit scripts between vectors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "edit-lenses" = callPackage
    ({ mkDerivation, base, containers, data-default, lattices, mtl }:
     mkDerivation {
       pname = "edit-lenses";
       version = "0.2";
       sha256 = "ca531695a14a2bb8e8e952ed401e4eefe1e6c48b5dfde5804ee76034705e37db";
       libraryHaskellDepends = [
         base containers data-default lattices mtl
       ];
       description = "Symmetric, stateful edit lenses";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "edit-lenses-demo" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "edit-lenses-demo";
       version = "0.1";
       sha256 = "ec7a4a7265d096c84e39ccd83cfcdb573190d11340c8563879d5ceba208f7d37";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       description = "Programs demoing the use of symmetric, stateful edit lenses";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "editable" = callPackage
    ({ mkDerivation, base, text, vty, vty-ui }:
     mkDerivation {
       pname = "editable";
       version = "1.0.0.2";
       sha256 = "b17b208bb6fd39d62a90091640b39270fd0d24cd9bcc6f47f3a8f511d2025f96";
       libraryHaskellDepends = [ base text vty vty-ui ];
       jailbreak = true;
       homepage = "https://github.com/maxpow4h/editable";
       description = "Interactive editors for Generics";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "editline" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "editline";
       version = "0.2.1.1";
       sha256 = "9fb64f89a38ad847de7d3537e9dff75d8fcebd12fc789a175cc892a0e4873f80";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://code.haskell.org/editline";
       description = "Bindings to the editline library (libedit)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "editor-open" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , directory, process, resourcet, temporary, transformers, unix
     }:
     mkDerivation {
       pname = "editor-open";
       version = "0.6.0.0";
       sha256 = "2fc5d19bce2d477935202a5a4522671529d0352a0ee28be1307f8ab391065265";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra directory process resourcet
         temporary transformers unix
       ];
       executableHaskellDepends = [
         base bytestring conduit conduit-extra resourcet
       ];
       homepage = "https://github.com/pharpend/editor-open";
       description = "Open the user's $VISUAL or $EDITOR for text input";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "effect-handlers_0_1_0_6" = callPackage
    ({ mkDerivation, base, free, hspec, hspec-discover, HUnit
     , kan-extensions, mtl, QuickCheck
     }:
     mkDerivation {
       pname = "effect-handlers";
       version = "0.1.0.6";
       sha256 = "c97f5c9ba0b2d9020bd7aa4a752900b329eb90534b7dfbbf77b70cc8e1a3ef44";
       libraryHaskellDepends = [ base free kan-extensions mtl ];
       testHaskellDepends = [
         base hspec hspec-discover HUnit QuickCheck
       ];
       homepage = "https://github.com/edofic/effect-handlers";
       description = "A library for writing extensible algebraic effects and handlers. Similar to extensible-effects but with deep handlers.";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "effect-handlers" = callPackage
    ({ mkDerivation, base, free, hspec, hspec-discover, HUnit
     , kan-extensions, mtl, QuickCheck
     }:
     mkDerivation {
       pname = "effect-handlers";
       version = "0.1.0.7";
       sha256 = "42649d2d1b02759e4c455cf36eb968a1496b8de83a3ffbeb1e1d7e6a9efa41f5";
       libraryHaskellDepends = [ base free kan-extensions mtl ];
       testHaskellDepends = [
         base hspec hspec-discover HUnit QuickCheck
       ];
       homepage = "https://github.com/edofic/effect-handlers";
       description = "A library for writing extensible algebraic effects and handlers. Similar to extensible-effects but with deep handlers.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "effect-monad" = callPackage
    ({ mkDerivation, base, ghc-prim, type-level-sets }:
     mkDerivation {
       pname = "effect-monad";
       version = "0.6.1";
       sha256 = "884b7f1b26767329051ca846ad20cef871decd992f63c2d7d50475b163d3724d";
       revision = "2";
       editedCabalFile = "5cb34f683ee8c60c89647fd5a283cbe4b640a596cf2608a937a0819503e3b3ea";
       libraryHaskellDepends = [ base ghc-prim type-level-sets ];
       jailbreak = true;
       description = "Embeds effect systems into Haskell using parameteric effect monads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "effective-aspects" = callPackage
    ({ mkDerivation, base, Cabal, ghc-prim, hashtables, HUnit, mtl
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "effective-aspects";
       version = "0.1.0.0";
       sha256 = "5108cc8d15fea847499715e9de91ea19d7d56b03b5017115c415719458fb8c41";
       libraryHaskellDepends = [
         base ghc-prim hashtables HUnit mtl QuickCheck
       ];
       testHaskellDepends = [
         base Cabal ghc-prim hashtables HUnit mtl QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://pleiad.cl/EffectiveAspects";
       description = "A monadic embedding of aspect oriented programming";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "effective-aspects-mzv" = callPackage
    ({ mkDerivation, base, Cabal, ghc-prim, hashtables, HUnit, mzv
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "effective-aspects-mzv";
       version = "0.1.0.1";
       sha256 = "723270ebcdccb379d3f03d89354aa56524b0e4939ad5142808ce46349c7db10e";
       libraryHaskellDepends = [
         base ghc-prim hashtables HUnit mzv QuickCheck
       ];
       testHaskellDepends = [
         base Cabal ghc-prim hashtables HUnit mzv QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://pleiad.cl/EffectiveAspects";
       description = "A monadic embedding of aspect oriented programming, using \"Monads, Zippers and Views\" instead of mtl";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "effects" = callPackage
    ({ mkDerivation, base, containers, newtype, void }:
     mkDerivation {
       pname = "effects";
       version = "0.2.2";
       sha256 = "64807819354882e0deab7212e6faf9dab1a36108f645ddc211ef25beb1005f7b";
       libraryHaskellDepends = [ base containers newtype void ];
       homepage = "http://github.com/sjoerdvisscher/effects";
       description = "Computational Effects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "effects-parser" = callPackage
    ({ mkDerivation, base, effects }:
     mkDerivation {
       pname = "effects-parser";
       version = "0.1";
       sha256 = "d914227168a339f3c24253aeb5f1316860c519e51428912d5102bc5952a3526e";
       libraryHaskellDepends = [ base effects ];
       homepage = "http://github.com/nybble41/effects-parser";
       description = "Parser Effect for the Control.Effects Library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "effin" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "effin";
       version = "0.3.0.1";
       sha256 = "2e6a4a183d3626ab2509e7e80461efaeeb7327fa41fe3883f7e4163e9bec9365";
       libraryHaskellDepends = [ base mtl ];
       homepage = "https://github.com/YellPika/effin";
       description = "A Typeable-free implementation of extensible effects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "egison" = callPackage
    ({ mkDerivation, array, base, containers, directory, filepath, ghc
     , ghc-paths, Glob, haskeline, HUnit, mtl, parsec, process, random
     , regex-tdfa, test-framework, test-framework-hunit, text
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "egison";
       version = "3.5.10";
       sha256 = "fe238837980117e0ac89dfc048e31444889d00c3d3216251ccd3dac3c471a81e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers directory ghc ghc-paths haskeline mtl parsec
         process random regex-tdfa text transformers unordered-containers
       ];
       executableHaskellDepends = [
         array base containers directory filepath ghc ghc-paths haskeline
         mtl parsec process regex-tdfa text transformers
         unordered-containers
       ];
       testHaskellDepends = [
         base Glob HUnit mtl test-framework test-framework-hunit
         transformers
       ];
       homepage = "http://www.egison.org";
       description = "Programming language with non-linear pattern-matching against non-free data";
       license = stdenv.lib.licenses.mit;
     }) {};

  "egison-quote" = callPackage
    ({ mkDerivation, base, egison, mtl, parsec, template-haskell }:
     mkDerivation {
       pname = "egison-quote";
       version = "0.2";
       sha256 = "f3b9aa2463787bd8c60919c3717ef2d3593fa743e3b3a2ed11155d4af28eabe2";
       libraryHaskellDepends = [
         base egison mtl parsec template-haskell
       ];
       homepage = "https://github.com/xenophobia/Egison-Quote";
       description = "A quasi quotes for using Egison expression in Haskell code";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "egison-tutorial" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , egison, filepath, ghc, ghc-paths, haskeline, mtl, parsec
     , regex-posix, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "egison-tutorial";
       version = "3.5.9";
       sha256 = "9540ca3bcf92594a9b203df1f1b862264ebfe0e36eb49bb04fe10bbae2a9c9ab";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring containers directory egison filepath ghc
         ghc-paths haskeline mtl parsec regex-posix transformers
         unordered-containers
       ];
       homepage = "http://www.egison.org";
       description = "A tutorial program for the Egison programming language";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ehaskell" = callPackage
    ({ mkDerivation, base, directory, filepath, mtlparse, process
     , regexpr, utf8-string, yjtools
     }:
     mkDerivation {
       pname = "ehaskell";
       version = "0.7";
       sha256 = "d2d69a10153f445857fb893b7b868dd138d0c0948efbb77cf0b8f89e2910f234";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath mtlparse process regexpr utf8-string
         yjtools
       ];
       homepage = "http://homepage3.nifty.com/salamander/second/projects/ehaskell/index.xhtml";
       description = "like eruby, ehaskell is embedded haskell";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ehs" = callPackage
    ({ mkDerivation, base, bytestring, haskell-src-meta, parsec
     , template-haskell, text, time, transformers
     }:
     mkDerivation {
       pname = "ehs";
       version = "0.7.0";
       sha256 = "3d84485f15b876982c857a57e6e0fec85417c85eddd6b6f4344b3db30f8b934d";
       revision = "3";
       editedCabalFile = "e27ea9e604b3868e61e330abcd605d550371ef7f2c27e12e60b1caad99458222";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring haskell-src-meta parsec template-haskell text
         transformers
       ];
       executableHaskellDepends = [ base bytestring text time ];
       homepage = "http://github.com/minpou/ehs/";
       description = "Embedded haskell template using quasiquotes";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "eibd-client-simple" = callPackage
    ({ mkDerivation, base, bytestring, containers, eibclient, mtl
     , transformers
     }:
     mkDerivation {
       pname = "eibd-client-simple";
       version = "0.0.4";
       sha256 = "2d18369ff6fddd45c19fb030cc7d1884e707c90aa1a1e89f74dd786c3f54dd92";
       revision = "1";
       editedCabalFile = "5154a0f9083521b4c60cee92f2614b253961fd1e2dd9e7c5b541630df8597d80";
       libraryHaskellDepends = [
         base bytestring containers mtl transformers
       ];
       librarySystemDepends = [ eibclient ];
       jailbreak = true;
       description = "EIBd Client";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {eibclient = null;};

  "eigen" = callPackage
    ({ mkDerivation, base, binary, bytestring, mtl, primitive
     , transformers, vector
     }:
     mkDerivation {
       pname = "eigen";
       version = "2.1.6";
       sha256 = "dffdac84c2d3495f08d117765d499087454c96d526f375f85952ab7b40920709";
       libraryHaskellDepends = [
         base binary bytestring primitive transformers vector
       ];
       testHaskellDepends = [
         base binary bytestring mtl primitive transformers vector
       ];
       homepage = "https://github.com/osidorkin/haskell-eigen";
       description = "Eigen C++ library (linear algebra: matrices, sparse matrices, vectors, numerical solvers)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "either_4_3_2" = callPackage
    ({ mkDerivation, base, bifunctors, exceptions, free, monad-control
     , MonadRandom, mtl, profunctors, semigroupoids, semigroups
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "either";
       version = "4.3.2";
       sha256 = "8183871e94a49143d8d135be111675136d2370fe0e93e4762cda0d231826bc2e";
       libraryHaskellDepends = [
         base bifunctors exceptions free monad-control MonadRandom mtl
         profunctors semigroupoids semigroups transformers transformers-base
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/either/";
       description = "An either monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "either_4_3_2_1" = callPackage
    ({ mkDerivation, base, bifunctors, exceptions, free, monad-control
     , MonadRandom, mtl, profunctors, semigroupoids, semigroups
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "either";
       version = "4.3.2.1";
       sha256 = "42ecada4fffbacf060bbd1f9ca9278dad3857c069157c418e05f9976a8ea8125";
       libraryHaskellDepends = [
         base bifunctors exceptions free monad-control MonadRandom mtl
         profunctors semigroupoids semigroups transformers transformers-base
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/either/";
       description = "An either monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "either_4_3_3" = callPackage
    ({ mkDerivation, base, bifunctors, exceptions, free, monad-control
     , MonadRandom, mtl, profunctors, semigroupoids, semigroups
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "either";
       version = "4.3.3";
       sha256 = "b46de4d97069c86a0127c9f53d4f347bc46780e0d347e18b32eee84ae64af569";
       libraryHaskellDepends = [
         base bifunctors exceptions free monad-control MonadRandom mtl
         profunctors semigroupoids semigroups transformers transformers-base
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/either/";
       description = "An either monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "either_4_3_3_2" = callPackage
    ({ mkDerivation, base, bifunctors, exceptions, free, monad-control
     , MonadRandom, mtl, profunctors, semigroupoids, semigroups
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "either";
       version = "4.3.3.2";
       sha256 = "2515fede7c927fd58b13d1b9372b07541b50aa25dc41c5c0e1e25c8ac3ac4416";
       libraryHaskellDepends = [
         base bifunctors exceptions free monad-control MonadRandom mtl
         profunctors semigroupoids semigroups transformers transformers-base
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/either/";
       description = "An either monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "either_4_3_4" = callPackage
    ({ mkDerivation, base, bifunctors, exceptions, free, monad-control
     , MonadRandom, mtl, profunctors, semigroupoids, semigroups
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "either";
       version = "4.3.4";
       sha256 = "881f0b7af04f7a534274c407526dafaa0eb27e199e3c8f853f9c3f76e824ec0d";
       libraryHaskellDepends = [
         base bifunctors exceptions free monad-control MonadRandom mtl
         profunctors semigroupoids semigroups transformers transformers-base
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/either/";
       description = "An either monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "either_4_3_4_1" = callPackage
    ({ mkDerivation, base, bifunctors, exceptions, free, monad-control
     , MonadRandom, mtl, profunctors, semigroupoids, semigroups
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "either";
       version = "4.3.4.1";
       sha256 = "8d37ba050c440342f0262b2b98ccc24b1306f9db7ef89b964dc4337c2b1fd9de";
       libraryHaskellDepends = [
         base bifunctors exceptions free monad-control MonadRandom mtl
         profunctors semigroupoids semigroups transformers transformers-base
       ];
       homepage = "http://github.com/ekmett/either/";
       description = "An either monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "either" = callPackage
    ({ mkDerivation, base, bifunctors, exceptions, free, mmorph
     , monad-control, MonadRandom, mtl, profunctors, semigroupoids
     , semigroups, transformers, transformers-base
     }:
     mkDerivation {
       pname = "either";
       version = "4.4.1";
       sha256 = "91e57debc09bcaa7d4b884902ea6d3201ca3fec77625a059edd84bcaeb5909cb";
       libraryHaskellDepends = [
         base bifunctors exceptions free mmorph monad-control MonadRandom
         mtl profunctors semigroupoids semigroups transformers
         transformers-base
       ];
       homepage = "http://github.com/ekmett/either/";
       description = "An either monad transformer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "either-unwrap" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "either-unwrap";
       version = "1.1";
       sha256 = "ccabd6f87118abc8dcba481b316c76b8195ac9e8a8f3ddb478de5eb64e2d2e3c";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/gcross/either-unwrap";
       description = "Functions for probing and unwrapping values inside of Either";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "eithers" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "eithers";
       version = "0.2.0";
       sha256 = "85e8f7b102565ace08fb9fba477de8b960ba782345d68839e241c3e7171e3c19";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ekg_0_4_0_8" = callPackage
    ({ mkDerivation, aeson, base, bytestring, ekg-core, ekg-json
     , filepath, network, snap-core, snap-server, text, time
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "ekg";
       version = "0.4.0.8";
       sha256 = "5b0488bab3b3b6309d28f3c73fbde65b9b238f0560c58f4d937711b7ca42e832";
       libraryHaskellDepends = [
         aeson base bytestring ekg-core ekg-json filepath network snap-core
         snap-server text time transformers unordered-containers
       ];
       homepage = "https://github.com/tibbe/ekg";
       description = "Remote monitoring of processes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ekg" = callPackage
    ({ mkDerivation, aeson, base, bytestring, ekg-core, ekg-json
     , filepath, network, snap-core, snap-server, text, time
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "ekg";
       version = "0.4.0.9";
       sha256 = "71028dd82b19c82d8aeb3182d1b678d4deef78cfbc1bd8a23d1da45c2bb2bdb4";
       libraryHaskellDepends = [
         aeson base bytestring ekg-core ekg-json filepath network snap-core
         snap-server text time transformers unordered-containers
       ];
       homepage = "https://github.com/tibbe/ekg";
       description = "Remote monitoring of processes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ekg-bosun" = callPackage
    ({ mkDerivation, aeson, base, ekg-core, http-client, lens, network
     , network-uri, old-locale, text, time, unordered-containers, vector
     , wreq
     }:
     mkDerivation {
       pname = "ekg-bosun";
       version = "1.0.5";
       sha256 = "3f09b8630041ff5ac96cedf03beaa51993389bc049d12b26448df0c428b56284";
       libraryHaskellDepends = [
         aeson base ekg-core http-client lens network network-uri old-locale
         text time unordered-containers vector wreq
       ];
       homepage = "http://github.com/ocharles/ekg-bosun";
       description = "Send ekg metrics to a Bosun instance";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ekg-carbon" = callPackage
    ({ mkDerivation, base, ekg-core, network, network-carbon, text
     , time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "ekg-carbon";
       version = "1.0.4";
       sha256 = "e29c0dd46b7fb0966c728757d99d32731355cfe606ffaa59673bface47782f50";
       libraryHaskellDepends = [
         base ekg-core network network-carbon text time unordered-containers
         vector
       ];
       jailbreak = true;
       homepage = "http://github.com/ocharles/ekg-carbon";
       description = "An EKG backend to send statistics to Carbon (part of Graphite monitoring tools)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ekg-core" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, text
     , unordered-containers
     }:
     mkDerivation {
       pname = "ekg-core";
       version = "0.1.1.0";
       sha256 = "7ba11eb73ad3b906610cc1ae3889543547c48d1b2f4ca68c288bb3f022a7061e";
       libraryHaskellDepends = [
         base containers ghc-prim text unordered-containers
       ];
       homepage = "https://github.com/tibbe/ekg-core";
       description = "Tracking of system metrics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ekg-json_0_1_0_0" = callPackage
    ({ mkDerivation, aeson, base, ekg-core, text, unordered-containers
     }:
     mkDerivation {
       pname = "ekg-json";
       version = "0.1.0.0";
       sha256 = "52c455ee7d1b54f530ba9243027e5bb332925589d9209dcdfc24bd16a5a218da";
       libraryHaskellDepends = [
         aeson base ekg-core text unordered-containers
       ];
       homepage = "https://github.com/tibbe/ekg-json";
       description = "JSON encoding of ekg metrics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ekg-json" = callPackage
    ({ mkDerivation, aeson, base, ekg-core, text, unordered-containers
     }:
     mkDerivation {
       pname = "ekg-json";
       version = "0.1.0.1";
       sha256 = "ab401e93dd9238eda389a09121bae049d3ed82a031d0fa52384494c2f8f61b3f";
       libraryHaskellDepends = [
         aeson base ekg-core text unordered-containers
       ];
       homepage = "https://github.com/tibbe/ekg-json";
       description = "JSON encoding of ekg metrics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ekg-log" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, ekg-core
     , fast-logger, filepath, text, time, unix, unordered-containers
     }:
     mkDerivation {
       pname = "ekg-log";
       version = "0.1.0.4";
       sha256 = "10827eaf0ba809fe1ea2f05e2a31e584f19354982436af8b73a2d7b422dbfbed";
       libraryHaskellDepends = [
         aeson base bytestring directory ekg-core fast-logger filepath text
         time unix unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/ixmatus/ekg-log";
       description = "Push metrics to a log file";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ekg-push" = callPackage
    ({ mkDerivation, base, bytestring, ekg-core, text, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "ekg-push";
       version = "0.0.3";
       sha256 = "be683041cb6935aa194a9d241b5f11c2038b7056884fbc0a10ec1f148706b7fb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring ekg-core text time unordered-containers
       ];
       executableHaskellDepends = [ base ekg-core ];
       jailbreak = true;
       homepage = "https://github.com/adarqui/ekg-push";
       description = "Small framework to push metric deltas to a broadcast channel using the ekg-core library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ekg-rrd" = callPackage
    ({ mkDerivation, base, directory, ekg-core, HUnit, mtl, process
     , test-framework, test-framework-hunit, text, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "ekg-rrd";
       version = "0.2.1.69";
       sha256 = "7910a7b02c6f0e3137469f948b096a90c63f0234f9b24c928d85622f2107579c";
       libraryHaskellDepends = [
         base directory ekg-core mtl process text time unordered-containers
       ];
       testHaskellDepends = [
         base ekg-core HUnit test-framework test-framework-hunit text time
         unordered-containers
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/davecturner/ekg-rrd";
       description = "Passes ekg statistics to rrdtool";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "ekg-statsd" = callPackage
    ({ mkDerivation, base, bytestring, ekg-core, network, text, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "ekg-statsd";
       version = "0.2.0.3";
       sha256 = "1686048310e6884f89666ddc66bb7575d57b9d35cc4789fd2a9e63563eb7530b";
       libraryHaskellDepends = [
         base bytestring ekg-core network text time unordered-containers
       ];
       homepage = "https://github.com/tibbe/ekg-statsd";
       description = "Push metrics to statsd";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "electrum-mnemonic" = callPackage
    ({ mkDerivation, base, tasty, tasty-quickcheck }:
     mkDerivation {
       pname = "electrum-mnemonic";
       version = "0.1.2";
       sha256 = "638a29ecaf2e3fb9123e01c959c4299bbcc487dadb3743821123d6280e775cd3";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base tasty tasty-quickcheck ];
       description = "easy to remember mnemonic for a high-entropy value";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "elerea" = callPackage
    ({ mkDerivation, base, containers, transformers, transformers-base
     }:
     mkDerivation {
       pname = "elerea";
       version = "2.8.0";
       sha256 = "4be921c06feda0a8084ad9a7c87c40565f6bbaa92e79050e6c071d57ce0987e9";
       libraryHaskellDepends = [
         base containers transformers transformers-base
       ];
       description = "A minimalistic FRP library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "elerea-examples" = callPackage
    ({ mkDerivation, base, elerea, GLFW, OpenGL }:
     mkDerivation {
       pname = "elerea-examples";
       version = "2.2.3";
       sha256 = "a1af24b4fc0b8205c2a6d5350a2e147b1bfca3b29052abdce50524850d13a59e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base elerea GLFW OpenGL ];
       description = "Example applications for Elerea";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "elerea-sdl" = callPackage
    ({ mkDerivation, base, elerea, SDL }:
     mkDerivation {
       pname = "elerea-sdl";
       version = "0.1.1";
       sha256 = "66e8885199241723e47de086267456990148ea98824dedc4a6434a60b97dcbb5";
       libraryHaskellDepends = [ base elerea SDL ];
       homepage = "http://github.com/singpolyma/elerea-sdl";
       description = "Elerea FRP wrapper for SDL";
       license = "unknown";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "elevator" = callPackage
    ({ mkDerivation, base, extensible, transformers }:
     mkDerivation {
       pname = "elevator";
       version = "0.2.3";
       sha256 = "82b7050b33c3e4710d6afb99122c271592e72892a23d21de4191a559604ba0d4";
       libraryHaskellDepends = [ base extensible transformers ];
       homepage = "https://github.com/fumieval/elevator";
       description = "Immediately lifts to a desired level";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "elf" = callPackage
    ({ mkDerivation, base, binary, bytestring }:
     mkDerivation {
       pname = "elf";
       version = "0.27";
       sha256 = "5ade563fb19d75af6bf02effe6f9fa8fc207102c259b8d9fe394096f4798d4a7";
       libraryHaskellDepends = [ base binary bytestring ];
       homepage = "http://github.com/erikcharlebois/elf";
       description = "Parser for ELF object format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "elision" = callPackage
    ({ mkDerivation, base, profunctors }:
     mkDerivation {
       pname = "elision";
       version = "0.1.3.2";
       sha256 = "5e40a0b20effd90f65817391b5eefed1450f90794af3a2a2048c46ef1ad00791";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base profunctors ];
       executableHaskellDepends = [ base ];
       homepage = "http://github.com/crough/elision#readme";
       description = "Arrows with holes";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "elm-bridge_0_1_0_0" = callPackage
    ({ mkDerivation, base, hspec, template-haskell }:
     mkDerivation {
       pname = "elm-bridge";
       version = "0.1.0.0";
       sha256 = "5eaaefea61b2a3e42c8da5dce5c310b349461261b7052500b2e0bd5e8c8a68d8";
       revision = "1";
       editedCabalFile = "705fd50300a9611e7be3908004980f1a82589bd82e1ea2f9bf1ec67396e86ca1";
       libraryHaskellDepends = [ base template-haskell ];
       testHaskellDepends = [ base hspec ];
       homepage = "http://github.com/agrafix/elm-bridge";
       description = "Derive Elm types from Haskell types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "elm-bridge_0_2_1_0" = callPackage
    ({ mkDerivation, aeson, base, containers, hspec, QuickCheck
     , template-haskell, text
     }:
     mkDerivation {
       pname = "elm-bridge";
       version = "0.2.1.0";
       sha256 = "13cffa6de3be713b7003f2c525164bf749c1e9e3127b177b27818164bbeb22c1";
       libraryHaskellDepends = [ aeson base template-haskell ];
       testHaskellDepends = [
         aeson base containers hspec QuickCheck text
       ];
       homepage = "http://github.com/agrafix/elm-bridge";
       description = "Derive Elm types from Haskell types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "elm-bridge" = callPackage
    ({ mkDerivation, aeson, base, containers, hspec, QuickCheck
     , template-haskell, text
     }:
     mkDerivation {
       pname = "elm-bridge";
       version = "0.2.1.1";
       sha256 = "caafa2706908f371004810cba472dabdfca4360b31fa6ba43414aacc433b6737";
       libraryHaskellDepends = [ aeson base template-haskell ];
       testHaskellDepends = [
         aeson base containers hspec QuickCheck text
       ];
       homepage = "http://github.com/agrafix/elm-bridge";
       description = "Derive Elm types from Haskell types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "elm-build-lib" = callPackage
    ({ mkDerivation, base, bytestring, containers, elm-compiler
     , elm-core-sources, file-embed, template-haskell
     }:
     mkDerivation {
       pname = "elm-build-lib";
       version = "0.14.0.0";
       sha256 = "45720345805bc88cdc1c35328eb1a2a6e3a18976b2d0fe8df90bea35b2f4108a";
       libraryHaskellDepends = [
         base bytestring containers elm-compiler elm-core-sources file-embed
         template-haskell
       ];
       jailbreak = true;
       homepage = "http://github.com/JoeyEremondi/elm-build-lib";
       description = "Compile Elm code to JS within Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "elm-compiler_0_14" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, binary, blaze-html
     , blaze-markup, bytestring, cmdargs, containers, directory
     , filemanip, filepath, HUnit, indents, language-ecmascript
     , language-glsl, mtl, parsec, pretty, process, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, transformers, union-find, unordered-containers
     }:
     mkDerivation {
       pname = "elm-compiler";
       version = "0.14";
       sha256 = "7e9cbaebe460c9317f09202cc02a6c56d8f90662130132cdc8cde8adecd0ebed";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty base binary blaze-html blaze-markup bytestring
         cmdargs containers directory filepath indents language-ecmascript
         language-glsl mtl parsec pretty process text transformers
         union-find unordered-containers
       ];
       executableHaskellDepends = [
         aeson aeson-pretty base binary bytestring cmdargs containers
         directory filepath indents language-glsl mtl parsec pretty process
         text transformers union-find
       ];
       testHaskellDepends = [
         aeson aeson-pretty base binary blaze-html blaze-markup bytestring
         cmdargs containers directory filemanip filepath HUnit indents
         language-ecmascript language-glsl mtl parsec pretty process
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 text transformers union-find
         unordered-containers
       ];
       jailbreak = true;
       homepage = "http://elm-lang.org";
       description = "Values to help with elm-package, elm-make, and elm-lang.org.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "elm-compiler_0_14_1" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, binary, blaze-html
     , blaze-markup, bytestring, cmdargs, containers, directory
     , filemanip, filepath, HUnit, indents, language-ecmascript
     , language-glsl, mtl, parsec, pretty, process, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, transformers, union-find, unordered-containers
     }:
     mkDerivation {
       pname = "elm-compiler";
       version = "0.14.1";
       sha256 = "8ea41928e562b5255ad5f9e772f63a740f3c09fbf97f2b00c745c5776325c057";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty base binary blaze-html blaze-markup bytestring
         cmdargs containers directory filepath indents language-ecmascript
         language-glsl mtl parsec pretty process text transformers
         union-find unordered-containers
       ];
       executableHaskellDepends = [
         aeson aeson-pretty base binary bytestring cmdargs containers
         directory filepath indents language-glsl mtl parsec pretty process
         text transformers union-find
       ];
       testHaskellDepends = [
         aeson aeson-pretty base binary blaze-html blaze-markup bytestring
         cmdargs containers directory filemanip filepath HUnit indents
         language-ecmascript language-glsl mtl parsec pretty process
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 text transformers union-find
         unordered-containers
       ];
       jailbreak = true;
       homepage = "http://elm-lang.org";
       description = "Values to help with elm-package, elm-make, and elm-lang.org.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "elm-compiler" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, binary, blaze-html
     , blaze-markup, bytestring, cmdargs, containers, directory
     , edit-distance, filemanip, filepath, HUnit, indents
     , language-ecmascript, language-glsl, mtl, parsec, pretty, process
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, transformers, union-find
     , unordered-containers
     }:
     mkDerivation {
       pname = "elm-compiler";
       version = "0.15";
       sha256 = "b63049b22c05901b3538f3cc29c14a42b716bdc2c84e37cde83b44b9cc0f78bc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty base binary blaze-html blaze-markup bytestring
         cmdargs containers directory edit-distance filepath indents
         language-ecmascript language-glsl mtl parsec pretty process text
         transformers union-find unordered-containers
       ];
       executableHaskellDepends = [
         aeson aeson-pretty base binary bytestring cmdargs containers
         directory filepath indents language-glsl mtl parsec pretty process
         text transformers union-find
       ];
       testHaskellDepends = [
         aeson aeson-pretty base binary blaze-html blaze-markup bytestring
         cmdargs containers directory edit-distance filemanip filepath HUnit
         indents language-ecmascript language-glsl mtl parsec pretty process
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 text transformers union-find
         unordered-containers
       ];
       jailbreak = true;
       homepage = "http://elm-lang.org";
       description = "Values to help with elm-package, elm-make, and elm-lang.org.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "elm-core-sources" = callPackage
    ({ mkDerivation, base, bytestring, containers, file-embed
     , template-haskell
     }:
     mkDerivation {
       pname = "elm-core-sources";
       version = "1.0.0";
       sha256 = "a403505d50cd6ff0d21243db55c6decc6dde14b88a6a393e2b6243f09f6620fb";
       libraryHaskellDepends = [
         base bytestring containers file-embed template-haskell
       ];
       homepage = "http://github.com/JoeyEremondi/elm-build-lib";
       description = "Source files for the Elm runtime and standard libraries";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "elm-get" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, ansi-wl-pprint, base, binary
     , bytestring, containers, directory, Elm, filepath, HTTP
     , http-client, http-client-tls, http-types, mtl, network
     , optparse-applicative, process, vector
     }:
     mkDerivation {
       pname = "elm-get";
       version = "0.1.3";
       sha256 = "98c4f2ab71866fde7d39334ce360aa61a1f88759a2354b558153c0d0e43e2db6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring directory Elm filepath http-client
         http-client-tls http-types mtl network process vector
       ];
       executableHaskellDepends = [
         aeson aeson-pretty ansi-wl-pprint base binary bytestring containers
         directory Elm filepath HTTP http-client http-client-tls http-types
         mtl network optparse-applicative process vector
       ];
       jailbreak = true;
       homepage = "http://github.com/elm-lang/elm-get";
       description = "Tool for sharing and using Elm libraries";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "elm-init" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, base-unicode-symbols
     , bytestring, containers, directory, file-embed, filepath, process
     , text, time
     }:
     mkDerivation {
       pname = "elm-init";
       version = "1.0.4";
       sha256 = "39f8ec1e64c1a5025f4568ff59b52470e846d777f3cd343176b7a25d672989d3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson aeson-pretty base base-unicode-symbols bytestring containers
         directory file-embed filepath process text time
       ];
       description = "Set up basic structure for an elm project";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "elm-make" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, binary, blaze-html
     , blaze-markup, bytestring, containers, directory, elm-compiler
     , elm-package, filepath, mtl, optparse-applicative, text
     }:
     mkDerivation {
       pname = "elm-make";
       version = "0.1.2";
       sha256 = "4b07824806ada383d4095276450611fd71bade2faa3671479ed37bd76d8ad483";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-wl-pprint base binary blaze-html blaze-markup bytestring
         containers directory elm-compiler elm-package filepath mtl
         optparse-applicative text
       ];
       jailbreak = true;
       homepage = "http://elm-lang.org";
       description = "A build tool for Elm projects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "elm-package_0_2_2" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, ansi-wl-pprint, base, binary
     , bytestring, containers, directory, elm-compiler, filepath, HTTP
     , http-client, http-client-tls, http-types, mtl, network
     , optparse-applicative, pretty, process, text, time
     , unordered-containers, vector, zip-archive
     }:
     mkDerivation {
       pname = "elm-package";
       version = "0.2.2";
       sha256 = "d956867ed45eee63fc12caa79a93745a81664d58efc32fa678368b1e6bf06c42";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty base binary bytestring containers directory
         elm-compiler filepath HTTP http-client http-client-tls http-types
         mtl network process text time unordered-containers vector
         zip-archive
       ];
       executableHaskellDepends = [
         aeson aeson-pretty ansi-wl-pprint base binary bytestring containers
         directory elm-compiler filepath HTTP http-client http-client-tls
         http-types mtl network optparse-applicative pretty process text
         time unordered-containers vector zip-archive
       ];
       jailbreak = true;
       homepage = "http://github.com/elm-lang/elm-package";
       description = "Package manager for Elm libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "elm-package" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, ansi-wl-pprint, base, binary
     , bytestring, containers, directory, elm-compiler, filepath, HTTP
     , http-client, http-client-tls, http-types, mtl, network
     , optparse-applicative, pretty, process, text, time
     , unordered-containers, vector, zip-archive
     }:
     mkDerivation {
       pname = "elm-package";
       version = "0.5";
       sha256 = "b654ba7803ee1bf8dbb03bcf7f6194b41c53c545a351abeb4d8e17f704a19a23";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty base binary bytestring containers directory
         elm-compiler filepath HTTP http-client http-client-tls http-types
         mtl network process text time unordered-containers vector
         zip-archive
       ];
       executableHaskellDepends = [
         aeson aeson-pretty ansi-wl-pprint base binary bytestring containers
         directory elm-compiler filepath HTTP http-client http-client-tls
         http-types mtl network optparse-applicative pretty process text
         time unordered-containers vector zip-archive
       ];
       jailbreak = true;
       homepage = "http://github.com/elm-lang/elm-package";
       description = "Package manager for Elm libraries";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "elm-reactor" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
     , cmdargs, containers, directory, elm-compiler, filepath, fsnotify
     , HTTP, mtl, process, snap-core, snap-server, system-filepath, text
     , time, transformers, unordered-containers, websockets
     , websockets-snap
     }:
     mkDerivation {
       pname = "elm-reactor";
       version = "0.3.1";
       sha256 = "ea5dba281fcaed361807760c44fcc8797f11d04312165d5067999f87d9681549";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-html blaze-markup bytestring cmdargs containers
         directory elm-compiler filepath fsnotify HTTP mtl process snap-core
         snap-server system-filepath text time transformers
         unordered-containers websockets websockets-snap
       ];
       homepage = "http://elm-lang.org";
       description = "Interactive development tool for Elm programs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "elm-repl" = callPackage
    ({ mkDerivation, base, binary, bytestring, bytestring-trie, cmdargs
     , containers, directory, elm-compiler, elm-package, filepath
     , haskeline, HUnit, mtl, parsec, process, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "elm-repl";
       version = "0.4.1";
       sha256 = "a3080c260d3a59fbea0a4964ab1c7b0ea3bbf37b72003ec9456c1071f098de15";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring bytestring-trie cmdargs containers directory
         elm-compiler elm-package filepath haskeline mtl parsec process
       ];
       testHaskellDepends = [
         base bytestring bytestring-trie cmdargs directory elm-compiler
         elm-package filepath haskeline HUnit mtl parsec process QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/elm-lang/elm-repl";
       description = "a REPL for Elm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "elm-server" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, containers, directory
     , Elm, filepath, mtl, process, snap-core, snap-server
     , unordered-containers
     }:
     mkDerivation {
       pname = "elm-server";
       version = "0.11.0.1";
       sha256 = "e18db27a56d3a35384c9ca35cef6988369393bc705f64ec2508632526b85d35a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs containers directory Elm filepath mtl
         process snap-core snap-server unordered-containers
       ];
       homepage = "http://elm-lang.org";
       description = "Server for developing Elm projects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "elm-yesod" = callPackage
    ({ mkDerivation, base, blaze-markup, Elm, shakespeare-js, text
     , yesod-core
     }:
     mkDerivation {
       pname = "elm-yesod";
       version = "0.2";
       sha256 = "69b41cb55e48af15b0cf0d52c0a88629403810085c404afdc2945fcde11cea43";
       libraryHaskellDepends = [
         base blaze-markup Elm shakespeare-js text yesod-core
       ];
       jailbreak = true;
       homepage = "http://elm-lang.org";
       description = "The Elm language Yesod compatibility module";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "elo" = callPackage
    ({ mkDerivation, base, tasty }:
     mkDerivation {
       pname = "elo";
       version = "0.1.0";
       sha256 = "2bdb18075718f17a84f1fa0190855f84fa5105b164c94d2fb4ac49447c5fca2d";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base tasty ];
       homepage = "http://github.com/mfine/elo";
       description = "Elo Rating Library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "elocrypt" = callPackage
    ({ mkDerivation, base, MonadRandom, proctest, QuickCheck, random
     , tasty, tasty-quickcheck, tasty-th
     }:
     mkDerivation {
       pname = "elocrypt";
       version = "0.4.1";
       sha256 = "8f2d96c3e91584e96d7a80f34577b541047220d1d9ca5d03c950985421ee5ac3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base MonadRandom random ];
       executableHaskellDepends = [ base random ];
       testHaskellDepends = [
         base MonadRandom proctest QuickCheck random tasty tasty-quickcheck
         tasty-th
       ];
       homepage = "https://www.github.com/sgillespie/elocrypt";
       description = "Generate easy-to-remember, hard-to-guess passwords";
       license = "unknown";
     }) {};

  "emacs-keys" = callPackage
    ({ mkDerivation, base, doctest, split, tasty, tasty-hspec
     , tasty-quickcheck, template-haskell, th-lift, xkbcommon
     }:
     mkDerivation {
       pname = "emacs-keys";
       version = "0.0.2.0";
       sha256 = "f00a0409fae74f3af62e1497875f0e999df5333e5fc5b32095d9804babdcfd8b";
       libraryHaskellDepends = [
         base split template-haskell th-lift xkbcommon
       ];
       testHaskellDepends = [
         base doctest tasty tasty-hspec tasty-quickcheck xkbcommon
       ];
       jailbreak = true;
       homepage = "https://github.com/cocreature/emacs-keys";
       description = "library to parse emacs style keybinding into the modifiers and the chars";
       license = stdenv.lib.licenses.isc;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "email" = callPackage
    ({ mkDerivation, array, base, bytestring, encoding, HaskellNet
     , hsemail, old-locale, old-time, parsec, process, time
     }:
     mkDerivation {
       pname = "email";
       version = "0.1.1.2";
       sha256 = "83b3801735ddb4835a442d2f6ab9b653468fbed45cf56f18db51d163d5288a90";
       libraryHaskellDepends = [
         array base bytestring encoding HaskellNet hsemail old-locale
         old-time parsec process time
       ];
       jailbreak = true;
       description = "Sending eMail in Haskell made easy";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "email-header" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, bytestring
     , case-insensitive, containers, QuickCheck, tasty, tasty-quickcheck
     , text, text-icu, time
     }:
     mkDerivation {
       pname = "email-header";
       version = "0.2.0";
       sha256 = "db474e1425647e860b67d3891451fec034a2149c9dd01e9b7cdee0ce746887ce";
       libraryHaskellDepends = [
         attoparsec base base64-bytestring bytestring case-insensitive
         containers text text-icu time
       ];
       testHaskellDepends = [
         base bytestring case-insensitive containers QuickCheck tasty
         tasty-quickcheck text time
       ];
       homepage = "http://github.com/knrafto/email-header";
       description = "Parsing and rendering of email and MIME headers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "email-postmark" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , HTTP, network
     }:
     mkDerivation {
       pname = "email-postmark";
       version = "0.2";
       sha256 = "de2b6b7ae3e472256377db8773528e070f96f937b4d76633d59abe2051f2eb9f";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers HTTP network
       ];
       jailbreak = true;
       description = "A simple wrapper to send emails via the api of the service postmark (http://postmarkapp.com/)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "email-validate_2_0_1" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, ghc-prim, HUnit
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "email-validate";
       version = "2.0.1";
       sha256 = "f2d363c06c09d9e1d348d10314831998eb6e516588c56fd503e5fbd85165bbe3";
       revision = "1";
       editedCabalFile = "b77a1e324d434b622c170c9593dcf8eead2e5e4219465667b90673339f2824e7";
       libraryHaskellDepends = [ attoparsec base bytestring ghc-prim ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "http://porg.es/blog/email-address-validation-simpler-faster-more-correct";
       description = "Validating an email address string against RFC 5322";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "email-validate_2_1_3" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, ghc-prim, HUnit
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "email-validate";
       version = "2.1.3";
       sha256 = "5b967999717a8216639b39de1583a87e8c8ec471c416386229215c233d2c81cb";
       libraryHaskellDepends = [ attoparsec base bytestring ghc-prim ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "http://porg.es/blog/email-address-validation-simpler-faster-more-correct";
       description = "Validating an email address string against RFC 5322";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "email-validate" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, ghc-prim, HUnit
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "email-validate";
       version = "2.2.0";
       sha256 = "aa7fd3f02c015bbc4ae67c2f3586f16c757d54a8cf09f7a04e70045828d9cb69";
       libraryHaskellDepends = [ attoparsec base bytestring ghc-prim ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "http://porg.es/blog/email-address-validation-simpler-faster-more-correct";
       description = "Validating an email address string against RFC 5322";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "email-validator" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, directory, dns, doctest
     , email-validate, HUnit, parallel-io, pcre-light, tasty
     , tasty-hunit
     }:
     mkDerivation {
       pname = "email-validator";
       version = "0.0.3";
       sha256 = "f6a0ea5f924355c464790f12fc5af179ce8537c73adb9f410430e19b8f74202a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs directory dns email-validate HUnit
         parallel-io pcre-light tasty tasty-hunit
       ];
       testHaskellDepends = [
         base bytestring cmdargs directory dns doctest email-validate HUnit
         parallel-io pcre-light tasty tasty-hunit
       ];
       jailbreak = true;
       description = "Perform basic syntax and deliverability checks on email addresses";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "embeddock" = callPackage
    ({ mkDerivation, base, filepath, her-lexer, MissingH, process }:
     mkDerivation {
       pname = "embeddock";
       version = "0.3.0.1";
       sha256 = "d9e5b08a795210d8b9ec47d29286ae82a35a7ec86f123f4fbb2ca8ef2dc7be07";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [
         base filepath her-lexer MissingH process
       ];
       homepage = "https://github.com/nushio3/embeddock";
       description = "Embed the values in scope in the haddock documentation of the module";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "embeddock-example" = callPackage
    ({ mkDerivation, base, embeddock, time }:
     mkDerivation {
       pname = "embeddock-example";
       version = "0.1";
       sha256 = "60b5f30ee25070e0c9b443d96b2e8dcc235bd982573ef811c8dc2d6adb3cac1f";
       libraryHaskellDepends = [ base embeddock time ];
       homepage = "https://github.com/nushio3/embeddock-example";
       description = "Example of using embeddock";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "embroidery" = callPackage
    ({ mkDerivation, base, bytestring, dlist, gloss, haskell98, HCodecs
     , mtl
     }:
     mkDerivation {
       pname = "embroidery";
       version = "0.1";
       sha256 = "dd0be47995c14e4ce2825675b8cacb4abdb2b475582c72bf89bf8ba0ced613ef";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring dlist gloss haskell98 HCodecs mtl
       ];
       executableHaskellDepends = [ base ];
       homepage = "https://ludflu@github.com/ludflu/embroidery.git";
       description = "support for embroidery formats in haskell";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "emgm" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, syb }:
     mkDerivation {
       pname = "emgm";
       version = "0.4";
       sha256 = "e1167e176cccf02db57c9bfc2725747b4cdea0fbb04accc31998636e56e6ec32";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base HUnit QuickCheck syb ];
       jailbreak = true;
       homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/EMGM";
       description = "Extensible and Modular Generics for the Masses";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "empty" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "empty";
       version = "9";
       sha256 = "a9099c3e5acb7cd4cdab93a7846237d750000b8894fc908ee311173bfcc2e72a";
       doHaddock = false;
       description = "Ceci n'est pas une package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "enclosed-exceptions_1_0_1" = callPackage
    ({ mkDerivation, async, base, deepseq, hspec, lifted-base
     , monad-control, QuickCheck, transformers, transformers-base
     }:
     mkDerivation {
       pname = "enclosed-exceptions";
       version = "1.0.1";
       sha256 = "ff9b35b2278574002bf4ccf1c2293a7b500edba95382aa8242088a34220c2dce";
       libraryHaskellDepends = [
         async base deepseq lifted-base monad-control transformers
         transformers-base
       ];
       testHaskellDepends = [
         async base deepseq hspec lifted-base monad-control QuickCheck
         transformers transformers-base
       ];
       homepage = "https://github.com/jcristovao/enclosed-exceptions";
       description = "Catching all exceptions from within an enclosed computation";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "enclosed-exceptions" = callPackage
    ({ mkDerivation, async, base, deepseq, hspec, lifted-base
     , monad-control, QuickCheck, transformers, transformers-base
     }:
     mkDerivation {
       pname = "enclosed-exceptions";
       version = "1.0.1.1";
       sha256 = "e5236133ba5a2395fbac9f8436eb8765ede4a0a8b36341ccbb8a4cddf00c5d99";
       libraryHaskellDepends = [
         async base deepseq lifted-base monad-control transformers
         transformers-base
       ];
       testHaskellDepends = [
         async base deepseq hspec lifted-base monad-control QuickCheck
         transformers transformers-base
       ];
       doCheck = false;
       homepage = "https://github.com/jcristovao/enclosed-exceptions";
       description = "Catching all exceptions from within an enclosed computation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "encoding" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , extensible-exceptions, ghc-prim, HaXml, mtl, regex-compat
     }:
     mkDerivation {
       pname = "encoding";
       version = "0.8";
       sha256 = "518a32d95a29cb1dff49afac6235287730dd675cf6e14b9ddc17e7be53ea4e78";
       libraryHaskellDepends = [
         array base binary bytestring containers extensible-exceptions
         ghc-prim HaXml mtl regex-compat
       ];
       homepage = "http://code.haskell.org/encoding/";
       description = "A library for various character encodings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "endo" = callPackage
    ({ mkDerivation, base, between, transformers }:
     mkDerivation {
       pname = "endo";
       version = "0.2.0.1";
       sha256 = "312ea501116bddc01dd523948b80693ec6348a8f6beb5a1b9bcbeaa709d9eb6b";
       revision = "1";
       editedCabalFile = "4c0b97bc6e43d18ae5dc423824ab4406e6b2188b887094b6eff3e49103e456b3";
       libraryHaskellDepends = [ base between transformers ];
       homepage = "https://github.com/trskop/endo";
       description = "Endomorphism utilities";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "engine-io_1_2_10" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, base64-bytestring
     , bytestring, either, free, monad-loops, mwc-random, stm, stm-delay
     , text, transformers, unordered-containers, vector, websockets
     }:
     mkDerivation {
       pname = "engine-io";
       version = "1.2.10";
       sha256 = "009ad01d28e72a822473310fa5589359d8dfac5b69ccbec8485cd9cc9b238c0b";
       libraryHaskellDepends = [
         aeson async attoparsec base base64-bytestring bytestring either
         free monad-loops mwc-random stm stm-delay text transformers
         unordered-containers vector websockets
       ];
       jailbreak = true;
       homepage = "http://github.com/ocharles/engine.io";
       description = "A Haskell implementation of Engine.IO";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "engine-io_1_2_11" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, base64-bytestring
     , bytestring, either, free, monad-loops, mwc-random, stm, stm-delay
     , text, transformers, unordered-containers, vector, websockets
     }:
     mkDerivation {
       pname = "engine-io";
       version = "1.2.11";
       sha256 = "bd57162b4b2233ef3fbe4ce6cba7d562476da59257b1baaa801847d9809e601d";
       libraryHaskellDepends = [
         aeson async attoparsec base base64-bytestring bytestring either
         free monad-loops mwc-random stm stm-delay text transformers
         unordered-containers vector websockets
       ];
       jailbreak = true;
       homepage = "http://github.com/ocharles/engine.io";
       description = "A Haskell implementation of Engine.IO";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "engine-io_1_2_12" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, base64-bytestring
     , bytestring, either, free, monad-loops, mwc-random, stm, stm-delay
     , text, transformers, unordered-containers, vector, websockets
     }:
     mkDerivation {
       pname = "engine-io";
       version = "1.2.12";
       sha256 = "06361c560976201923c0db9d010a19d059b902859d88eda18865ebedd55fcc4c";
       libraryHaskellDepends = [
         aeson async attoparsec base base64-bytestring bytestring either
         free monad-loops mwc-random stm stm-delay text transformers
         unordered-containers vector websockets
       ];
       homepage = "http://github.com/ocharles/engine.io";
       description = "A Haskell implementation of Engine.IO";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "engine-io" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, base64-bytestring
     , bytestring, either, free, monad-loops, mwc-random, stm, stm-delay
     , text, transformers, unordered-containers, vector, websockets
     }:
     mkDerivation {
       pname = "engine-io";
       version = "1.2.13";
       sha256 = "5fc53f8a4a0ba563b9592e7bf3d9475a4a7ce165c66cd63a303567f6a941cf45";
       libraryHaskellDepends = [
         aeson async attoparsec base base64-bytestring bytestring either
         free monad-loops mwc-random stm stm-delay text transformers
         unordered-containers vector websockets
       ];
       homepage = "http://github.com/ocharles/engine.io";
       description = "A Haskell implementation of Engine.IO";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "engine-io-growler" = callPackage
    ({ mkDerivation, base, bytestring, engine-io, growler, http-types
     , mtl, pipes, pipes-attoparsec, pipes-wai, socket-io, text
     , transformers, unordered-containers, wai, wai-websockets
     , websockets
     }:
     mkDerivation {
       pname = "engine-io-growler";
       version = "0.1.0.1";
       sha256 = "4cf29b585a8212da3d2c834fa2b2a291a3ec1febb9f5ba676a55db84de6567fa";
       libraryHaskellDepends = [
         base bytestring engine-io growler http-types mtl pipes
         pipes-attoparsec pipes-wai socket-io text transformers
         unordered-containers wai wai-websockets websockets
       ];
       jailbreak = true;
       homepage = "http://github.com/iand675/growler";
       license = stdenv.lib.licenses.mit;
     }) {};

  "engine-io-snap" = callPackage
    ({ mkDerivation, attoparsec-enumerator, base, bytestring
     , containers, engine-io, MonadCatchIO-transformers, snap-core
     , unordered-containers, websockets, websockets-snap
     }:
     mkDerivation {
       pname = "engine-io-snap";
       version = "1.0.3";
       sha256 = "6f411258df83db0466096a70f3b3eb78aee8de6e24ba68be9d7fe746564a4044";
       libraryHaskellDepends = [
         attoparsec-enumerator base bytestring containers engine-io
         MonadCatchIO-transformers snap-core unordered-containers websockets
         websockets-snap
       ];
       homepage = "http://github.com/ocharles/engine.io";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "engine-io-wai" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, either, engine-io
     , http-types, mtl, text, transformers, transformers-compat
     , unordered-containers, wai, wai-websockets, websockets
     }:
     mkDerivation {
       pname = "engine-io-wai";
       version = "1.0.5";
       sha256 = "80e4737835acbadb0aafa66defc961e32045c66760040456700853e5baf0dab3";
       libraryHaskellDepends = [
         attoparsec base bytestring either engine-io http-types mtl text
         transformers transformers-compat unordered-containers wai
         wai-websockets websockets
       ];
       homepage = "http://github.com/ocharles/engine.io";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "engine-io-yesod_1_0_3" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , engine-io, http-types, text, unordered-containers, wai
     , wai-websockets, websockets, yesod-core
     }:
     mkDerivation {
       pname = "engine-io-yesod";
       version = "1.0.3";
       sha256 = "ef27642e8ffcb149d98dadb6c695aff7c2a66a63ee7dddf75b4168fa71b5de2f";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra engine-io http-types text
         unordered-containers wai wai-websockets websockets yesod-core
       ];
       jailbreak = true;
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "engine-io-yesod" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , engine-io, http-types, text, unordered-containers, wai
     , wai-websockets, websockets, yesod-core
     }:
     mkDerivation {
       pname = "engine-io-yesod";
       version = "1.0.4";
       sha256 = "d569661729341eca76a4c04fea27e02fccf27978e61ca93848cd095f36dcdbc5";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra engine-io http-types text
         unordered-containers wai wai-websockets websockets yesod-core
       ];
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "engineering-units" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "engineering-units";
       version = "0.0.2";
       sha256 = "d2c640271c9ec07026eb76bb56c09f69988367c444886e46032c584b700973aa";
       libraryHaskellDepends = [ base ];
       description = "A numeric type for managing and automating engineering units";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "entropy_0_3_4_1" = callPackage
    ({ mkDerivation, base, bytestring, unix }:
     mkDerivation {
       pname = "entropy";
       version = "0.3.4.1";
       sha256 = "60fa974e1f1685b8d60eb07d1028bc7f577a9abeef396ab9d768a0a384eebe82";
       revision = "1";
       editedCabalFile = "a7770a86c27d5d48a82b519e9eed75d276ffc2ca942275d0b901299109b590bc";
       libraryHaskellDepends = [ base bytestring unix ];
       homepage = "https://github.com/TomMD/entropy";
       description = "A platform independent entropy source";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "entropy_0_3_5" = callPackage
    ({ mkDerivation, base, bytestring, unix }:
     mkDerivation {
       pname = "entropy";
       version = "0.3.5";
       sha256 = "a2b991bc5489df23fa392484a87e5431bfa5c9c575870c52a28457ce4a26db57";
       libraryHaskellDepends = [ base bytestring unix ];
       homepage = "https://github.com/TomMD/entropy";
       description = "A platform independent entropy source";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "entropy_0_3_6" = callPackage
    ({ mkDerivation, base, bytestring, unix }:
     mkDerivation {
       pname = "entropy";
       version = "0.3.6";
       sha256 = "164a025c7d325874206d16f0405239f22dc1942c81b6675100aeb60dc148dbe9";
       libraryHaskellDepends = [ base bytestring unix ];
       homepage = "https://github.com/TomMD/entropy";
       description = "A platform independent entropy source";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "entropy" = callPackage
    ({ mkDerivation, base, bytestring, unix }:
     mkDerivation {
       pname = "entropy";
       version = "0.3.7";
       sha256 = "1ff020eba2edbb93c4b23297470f8c11d69d0ff1e1642d17cbab9d54a24befef";
       libraryHaskellDepends = [ base bytestring unix ];
       homepage = "https://github.com/TomMD/entropy";
       description = "A platform independent entropy source";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "enumerable" = callPackage
    ({ mkDerivation, base, control-monad-omega, tagged }:
     mkDerivation {
       pname = "enumerable";
       version = "0.0.3";
       sha256 = "f88472c057c96bcbca7ab427e482d31aca2de40f0d9cbd281e6fd23c14f024ed";
       libraryHaskellDepends = [ base control-monad-omega tagged ];
       description = "A typeclass for enumerating all values a type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "enumerate" = callPackage
    ({ mkDerivation, base, containers, deepseq, exceptions, ghc-prim
     , MemoTrie, modular-arithmetic, semigroups, template-haskell, vinyl
     }:
     mkDerivation {
       pname = "enumerate";
       version = "0.0.0";
       sha256 = "a94c036510a6f14724cdc8adefefd85382902e049633234f69cb3f5fea4a3839";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers deepseq exceptions ghc-prim MemoTrie
         modular-arithmetic semigroups template-haskell vinyl
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/sboosali/enumerate";
       description = "enumerate all the values in a finite type (automatically)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "enumeration" = callPackage
    ({ mkDerivation, arith-encode, arithmoi, base, binary, Cabal
     , containers, heap, HUnit-Plus
     }:
     mkDerivation {
       pname = "enumeration";
       version = "0.1.0";
       sha256 = "73815ef9d5fada9b394a9beb47f1fb78169f78a6d44c0e9ce01dfa6945dda79d";
       libraryHaskellDepends = [
         arith-encode arithmoi base binary Cabal containers heap
       ];
       testHaskellDepends = [
         arith-encode arithmoi base binary Cabal containers heap HUnit-Plus
       ];
       homepage = "https://github.com/emc2/enumeration";
       description = "A practical API for building recursive enumeration procedures and enumerating datatypes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "enumerator" = callPackage
    ({ mkDerivation, base, bytestring, containers, text, transformers
     }:
     mkDerivation {
       pname = "enumerator";
       version = "0.4.20";
       sha256 = "33e21054352bb579e8db8697256ff3c61b3dc862c567f9e0fc2509f95e2b4709";
       libraryHaskellDepends = [
         base bytestring containers text transformers
       ];
       homepage = "https://john-millikin.com/software/enumerator/";
       description = "Reliable, high-performance processing with left-fold enumerators";
       license = stdenv.lib.licenses.mit;
     }) {};

  "enumerator-fd" = callPackage
    ({ mkDerivation, base, enumerator, mtl }:
     mkDerivation {
       pname = "enumerator-fd";
       version = "0.1.0.2";
       sha256 = "37894f7f9158dc30fcd81c46db72481cca3d45596e516937c506885acc9e7975";
       libraryHaskellDepends = [ base enumerator mtl ];
       homepage = "https://john-millikin.com/software/enumerator/";
       description = "Enumerator instances for monads-fd classes";
       license = stdenv.lib.licenses.mit;
     }) {};

  "enumerator-tf" = callPackage
    ({ mkDerivation, base, enumerator, monads-tf }:
     mkDerivation {
       pname = "enumerator-tf";
       version = "0.1.1";
       sha256 = "57cb0bba42ebd944e42ca8c567d20e3a3e14acde7c8b5840a0dc16e0ae918768";
       libraryHaskellDepends = [ base enumerator monads-tf ];
       homepage = "https://john-millikin.com/software/enumerator/";
       description = "Enumerator instances for monads-tf classes";
       license = stdenv.lib.licenses.mit;
     }) {};

  "enumfun" = callPackage
    ({ mkDerivation, base, enummapset-th }:
     mkDerivation {
       pname = "enumfun";
       version = "0.5.1.0";
       sha256 = "acd941d794803ab684bc96fcfcd83807e324945ef35447b5afab08c460fd04bb";
       libraryHaskellDepends = [ base enummapset-th ];
       jailbreak = true;
       homepage = "https://github.com/liyang/enumfun";
       description = "Finitely represented /total/ EnumMaps";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "enummapmap" = callPackage
    ({ mkDerivation, base, cereal, containers, contravariant
     , data-default, deepseq, ghc-prim, hspec, hspec-expectations, HUnit
     , lens, QuickCheck, safecopy, semigroups
     }:
     mkDerivation {
       pname = "enummapmap";
       version = "0.7.0";
       sha256 = "99c7611e3e080524e48f6d206e55a8453250fe94aa68a4ab397e4443aaf5349f";
       libraryHaskellDepends = [
         base contravariant data-default deepseq ghc-prim lens safecopy
         semigroups
       ];
       testHaskellDepends = [
         base cereal containers deepseq hspec hspec-expectations HUnit lens
         QuickCheck safecopy semigroups
       ];
       jailbreak = true;
       description = "Map of maps using Enum types as keys";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "enummapset" = callPackage
    ({ mkDerivation, base, containers, deepseq }:
     mkDerivation {
       pname = "enummapset";
       version = "0.5.2.1";
       sha256 = "0f77b5235f1ebdb423e5be2df9390edd7173f0a6531dd368b86c998ac3023805";
       libraryHaskellDepends = [ base containers deepseq ];
       homepage = "https://github.com/michalt/enummapset";
       description = "IntMap and IntSet with Enum keys/elements";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "enummapset-th" = callPackage
    ({ mkDerivation, base, containers, deepseq, template-haskell }:
     mkDerivation {
       pname = "enummapset-th";
       version = "0.6.1.0";
       sha256 = "bd7ec9fd9063dcf9c8504fe509abdd15466261ef2ba9ec62d6e6abb51e8694f6";
       revision = "1";
       editedCabalFile = "2544cf675da1fd28debde06f5d2c9747da0d8b48aa66f2374886d38333f8dc17";
       libraryHaskellDepends = [
         base containers deepseq template-haskell
       ];
       homepage = "https://github.com/liyang/enummapset-th";
       description = "TH-generated EnumSet/EnumMap wrappers around IntSet/IntMap";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "enumset" = callPackage
    ({ mkDerivation, base, data-accessor, storable-record }:
     mkDerivation {
       pname = "enumset";
       version = "0.0.4";
       sha256 = "bc00048a2908f3ee31af810d1eca9be805cb1bb2e0908d8c6bff94134fecfcb7";
       libraryHaskellDepends = [ base data-accessor storable-record ];
       description = "Sets of enumeration values represented by machine words";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "env-parser" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, bytestring, containers, http-types, mtl
     , network, old-locale, text, time, transformers
     }:
     mkDerivation {
       pname = "env-parser";
       version = "0.0.2.1";
       sha256 = "3907aa97cdaeff08507a4e3655c95f76966d128fce0dcb982528b6254bf4a68d";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         bytestring containers http-types mtl network old-locale text time
         transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/tel/env-parser";
       description = "Pull configuration information from the ENV";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "envparse" = callPackage
    ({ mkDerivation, base, containers, hspec }:
     mkDerivation {
       pname = "envparse";
       version = "0.2.2";
       sha256 = "72bbac6a4c6755c6f1f0b68a68475afb71cd6763e8fb90c88411457ff16f4a03";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [ base containers hspec ];
       homepage = "https://supki.github.io/envparse";
       description = "Parse environment variables";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "envy" = callPackage
    ({ mkDerivation, base, bytestring, containers, hspec, mtl
     , QuickCheck, quickcheck-instances, text, time, transformers
     }:
     mkDerivation {
       pname = "envy";
       version = "1.1.0.0";
       sha256 = "27a2496640ea74ceab5a23a3fe8ef325bfb23d64a851f5dfc18b7c3411beca99";
       revision = "1";
       editedCabalFile = "a3922d3ddac9dd572059abbc0a9af991467cf10c93d6fc579c53faa5d3d22c2e";
       libraryHaskellDepends = [
         base bytestring containers mtl text time transformers
       ];
       testHaskellDepends = [
         base bytestring hspec mtl QuickCheck quickcheck-instances text time
         transformers
       ];
       description = "An environmentally friendly way to deal with environment variables";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "epanet-haskell" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "epanet-haskell";
       version = "2.0.12.4";
       sha256 = "1d6a8cd92ffb55b93d52af99c2f5f07c358c67bb2c7e47a813eec1493f2affca";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://epanet.de/developer/haskell.html";
       description = "Haskell binding for EPANET";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "epass" = callPackage
    ({ mkDerivation, base, stm, time }:
     mkDerivation {
       pname = "epass";
       version = "0.2.1";
       sha256 = "d58fa2162973e885523ce55a3ccd811eee255fcc27663510ee4913f66fbce569";
       libraryHaskellDepends = [ base stm time ];
       jailbreak = true;
       homepage = "http://github.com/baldo/epass";
       description = "Baisc, Erlang-like message passing supporting sockets";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "epic" = callPackage
    ({ mkDerivation, array, base, Cabal, directory, mtl, process }:
     mkDerivation {
       pname = "epic";
       version = "0.9.3.3";
       sha256 = "559844322f0f3c6d511d70e1a3166175f4aea084ea0e109b161b4d1d4296e82a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base Cabal directory mtl process ];
       executableHaskellDepends = [
         array base Cabal directory mtl process
       ];
       homepage = "http://www.dcs.st-and.ac.uk/~eb/epic.php";
       description = "Compiler for a simple functional language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "epoll" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "epoll";
       version = "0.2.2";
       sha256 = "d7725bc62beaaf7d54d67928847621447ee4cab69aa9f83481e1acb2a8e9e147";
       revision = "1";
       editedCabalFile = "215673c26bb5d38b7655b5b52d6c21d65d228c4ac231606525991a60add70ab8";
       libraryHaskellDepends = [ base unix ];
       homepage = "https://gitlab.com/twittner/epoll";
       description = "epoll bindings";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "eprocess" = callPackage
    ({ mkDerivation, base, exceptions, mtl }:
     mkDerivation {
       pname = "eprocess";
       version = "1.7.2";
       sha256 = "726779125a7462d479625c71745b4b557e808f8b92be2ce19dab0522b17e18a4";
       libraryHaskellDepends = [ base exceptions mtl ];
       description = "Basic Erlang-like process support for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "epub" = callPackage
    ({ mkDerivation, base, bytestring, filepath, old-time, utf8-string
     , xml, zip-archive
     }:
     mkDerivation {
       pname = "epub";
       version = "0.0.7";
       sha256 = "42f0ca61a43015f1bb3f90fb5bc12ed1f64f48bb0e9dc447787652da304e3241";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring filepath old-time utf8-string xml zip-archive
       ];
       description = "EPUB E-Book construction support library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "epub-metadata" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , HUnit, hxt, mtl, regex-compat, zip-archive
     }:
     mkDerivation {
       pname = "epub-metadata";
       version = "4.3";
       sha256 = "d33be727a9e75fbbba889cd7fe6f502005d809c60720a2544b13bbadbdab853f";
       libraryHaskellDepends = [
         base bytestring containers directory filepath hxt mtl regex-compat
         zip-archive
       ];
       testHaskellDepends = [
         base bytestring directory filepath HUnit hxt mtl regex-compat
         zip-archive
       ];
       homepage = "http://hub.darcs.net/dino/epub-metadata";
       description = "Library for parsing epub document metadata";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "epub-tools" = callPackage
    ({ mkDerivation, base, bytestring, directory, epub-metadata
     , filepath, HUnit, mtl, parsec, process, regex-compat, zip-archive
     }:
     mkDerivation {
       pname = "epub-tools";
       version = "2.8";
       sha256 = "16a5004b4a408919a48e09f65f8ab1007132ddc2d9d0ffb2c5c1609f09395434";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory epub-metadata filepath mtl parsec process
         regex-compat zip-archive
       ];
       testHaskellDepends = [
         base directory epub-metadata filepath HUnit mtl parsec regex-compat
       ];
       homepage = "http://hub.darcs.net/dino/epub-tools";
       description = "Command line utilities for working with epub files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "epubname" = callPackage
    ({ mkDerivation, base, directory, epub-metadata, mtl, regex-compat
     }:
     mkDerivation {
       pname = "epubname";
       version = "2.3.2";
       sha256 = "035218066f6d067692fbf2d65b992e9a44735eca0f9ed4072c9574437e897bd0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory epub-metadata mtl regex-compat
       ];
       homepage = "http://ui3.info/d/proj/epubname.html";
       description = "Rename epub ebook files based on meta information";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "eq_4_0_3" = callPackage
    ({ mkDerivation, base, semigroupoids }:
     mkDerivation {
       pname = "eq";
       version = "4.0.3";
       sha256 = "c33aaede2d2228612ed906c1df906fc1e0aadea5edb54118daf0e5001b104ed8";
       libraryHaskellDepends = [ base semigroupoids ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/eq/";
       description = "Leibnizian equality";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "eq" = callPackage
    ({ mkDerivation, base, semigroupoids }:
     mkDerivation {
       pname = "eq";
       version = "4.0.4";
       sha256 = "042f4c1e9eeb25a52c20623fc482cc00e3235198089c5b60bc36fa47ebacbde5";
       libraryHaskellDepends = [ base semigroupoids ];
       homepage = "http://github.com/ekmett/eq/";
       description = "Leibnizian equality";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "equal-files" = callPackage
    ({ mkDerivation, base, bytestring, explicit-exception, filemanip
     , transformers, utility-ht
     }:
     mkDerivation {
       pname = "equal-files";
       version = "0.0.5.2";
       sha256 = "1c391e4f2e813d5aaaa77c849ce96f070fd0846d192fd0784fdf021075ebc91e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring explicit-exception filemanip transformers
         utility-ht
       ];
       homepage = "http://code.haskell.org/~thielema/equal-files/";
       description = "Shell command for finding equal files";
       license = "GPL";
     }) {};

  "equational-reasoning" = callPackage
    ({ mkDerivation, base, singletons, template-haskell, void }:
     mkDerivation {
       pname = "equational-reasoning";
       version = "0.2.0.7";
       sha256 = "8fb23a193f904527e632e0eaea89f42ad08caacbed133ac08af23e38baf32711";
       libraryHaskellDepends = [ base singletons template-haskell void ];
       description = "Proof assistant for Haskell using DataKinds & PolyKinds";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "equivalence" = callPackage
    ({ mkDerivation, base, containers, mtl, QuickCheck, STMonadTrans
     , template-haskell, test-framework, test-framework-quickcheck2
     , transformers, transformers-compat
     }:
     mkDerivation {
       pname = "equivalence";
       version = "0.3.1";
       sha256 = "7a0539546e4fc1a00fb190109be45b0cb4af7047d8c2abaf65b8e401e828207e";
       libraryHaskellDepends = [
         base containers mtl STMonadTrans transformers transformers-compat
       ];
       testHaskellDepends = [
         base containers mtl QuickCheck STMonadTrans template-haskell
         test-framework test-framework-quickcheck2 transformers
         transformers-compat
       ];
       homepage = "https://bitbucket.org/paba/equivalence/";
       description = "Maintaining an equivalence relation implemented as union-find using STT";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "erd" = callPackage
    ({ mkDerivation, base, bytestring, containers, graphviz, parsec
     , text
     }:
     mkDerivation {
       pname = "erd";
       version = "0.1.3.0";
       sha256 = "09b016a8a57003e92a3ea7f8150a4969fadd23b4bc21f245a0738a430e0e8e01";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers graphviz parsec text
       ];
       jailbreak = true;
       homepage = "https://github.com/BurntSushi/erd";
       description = "An entity-relationship diagram generator from a plain text description";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "erf" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "erf";
       version = "2.0.0.0";
       sha256 = "24f0b79c7e1d25cb2cd44c2258d7a464bf6db8079775b50b60b54a254616b337";
       libraryHaskellDepends = [ base ];
       description = "The error function, erf, and related functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "erf-native" = callPackage
    ({ mkDerivation, base, polynomial }:
     mkDerivation {
       pname = "erf-native";
       version = "1.0.0.1";
       sha256 = "6cb2b9ba4150f8da004cfcdbe15a3e7fa24ebd9b1713625fa1322714340f0344";
       libraryHaskellDepends = [ base polynomial ];
       homepage = "http://code.haskell.org/~mokus/erf-native";
       description = "Native Haskell implementation of the interface from the erf package";
       license = "GPL";
     }) {};

  "erlang" = callPackage
    ({ mkDerivation, base, binary, bytestring, directory, filepath
     , MissingH, network, random
     }:
     mkDerivation {
       pname = "erlang";
       version = "0.2.1";
       sha256 = "7322f24dcc10cfde8a2f9afa6835893b93b7b4c3e20f7514a24ca6d169b7f334";
       libraryHaskellDepends = [
         base binary bytestring directory filepath MissingH network random
       ];
       homepage = "http://github.com/gombocarti/erlang-ffi";
       description = "FFI interface to Erlang";
       license = "GPL";
     }) {};

  "eros" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, text }:
     mkDerivation {
       pname = "eros";
       version = "0.6.0.0";
       sha256 = "3c53decd098d5da2ae5bdc1fcdf1c4268ea3ccca7466e92f28518281b160205b";
       libraryHaskellDepends = [ aeson base bytestring containers text ];
       jailbreak = true;
       description = "A text censorship library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "eros-client" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
     , eros, text
     }:
     mkDerivation {
       pname = "eros-client";
       version = "0.5.0.1";
       sha256 = "8b6574cd7a65f61c309f07933eeb2443232d92337f8e4da2edd7ed15e124f196";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson aeson-pretty base bytestring containers eros text
       ];
       jailbreak = true;
       description = "DEPRECATED in favor of eros-http";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "eros-http" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, bytestring, eros
     , http-types, markdown, text, wai, warp
     }:
     mkDerivation {
       pname = "eros-http";
       version = "0.6.0.1";
       sha256 = "d37729af17787e0d170441437aa96fe68b2e6cdca0cabb97c563ad2dbfe6ebb0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base blaze-html bytestring eros http-types markdown text wai
         warp
       ];
       jailbreak = true;
       description = "JSON HTTP interface to Eros";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "errno" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "errno";
       version = "0.1";
       sha256 = "ca8170efa40857aa988e6cfd8f44bcbc7d64a80de0c53cd87297082696093d4a";
       libraryHaskellDepends = [ base mtl ];
       description = "a FFI utility";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "error-analyze" = callPackage
    ({ mkDerivation, base, HUnit, tasty, tasty-hunit, text }:
     mkDerivation {
       pname = "error-analyze";
       version = "0.0.1";
       sha256 = "7e944f26c934f38e7baed53def81900188e9593dc119baef355bd2cd98350c75";
       libraryHaskellDepends = [ base text ];
       testHaskellDepends = [ base HUnit tasty tasty-hunit text ];
       description = "Parse ghc and cabal error messages and give their causes for easier resolution";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "error-continuations" = callPackage
    ({ mkDerivation, base, either, mtl, transformers }:
     mkDerivation {
       pname = "error-continuations";
       version = "0.1.0.0";
       sha256 = "3ab057e6686e4d3f3e40266fefba2a314cff087db29e9274c4036447a14b6567";
       libraryHaskellDepends = [ base either mtl transformers ];
       jailbreak = true;
       homepage = "https://github.com/echatav/error-continuations";
       description = "Error Continuations";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "error-list" = callPackage
    ({ mkDerivation, base, mtl, text, text-render }:
     mkDerivation {
       pname = "error-list";
       version = "0.1.0.3";
       sha256 = "3248165acff3927d9e7f9aee206a146e285a9a17a7cd574b10a540f298be194c";
       libraryHaskellDepends = [ base mtl text text-render ];
       homepage = "http://github.com/thinkpad20/error-list";
       description = "A useful type for collecting error messages";
       license = stdenv.lib.licenses.mit;
     }) {};

  "error-loc" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "error-loc";
       version = "0.1.0.0";
       sha256 = "a52e905a87edc15a1788e38de53f600c1c4f744e3bb08ac7f3a25c7746610732";
       libraryHaskellDepends = [ base template-haskell ];
       jailbreak = true;
       homepage = "https://github.com/joelteon/error-loc";
       description = "An error replacement with call-site metadata";
       license = stdenv.lib.licenses.mit;
     }) {};

  "error-location" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "error-location";
       version = "0.1.5.5";
       sha256 = "2dfa1a0e258da3895f5225784b8d3c6ce874d16ab69c1df5eac298a7b61cd1bd";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "https://github.com/gregwebs/ErrorLocation.hs";
       description = "error functions that show file location information";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "error-message" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, containers, either-unwrap
     , InfixApplicative, mtl
     }:
     mkDerivation {
       pname = "error-message";
       version = "1.1";
       sha256 = "c91df7156f955fb26278224fdc3c6e1ffba079cebf356b56bd01f594072ddf76";
       libraryHaskellDepends = [
         ansi-wl-pprint base containers either-unwrap InfixApplicative mtl
       ];
       jailbreak = true;
       homepage = "http://github.com/gcross/error-message";
       description = "Composable error messages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "error-util" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "error-util";
       version = "0.0.1.1";
       sha256 = "68d133f2211d9be2f66f7529d1d2251ec13f12f9ccdd5f1c96be53f09cf3e193";
       libraryHaskellDepends = [ base transformers ];
       homepage = "http://github.com/pmlodawski/error-util";
       description = "Set of utils and operators for error handling";
       license = stdenv.lib.licenses.mit;
     }) {};

  "errorcall-eq-instance_0_1_0" = callPackage
    ({ mkDerivation, base, hspec, QuickCheck }:
     mkDerivation {
       pname = "errorcall-eq-instance";
       version = "0.1.0";
       sha256 = "733e93c432589bb44adab87cea3b5b1dc479b90da0ed1d1957ed7edc56e722eb";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec QuickCheck ];
       description = "An orphan Eq instance for ErrorCall";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "errorcall-eq-instance_0_2_0" = callPackage
    ({ mkDerivation, base, base-compat, hspec, QuickCheck }:
     mkDerivation {
       pname = "errorcall-eq-instance";
       version = "0.2.0";
       sha256 = "d6c8a54f8b21f039476313248490db2094941a8f032656b6ffcc5c782a7103c3";
       revision = "1";
       editedCabalFile = "3fbf227797a535c61367011e105c8b0131e679ebac4926180bff6ef2bbf4b561";
       libraryHaskellDepends = [ base base-compat ];
       testHaskellDepends = [ base hspec QuickCheck ];
       jailbreak = true;
       description = "An orphan Eq instance for ErrorCall";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "errorcall-eq-instance_0_2_0_1" = callPackage
    ({ mkDerivation, base, base-compat, hspec, QuickCheck }:
     mkDerivation {
       pname = "errorcall-eq-instance";
       version = "0.2.0.1";
       sha256 = "05ff3fb1bc3e80d64ae7af457d77f912abadd10d0ee9cd279ca9da2510e2c235";
       revision = "1";
       editedCabalFile = "9a3191d098a6aed54fac811a35a54e275dcb0332ba9c5c1fbf05aa2cfbd89b37";
       libraryHaskellDepends = [ base base-compat ];
       testHaskellDepends = [ base hspec QuickCheck ];
       jailbreak = true;
       description = "An orphan Eq instance for ErrorCall";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "errorcall-eq-instance" = callPackage
    ({ mkDerivation, base, base-orphans, hspec, QuickCheck }:
     mkDerivation {
       pname = "errorcall-eq-instance";
       version = "0.3.0";
       sha256 = "5546a810408b1d253dd439d58c570407f4f6e11a68f1f676f13daf85aa401c43";
       libraryHaskellDepends = [ base base-orphans ];
       testHaskellDepends = [ base hspec QuickCheck ];
       description = "An orphan Eq instance for ErrorCall";
       license = stdenv.lib.licenses.mit;
     }) {};

  "errors_1_4_7" = callPackage
    ({ mkDerivation, base, either, safe, transformers }:
     mkDerivation {
       pname = "errors";
       version = "1.4.7";
       sha256 = "8732ebeae477feeb5b669532bc6ffc985f7b115e13fe823bbc816b4e7d1be525";
       libraryHaskellDepends = [ base either safe transformers ];
       description = "Simplified error-handling";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "errors_2_0_0" = callPackage
    ({ mkDerivation, base, safe, transformers }:
     mkDerivation {
       pname = "errors";
       version = "2.0.0";
       sha256 = "4527db37c2560b9b3a96eab58c632bf1fbb5e2d530b378eb9043ecedb0de4703";
       libraryHaskellDepends = [ base safe transformers ];
       description = "Simplified error-handling";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "errors_2_0_1" = callPackage
    ({ mkDerivation, base, safe, transformers, transformers-compat }:
     mkDerivation {
       pname = "errors";
       version = "2.0.1";
       sha256 = "7e5585e4a9fafd64b39825ff6d5d6872fe000db0be5f968d8d619cb6a0c997f0";
       libraryHaskellDepends = [
         base safe transformers transformers-compat
       ];
       jailbreak = true;
       description = "Simplified error-handling";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "errors_2_1_1" = callPackage
    ({ mkDerivation, base, safe, transformers, transformers-compat
     , unexceptionalio
     }:
     mkDerivation {
       pname = "errors";
       version = "2.1.1";
       sha256 = "28002b14fd33135870ed8fad398aeef3c43f1cfb2501ad2e4d9d72f0a3bf19d3";
       libraryHaskellDepends = [
         base safe transformers transformers-compat unexceptionalio
       ];
       description = "Simplified error-handling";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "errors" = callPackage
    ({ mkDerivation, base, safe, transformers, transformers-compat
     , unexceptionalio
     }:
     mkDerivation {
       pname = "errors";
       version = "2.1.2";
       sha256 = "5c818778b88b76eca016348a04395c1d4913d7c125c0b9c0a1ccf69accf9d887";
       libraryHaskellDepends = [
         base safe transformers transformers-compat unexceptionalio
       ];
       description = "Simplified error-handling";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ersatz_0_2_6_1" = callPackage
    ({ mkDerivation, array, base, blaze-builder, blaze-textual
     , bytestring, containers, data-default, data-reify, directory
     , doctest, filepath, HUnit, lens, mtl, parsec, process, QuickCheck
     , temporary, test-framework, test-framework-hunit
     , test-framework-quickcheck, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "ersatz";
       version = "0.2.6.1";
       sha256 = "52e62e2a44349dc1d6202f0555131aaa213584a6affde2e42fee10c67c2276c1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base blaze-builder blaze-textual bytestring containers
         data-default lens mtl process temporary transformers
         unordered-containers
       ];
       executableHaskellDepends = [
         array base containers lens mtl parsec
       ];
       testHaskellDepends = [
         array base containers data-reify directory doctest filepath HUnit
         mtl QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck transformers
       ];
       doHaddock = false;
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ersatz" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, data-default
     , directory, doctest, filepath, lens, mtl, parsec, process
     , temporary, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "ersatz";
       version = "0.3";
       sha256 = "79dd8a7783cfc33597a6626238809096f31a4537e32b9d90008cef1c786306c3";
       revision = "3";
       editedCabalFile = "aafa6482bcf20d998dfc122b780b0378ec05187235252f4715e98bac02fc5b6c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers data-default lens mtl process
         temporary transformers unordered-containers
       ];
       executableHaskellDepends = [
         array base containers lens mtl parsec
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ersatz-toysat" = callPackage
    ({ mkDerivation, array, base, containers, ersatz, toysolver
     , transformers
     }:
     mkDerivation {
       pname = "ersatz-toysat";
       version = "0.2.1.0";
       sha256 = "b83980c6f537ab812ac8605a9fe8c3bb9764bb5ae098e20ef882fd5aa824f7b6";
       revision = "1";
       editedCabalFile = "146f86cb3df790cd26c0ec2f7061027257c7932a64ff8a6725eee5356a887776";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers ersatz toysolver transformers
       ];
       homepage = "https://github.com/msakai/ersatz-toysat";
       description = "toysat driver as backend for ersatz";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ert" = callPackage
    ({ mkDerivation, aeson, attoparsec, attoparsec-expr, base
     , bytestring, regex-compat, text, unordered-containers, vector
     , yaml
     }:
     mkDerivation {
       pname = "ert";
       version = "0.0.2.1";
       sha256 = "2f0a2cddf236bef3c5902c183f516f0d58cb2cacf4cfdc07634f6592e33e8a45";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec attoparsec-expr base bytestring regex-compat text
         unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson attoparsec base bytestring yaml
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/kayo/ert";
       description = "Easy Runtime Templates";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "esotericbot" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , directory, fgl, mtl, network, stm, stream-fusion, tuple, unix
     }:
     mkDerivation {
       pname = "esotericbot";
       version = "0.0.6";
       sha256 = "470f51be83e687f0b28c4377e5e46b0128953314b503f524b62008e748f2e764";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring containers directory fgl mtl network stm
         stream-fusion tuple unix
       ];
       executableHaskellDepends = [
         attoparsec base bytestring containers directory fgl mtl network stm
         stream-fusion tuple unix
       ];
       doHaddock = false;
       jailbreak = true;
       homepage = "http://www.killersmurf.com/projects/esotericbot";
       description = "Esotericbot is a sophisticated, lightweight IRC bot";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "esqueleto_2_1_2_1" = callPackage
    ({ mkDerivation, base, conduit, containers, hspec, HUnit
     , monad-control, monad-logger, persistent, persistent-sqlite
     , persistent-template, QuickCheck, resourcet, tagged, text
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "esqueleto";
       version = "2.1.2.1";
       sha256 = "f1e413058d54234066d0efb4db7e1b95689162a59db422db7e36f79ed784d653";
       libraryHaskellDepends = [
         base conduit monad-logger persistent resourcet tagged text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         base conduit containers hspec HUnit monad-control monad-logger
         persistent persistent-sqlite persistent-template QuickCheck
         resourcet text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/prowdsponsor/esqueleto";
       description = "Type-safe EDSL for SQL queries on persistent backends";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "esqueleto_2_1_2_2" = callPackage
    ({ mkDerivation, base, conduit, containers, hspec, HUnit
     , monad-control, monad-logger, persistent, persistent-sqlite
     , persistent-template, QuickCheck, resourcet, tagged, text
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "esqueleto";
       version = "2.1.2.2";
       sha256 = "46d92fc7e9c560aa04fd76b966545044b9dd0d835996592231581fea06dd74ea";
       libraryHaskellDepends = [
         base conduit monad-logger persistent resourcet tagged text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         base conduit containers hspec HUnit monad-control monad-logger
         persistent persistent-sqlite persistent-template QuickCheck
         resourcet text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/prowdsponsor/esqueleto";
       description = "Type-safe EDSL for SQL queries on persistent backends";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "esqueleto_2_1_2_3" = callPackage
    ({ mkDerivation, base, conduit, containers, hspec, HUnit
     , monad-control, monad-logger, persistent, persistent-sqlite
     , persistent-template, QuickCheck, resourcet, tagged, text
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "esqueleto";
       version = "2.1.2.3";
       sha256 = "39a28a77363d56e44e9e17fc041d8857923010985dcef75c8d6242d47a92445d";
       libraryHaskellDepends = [
         base conduit monad-logger persistent resourcet tagged text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         base conduit containers hspec HUnit monad-control monad-logger
         persistent persistent-sqlite persistent-template QuickCheck
         resourcet text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/prowdsponsor/esqueleto";
       description = "Type-safe EDSL for SQL queries on persistent backends";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "esqueleto_2_1_3" = callPackage
    ({ mkDerivation, base, conduit, containers, hspec, HUnit
     , monad-control, monad-logger, persistent, persistent-sqlite
     , persistent-template, QuickCheck, resourcet, tagged, text
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "esqueleto";
       version = "2.1.3";
       sha256 = "2d6da3477660212ed7cddec606d0324537b39ef24abe627ba389a0da500158f3";
       libraryHaskellDepends = [
         base conduit monad-logger persistent resourcet tagged text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         base conduit containers hspec HUnit monad-control monad-logger
         persistent persistent-sqlite persistent-template QuickCheck
         resourcet text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/prowdsponsor/esqueleto";
       description = "Type-safe EDSL for SQL queries on persistent backends";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "esqueleto_2_4_1" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, conduit, containers
     , hspec, HUnit, monad-control, monad-logger, persistent
     , persistent-sqlite, persistent-template, QuickCheck, resourcet
     , tagged, text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "esqueleto";
       version = "2.4.1";
       sha256 = "12cc83bd2774906c29df20be8b77d11e0fc6efedadf208714494dc406cd8f7fd";
       libraryHaskellDepends = [
         base blaze-html bytestring conduit monad-logger persistent
         resourcet tagged text transformers unordered-containers
       ];
       testHaskellDepends = [
         base conduit containers hspec HUnit monad-control monad-logger
         persistent persistent-sqlite persistent-template QuickCheck
         resourcet text transformers
       ];
       homepage = "https://github.com/prowdsponsor/esqueleto";
       description = "Type-safe EDSL for SQL queries on persistent backends";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "esqueleto_2_4_2" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, conduit, containers
     , hspec, HUnit, monad-control, monad-logger, persistent
     , persistent-sqlite, persistent-template, QuickCheck, resourcet
     , tagged, text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "esqueleto";
       version = "2.4.2";
       sha256 = "bd5207df73339bf22f426dde9e6945d5a9376a7e12c5a3948291e75d4468174f";
       libraryHaskellDepends = [
         base blaze-html bytestring conduit monad-logger persistent
         resourcet tagged text transformers unordered-containers
       ];
       testHaskellDepends = [
         base conduit containers hspec HUnit monad-control monad-logger
         persistent persistent-sqlite persistent-template QuickCheck
         resourcet text transformers
       ];
       homepage = "https://github.com/prowdsponsor/esqueleto";
       description = "Type-safe EDSL for SQL queries on persistent backends";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "esqueleto" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, conduit, containers
     , hspec, HUnit, monad-control, monad-logger, persistent
     , persistent-sqlite, persistent-template, QuickCheck, resourcet
     , tagged, text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "esqueleto";
       version = "2.4.3";
       sha256 = "bf555cfb40519ed1573f7bb90c65f693b9639dfa93fc2222230d3ded6e897434";
       libraryHaskellDepends = [
         base blaze-html bytestring conduit monad-logger persistent
         resourcet tagged text transformers unordered-containers
       ];
       testHaskellDepends = [
         base conduit containers hspec HUnit monad-control monad-logger
         persistent persistent-sqlite persistent-template QuickCheck
         resourcet text transformers
       ];
       homepage = "https://github.com/prowdsponsor/esqueleto";
       description = "Type-safe EDSL for SQL queries on persistent backends";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ess" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ess";
       version = "0.1.0.0";
       sha256 = "98ad5094a53857d5817e3e0b8e9b5572cfe80a6b3d139c5a0d863d9377d2b95f";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/michaelochurch/ess";
       description = "The type-level S combinator in Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "estimator" = callPackage
    ({ mkDerivation, ad, base, distributive, lens, linear, reflection
     }:
     mkDerivation {
       pname = "estimator";
       version = "1.1.0.1";
       sha256 = "f8e923df2dd45bcd2586facfed745334e0bced69c1da33e757bdeb0a313ac3e9";
       libraryHaskellDepends = [
         ad base distributive lens linear reflection
       ];
       jailbreak = true;
       homepage = "https://github.com/GaloisInc/estimator";
       description = "State-space estimation algorithms such as Kalman Filters";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "estimators" = callPackage
    ({ mkDerivation, base, binary, containers, deepseq, list-tries
     , MonadRandom, mtl, pretty, prettyclass, QuickCheck, text
     }:
     mkDerivation {
       pname = "estimators";
       version = "0.1.4";
       sha256 = "9e3d655ca937477e3c281915c7b7ba0ee01c34cbb96b376b70e35464bc12f258";
       libraryHaskellDepends = [
         base binary containers deepseq list-tries MonadRandom mtl pretty
         prettyclass QuickCheck text
       ];
       jailbreak = true;
       description = "Tool for managing probability estimation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "estreps" = callPackage
    ({ mkDerivation, base, bio, bytestring, containers, random }:
     mkDerivation {
       pname = "estreps";
       version = "0.3.1";
       sha256 = "f1be3703590f24ed6572e6bcde286ae56ce4c990e3df0fe5bf95326e9fc71780";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bio bytestring containers random
       ];
       jailbreak = true;
       homepage = "http://blog.malde.org/";
       description = "Repeats from ESTs";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "etcd" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, hspec
     , http-conduit, MonadRandom, mtl, text, time
     }:
     mkDerivation {
       pname = "etcd";
       version = "1.0.5";
       sha256 = "916fc01e40cc5488f54fea8c623b31087b364432a78acffd95825f5bd1311f2f";
       revision = "1";
       editedCabalFile = "5cdbbc8d2aedc68e82e7c4d0cface390c3c68fb7ee7fb162d8123e42351f98fa";
       libraryHaskellDepends = [
         aeson base bytestring http-conduit text time
       ];
       testHaskellDepends = [ async base hspec MonadRandom mtl text ];
       doCheck = false;
       description = "Client for etcd, a highly-available key value store";
       license = "unknown";
     }) {};

  "eternal" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, transformers
     , utf8-string
     }:
     mkDerivation {
       pname = "eternal";
       version = "0.1.3";
       sha256 = "9db1f4e585dab1a838310d746799dc59db6840575c9c3b82e7fca0b1f939ecef";
       libraryHaskellDepends = [
         base base-unicode-symbols transformers utf8-string
       ];
       description = "everything breaking the Fairbairn threshold";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ether_0_3_0_0" = callPackage
    ({ mkDerivation, base, mmorph, monad-control, mtl, newtype-generics
     , QuickCheck, tasty, tasty-quickcheck, template-haskell
     , transformers, transformers-base, transformers-lift
     }:
     mkDerivation {
       pname = "ether";
       version = "0.3.0.0";
       sha256 = "95809576f8e3c7920543e5eb50d1344ffea99a56830f67ae361c4c767d000fcd";
       libraryHaskellDepends = [
         base mmorph monad-control mtl newtype-generics template-haskell
         transformers transformers-base transformers-lift
       ];
       testHaskellDepends = [
         base mtl QuickCheck tasty tasty-quickcheck transformers
       ];
       homepage = "https://int-index.github.io/ether/";
       description = "Monad transformers and classes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ether_0_3_1_1" = callPackage
    ({ mkDerivation, base, mmorph, monad-control, mtl, newtype-generics
     , QuickCheck, tasty, tasty-quickcheck, template-haskell
     , transformers, transformers-base, transformers-lift
     }:
     mkDerivation {
       pname = "ether";
       version = "0.3.1.1";
       sha256 = "bafa8037e0ee2fef84b7e14e6064a7c4ce72d4acabd72da5ed58cb4ead1b00b1";
       libraryHaskellDepends = [
         base mmorph monad-control mtl newtype-generics template-haskell
         transformers transformers-base transformers-lift
       ];
       testHaskellDepends = [
         base mtl QuickCheck tasty tasty-quickcheck transformers
       ];
       homepage = "https://int-index.github.io/ether/";
       description = "Monad transformers and classes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ether" = callPackage
    ({ mkDerivation, base, exceptions, mmorph, monad-control, mtl
     , QuickCheck, tasty, tasty-quickcheck, template-haskell
     , transformers, transformers-base, transformers-lift
     }:
     mkDerivation {
       pname = "ether";
       version = "0.4.0.0";
       sha256 = "19470d47313c0fe2984010871c8d13398b9c13d4cdc799b9bd0e431bc9714d6e";
       libraryHaskellDepends = [
         base exceptions mmorph monad-control mtl template-haskell
         transformers transformers-base transformers-lift
       ];
       testHaskellDepends = [
         base mtl QuickCheck tasty tasty-quickcheck transformers
       ];
       homepage = "https://int-index.github.io/ether/";
       description = "Monad transformers and classes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ethereum-client-haskell" = callPackage
    ({ mkDerivation, ansi-wl-pprint, array, base, base16-bytestring
     , binary, bytestring, cmdargs, containers, cryptohash, data-default
     , directory, either, entropy, ethereum-merkle-patricia-db
     , ethereum-rlp, filepath, haskoin, HUnit, leveldb-haskell, mtl
     , network, network-simple, nibblestring, resourcet, test-framework
     , test-framework-hunit, time, transformers, vector
     }:
     mkDerivation {
       pname = "ethereum-client-haskell";
       version = "0.0.4";
       sha256 = "cc2d4cda0e9f9ea0469b28ac3134128b913b498830fe90abc4ea92b98ede7b36";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-wl-pprint array base base16-bytestring binary bytestring
         cmdargs containers cryptohash data-default directory either entropy
         ethereum-merkle-patricia-db ethereum-rlp filepath haskoin
         leveldb-haskell mtl network network-simple nibblestring resourcet
         time transformers vector
       ];
       testHaskellDepends = [
         base containers HUnit test-framework test-framework-hunit
       ];
       description = "A Haskell version of an Ethereum client";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ethereum-merkle-patricia-db" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, base16-bytestring, binary
     , bytestring, containers, cryptohash, data-default, ethereum-rlp
     , HUnit, leveldb-haskell, nibblestring, resourcet, test-framework
     , test-framework-hunit, transformers
     }:
     mkDerivation {
       pname = "ethereum-merkle-patricia-db";
       version = "0.0.1";
       sha256 = "287bf459d752346727085f2b1bcd1dc8786d2d732786ca53a2368d509562b65f";
       libraryHaskellDepends = [
         ansi-wl-pprint base base16-bytestring binary bytestring cryptohash
         data-default ethereum-rlp leveldb-haskell nibblestring resourcet
       ];
       testHaskellDepends = [
         ansi-wl-pprint base base16-bytestring binary bytestring containers
         cryptohash data-default ethereum-rlp HUnit leveldb-haskell
         nibblestring resourcet test-framework test-framework-hunit
         transformers
       ];
       description = "A modified Merkle Patricia DB";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ethereum-rlp" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, base16-bytestring
     , bytestring, HUnit, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "ethereum-rlp";
       version = "0.0.1";
       sha256 = "25276bc29110900f8d1a5cf743ee3a1fe4d81d7ef2a3c8eb317d1ee11bb4a5c3";
       libraryHaskellDepends = [
         ansi-wl-pprint base base16-bytestring bytestring
       ];
       testHaskellDepends = [
         ansi-wl-pprint base base16-bytestring bytestring HUnit
         test-framework test-framework-hunit
       ];
       description = "Ethereum Recursive Length Prefix Encoding";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ety" = callPackage
    ({ mkDerivation, base, bytestring, curl, random, text-icu
     , utf8-string, xml
     }:
     mkDerivation {
       pname = "ety";
       version = "0.1";
       sha256 = "57dc267d92cc3a935b6207a41bb595054f228e836e27e092ba01001c14e3bb98";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring curl random text-icu utf8-string xml
       ];
       executableHaskellDepends = [
         base bytestring curl random text-icu utf8-string xml
       ];
       description = "Random etymology online entry";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "euler" = callPackage
    ({ mkDerivation, base, directory, happy, hlint, hspec, process
     , regex-posix, xml
     }:
     mkDerivation {
       pname = "euler";
       version = "0.9.2";
       sha256 = "054e53786a5f010afef5121639d270f4697d8d92f280651853cfd1858baff091";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base directory hlint hspec process regex-posix xml
       ];
       testToolDepends = [ happy ];
       jailbreak = true;
       homepage = "https://github.com/decomputed/euler";
       description = "Mathematics utilities for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "euphoria" = callPackage
    ({ mkDerivation, base, containers, data-default, deepseq, elerea
     , enummapset-th, hashable, HUnit, test-framework
     , test-framework-hunit, test-framework-th, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "euphoria";
       version = "0.6.0.1";
       sha256 = "a92641035be6dba46d44b9c24d227ba6a5c59e19eba862e91ac883216939b4ae";
       libraryHaskellDepends = [
         base containers data-default deepseq elerea enummapset-th hashable
         HUnit transformers unordered-containers
       ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit test-framework-th
       ];
       homepage = "http://github.com/tsurucapital/euphoria";
       description = "Dynamic network FRP with events and continuous values";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "eurofxref" = callPackage
    ({ mkDerivation, base, bytestring, conduit, containers, failure
     , hexpat, http-conduit, http-types, monad-control, mtl, time
     }:
     mkDerivation {
       pname = "eurofxref";
       version = "0.2.1";
       sha256 = "a9238366d4eb8830b5c82f739b040cfa8ecd9201e07b9f09b68273e1671e4e7e";
       libraryHaskellDepends = [
         base bytestring conduit containers failure hexpat http-conduit
         http-types monad-control mtl time
       ];
       jailbreak = true;
       description = "Free foreign exchange/currency feed from the European Central Bank";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "event_0_1_1" = callPackage
    ({ mkDerivation, base, containers, semigroups, transformers }:
     mkDerivation {
       pname = "event";
       version = "0.1.1";
       sha256 = "a662dcffaf1b0970b0a35eb395a5e8593b1e0b09c02041b1a0bd35b59a382da4";
       libraryHaskellDepends = [
         base containers semigroups transformers
       ];
       jailbreak = true;
       description = "Monoidal, monadic and first-class events";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "event_0_1_2" = callPackage
    ({ mkDerivation, base, containers, semigroups, transformers }:
     mkDerivation {
       pname = "event";
       version = "0.1.2";
       sha256 = "8adbd4459d553c07dc1a60155ca64e0fd478d2c62ac9a302c0b913c1595942c7";
       libraryHaskellDepends = [
         base containers semigroups transformers
       ];
       jailbreak = true;
       description = "Monoidal, monadic and first-class events";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "event_0_1_2_1" = callPackage
    ({ mkDerivation, base, containers, semigroups, transformers }:
     mkDerivation {
       pname = "event";
       version = "0.1.2.1";
       sha256 = "2a14209d4788d810181bed2fc13f534c51399cfbe29f648d6a44edd9a3db4c22";
       libraryHaskellDepends = [
         base containers semigroups transformers
       ];
       description = "Monoidal, monadic and first-class events";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "event" = callPackage
    ({ mkDerivation, base, containers, semigroups, transformers }:
     mkDerivation {
       pname = "event";
       version = "0.1.3";
       sha256 = "5968eb8c2bac404b48a6e18a110465a21198791fd187740f160f43459b52525a";
       libraryHaskellDepends = [
         base containers semigroups transformers
       ];
       description = "Monoidal, monadic and first-class events";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "event-driven" = callPackage
    ({ mkDerivation, base, monads-tf, yjtools }:
     mkDerivation {
       pname = "event-driven";
       version = "0.0.2";
       sha256 = "572d4e3eee8d12e0525c86fde21cdea5df1711c8cf0cb95d495af608666079ca";
       libraryHaskellDepends = [ base monads-tf yjtools ];
       description = "library for event driven programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "event-handlers" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "event-handlers";
       version = "0.0.0.3";
       sha256 = "8d26d54ee234569b9aabbcd0cbecd2ee5fd8b21235db587e2121cf0667d82594";
       libraryHaskellDepends = [ base containers ];
       homepage = "http://code.haskell.org/~mokus/event-handlers";
       description = "Event handlers";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "event-list" = callPackage
    ({ mkDerivation, base, non-negative, QuickCheck, random
     , transformers, utility-ht
     }:
     mkDerivation {
       pname = "event-list";
       version = "0.1.1.3";
       sha256 = "f58250c839eab441221fdfcc82795f4a4bddd397cd08dc02729ebe3bb05e8416";
       libraryHaskellDepends = [
         base non-negative QuickCheck transformers utility-ht
       ];
       testHaskellDepends = [
         base non-negative QuickCheck random transformers utility-ht
       ];
       homepage = "http://code.haskell.org/~thielema/event-list/";
       description = "Event lists with relative or absolute time stamps";
       license = "GPL";
     }) {};

  "event-monad" = callPackage
    ({ mkDerivation, base, containers, event-handlers, haskell98
     , monad-loops, mtl, pretty, prettyclass, priority-queue, stateref
     }:
     mkDerivation {
       pname = "event-monad";
       version = "0.0.3";
       sha256 = "c4fd174c9b23eef22d9a94d3b8957d1ff66447ba0b8cd29fb3413512533a1ade";
       libraryHaskellDepends = [
         base containers event-handlers haskell98 monad-loops mtl pretty
         prettyclass priority-queue stateref
       ];
       homepage = "http://code.haskell.org/~mokus/event-monad";
       description = "Event-graph simulation monad transformer";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "eventloop" = callPackage
    ({ mkDerivation, aeson, base, bytestring, concurrent-utilities
     , deepseq, network, stm, suspend, text, timers, websockets
     }:
     mkDerivation {
       pname = "eventloop";
       version = "0.7.0.1";
       sha256 = "4798d3a5ce6c2daf8f11b3f6aa8eed1ae411894da12a278dd7686b4b4c487b1e";
       libraryHaskellDepends = [
         aeson base bytestring concurrent-utilities deepseq network stm
         suspend text timers websockets
       ];
       jailbreak = true;
       homepage = "-";
       description = "A different take on an IO system. Based on Amanda's IO loop, this eventloop takes a function that maps input events to output events. It can easily be extended by modules that represent IO devices or join multiple modules together.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "eventstore_0_10_0_1" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, cereal, containers
     , network, protobuf, random, stm, tasty, tasty-hunit, text, time
     , unordered-containers, uuid
     }:
     mkDerivation {
       pname = "eventstore";
       version = "0.10.0.1";
       sha256 = "feb924dddfa68f75c2513725c1f5b7e7035ac21fdf5c8903b0cf486ddf8f3867";
       libraryHaskellDepends = [
         aeson async base bytestring cereal containers network protobuf
         random stm text time unordered-containers uuid
       ];
       testHaskellDepends = [
         aeson base stm tasty tasty-hunit text time
       ];
       doCheck = false;
       homepage = "http://github.com/YoEight/eventstore";
       description = "EventStore TCP Client";
       license = stdenv.lib.licenses.bsd3;
       platforms = [ "x86_64-darwin" "x86_64-linux" ];
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "eventstore" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, cereal, containers
     , network, protobuf, random, stm, tasty, tasty-hunit, text, time
     , unordered-containers, uuid
     }:
     mkDerivation {
       pname = "eventstore";
       version = "0.10.0.2";
       sha256 = "dab85bb0b250c01b36665a2e4945ad6b249cfa2d4d0cd2cbcd564f1b9ad575c8";
       libraryHaskellDepends = [
         aeson async base bytestring cereal containers network protobuf
         random stm text time unordered-containers uuid
       ];
       testHaskellDepends = [
         aeson base stm tasty tasty-hunit text time
       ];
       doCheck = false;
       homepage = "http://github.com/YoEight/eventstore";
       description = "EventStore TCP Client";
       license = stdenv.lib.licenses.bsd3;
       platforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "every-bit-counts" = callPackage
    ({ mkDerivation, base, haskell98 }:
     mkDerivation {
       pname = "every-bit-counts";
       version = "0.1";
       sha256 = "72133813f8de7a9cf0a6e0e9c8696a54a9d718d3fc817ba41e5cdbd27c4c2565";
       libraryHaskellDepends = [ base haskell98 ];
       homepage = "http://research.microsoft.com/en-us/people/dimitris/pearl.pdf";
       description = "A functional pearl on encoding and decoding using question-and-answer strategies";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ewe" = callPackage
    ({ mkDerivation, alex, array, base, containers, happy, mtl, pretty
     , transformers
     }:
     mkDerivation {
       pname = "ewe";
       version = "0.1.0.46";
       sha256 = "ce3c9bea5cad4c5e7e1d2243d3f67530c47b60dc9602106e0046924c9429ff1a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers mtl pretty transformers
       ];
       executableToolDepends = [ alex happy ];
       homepage = "http://github.com/jfcmacro/ewe";
       description = "A language for teaching simple programming languages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ex-pool" = callPackage
    ({ mkDerivation, base, exceptions, hashable, stm, time
     , transformers, vector
     }:
     mkDerivation {
       pname = "ex-pool";
       version = "0.2";
       sha256 = "6ad735f99183e91b93601ff7bd8b23ab556d8215f8590a3f118a3527687e4535";
       libraryHaskellDepends = [
         base exceptions hashable stm time transformers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/kim/ex-pool";
       description = "Another fork of resource-pool, with a MonadIO and MonadCatch constraint";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "exact-combinatorics" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "exact-combinatorics";
       version = "0.2.0.8";
       sha256 = "32a822b109ab6e9f62fe23d76bd5af593c20ba0e589005d3985ccda00dd4475e";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.haskell.org/~wren/";
       description = "Efficient exact computation of combinatoric functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "exact-pi_0_4_1_0" = callPackage
    ({ mkDerivation, base, numtype-dk }:
     mkDerivation {
       pname = "exact-pi";
       version = "0.4.1.0";
       sha256 = "ccee78d83c51a837613ba52af2e1aa1fb3be1366691eb156d450a1ac8a9343b9";
       libraryHaskellDepends = [ base numtype-dk ];
       homepage = "https://github.com/dmcclean/exact-pi";
       description = "Exact rational multiples of pi (and integer powers of pi)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "exact-pi" = callPackage
    ({ mkDerivation, base, numtype-dk }:
     mkDerivation {
       pname = "exact-pi";
       version = "0.4.1.1";
       sha256 = "ea5928688a202ae54fd7216dbaab073ae660ffec4b3165724d98c938cc1acad8";
       libraryHaskellDepends = [ base numtype-dk ];
       homepage = "https://github.com/dmcclean/exact-pi/";
       description = "Exact rational multiples of pi (and integer powers of pi)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "exact-real" = callPackage
    ({ mkDerivation, base, checkers, directory, doctest, filepath
     , groups, integer-gmp, memoize, QuickCheck, random, tasty
     , tasty-hunit, tasty-quickcheck, tasty-th
     }:
     mkDerivation {
       pname = "exact-real";
       version = "0.12.0";
       sha256 = "fcfdaeef23074efc26c49894c12b147a7eda32bd82af607147b0dc140119d938";
       libraryHaskellDepends = [ base integer-gmp memoize random ];
       testHaskellDepends = [
         base checkers directory doctest filepath groups QuickCheck random
         tasty tasty-hunit tasty-quickcheck tasty-th
       ];
       homepage = "http://github.com/expipiplus1/exact-real";
       description = "Exact real arithmetic";
       license = stdenv.lib.licenses.mit;
     }) {};

  "exception-hierarchy" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "exception-hierarchy";
       version = "0.0.0.2";
       sha256 = "8c899c08ce4cc7b3d599d1938ddfb12c03ac7b6088ed24a4ae1f62f1eb1d67d2";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "yet";
       description = "Exception type hierarchy with TemplateHaskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "exception-mailer" = callPackage
    ({ mkDerivation, base, hslogger, mime-mail, text }:
     mkDerivation {
       pname = "exception-mailer";
       version = "0.4.1";
       sha256 = "43a8080ce813dc918dddf6a9372a84d938666fb8d8a96e1cb0b1d10752861f19";
       libraryHaskellDepends = [ base hslogger mime-mail text ];
       homepage = "https://github.com/drpowell/exception-mailer";
       description = "Catch all runtime exceptions and send an email";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "exception-monads-fd" = callPackage
    ({ mkDerivation, base, exception-transformers, monads-fd
     , transformers
     }:
     mkDerivation {
       pname = "exception-monads-fd";
       version = "0.2";
       sha256 = "71d3a82f85ba38164fdfb69f11aafd288cd13dad7763053070c88029608a30f3";
       libraryHaskellDepends = [
         base exception-transformers monads-fd transformers
       ];
       jailbreak = true;
       homepage = "http://www.eecs.harvard.edu/~mainland/";
       description = "Exception monad transformer instances for monads-fd classes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "exception-monads-tf" = callPackage
    ({ mkDerivation, base, exception-transformers, monads-tf
     , transformers
     }:
     mkDerivation {
       pname = "exception-monads-tf";
       version = "0.4";
       sha256 = "0fa6b5abb40ae3b1cb8664cd955ec37d7ff17e73ccddacdeebbc5bf2806a2a4d";
       libraryHaskellDepends = [
         base exception-transformers monads-tf transformers
       ];
       description = "Exception monad transformer instances for monads-tf classes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "exception-mtl_0_3_0_5" = callPackage
    ({ mkDerivation, base, exception-transformers, mtl, transformers }:
     mkDerivation {
       pname = "exception-mtl";
       version = "0.3.0.5";
       sha256 = "12c781ef38903ed9044e7a5908b8b3896bba95fee5bd00574efc98ba788019e7";
       libraryHaskellDepends = [
         base exception-transformers mtl transformers
       ];
       jailbreak = true;
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "Exception monad transformer instances for mtl2 classes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "exception-mtl" = callPackage
    ({ mkDerivation, base, exception-transformers, mtl, transformers }:
     mkDerivation {
       pname = "exception-mtl";
       version = "0.4";
       sha256 = "438e51be3f4de26216d006e87dc8f3df86c4b28bf16f417b16d2a92268ef42f9";
       libraryHaskellDepends = [
         base exception-transformers mtl transformers
       ];
       description = "Exception monad transformer instances for mtl classes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "exception-transformers_0_3_0_4" = callPackage
    ({ mkDerivation, base, HUnit, stm, test-framework
     , test-framework-hunit, transformers
     }:
     mkDerivation {
       pname = "exception-transformers";
       version = "0.3.0.4";
       sha256 = "2a0b3e4863b05f9d9cd354787fc08cfc5d64080689ee9cf396ad7aebffe395d4";
       libraryHaskellDepends = [ base stm transformers ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit transformers
       ];
       jailbreak = true;
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "Type classes and monads for unchecked extensible exceptions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "exception-transformers_0_4_0_1" = callPackage
    ({ mkDerivation, base, HUnit, stm, test-framework
     , test-framework-hunit, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "exception-transformers";
       version = "0.4.0.1";
       sha256 = "d86902a151b8a440a331ed50c01d3fd9acf198881d4fb2468c5be7cc1537c4ab";
       libraryHaskellDepends = [
         base stm transformers transformers-compat
       ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit transformers
         transformers-compat
       ];
       jailbreak = true;
       description = "Type classes and monads for unchecked extensible exceptions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "exception-transformers_0_4_0_2" = callPackage
    ({ mkDerivation, base, HUnit, stm, test-framework
     , test-framework-hunit, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "exception-transformers";
       version = "0.4.0.2";
       sha256 = "d24ba7d2d96688f867cce18bb58d073515c679d083f7c900dcdef02333000452";
       libraryHaskellDepends = [
         base stm transformers transformers-compat
       ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit transformers
         transformers-compat
       ];
       jailbreak = true;
       description = "Type classes and monads for unchecked extensible exceptions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "exception-transformers" = callPackage
    ({ mkDerivation, base, HUnit, stm, test-framework
     , test-framework-hunit, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "exception-transformers";
       version = "0.4.0.3";
       sha256 = "0e8bd44231d6b5478f93cffa9c1f3e59ff44130c610fc20fcfa3880eb58d2a88";
       libraryHaskellDepends = [
         base stm transformers transformers-compat
       ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit transformers
         transformers-compat
       ];
       description = "Type classes and monads for unchecked extensible exceptions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "exceptional" = callPackage
    ({ mkDerivation, base, exceptions }:
     mkDerivation {
       pname = "exceptional";
       version = "0.3.0.0";
       sha256 = "da866ed28ea14d245cc065271f4ddd6da0a91b83e8d83daddcd1ef0623e99f06";
       libraryHaskellDepends = [ base exceptions ];
       homepage = "https://github.com/";
       description = "Essentially the Maybe type with error messages";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "exceptions_0_6_1" = callPackage
    ({ mkDerivation, base, mtl, QuickCheck, test-framework
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "exceptions";
       version = "0.6.1";
       sha256 = "f56b3f97f5ad49c6e7efde386683ec52c8c4b853bbdda068690e913db52c5b26";
       revision = "1";
       editedCabalFile = "e86a40308d3a603a445e0fc2989d83fbf4216e96e7d241e7703e4394442ac9d6";
       libraryHaskellDepends = [ base mtl transformers ];
       testHaskellDepends = [
         base mtl QuickCheck test-framework test-framework-quickcheck2
         transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/exceptions/";
       description = "Extensible optionally-pure exceptions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "exceptions_0_8_0_2" = callPackage
    ({ mkDerivation, base, mtl, QuickCheck, stm, test-framework
     , test-framework-quickcheck2, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "exceptions";
       version = "0.8.0.2";
       sha256 = "070a3e0d1495243770fb3a629d5187ce898f069cb3621c5f7c610ae264982bf4";
       libraryHaskellDepends = [
         base mtl stm transformers transformers-compat
       ];
       testHaskellDepends = [
         base mtl QuickCheck stm test-framework test-framework-quickcheck2
         transformers transformers-compat
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/ekmett/exceptions/";
       description = "Extensible optionally-pure exceptions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "exceptions" = callPackage
    ({ mkDerivation, base, mtl, QuickCheck, stm, template-haskell
     , test-framework, test-framework-quickcheck2, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "exceptions";
       version = "0.8.2.1";
       sha256 = "c435877ff2f04a1855e50c78bbcbf8c89f3dc42837e440956500599f6d851035";
       libraryHaskellDepends = [
         base mtl stm template-haskell transformers transformers-compat
       ];
       testHaskellDepends = [
         base mtl QuickCheck stm template-haskell test-framework
         test-framework-quickcheck2 transformers transformers-compat
       ];
       doCheck = false;
       homepage = "http://github.com/ekmett/exceptions/";
       description = "Extensible optionally-pure exceptions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "executable-hash_0_2_0_0" = callPackage
    ({ mkDerivation, base, bytestring, cryptohash, directory
     , executable-path, file-embed, template-haskell
     }:
     mkDerivation {
       pname = "executable-hash";
       version = "0.2.0.0";
       sha256 = "976c651bc22a2123c007f66f016c41c92a66b185de315b0b6d321753a71ae33c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cryptohash directory executable-path file-embed
         template-haskell
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/fpco/executable-hash";
       description = "Provides the SHA1 hash of the program executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "executable-hash" = callPackage
    ({ mkDerivation, base, bytestring, cryptohash, directory
     , executable-path, file-embed, template-haskell
     }:
     mkDerivation {
       pname = "executable-hash";
       version = "0.2.0.2";
       sha256 = "7285dc07aef00b71d76ef3fa9403c88e976a0517fcc3aec6e7e1ac5512007a80";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cryptohash directory executable-path file-embed
         template-haskell
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       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, unix }:
     mkDerivation {
       pname = "executable-path";
       version = "0.0.3";
       sha256 = "8c7215ed4c3cd558f89dc862d21cf9dab3c6b762f4f90c0c1be9e3141c46e5c9";
       libraryHaskellDepends = [ base directory filepath unix ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "Finding out the full path of the executable";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "exhaustive_1_1_1" = callPackage
    ({ mkDerivation, base, generics-sop, template-haskell, transformers
     }:
     mkDerivation {
       pname = "exhaustive";
       version = "1.1.1";
       sha256 = "af86bfd0d10c88eecf7a84aa24de10f5302c3233bbaf104e6a30a40eb178ff2d";
       libraryHaskellDepends = [
         base generics-sop template-haskell transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ocharles/exhaustive";
       description = "Compile time checks that a computation considers producing data through all possible constructors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "exhaustive" = callPackage
    ({ mkDerivation, base, generics-sop, template-haskell, transformers
     }:
     mkDerivation {
       pname = "exhaustive";
       version = "1.1.2";
       sha256 = "658e1542d9f11f608a8898a7d4a7953b558095ea337d47dc1ab9996fc060127b";
       libraryHaskellDepends = [
         base generics-sop template-haskell transformers
       ];
       homepage = "http://github.com/ocharles/exhaustive";
       description = "Compile time checks that a computation considers producing data through all possible constructors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "exherbo-cabal" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, bytestring, Cabal
     , containers, data-default, doctest, haddock-library, http-client
     , http-types, optparse-applicative, pcre-light, pretty
     }:
     mkDerivation {
       pname = "exherbo-cabal";
       version = "0.2.0.0";
       sha256 = "f052683dc1c0ecd91dfae4c3c3200e6601615590b51549e756e8ccb5260a7d5f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers data-default haddock-library pretty
       ];
       executableHaskellDepends = [
         ansi-wl-pprint base bytestring Cabal data-default http-client
         http-types optparse-applicative pcre-light
       ];
       testHaskellDepends = [ base doctest ];
       description = "Exheres generator for cabal packages";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "exif" = callPackage
    ({ mkDerivation, base, exif }:
     mkDerivation {
       pname = "exif";
       version = "3000.0.0";
       sha256 = "911b286d849eeb12dde1cdb964ddeda4cfe6784de2008440e0d1713c66271470";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ exif ];
       description = "A Haskell binding to a subset of libexif";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) exif;};

  "exinst" = callPackage
    ({ mkDerivation, base, constraints, singletons }:
     mkDerivation {
       pname = "exinst";
       version = "0.1.1";
       sha256 = "ed8e30b2671102878767f275304e10d584b6e6e2e42fb179b5514b54dfc67147";
       libraryHaskellDepends = [ base constraints singletons ];
       jailbreak = true;
       homepage = "https://github.com/k0001/exinst";
       description = "Derive instances for your existential types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "exinst-aeson" = callPackage
    ({ mkDerivation, aeson, base, constraints, exinst, singletons }:
     mkDerivation {
       pname = "exinst-aeson";
       version = "0.1.0.1";
       sha256 = "bc916d6b4c3e6617b1b82e895b8a373f9ee1f2bf7c9b22efb43e8fb616995162";
       libraryHaskellDepends = [
         aeson base constraints exinst singletons
       ];
       jailbreak = true;
       homepage = "https://github.com/k0001/exinst";
       description = "Derive instances for the `aeson` library for your existential types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "exinst-bytes" = callPackage
    ({ mkDerivation, base, bytes, constraints, exinst, singletons }:
     mkDerivation {
       pname = "exinst-bytes";
       version = "0.1.0.1";
       sha256 = "5dc66779093560fce4d5c4722615dab2d330d5c29bca4937981b009a391a8e67";
       libraryHaskellDepends = [
         base bytes constraints exinst singletons
       ];
       jailbreak = true;
       homepage = "https://github.com/k0001/exinst";
       description = "Derive instances for the `bytes` library for your existential types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "exinst-deepseq" = callPackage
    ({ mkDerivation, base, constraints, deepseq, exinst }:
     mkDerivation {
       pname = "exinst-deepseq";
       version = "0.1";
       sha256 = "ea7e155a3a09064f65c39cd5e4323a64b8bf8dc4aa32de33b3495207315c361d";
       libraryHaskellDepends = [ base constraints deepseq exinst ];
       jailbreak = true;
       homepage = "https://github.com/k0001/exinst";
       description = "Derive instances for the `deepseq` library for your existential types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "exinst-hashable" = callPackage
    ({ mkDerivation, base, constraints, exinst, hashable, singletons }:
     mkDerivation {
       pname = "exinst-hashable";
       version = "0.1.0.1";
       sha256 = "7e76bd3604659dcb861a269362e1311bfe26ac92d5b88d6d6aa8253136c9ba68";
       libraryHaskellDepends = [
         base constraints exinst hashable singletons
       ];
       jailbreak = true;
       homepage = "https://github.com/k0001/exinst";
       description = "Derive instances for the `hashable` library for your existential types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "existential" = callPackage
    ({ mkDerivation, base, lens, QuickCheck, template-haskell }:
     mkDerivation {
       pname = "existential";
       version = "0.1.0.0";
       sha256 = "1aea3b930ba0343fb9f3d8bef2d96dde79b9fb353ce80b6a93c9d99599c6b46a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base lens QuickCheck template-haskell ];
       executableHaskellDepends = [ base lens ];
       homepage = "https://bitbucket.org/cipher2048/existential/wiki/Home";
       description = "A library for existential types";
       license = stdenv.lib.licenses.mit;
     }) {};

  "exists" = callPackage
    ({ mkDerivation, base, contravariant }:
     mkDerivation {
       pname = "exists";
       version = "0.2";
       sha256 = "fe69c878ed93c8e5aade799c458edaca06b16c4548512ee8b4a0e32a8f13fbb8";
       libraryHaskellDepends = [ base contravariant ];
       jailbreak = true;
       homepage = "http://github.com/glehel/exists";
       description = "Existential datatypes holding evidence of constraints";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "exit-codes" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "exit-codes";
       version = "0.1.1.0";
       sha256 = "0185d88b9594cd286d67bba6bf24ebe1be559310552ec7fe3f6d2b0f272f1f6d";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/JustusAdam/exit-codes";
       description = "Exit codes as defined by BSD";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "exp-extended" = callPackage
    ({ mkDerivation, base, compensated, log-domain }:
     mkDerivation {
       pname = "exp-extended";
       version = "0.1.1.1";
       sha256 = "fe4c8955f0fdff62525d7457b7be08147d063838cbb0f39bc2600256e24008a7";
       libraryHaskellDepends = [ base compensated log-domain ];
       homepage = "http://code.mathr.co.uk/exp-extended";
       description = "floating point with extended exponent range";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "exp-pairs" = callPackage
    ({ mkDerivation, base, deepseq, ghc-prim, matrix, memoize
     , QuickCheck, random, smallcheck, tasty, tasty-hunit
     , tasty-quickcheck, tasty-smallcheck, wl-pprint
     }:
     mkDerivation {
       pname = "exp-pairs";
       version = "0.1.4.1";
       sha256 = "8532ee6bf433c613f0eb9315219175330808aee326651dad74bbd467aedb4d4b";
       libraryHaskellDepends = [
         base deepseq ghc-prim memoize wl-pprint
       ];
       testHaskellDepends = [
         base matrix memoize QuickCheck random smallcheck tasty tasty-hunit
         tasty-quickcheck tasty-smallcheck
       ];
       homepage = "https://github.com/Bodigrim/exp-pairs";
       description = "Linear programming over exponent pairs";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "expand" = callPackage
    ({ mkDerivation, AspectAG, base, HList, murder, uu-parsinglib }:
     mkDerivation {
       pname = "expand";
       version = "0.0.1";
       sha256 = "5a2f0b07681eef3a866d8788aec594780fbc5df8127d543e20efa26b537e0a45";
       libraryHaskellDepends = [
         AspectAG base HList murder uu-parsinglib
       ];
       jailbreak = true;
       description = "Extensible Pandoc";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "expat-enumerator" = callPackage
    ({ mkDerivation, base, bytestring, enumerator, hexpat, text
     , transformers, xml-types
     }:
     mkDerivation {
       pname = "expat-enumerator";
       version = "0.1.0.3";
       sha256 = "bd0eb05a626be3af5eac5250a1961a64ed3619816bfb9bd29524499c94a2942a";
       libraryHaskellDepends = [
         base bytestring enumerator hexpat text transformers xml-types
       ];
       jailbreak = true;
       homepage = "http://john-millikin.com/software/expat-enumerator/";
       description = "Enumerator-based API for Expat";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "expiring-cache-map" = callPackage
    ({ mkDerivation, base, bytestring, containers, hashable, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "expiring-cache-map";
       version = "0.0.5.4";
       sha256 = "088ec3c56e23825f8709b185a97c8e3e485f2775d7299c58e62fc5992e4e7d71";
       libraryHaskellDepends = [
         base containers hashable unordered-containers
       ];
       testHaskellDepends = [
         base bytestring containers hashable time unordered-containers
       ];
       homepage = "https://github.com/elblake/expiring-cache-map";
       description = "General purpose simple caching";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "expiring-mvar" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "expiring-mvar";
       version = "0.1";
       sha256 = "de9fc8b0e9d3041c928b810b23f228fa5ec20d4aa30835d093ba6d43463b6c56";
       libraryHaskellDepends = [ base ];
       description = "Create values which expire after a period of time";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "explain" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, haskell-src-exts }:
     mkDerivation {
       pname = "explain";
       version = "0.1.0.1";
       sha256 = "a2cb9dd32999ef8261d87ada4d0533e9fb99bbe39f91b9924e0189570b8bc892";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-wl-pprint base haskell-src-exts
       ];
       jailbreak = true;
       homepage = "https://github.com/joelteon/explain";
       description = "Show how expressions are parsed";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "explicit-determinant" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "explicit-determinant";
       version = "0.1.0.0";
       sha256 = "9ed4750f815408ee8d43185ba57f964e5bd093e8373b81621da5c3fde99a403c";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/jwaldmann/haskell-explicit-determinant";
       description = "explicit computation of determinant of small matrices";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "explicit-exception_0_1_7_3" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "explicit-exception";
       version = "0.1.7.3";
       sha256 = "e1730a5b8ef61a672e9da88207d43e7cb160507df5146779788a7cf3290d3738";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base transformers ];
       homepage = "http://www.haskell.org/haskellwiki/Exception";
       description = "Exceptions which are explicit in the type signature";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "explicit-exception" = callPackage
    ({ mkDerivation, base, deepseq, transformers }:
     mkDerivation {
       pname = "explicit-exception";
       version = "0.1.8";
       sha256 = "7fee7a3781db3c3bf82079e635d510088dbb6f4295fde887c603819ec14cd16f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base deepseq transformers ];
       homepage = "http://www.haskell.org/haskellwiki/Exception";
       description = "Exceptions which are explicit in the type signature";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "explicit-iomodes" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, tagged }:
     mkDerivation {
       pname = "explicit-iomodes";
       version = "0.6.0.5";
       sha256 = "ed376a5af54934624af64bae2d2233d56366f2fe838c3e4ef537aa68fc0f3f47";
       libraryHaskellDepends = [ base base-unicode-symbols tagged ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/explicit-iomodes/";
       description = "File handles with explicit IOModes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "explicit-iomodes-bytestring" = callPackage
    ({ mkDerivation, base, bytestring, explicit-iomodes }:
     mkDerivation {
       pname = "explicit-iomodes-bytestring";
       version = "0.2.0.2";
       sha256 = "129ac02fbe52ca948a0d9bdcfbda20e9b5fc30b48924a847fea83fd1e6a36d40";
       libraryHaskellDepends = [ base bytestring explicit-iomodes ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/explicit-iomodes-bytestring/";
       description = "Extends explicit-iomodes with ByteString operations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "explicit-iomodes-text" = callPackage
    ({ mkDerivation, base, explicit-iomodes, text }:
     mkDerivation {
       pname = "explicit-iomodes-text";
       version = "0.1.0.8";
       sha256 = "cf576820f38d549ddd7870bbcdbad6b5aba1c89e1fcdf29643970719142fde8a";
       libraryHaskellDepends = [ base explicit-iomodes text ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/explicit-iomodes-text/";
       description = "Extends explicit-iomodes with Text operations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "explicit-sharing" = callPackage
    ({ mkDerivation, base, containers, derive, mtl, template-haskell }:
     mkDerivation {
       pname = "explicit-sharing";
       version = "0.9";
       sha256 = "f8ca7db78e9f971019ae2b01683ca40dff7c24e86cbadd9aa3bf02134dd9504b";
       libraryHaskellDepends = [
         base containers derive mtl template-haskell
       ];
       jailbreak = true;
       homepage = "http://sebfisch.github.com/explicit-sharing";
       description = "Explicit Sharing of Monadic Effects";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "explore" = callPackage
    ({ mkDerivation, array, base, directory, pngload }:
     mkDerivation {
       pname = "explore";
       version = "0.0.7.2";
       sha256 = "cc057ea8adeaa2ca16c34d2d7ce5a2966a432bcde26a28a8d7f14bc1137fa2a3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base directory pngload ];
       homepage = "http://corsis.sourceforge.net/haskell/explore";
       description = "Experimental Plot data Reconstructor";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "exposed-containers" = callPackage
    ({ mkDerivation, array, base, ChasingBottoms, deepseq, ghc-prim
     , HUnit, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "exposed-containers";
       version = "0.5.5.1";
       sha256 = "6762b8c800e81710bb00ab345e61fcf3d76044eeb290dcdfc5b4bdde14249325";
       revision = "1";
       editedCabalFile = "25516f8a7288ce438b872a0d3054434c3ba48ce0ce8a57209ea6d78ce6e2665c";
       libraryHaskellDepends = [ array base deepseq ghc-prim ];
       testHaskellDepends = [
         array base ChasingBottoms deepseq ghc-prim HUnit QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       description = "A distribution of the 'containers' package, with all modules exposed";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "expression-parser" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "expression-parser";
       version = "0.1";
       sha256 = "1aa304d83d433b473596f47c8712a64670b812ae57a2a748f76b08c4840bb7d1";
       libraryHaskellDepends = [ base ];
       description = "Generalization of parsec's expression parser";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "extcore" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , filepath, mtl, parsec, pretty, syb
     }:
     mkDerivation {
       pname = "extcore";
       version = "1.0.2";
       sha256 = "6790bef1e3dba2209c3744f1178cbbe9ee93d6b6e8cd0e33fea315bb5623f6b6";
       libraryHaskellDepends = [
         array base bytestring containers directory filepath mtl parsec
         pretty syb
       ];
       description = "Libraries for processing GHC Core";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "extemp" = callPackage
    ({ mkDerivation, base, bytestring, containers, feed, happstack-auth
     , happstack-server, happstack-state, happstack-util, HTTP, MaybeT
     , monad-parallel, mtl, network, old-locale, regex-tdfa, smartGroup
     , stringsearch, time, xhtml, xml
     }:
     mkDerivation {
       pname = "extemp";
       version = "0.0.1";
       sha256 = "be83a40941c7c0c1f0b3e92cb6a7edad924ecbf9c7a1e13e7498c818f4fe6aed";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers feed happstack-auth happstack-server
         happstack-state happstack-util HTTP MaybeT monad-parallel mtl
         network old-locale regex-tdfa smartGroup stringsearch time xhtml
         xml
       ];
       homepage = "http://patch-tag.com/r/salazar/extemp";
       description = "automated printing for extemp speakers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "extended-categories" = callPackage
    ({ mkDerivation, base, constraints, ghc-prim, tagged }:
     mkDerivation {
       pname = "extended-categories";
       version = "0.2.0";
       sha256 = "e2e016c10bf167fe47277b8fedf3ad6c524c507dffabe7ebd8e5d1aff1fee9b5";
       libraryHaskellDepends = [ base constraints ghc-prim tagged ];
       jailbreak = true;
       homepage = "github.com/ian-mi/extended-categories";
       description = "Extended Categories";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "extended-reals" = callPackage
    ({ mkDerivation, base, deepseq, hashable, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , test-framework-th
     }:
     mkDerivation {
       pname = "extended-reals";
       version = "0.2.1.0";
       sha256 = "b7397efc31d717943304dc985316526163aa7c5ec5a3536e41721e4043b97ba8";
       libraryHaskellDepends = [ base deepseq hashable ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 test-framework-th
       ];
       jailbreak = true;
       homepage = "https://github.com/msakai/extended-reals/";
       description = "Extension of real numbers with positive/negative infinities";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "extensible" = callPackage
    ({ mkDerivation, base, constraints, monad-skeleton, profunctors
     , tagged, template-haskell, transformers
     }:
     mkDerivation {
       pname = "extensible";
       version = "0.3.5";
       sha256 = "be5e73575f388277713e51398a9734b58cbec42dd1bd58476bba4858f33ece49";
       libraryHaskellDepends = [
         base constraints monad-skeleton profunctors tagged template-haskell
         transformers
       ];
       homepage = "https://github.com/fumieval/extensible";
       description = "Extensible, efficient, lens-friendly data types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "extensible-data" = callPackage
    ({ mkDerivation, base, data-lens, hashable, template-haskell
     , unordered-containers
     }:
     mkDerivation {
       pname = "extensible-data";
       version = "0.1.0.4";
       sha256 = "cf2855cb8cd86ea5aa671482a9d15702b7d0c71ea6531088deb32611f8a06c90";
       libraryHaskellDepends = [
         base data-lens hashable template-haskell unordered-containers
       ];
       jailbreak = true;
       description = "Sums/products/lists/trees which can be extended in other modules";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "extensible-effects" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     , test-framework-th, transformers, transformers-base, type-aligned
     , void
     }:
     mkDerivation {
       pname = "extensible-effects";
       version = "1.11.0.3";
       sha256 = "ae44bc66608f000a9da20d8ae53c1e2a0ed4c46fa7b9bab2f5d44c0da1c1ebb3";
       libraryHaskellDepends = [
         base transformers transformers-base type-aligned void
       ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 test-framework-th void
       ];
       homepage = "https://github.com/suhailshergill/extensible-effects";
       description = "An Alternative to Monad Transformers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "extensible-exceptions" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "extensible-exceptions";
       version = "0.1.1.4";
       sha256 = "6ce5e8801760385a408dab71b53550f87629e661b260bdc2cd41c6a439b6e388";
       libraryHaskellDepends = [ base ];
       description = "Extensible exceptions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "external-sort" = callPackage
    ({ mkDerivation, base, binary, bytestring, EdisonAPI, EdisonCore }:
     mkDerivation {
       pname = "external-sort";
       version = "0.2";
       sha256 = "291b74747478de0407d1bea721efb5160a3432d2bc6a62b9d9de1126201ff8c4";
       libraryHaskellDepends = [
         base binary bytestring EdisonAPI EdisonCore
       ];
       description = "Sort large arrays on your hard drive. Kind of like the unix util sort.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "extra_1_0" = callPackage
    ({ mkDerivation, base, directory, filepath, process, QuickCheck
     , time, unix
     }:
     mkDerivation {
       pname = "extra";
       version = "1.0";
       sha256 = "6bb6b0d583a1a4de739de145cfb267d962e27b3889660d06e3e156e110e6362a";
       revision = "2";
       editedCabalFile = "d4393e372b4bca0c8a47a3780430c3548879921bf41c56c1fefabf79e51acdb7";
       libraryHaskellDepends = [
         base directory filepath process time unix
       ];
       testHaskellDepends = [
         base directory filepath QuickCheck time unix
       ];
       homepage = "https://github.com/ndmitchell/extra#readme";
       description = "Extra functions I use";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "extra_1_0_1" = callPackage
    ({ mkDerivation, base, directory, filepath, process, QuickCheck
     , time, unix
     }:
     mkDerivation {
       pname = "extra";
       version = "1.0.1";
       sha256 = "46c61e755d20e5780ae417279744205eee03dc37a943e6235ec08e45447cacda";
       revision = "1";
       editedCabalFile = "a928bd1bd8516ace1c3b0d6413a60ba7ef164c0fed4bde83b1aea82f1949ecb9";
       libraryHaskellDepends = [
         base directory filepath process time unix
       ];
       testHaskellDepends = [
         base directory filepath QuickCheck time unix
       ];
       homepage = "https://github.com/ndmitchell/extra#readme";
       description = "Extra functions I use";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "extra_1_1" = callPackage
    ({ mkDerivation, base, directory, filepath, process, QuickCheck
     , time, unix
     }:
     mkDerivation {
       pname = "extra";
       version = "1.1";
       sha256 = "9ebc9f0579b18fd4fae3deedb8e4d6cc707b04604a543c9d65cbd57c7cd91b45";
       revision = "1";
       editedCabalFile = "cf929eb72bd834c6dfe7d059c234905077cde112643c961f7bde9e475bf07c0e";
       libraryHaskellDepends = [
         base directory filepath process time unix
       ];
       testHaskellDepends = [
         base directory filepath QuickCheck time unix
       ];
       homepage = "https://github.com/ndmitchell/extra#readme";
       description = "Extra functions I use";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "extra_1_4_1" = callPackage
    ({ mkDerivation, base, directory, filepath, process, QuickCheck
     , time, unix
     }:
     mkDerivation {
       pname = "extra";
       version = "1.4.1";
       sha256 = "e02ca751533eb44b221a8e6250c70a125627be8fc1c9711092dc3d2668f2d001";
       libraryHaskellDepends = [
         base directory filepath process time unix
       ];
       testHaskellDepends = [
         base directory filepath QuickCheck time unix
       ];
       homepage = "https://github.com/ndmitchell/extra#readme";
       description = "Extra functions I use";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "extra_1_4_2" = callPackage
    ({ mkDerivation, base, directory, filepath, process, QuickCheck
     , time, unix
     }:
     mkDerivation {
       pname = "extra";
       version = "1.4.2";
       sha256 = "0ea699d56bb08ad6e70ee6aaa2069326c2bc76ac347c0f04e94ce38cf3ec30c1";
       libraryHaskellDepends = [
         base directory filepath process time unix
       ];
       testHaskellDepends = [
         base directory filepath QuickCheck time unix
       ];
       homepage = "https://github.com/ndmitchell/extra#readme";
       description = "Extra functions I use";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "extra" = callPackage
    ({ mkDerivation, base, directory, filepath, process, QuickCheck
     , time, unix
     }:
     mkDerivation {
       pname = "extra";
       version = "1.4.3";
       sha256 = "905325626869958eeb1660469df79d75165f932b2f8b6e80798ebec8c570e1f8";
       libraryHaskellDepends = [
         base directory filepath process time unix
       ];
       testHaskellDepends = [
         base directory filepath QuickCheck time unix
       ];
       homepage = "https://github.com/ndmitchell/extra#readme";
       description = "Extra functions I use";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "extract-dependencies" = callPackage
    ({ mkDerivation, async, base, Cabal, containers
     , package-description-remote
     }:
     mkDerivation {
       pname = "extract-dependencies";
       version = "0.2.0.0";
       sha256 = "30224debda1f730a50bd1f92a7906c9addef641475f60dd7feb3c14011da8b35";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base Cabal containers package-description-remote
       ];
       executableHaskellDepends = [
         async base Cabal containers package-description-remote
       ];
       homepage = "https://github.com/yamadapc/stack-run-auto/extract-dependencies";
       description = "Given a hackage package outputs the list of its dependencies";
       license = stdenv.lib.licenses.mit;
     }) {};

  "extractelf" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-mmap, directory, elf
     , filepath, optparse-applicative
     }:
     mkDerivation {
       pname = "extractelf";
       version = "0.1.0.0";
       sha256 = "12dfbad45b41874d4cd2f77afaf9861bf38d68efc92a9e1b9efdfc0838fe8b8f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring bytestring-mmap directory elf filepath
         optparse-applicative
       ];
       jailbreak = true;
       homepage = "https://github.com/Peaker/extractelf";
       description = "Extract an ELF's metadata and sections into files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ez-couch" = callPackage
    ({ mkDerivation, aeson, attoparsec, attoparsec-conduit, base
     , blaze-builder, bytestring, classy-prelude, classy-prelude-conduit
     , containers, ghc-prim, hashable, hslogger, http-conduit
     , http-types, mtl, neat-interpolation, old-locale, random
     , resourcet, string-conversions, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "ez-couch";
       version = "0.7.0";
       sha256 = "c0980584148a3ca5c3e3dbd6031bc73f9c73b7bb5ae943ca452f537d66ce7c08";
       libraryHaskellDepends = [
         aeson attoparsec attoparsec-conduit base blaze-builder bytestring
         classy-prelude classy-prelude-conduit containers ghc-prim hashable
         hslogger http-conduit http-types mtl neat-interpolation old-locale
         random resourcet string-conversions text time unordered-containers
         vector
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/ez-couch";
       description = "A high level static library for working with CouchDB";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "faceted" = callPackage
    ({ mkDerivation, base, free }:
     mkDerivation {
       pname = "faceted";
       version = "0.0.2.0";
       sha256 = "0374e69df55022c99b537eebcd156bbed3ecea53285910eaf5fd5d9c4553ef2a";
       libraryHaskellDepends = [ base free ];
       jailbreak = true;
       homepage = "http://github.com/haskell-faceted/haskell-faceted";
       description = "Faceted computation for dynamic information flow security";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "factory" = callPackage
    ({ mkDerivation, array, base, Cabal, containers, deepseq, parallel
     , primes, QuickCheck, random, toolshed
     }:
     mkDerivation {
       pname = "factory";
       version = "0.2.1.2";
       sha256 = "0d8d4c53c948e1e577a2813c6c512bb25615dfad790839414705b53ed5b402bd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers deepseq parallel primes random toolshed
       ];
       executableHaskellDepends = [
         array base Cabal containers deepseq random toolshed
       ];
       testHaskellDepends = [
         array base containers deepseq primes QuickCheck random toolshed
       ];
       homepage = "http://functionalley.eu/Factory/factory.html";
       description = "Rational arithmetic in an irrational world";
       license = "GPL";
       hydraPlatforms = [ "i686-linux" "x86_64-darwin" ];
     }) {};

  "factual-api" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , curl, dataenc, hoauth, HTTP, MissingH, text, unordered-containers
     , utf8-string, vector
     }:
     mkDerivation {
       pname = "factual-api";
       version = "0.6.1";
       sha256 = "b7451a99bbe3626ad12e1fee646dff0435e64094d8d75e6eb3f81c418b9351da";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers curl dataenc hoauth
         HTTP MissingH text unordered-containers utf8-string vector
       ];
       homepage = "https://github.com/rudyl313/factual-haskell-driver";
       description = "A driver for the Factual API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fad" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fad";
       version = "1.1.0.1";
       sha256 = "f5fd6064edcbef46e16342ee0db321f72d5202e3f7f06fb340c893a0dca8c502";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/bjornbm/fad";
       description = "Forward Automatic Differentiation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fail" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fail";
       version = "4.9.0.0";
       sha256 = "6d5cdb1a5c539425a9665f740e364722e1d9d6ae37fbc55f30fe3dbbbb91d4a2";
       libraryHaskellDepends = [ base ];
       homepage = "https://prime.haskell.org/wiki/Libraries/Proposals/MonadFail";
       description = "Forward-compatible MonadFail class";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "failable-list" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "failable-list";
       version = "0.2";
       sha256 = "dd008e4a9bf81d04ab9a683ee25cb1265453e814219e5034964c594e6cc2002f";
       libraryHaskellDepends = [ base ];
       description = "A list-like type for lazy streams, which might terminate with an error";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "failure" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "failure";
       version = "0.2.0.3";
       sha256 = "77285693b66edcc4a8a4c52807f25ed0232a8f89d82ef7abe5077f43ba60354a";
       libraryHaskellDepends = [ base transformers ];
       homepage = "http://www.haskell.org/haskellwiki/Failure";
       description = "A simple type class for success/failure computations. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fair-predicates" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fair-predicates";
       version = "0.1.1";
       sha256 = "46d61503d9bf93ebcddf2116c1a2958875cf7a1582fc28a4fe90efeade400cfc";
       libraryHaskellDepends = [ base ];
       homepage = "http://sebfisch.github.com/fair-predicates";
       description = "Fair Predicates";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "fake-type" = callPackage
    ({ mkDerivation, base, base-prelude, libXtst, split, X11 }:
     mkDerivation {
       pname = "fake-type";
       version = "0.2.0.0";
       sha256 = "3ce6a7298e92c836272d71fb9f604cb37d2c90a2394720c6b67c1b6f21063c54";
       libraryHaskellDepends = [ base base-prelude split X11 ];
       librarySystemDepends = [ libXtst ];
       jailbreak = true;
       homepage = "http://github.com/aelve/fake-type";
       description = "A crossplatform library to simulate keyboard input";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs.xorg) libXtst;};

  "faker" = callPackage
    ({ mkDerivation, base, gimlh, random, split }:
     mkDerivation {
       pname = "faker";
       version = "0.0.0.2";
       sha256 = "786a74e347813217f5c564e009ff70756e0952b64dc931d13f6ec5a6469780f2";
       libraryHaskellDepends = [ base gimlh random split ];
       homepage = "https://github.com/gazay/faker";
       description = "Pure Haskell library for generating fake data";
       license = stdenv.lib.licenses.mit;
     }) {};

  "falling-turnip" = callPackage
    ({ mkDerivation, base, gloss, gloss-raster, JuicyPixels-repa
     , QuickCheck, random, repa, repa-algorithms, vector
     }:
     mkDerivation {
       pname = "falling-turnip";
       version = "0.1.0.0";
       sha256 = "f341317b8935ca620d4e4e8074788c3e245f54ec3e566acd275c2ebea594b90c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base gloss gloss-raster JuicyPixels-repa QuickCheck random repa
         repa-algorithms vector
       ];
       homepage = "http://github.com/tranma/falling-turnip";
       description = "Falling sand game/cellular automata simulation using regular parallel arrays";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fallingblocks" = callPackage
    ({ mkDerivation, base, containers, haskell98, SDL, SDL-mixer
     , SDL-ttf
     }:
     mkDerivation {
       pname = "fallingblocks";
       version = "0.1.4";
       sha256 = "20d3cfcbe4d1918ade5e4a3580c5ccbc5f43d8a1bf225058339a9106c76805a2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers haskell98 SDL SDL-mixer SDL-ttf
       ];
       jailbreak = true;
       homepage = "http://bencode.blogspot.com/2009/03/falling-blocks-tetris-clone-in-haskell.html";
       description = "A fun falling blocks game";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "family-tree" = callPackage
    ({ mkDerivation, base, binary, containers, hashable, intervals
     , lens, tables, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "family-tree";
       version = "0.5.1";
       sha256 = "418b93abb88f8be75e39187416348125d367e0cb3a7a00cfe6f07c8fdc30402c";
       libraryHaskellDepends = [
         base binary containers hashable intervals lens tables text time
         unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/Taneb/family-tree";
       description = "A family tree library for the Haskell programming language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "farmhash" = callPackage
    ({ mkDerivation, base, bytestring, hspec, QuickCheck }:
     mkDerivation {
       pname = "farmhash";
       version = "0.1.0.4";
       sha256 = "71e43616fe48c0454db551110229bd50ca4b4625f255478cb45f4a6480e113d7";
       libraryHaskellDepends = [ base bytestring ];
       testHaskellDepends = [ base bytestring hspec QuickCheck ];
       homepage = "https://github.com/abhinav/farmhash";
       description = "Fast hash functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "fast-builder" = callPackage
    ({ mkDerivation, base, bytestring, ghc-prim, process, QuickCheck
     , stm
     }:
     mkDerivation {
       pname = "fast-builder";
       version = "0.0.0.2";
       sha256 = "ee921b721243896e8f1aa77cc50f8732a10e43c8d2366ddd7cd5352a90b0d61d";
       libraryHaskellDepends = [ base bytestring ghc-prim ];
       testHaskellDepends = [ base bytestring process QuickCheck stm ];
       homepage = "http://github.com/takano-akio/fast-builder";
       description = "Fast ByteString Builder";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "fast-digits" = callPackage
    ({ mkDerivation, base, digits, integer-gmp, QuickCheck, smallcheck
     , tasty, tasty-quickcheck, tasty-smallcheck
     }:
     mkDerivation {
       pname = "fast-digits";
       version = "0.2.0.0";
       sha256 = "b5e050775cf9cfffac1adc90ded981b5fbc56be903984aecacc138ac62e98c33";
       libraryHaskellDepends = [ base integer-gmp ];
       testHaskellDepends = [
         base digits QuickCheck smallcheck tasty tasty-quickcheck
         tasty-smallcheck
       ];
       homepage = "https://github.com/Bodigrim/fast-digits";
       description = "The fast library for integer-to-digits conversion";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "fast-logger_2_2_3" = callPackage
    ({ mkDerivation, array, auto-update, base, blaze-builder
     , bytestring, directory, filepath, hspec, text
     }:
     mkDerivation {
       pname = "fast-logger";
       version = "2.2.3";
       sha256 = "034a0ab0c4ce8f6d1ad6e7b8e46da84c64778681d25b0405c1cb6af05f30577d";
       revision = "1";
       editedCabalFile = "b91fddb2ba8e830edbebf1797c65ac315100808b7fd1e3a3a96536645c4a3539";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring directory filepath
         text
       ];
       testHaskellDepends = [ base bytestring directory hspec ];
       jailbreak = true;
       description = "A fast logging system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fast-logger_2_3_1" = callPackage
    ({ mkDerivation, array, auto-update, base, bytestring
     , bytestring-builder, directory, filepath, hspec, text
     }:
     mkDerivation {
       pname = "fast-logger";
       version = "2.3.1";
       sha256 = "31ebf986082ea8871f07fa7638ca956d80a6fff13d89d423612047298cac550b";
       revision = "1";
       editedCabalFile = "9823350b03eb3ff26c7088f9ea871ff54996b4545f534c268d988f72a126ccea";
       libraryHaskellDepends = [
         array auto-update base bytestring bytestring-builder directory
         filepath text
       ];
       testHaskellDepends = [ base bytestring directory hspec ];
       description = "A fast logging system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fast-logger_2_4_0" = callPackage
    ({ mkDerivation, array, auto-update, base, bytestring
     , bytestring-builder, directory, filepath, hspec, text
     }:
     mkDerivation {
       pname = "fast-logger";
       version = "2.4.0";
       sha256 = "4cff4e1a38b07ce18083028406c51efdfa6d6764104c4f2fd4b7112c28cd05c2";
       revision = "3";
       editedCabalFile = "af5edf5e05ecd782e1d87b9d5730c5a9eb1016ac01fb1a377dda1cd8e88a274b";
       libraryHaskellDepends = [
         array auto-update base bytestring bytestring-builder directory
         filepath text
       ];
       testHaskellDepends = [ base bytestring directory hspec ];
       description = "A fast logging system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fast-logger" = callPackage
    ({ mkDerivation, array, auto-update, base, bytestring
     , bytestring-builder, directory, filepath, hspec, text
     }:
     mkDerivation {
       pname = "fast-logger";
       version = "2.4.1";
       sha256 = "e51218b5a00b8b5746fcbd1666262f9ae77b9daea5c4e351459a321c0c0a534e";
       revision = "2";
       editedCabalFile = "6c01800297493584d7bcdf31c6864c23b106a0ccbc5f57d5357380788daa0d41";
       libraryHaskellDepends = [
         array auto-update base bytestring bytestring-builder directory
         filepath text
       ];
       testHaskellDepends = [ base bytestring directory hspec ];
       description = "A fast logging system";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fast-math" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fast-math";
       version = "1.0.2";
       sha256 = "45101ddc8b86402e866ec029bcfbc2662779e578e43b40acd971a9f411e2be95";
       libraryHaskellDepends = [ base ];
       description = "Non IEEE-754 compliant compile-time floating-point optimisations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fast-tags" = callPackage
    ({ mkDerivation, array, async, base, bytestring, containers, cpphs
     , deepseq, directory, filepath, mtl, tasty, tasty-hunit, text
     , utf8-string
     }:
     mkDerivation {
       pname = "fast-tags";
       version = "1.2";
       sha256 = "59033dc40770e9f96207b2ba6b458c68a3138f0102787e4858b71a4299d90eef";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array async base bytestring containers cpphs deepseq directory
         filepath mtl text utf8-string
       ];
       executableHaskellDepends = [
         async base bytestring containers directory filepath text
       ];
       testHaskellDepends = [
         async base bytestring containers directory filepath tasty
         tasty-hunit text
       ];
       homepage = "https://github.com/elaforge/fast-tags";
       description = "Fast incremental vi and emacs tags";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fast-tagsoup" = callPackage
    ({ mkDerivation, base, bytestring, tagsoup, text, text-icu }:
     mkDerivation {
       pname = "fast-tagsoup";
       version = "1.0.7";
       sha256 = "a885e4cb187c1b134bc4410bac8016f118090ee8220f941d051f01d95a563321";
       libraryHaskellDepends = [ base bytestring tagsoup text text-icu ];
       homepage = "https://github.com/vshabanov/fast-tagsoup";
       description = "Fast parser for tagsoup package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fast-tagsoup-utf8-only" = callPackage
    ({ mkDerivation, base, bytestring, tagsoup, text }:
     mkDerivation {
       pname = "fast-tagsoup-utf8-only";
       version = "1.0.5";
       sha256 = "c4b9bdb4bad204e180a9f9816920ec82321b27644587cc95140085bbe5835b83";
       libraryHaskellDepends = [ base bytestring tagsoup text ];
       homepage = "https://github.com/exbb2/fast-tagsoup";
       description = "Fast parser for tagsoup package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fasta_0_10_1_0" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, foldl
     , lens, parsec, pipes, pipes-attoparsec, pipes-bytestring
     , pipes-group, pipes-text, split, text
     }:
     mkDerivation {
       pname = "fasta";
       version = "0.10.1.0";
       sha256 = "482c49774890eae936a8077060c76fe482a155b0809cb095915489a63338e680";
       libraryHaskellDepends = [
         attoparsec base bytestring containers foldl lens parsec pipes
         pipes-attoparsec pipes-bytestring pipes-group pipes-text split text
       ];
       homepage = "https://github.com/GregorySchwartz/fasta";
       description = "A simple, mindless parser for fasta files";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fasta" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, foldl
     , lens, parsec, pipes, pipes-attoparsec, pipes-bytestring
     , pipes-group, pipes-text, split, text
     }:
     mkDerivation {
       pname = "fasta";
       version = "0.10.2.0";
       sha256 = "da98cdcb501840341b34d354dae5063f1574d60fb48469b9d070631970fe4f50";
       libraryHaskellDepends = [
         attoparsec base bytestring containers foldl lens parsec pipes
         pipes-attoparsec pipes-bytestring pipes-group pipes-text split text
       ];
       homepage = "https://github.com/GregorySchwartz/fasta";
       description = "A simple, mindless parser for fasta files";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "fastbayes" = callPackage
    ({ mkDerivation, base, hmatrix, vector }:
     mkDerivation {
       pname = "fastbayes";
       version = "0.2.0.0";
       sha256 = "958d6da0e807f2294cff0b10c395eb0b734eea3d6ef1fc1d5da33dc4617619db";
       libraryHaskellDepends = [ base hmatrix vector ];
       jailbreak = true;
       homepage = "https://github.com/cscherrer/fastbayes";
       description = "Bayesian modeling algorithms accelerated for particular model structures";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fastcgi" = callPackage
    ({ mkDerivation, base, bytestring, cgi, fcgi }:
     mkDerivation {
       pname = "fastcgi";
       version = "3001.0.2.4";
       sha256 = "b91faff0f2316105147d4d95bd4ff5f9f3437a8007aac93feb830094003fe152";
       revision = "1";
       editedCabalFile = "74cd87692a90492171802f25c034ef047f0b68aaa1b53303d4e50ce3ec30e98a";
       libraryHaskellDepends = [ base bytestring cgi ];
       librarySystemDepends = [ fcgi ];
       description = "A Haskell library for writing FastCGI programs";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) fcgi;};

  "fastedit" = callPackage
    ({ mkDerivation, base, base-prelude, bytestring, containers
     , edit-distance, file-embed, hashable, hspec, QuickCheck, safe
     , unordered-containers
     }:
     mkDerivation {
       pname = "fastedit";
       version = "0.1.0.0";
       sha256 = "d275d7642e611c5cd8ba8ac3759380f40ff486eb80afd4324bc396e396e5a52b";
       libraryHaskellDepends = [
         base base-prelude bytestring containers hashable safe
         unordered-containers
       ];
       testHaskellDepends = [
         base base-prelude bytestring edit-distance file-embed hspec
         QuickCheck
       ];
       jailbreak = true;
       description = "find nearest neighbours by edit-distance";
       license = stdenv.lib.licenses.mit;
     }) {};

  "fastirc" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, bytestring-show
     , containers, monadLib, network-fancy
     }:
     mkDerivation {
       pname = "fastirc";
       version = "0.2.0";
       sha256 = "a4c62fb47a03a68f08ec2207ef8b45d0bf49195f3e6989240103ce14f865aa35";
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-show containers monadLib
         network-fancy
       ];
       description = "Fast Internet Relay Chat (IRC) library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fault-tree" = callPackage
    ({ mkDerivation, base, yices }:
     mkDerivation {
       pname = "fault-tree";
       version = "0.0.0";
       sha256 = "e0af859850cdcfc2f577e639387f1e17b01cfe8b043bee12c215620da483a612";
       libraryHaskellDepends = [ base yices ];
       homepage = "http://tomahawkins.org";
       description = "A fault tree analysis library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay_0_21_2_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, data-default
     , directory, filepath, ghc-paths, haskell-names, haskell-packages
     , haskell-src-exts, language-ecmascript, mtl, optparse-applicative
     , process, safe, sourcemap, split, spoon, syb, text, time
     , transformers, uniplate, unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "fay";
       version = "0.21.2.1";
       sha256 = "d5d18eab9a7ce0542b80ae1fe026146a67131cd18cb8c4142c41951eea74321a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers data-default directory filepath
         ghc-paths haskell-names haskell-packages haskell-src-exts
         language-ecmascript mtl process safe sourcemap split spoon syb text
         time transformers uniplate unordered-containers utf8-string vector
       ];
       executableHaskellDepends = [ base mtl optparse-applicative split ];
       jailbreak = true;
       homepage = "https://github.com/faylang/fay/wiki";
       description = "A compiler for Fay, a Haskell subset that compiles to JavaScript";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay_0_23_1_4" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, data-default
     , data-lens-light, directory, filepath, ghc-paths, haskell-src-exts
     , language-ecmascript, mtl, mtl-compat, optparse-applicative
     , process, safe, sourcemap, split, spoon, syb, text, time
     , transformers, transformers-compat, traverse-with-class, type-eq
     , uniplate, unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "fay";
       version = "0.23.1.4";
       sha256 = "2617cd682ce07a617e2a2cb7d8b146992514d1d88e4fcd520578721e493b19d1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers data-default data-lens-light
         directory filepath ghc-paths haskell-src-exts language-ecmascript
         mtl mtl-compat process safe sourcemap split spoon syb text time
         transformers transformers-compat traverse-with-class type-eq
         uniplate unordered-containers utf8-string vector
       ];
       executableHaskellDepends = [ base mtl optparse-applicative split ];
       jailbreak = true;
       homepage = "https://github.com/faylang/fay/wiki";
       description = "A compiler for Fay, a Haskell subset that compiles to JavaScript";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay_0_23_1_5" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, data-default
     , data-lens-light, directory, filepath, ghc-paths, haskell-src-exts
     , language-ecmascript, mtl, mtl-compat, optparse-applicative
     , process, safe, sourcemap, split, spoon, syb, text, time
     , transformers, transformers-compat, traverse-with-class, type-eq
     , uniplate, unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "fay";
       version = "0.23.1.5";
       sha256 = "99d41538a9bb397f1f8c69ef44882b76bc0b57d815819363f3e0d5842ddaa41f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers data-default data-lens-light
         directory filepath ghc-paths haskell-src-exts language-ecmascript
         mtl mtl-compat process safe sourcemap split spoon syb text time
         transformers transformers-compat traverse-with-class type-eq
         uniplate unordered-containers utf8-string vector
       ];
       executableHaskellDepends = [ base mtl optparse-applicative split ];
       jailbreak = true;
       homepage = "https://github.com/faylang/fay/wiki";
       description = "A compiler for Fay, a Haskell subset that compiles to JavaScript";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay_0_23_1_6" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, data-default
     , data-lens-light, directory, filepath, ghc-paths, haskell-src-exts
     , language-ecmascript, mtl, mtl-compat, optparse-applicative
     , process, safe, sourcemap, split, spoon, syb, text, time
     , transformers, transformers-compat, traverse-with-class, type-eq
     , uniplate, unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "fay";
       version = "0.23.1.6";
       sha256 = "33a678aaf8f1993c18b60447d99d218e025570ed9c6300b22d89a95771a78409";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers data-default data-lens-light
         directory filepath ghc-paths haskell-src-exts language-ecmascript
         mtl mtl-compat process safe sourcemap split spoon syb text time
         transformers transformers-compat traverse-with-class type-eq
         uniplate unordered-containers utf8-string vector
       ];
       executableHaskellDepends = [ base mtl optparse-applicative split ];
       jailbreak = true;
       homepage = "https://github.com/faylang/fay/wiki";
       description = "A compiler for Fay, a Haskell subset that compiles to JavaScript";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay_0_23_1_7" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, data-default
     , data-lens-light, directory, filepath, ghc-paths, haskell-src-exts
     , language-ecmascript, mtl, mtl-compat, optparse-applicative
     , process, safe, sourcemap, split, spoon, syb, text, time
     , transformers, transformers-compat, traverse-with-class, type-eq
     , uniplate, unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "fay";
       version = "0.23.1.7";
       sha256 = "8bf06c29b131c3dae7115bbc4f489e66249d223996653516ce107dd9fb5a57fa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers data-default data-lens-light
         directory filepath ghc-paths haskell-src-exts language-ecmascript
         mtl mtl-compat process safe sourcemap split spoon syb text time
         transformers transformers-compat traverse-with-class type-eq
         uniplate unordered-containers utf8-string vector
       ];
       executableHaskellDepends = [ base mtl optparse-applicative split ];
       jailbreak = true;
       homepage = "https://github.com/faylang/fay/wiki";
       description = "A compiler for Fay, a Haskell subset that compiles to JavaScript";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay_0_23_1_8" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, data-default
     , data-lens-light, directory, filepath, ghc-paths, haskell-src-exts
     , language-ecmascript, mtl, mtl-compat, optparse-applicative
     , process, safe, sourcemap, split, spoon, syb, text, time
     , transformers, transformers-compat, traverse-with-class, type-eq
     , uniplate, unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "fay";
       version = "0.23.1.8";
       sha256 = "66bf327322a2342ce7dee9b981c5e8bd2876935acb1cbc847e0c1635717be29c";
       revision = "4";
       editedCabalFile = "138bcb1a168a17dd1a74f621fc80b1ca1fc06674cf06ff519e2e06c5d35b923d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers data-default data-lens-light
         directory filepath ghc-paths haskell-src-exts language-ecmascript
         mtl mtl-compat process safe sourcemap split spoon syb text time
         transformers transformers-compat traverse-with-class type-eq
         uniplate unordered-containers utf8-string vector
       ];
       executableHaskellDepends = [ base mtl optparse-applicative split ];
       jailbreak = true;
       homepage = "https://github.com/faylang/fay/wiki";
       description = "A compiler for Fay, a Haskell subset that compiles to JavaScript";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay_0_23_1_10" = callPackage
    ({ mkDerivation, aeson, base, base-compat, bytestring, containers
     , data-default, data-lens-light, directory, filepath, ghc-paths
     , haskell-src-exts, language-ecmascript, mtl, mtl-compat
     , optparse-applicative, process, safe, sourcemap, split, spoon, syb
     , text, time, transformers, transformers-compat
     , traverse-with-class, type-eq, uniplate, unordered-containers
     , utf8-string, vector
     }:
     mkDerivation {
       pname = "fay";
       version = "0.23.1.10";
       sha256 = "600005bf694f64a394934a7dc539b292d928af27f70169a0ac9af0cd8ee0dc76";
       revision = "2";
       editedCabalFile = "8cd0961f893a01cb5a6fb6cd4b4928992a1b17dc689adc7a0185c21ab3eb483e";
       isLibrary = true;
       isExecutable = true;
       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 sourcemap split
         spoon syb text time transformers transformers-compat
         traverse-with-class type-eq uniplate unordered-containers
         utf8-string vector
       ];
       executableHaskellDepends = [ base mtl optparse-applicative split ];
       jailbreak = true;
       homepage = "https://github.com/faylang/fay/wiki";
       description = "A compiler for Fay, a Haskell subset that compiles to JavaScript";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay" = callPackage
    ({ mkDerivation, aeson, base, base-compat, bytestring, containers
     , data-default, data-lens-light, directory, filepath, ghc-paths
     , haskell-src-exts, language-ecmascript, mtl, mtl-compat
     , optparse-applicative, process, safe, sourcemap, split, spoon, syb
     , text, time, transformers, transformers-compat
     , traverse-with-class, type-eq, uniplate, unordered-containers
     , utf8-string, vector
     }:
     mkDerivation {
       pname = "fay";
       version = "0.23.1.12";
       sha256 = "3d9c0a64f6d30923e2e45f27c043a7fa4f451c676466c8ca5b69a4121462f727";
       revision = "2";
       editedCabalFile = "8b1d2491a1f85893a14f5212460ec030b22e47e2da680f275f7ff619ad15b4b0";
       isLibrary = true;
       isExecutable = true;
       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 sourcemap split
         spoon syb text time transformers transformers-compat
         traverse-with-class type-eq uniplate unordered-containers
         utf8-string vector
       ];
       executableHaskellDepends = [ base mtl optparse-applicative split ];
       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_0_19_4_1" = callPackage
    ({ mkDerivation, base, fay }:
     mkDerivation {
       pname = "fay-base";
       version = "0.19.4.1";
       sha256 = "e6614e6e306c333a4bc208546739bcf4e14229688cec81ca73c90ae8b99461de";
       libraryHaskellDepends = [ base fay ];
       jailbreak = true;
       homepage = "https://github.com/faylang/fay/";
       description = "The base package for Fay";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay-base_0_19_4_2" = callPackage
    ({ mkDerivation, base, fay }:
     mkDerivation {
       pname = "fay-base";
       version = "0.19.4.2";
       sha256 = "194646370b9e68ca175c169be72eb72b39608bdb1c36cb24e28cf53d792590e5";
       libraryHaskellDepends = [ base fay ];
       jailbreak = true;
       homepage = "https://github.com/faylang/fay/";
       description = "The base package for Fay";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay-base_0_20_0_0" = callPackage
    ({ mkDerivation, base, fay }:
     mkDerivation {
       pname = "fay-base";
       version = "0.20.0.0";
       sha256 = "83ebd4aa75e06f36ff8291eb8bad63414cc2e513500fdc73a4561e0f59fc111e";
       libraryHaskellDepends = [ base fay ];
       homepage = "https://github.com/faylang/fay/";
       description = "The base package for Fay";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay-base" = callPackage
    ({ mkDerivation, base, fay }:
     mkDerivation {
       pname = "fay-base";
       version = "0.20.0.1";
       sha256 = "59ce66ae8de469e47ff16e2b565a719c92a93bb0c06ef3f748164a40325dae9e";
       libraryHaskellDepends = [ base fay ];
       homepage = "https://github.com/faylang/fay/";
       description = "The base package for Fay";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fay-builder_0_2_0_1" = callPackage
    ({ mkDerivation, base, Cabal, data-default, directory, fay
     , filepath, safe, split, text
     }:
     mkDerivation {
       pname = "fay-builder";
       version = "0.2.0.1";
       sha256 = "cbf05dd305e6138e66ca4b74ce181c82db538ee3025037dcdc564b209e7915dd";
       libraryHaskellDepends = [
         base Cabal data-default directory fay filepath safe split text
       ];
       jailbreak = true;
       description = "Compile Fay code on cabal install, and ad-hoc recompile during development";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay-builder_0_2_0_2" = callPackage
    ({ mkDerivation, base, Cabal, data-default, directory, fay
     , filepath, safe, split, text
     }:
     mkDerivation {
       pname = "fay-builder";
       version = "0.2.0.2";
       sha256 = "ca23d600d257ad955ca35c1cb5b1207a38882e32c7be2b038cc5101059fc7169";
       libraryHaskellDepends = [
         base Cabal data-default directory fay filepath safe split text
       ];
       jailbreak = true;
       description = "Compile Fay code on cabal install, and ad-hoc recompile during development";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay-builder_0_2_0_3" = callPackage
    ({ mkDerivation, base, Cabal, data-default, directory, fay
     , filepath, safe, split, text
     }:
     mkDerivation {
       pname = "fay-builder";
       version = "0.2.0.3";
       sha256 = "3ab1fff4715e3d1bf24cdcf5cc7f18f362e7f965a7b7777963a2ad9d97327dce";
       libraryHaskellDepends = [
         base Cabal data-default directory fay filepath safe split text
       ];
       jailbreak = true;
       description = "Compile Fay code on cabal install, and ad-hoc recompile during development";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay-builder_0_2_0_4" = callPackage
    ({ mkDerivation, base, Cabal, data-default, directory, fay
     , filepath, safe, split, text
     }:
     mkDerivation {
       pname = "fay-builder";
       version = "0.2.0.4";
       sha256 = "056049a764d9f9d18545cfc8fe18aeba91d27c1b84357fdcf173c407454b3e74";
       libraryHaskellDepends = [
         base Cabal data-default directory fay filepath safe split text
       ];
       jailbreak = true;
       description = "Compile Fay code on cabal install, and ad-hoc recompile during development";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay-builder" = callPackage
    ({ mkDerivation, base, Cabal, data-default, directory, fay
     , filepath, safe, split, text
     }:
     mkDerivation {
       pname = "fay-builder";
       version = "0.2.0.5";
       sha256 = "116dea6dc304834be81d70faec7e3de1fd867ebbda0d02d3c1c6a0f96d2b31a2";
       libraryHaskellDepends = [
         base Cabal data-default directory fay filepath safe split text
       ];
       description = "Compile Fay code on cabal install, and ad-hoc recompile during development";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fay-dom_0_5" = callPackage
    ({ mkDerivation, fay-base }:
     mkDerivation {
       pname = "fay-dom";
       version = "0.5";
       sha256 = "21d7f0b0016531e1d8dc4f51f1fe3f5788f4ec1d49ff241836a1d0bcb8a113e5";
       libraryHaskellDepends = [ fay-base ];
       jailbreak = true;
       homepage = "https://github.com/faylang/fay-dom";
       description = "DOM FFI wrapper library for Fay";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay-dom" = callPackage
    ({ mkDerivation, fay-base }:
     mkDerivation {
       pname = "fay-dom";
       version = "0.5.0.1";
       sha256 = "e0f2e4dc11a13c4a9c43d707a3cf24bc1badb585540d24b29e8a6bc6ace1a6fe";
       libraryHaskellDepends = [ fay-base ];
       homepage = "https://github.com/faylang/fay-dom";
       description = "DOM FFI wrapper library for Fay";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fay-geoposition" = callPackage
    ({ mkDerivation, fay-base, fay-text }:
     mkDerivation {
       pname = "fay-geoposition";
       version = "0.1.0.1";
       sha256 = "38ecfe36f4093ef046901856d15cde00d0fb1e0a71d0609543cac8fdb0e3b3e2";
       libraryHaskellDepends = [ fay-base fay-text ];
       homepage = "https://github.com/victoredwardocallaghan/fay-geoposition";
       description = "W3C compliant implementation of GeoPosition API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fay-hsx" = callPackage
    ({ mkDerivation, fay-base, fay-jquery }:
     mkDerivation {
       pname = "fay-hsx";
       version = "0.2.0";
       sha256 = "b1fef2c647e7c067fbaffb33094c13c7c7a94c4cf0b1fbdefb4c1ee691b2f2d7";
       libraryHaskellDepends = [ fay-base fay-jquery ];
       jailbreak = true;
       homepage = "http://www.happstack.com/";
       description = "Clientside HTML generation for fay";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay-jquery_0_6_0_2" = callPackage
    ({ mkDerivation, fay-base, fay-text }:
     mkDerivation {
       pname = "fay-jquery";
       version = "0.6.0.2";
       sha256 = "f5eed92b051d37aad3de4932eef24a7f66eff1033b0a49e894616d0c9a262ebe";
       libraryHaskellDepends = [ fay-base fay-text ];
       homepage = "https://github.com/faylang/fay-jquery";
       description = "jQuery bindings for Fay";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay-jquery_0_6_0_3" = callPackage
    ({ mkDerivation, fay-base, fay-text }:
     mkDerivation {
       pname = "fay-jquery";
       version = "0.6.0.3";
       sha256 = "0e3eabb54963ef40419607fab6094dfd6d59e1c46cc854f8f796fcd58d47d1f4";
       libraryHaskellDepends = [ fay-base fay-text ];
       homepage = "https://github.com/faylang/fay-jquery";
       description = "jQuery bindings for Fay";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay-jquery" = callPackage
    ({ mkDerivation, fay-base, fay-text }:
     mkDerivation {
       pname = "fay-jquery";
       version = "0.6.1.0";
       sha256 = "0ff57ef8115e5c3fce1c14cca2509713e945874a2a2976e4646559ff51006f13";
       libraryHaskellDepends = [ fay-base fay-text ];
       homepage = "https://github.com/faylang/fay-jquery";
       description = "jQuery bindings for Fay";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fay-ref" = callPackage
    ({ mkDerivation, fay-base }:
     mkDerivation {
       pname = "fay-ref";
       version = "0.1.0.0";
       sha256 = "96a51eaec9088c16abf75b05c4549c2d0ff31c3fc576522bc77f0418557691b5";
       libraryHaskellDepends = [ fay-base ];
       homepage = "https://github.com/A1kmm/fay-ref";
       description = "Like IORef but for Fay";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fay-text_0_3_2" = callPackage
    ({ mkDerivation, fay, fay-base, text }:
     mkDerivation {
       pname = "fay-text";
       version = "0.3.2";
       sha256 = "55944212c1e36c39ae81483c32e3f26d94bdf229d4f77272c3eef68850b05afa";
       libraryHaskellDepends = [ fay fay-base text ];
       jailbreak = true;
       homepage = "https://github.com/faylang/fay-text";
       description = "Fay Text type represented as JavaScript strings";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay-text_0_3_2_1" = callPackage
    ({ mkDerivation, fay, fay-base, text }:
     mkDerivation {
       pname = "fay-text";
       version = "0.3.2.1";
       sha256 = "616306856dd590fb4450c6a7a27c3812dff42146e56fabd827d5a4f6e937cfe2";
       libraryHaskellDepends = [ fay fay-base text ];
       jailbreak = true;
       homepage = "https://github.com/faylang/fay-text";
       description = "Fay Text type represented as JavaScript strings";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fay-text" = callPackage
    ({ mkDerivation, fay, fay-base, text }:
     mkDerivation {
       pname = "fay-text";
       version = "0.3.2.2";
       sha256 = "da2a75e803d6d41249f49fa7dd420bc984faaff5e44f697056c93336bf443be0";
       libraryHaskellDepends = [ fay fay-base text ];
       homepage = "https://github.com/faylang/fay-text";
       description = "Fay Text type represented as JavaScript strings";
       license = stdenv.lib.licenses.mit;
     }) {};

  "fay-uri" = callPackage
    ({ mkDerivation, fay-base }:
     mkDerivation {
       pname = "fay-uri";
       version = "0.2.0.0";
       sha256 = "d906cd3d903a8aa98388b4488a039a2a380bd4b0da3c63978da8b3f4e79364ef";
       libraryHaskellDepends = [ fay-base ];
       homepage = "https://github.com/faylang/fay-uri";
       description = "Persistent FFI bindings for using jsUri in Fay";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fb_1_0_7" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, bytestring, cereal, conduit, conduit-extra
     , containers, crypto-api, cryptohash, cryptohash-cryptoapi
     , data-default, hspec, http-conduit, http-types, HUnit, lifted-base
     , monad-control, monad-logger, old-locale, QuickCheck, resourcet
     , text, time, transformers, transformers-base, unordered-containers
     }:
     mkDerivation {
       pname = "fb";
       version = "1.0.7";
       sha256 = "0842e961d609f96ecf0a81074fa4831c58b5d49377a4ba366e112be27a6b1e3e";
       revision = "1";
       editedCabalFile = "e07f6144f066646f3e35cbd49ee0abea47f5ccc32c83b8197bb6cc89dc01be0c";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         bytestring cereal conduit conduit-extra crypto-api cryptohash
         cryptohash-cryptoapi data-default http-conduit http-types
         lifted-base monad-control monad-logger old-locale resourcet text
         time transformers transformers-base unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring conduit containers data-default hspec
         http-conduit HUnit lifted-base monad-control QuickCheck resourcet
         text time transformers
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/prowdsponsor/fb";
       description = "Bindings to Facebook's API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fb_1_0_8" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, bytestring, cereal, conduit, conduit-extra
     , containers, crypto-api, cryptohash, cryptohash-cryptoapi
     , data-default, hspec, http-conduit, http-types, HUnit, lifted-base
     , monad-control, monad-logger, old-locale, QuickCheck, resourcet
     , text, time, transformers, transformers-base, unordered-containers
     }:
     mkDerivation {
       pname = "fb";
       version = "1.0.8";
       sha256 = "3569d353a975948327c6d73b1688f72111d1110244cdb1a5ea8b9a3ba71067b3";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         bytestring cereal conduit conduit-extra crypto-api cryptohash
         cryptohash-cryptoapi data-default http-conduit http-types
         lifted-base monad-control monad-logger old-locale resourcet text
         time transformers transformers-base unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring conduit containers data-default hspec
         http-conduit HUnit lifted-base monad-control QuickCheck resourcet
         text time transformers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/prowdsponsor/fb";
       description = "Bindings to Facebook's API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fb_1_0_9" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, bytestring, cereal, conduit, conduit-extra
     , containers, crypto-api, cryptohash, cryptohash-cryptoapi
     , data-default, hspec, http-conduit, http-types, HUnit, lifted-base
     , monad-control, monad-logger, old-locale, QuickCheck, resourcet
     , text, time, transformers, transformers-base, unordered-containers
     }:
     mkDerivation {
       pname = "fb";
       version = "1.0.9";
       sha256 = "cb10028ff47a5711746b02e6e34ff2a8d02ee4a04650b61d6d194e6971d0bf38";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         bytestring cereal conduit conduit-extra crypto-api cryptohash
         cryptohash-cryptoapi data-default http-conduit http-types
         lifted-base monad-control monad-logger old-locale resourcet text
         time transformers transformers-base unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring conduit containers data-default hspec
         http-conduit HUnit lifted-base monad-control QuickCheck resourcet
         text time transformers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/prowdsponsor/fb";
       description = "Bindings to Facebook's API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fb_1_0_10" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, bytestring, cereal, conduit, conduit-extra
     , containers, crypto-api, cryptohash, cryptohash-cryptoapi
     , data-default, hspec, http-conduit, http-types, HUnit, lifted-base
     , monad-control, monad-logger, old-locale, QuickCheck, resourcet
     , text, time, transformers, transformers-base, unordered-containers
     }:
     mkDerivation {
       pname = "fb";
       version = "1.0.10";
       sha256 = "a7b3d5e5c15ae8711ad8692f9fc3c4e384e7b1a21e9b2b63a81b36db22fa0286";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         bytestring cereal conduit conduit-extra crypto-api cryptohash
         cryptohash-cryptoapi data-default http-conduit http-types
         lifted-base monad-control monad-logger old-locale resourcet text
         time transformers transformers-base unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring conduit containers data-default hspec
         http-conduit HUnit lifted-base monad-control QuickCheck resourcet
         text time transformers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/prowdsponsor/fb";
       description = "Bindings to Facebook's API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fb_1_0_11" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, bytestring, cereal, conduit, conduit-extra
     , containers, crypto-api, cryptohash, cryptohash-cryptoapi
     , data-default, hspec, http-conduit, http-types, HUnit, lifted-base
     , monad-control, monad-logger, old-locale, QuickCheck, resourcet
     , text, time, transformers, transformers-base, unordered-containers
     }:
     mkDerivation {
       pname = "fb";
       version = "1.0.11";
       sha256 = "057edbdab871766b2002fd8f0629964763fb7ac5d272f3031ccb94ab0cd37ba6";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         bytestring cereal conduit conduit-extra crypto-api cryptohash
         cryptohash-cryptoapi data-default http-conduit http-types
         lifted-base monad-control monad-logger old-locale resourcet text
         time transformers transformers-base unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring conduit containers data-default hspec
         http-conduit HUnit lifted-base monad-control QuickCheck resourcet
         text time transformers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/prowdsponsor/fb";
       description = "Bindings to Facebook's API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fb_1_0_12" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, bytestring, cereal, conduit, conduit-extra
     , containers, crypto-api, cryptohash, cryptohash-cryptoapi
     , data-default, hspec, http-conduit, http-types, HUnit, lifted-base
     , monad-control, monad-logger, old-locale, QuickCheck, resourcet
     , text, time, transformers, transformers-base, unordered-containers
     }:
     mkDerivation {
       pname = "fb";
       version = "1.0.12";
       sha256 = "e59f512c9fed9aa7f8aa0a891ffc06d82141a40a9f47cb5c57caec1d051fc4f6";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         bytestring cereal conduit conduit-extra crypto-api cryptohash
         cryptohash-cryptoapi data-default http-conduit http-types
         lifted-base monad-control monad-logger old-locale resourcet text
         time transformers transformers-base unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring conduit containers data-default hspec
         http-conduit HUnit lifted-base monad-control QuickCheck resourcet
         text time transformers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/prowdsponsor/fb";
       description = "Bindings to Facebook's API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fb" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, bytestring, cereal, conduit, conduit-extra
     , containers, crypto-api, cryptohash, cryptohash-cryptoapi
     , data-default, hspec, http-conduit, http-types, HUnit, lifted-base
     , monad-control, monad-logger, old-locale, QuickCheck, resourcet
     , text, time, transformers, transformers-base, unordered-containers
     }:
     mkDerivation {
       pname = "fb";
       version = "1.0.13";
       sha256 = "52af3e05b5721b5d38fea9231e9fde68b0e1987c4cc979acaf6e2f940537935e";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         bytestring cereal conduit conduit-extra crypto-api cryptohash
         cryptohash-cryptoapi data-default http-conduit http-types
         lifted-base monad-control monad-logger old-locale resourcet text
         time transformers transformers-base unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring conduit containers data-default hspec
         http-conduit HUnit lifted-base monad-control QuickCheck resourcet
         text time transformers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/prowdsponsor/fb";
       description = "Bindings to Facebook's API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fb-persistent_0_3_4" = callPackage
    ({ mkDerivation, base, cereal, fb, persistent, text, time }:
     mkDerivation {
       pname = "fb-persistent";
       version = "0.3.4";
       sha256 = "6ba819c4ad302b60fd42da0072badf9e14647f5fee457020feeeeccdbf8b191e";
       libraryHaskellDepends = [ base cereal fb persistent text time ];
       jailbreak = true;
       homepage = "https://github.com/prowdsponsor/fb-persistent";
       description = "Provides Persistent instances to Facebook types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fb-persistent_0_3_5" = callPackage
    ({ mkDerivation, base, cereal, fb, persistent, text, time }:
     mkDerivation {
       pname = "fb-persistent";
       version = "0.3.5";
       sha256 = "1086428a9e4463f26882438405f4df84a5d7a9d15ef7af901ec7aebc48e5bd45";
       libraryHaskellDepends = [ base cereal fb persistent text time ];
       jailbreak = true;
       homepage = "https://github.com/prowdsponsor/fb-persistent";
       description = "Provides Persistent instances to Facebook types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fb-persistent" = callPackage
    ({ mkDerivation, base, cereal, fb, persistent, text, time }:
     mkDerivation {
       pname = "fb-persistent";
       version = "0.3.6";
       sha256 = "9a24e190b70fd3bcd5a70813e50872398217b24d39da76b175cbcbbd693580c6";
       libraryHaskellDepends = [ base cereal fb persistent text time ];
       homepage = "https://github.com/prowdsponsor/fb-persistent";
       description = "Provides Persistent instances to Facebook types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fca" = callPackage
    ({ mkDerivation, base, bytestring, containers, cryptohash, hashable
     , text, unordered-containers
     }:
     mkDerivation {
       pname = "fca";
       version = "0.1.0.2";
       sha256 = "770796b02fff924ee67749a10f3a286ef7348a656eb3a04f251ed691892868b0";
       libraryHaskellDepends = [
         base bytestring containers cryptohash hashable text
         unordered-containers
       ];
       jailbreak = true;
       description = "Algo for Formal Concept Analysis";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "fcache" = callPackage
    ({ mkDerivation, base, containers, hashable, hspec, mtl
     , unordered-containers
     }:
     mkDerivation {
       pname = "fcache";
       version = "0.1.0.0";
       sha256 = "52340d228a564a7eb0fe84d386075af019540145fbe53b4e20925b746e3a0eae";
       libraryHaskellDepends = [
         base containers hashable mtl unordered-containers
       ];
       testHaskellDepends = [ base hspec mtl ];
       homepage = "http://github.com/ylilarry/fcache#readme";
       description = "Cache a function (a -> b)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fcd" = callPackage
    ({ mkDerivation, array, base, directory, process, tasty
     , tasty-hunit, text, unix, vty, vty-ui
     }:
     mkDerivation {
       pname = "fcd";
       version = "1.0.0.0";
       sha256 = "c6e28f9511a1ab3879ae1565f392b43c9d3d809e7a43a82bc07abf3d2cbc7bfc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base directory process text unix vty vty-ui
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       homepage = "https://github.com/Neki/fcd";
       description = "A faster way to navigate directories using the command line";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fckeditor" = callPackage
    ({ mkDerivation, base, cgi, HaXml, xhtml }:
     mkDerivation {
       pname = "fckeditor";
       version = "0.1";
       sha256 = "bd18cb1a282478e11d084c3d60fcac139c5e68e0c80801e5206146aed2b47afb";
       libraryHaskellDepends = [ base cgi HaXml xhtml ];
       jailbreak = true;
       homepage = "http://peteg.org/";
       description = "Server-Side Integration for FCKeditor";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fclabels_2_0_2" = callPackage
    ({ mkDerivation, base, mtl, template-haskell, transformers }:
     mkDerivation {
       pname = "fclabels";
       version = "2.0.2";
       sha256 = "b7bd4e6aad908dd2d6c6872a5d3f0b5f538d2fe69e42008025e4af88a8690a81";
       libraryHaskellDepends = [ base mtl template-haskell transformers ];
       jailbreak = true;
       homepage = "https://github.com/sebastiaanvisser/fclabels";
       description = "First class accessor labels implemented as lenses";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fclabels_2_0_2_2" = callPackage
    ({ mkDerivation, base, HUnit, mtl, template-haskell, transformers
     }:
     mkDerivation {
       pname = "fclabels";
       version = "2.0.2.2";
       sha256 = "4865e78c114120bde4313ee9b0e90d39e4e03292c7c80f20359140e167ad754b";
       libraryHaskellDepends = [ base mtl template-haskell transformers ];
       testHaskellDepends = [
         base HUnit mtl template-haskell transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/sebastiaanvisser/fclabels";
       description = "First class accessor labels implemented as lenses";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fclabels_2_0_2_3" = callPackage
    ({ mkDerivation, base, HUnit, mtl, template-haskell, transformers
     }:
     mkDerivation {
       pname = "fclabels";
       version = "2.0.2.3";
       sha256 = "82ba7747afeec6526d3bc2df61b222ae71b45aa3dd8bb8787e9ab2c537f6fad5";
       libraryHaskellDepends = [ base mtl template-haskell transformers ];
       testHaskellDepends = [
         base HUnit mtl template-haskell transformers
       ];
       homepage = "https://github.com/sebastiaanvisser/fclabels";
       description = "First class accessor labels implemented as lenses";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fclabels_2_0_2_4" = callPackage
    ({ mkDerivation, base, HUnit, mtl, template-haskell, transformers
     }:
     mkDerivation {
       pname = "fclabels";
       version = "2.0.2.4";
       sha256 = "f030940b23701aa2580a8c3f8af3c8a7c0a5ed83b30e07607ce9ef75eb4f60b7";
       libraryHaskellDepends = [ base mtl template-haskell transformers ];
       testHaskellDepends = [
         base HUnit mtl template-haskell transformers
       ];
       homepage = "https://github.com/sebastiaanvisser/fclabels";
       description = "First class accessor labels implemented as lenses";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fclabels" = callPackage
    ({ mkDerivation, base, HUnit, mtl, template-haskell, transformers
     }:
     mkDerivation {
       pname = "fclabels";
       version = "2.0.3";
       sha256 = "b43e4dcc9000be435145b13b97e0997ec1fb8291ec0af8f18cf2a2b696d9ce43";
       libraryHaskellDepends = [ base mtl template-haskell transformers ];
       testHaskellDepends = [
         base HUnit mtl template-haskell transformers
       ];
       homepage = "https://github.com/sebastiaanvisser/fclabels";
       description = "First class accessor labels implemented as lenses";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fclabels-monadlib" = callPackage
    ({ mkDerivation, base, fclabels, monadLib }:
     mkDerivation {
       pname = "fclabels-monadlib";
       version = "0.2.1";
       sha256 = "6de42ff53b6ae613cd49c5e9c6a0157201876c97c66baea75c565a7e737725c8";
       libraryHaskellDepends = [ base fclabels monadLib ];
       jailbreak = true;
       description = "MonadLib monadic interface for the \"fclabels\" package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fdo-notify" = callPackage
    ({ mkDerivation, base, containers, dbus }:
     mkDerivation {
       pname = "fdo-notify";
       version = "0.3.1";
       sha256 = "7083414bb25e3057f6444722288cebf4ad3e4c2616f95f26079c8c7762989fd8";
       libraryHaskellDepends = [ base containers dbus ];
       homepage = "http://bitbucket.org/taejo/fdo-notify/";
       description = "Desktop Notifications client";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fdo-trash" = callPackage
    ({ mkDerivation, base, Diff, directory, filepath, old-locale
     , parsec, time, unix, url
     }:
     mkDerivation {
       pname = "fdo-trash";
       version = "0.0.0.2";
       sha256 = "7309b49bb844c59dc1abefd16d41a318fdd19f3cf514d963a679fb662b4fc213";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Diff directory filepath old-locale parsec time unix url
       ];
       executableHaskellDepends = [
         base Diff directory filepath old-locale parsec time unix url
       ];
       homepage = "https://github.com/jkarlson/fdo-trash";
       description = "Utilities related to freedesktop Trash standard";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "feature-flags" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "feature-flags";
       version = "0.1.0.1";
       sha256 = "0e4cf7db6791b0875975dfa001d71bf31797b2edbfd2424f6b6202ace7935ad3";
       libraryHaskellDepends = [ base text ];
       homepage = "https://github.com/iand675/feature-flags";
       description = "A simple library for dynamically enabling and disabling functionality";
       license = stdenv.lib.licenses.mit;
     }) {};

  "fec" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "fec";
       version = "0.1.1";
       sha256 = "cdcc6ad886afa4ec17c02f4d40790e33030df3dd721f618c5385500358683e13";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://allmydata.org/source/zfec";
       description = "Forward error correction of ByteStrings";
       license = "GPL";
     }) {};

  "fedora-packages" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, hlint
     , HsOpenSSL, hspec, http-streams, io-streams, lens, text
     }:
     mkDerivation {
       pname = "fedora-packages";
       version = "0.0.3";
       sha256 = "133f5bbb01b60a2970ae4fe96616142f97911f14caafa77d2de5dc66cdd9d791";
       revision = "1";
       editedCabalFile = "b09d857e6d91527f8c9fbb8626e1610c5c7b994a6fcf30cd3328c668a6e8d33a";
       libraryHaskellDepends = [
         aeson base bytestring containers HsOpenSSL http-streams io-streams
         lens text
       ];
       testHaskellDepends = [
         aeson base bytestring containers hlint HsOpenSSL hspec http-streams
         io-streams lens text
       ];
       jailbreak = true;
       homepage = "https://github.com/relrod/fedora-packages-hs";
       description = "Haskell interface to the Fedora Packages webapp API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "feed_0_3_9_7" = callPackage
    ({ mkDerivation, base, HUnit, old-locale, old-time, test-framework
     , test-framework-hunit, time, time-locale-compat, utf8-string, xml
     }:
     mkDerivation {
       pname = "feed";
       version = "0.3.9.7";
       sha256 = "1468425b73887fba6740ab3e64ac62473be5f5ec61de17c5e1ac8812d4f15a07";
       libraryHaskellDepends = [
         base old-locale old-time time time-locale-compat utf8-string xml
       ];
       testHaskellDepends = [
         base HUnit old-locale old-time test-framework test-framework-hunit
         time time-locale-compat utf8-string xml
       ];
       jailbreak = true;
       homepage = "https://github.com/bergmark/feed";
       description = "Interfacing with RSS (v 0.9x, 2.x, 1.0) + Atom feeds.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "feed_0_3_10_0" = callPackage
    ({ mkDerivation, base, HUnit, old-locale, old-time, test-framework
     , test-framework-hunit, time, time-locale-compat, utf8-string, xml
     }:
     mkDerivation {
       pname = "feed";
       version = "0.3.10.0";
       sha256 = "74b25a85eab11fda19be3c837755f024036542f5bd729911526845cac572d094";
       libraryHaskellDepends = [
         base old-locale old-time time time-locale-compat utf8-string xml
       ];
       testHaskellDepends = [
         base HUnit old-locale old-time test-framework test-framework-hunit
         time time-locale-compat utf8-string xml
       ];
       jailbreak = true;
       homepage = "https://github.com/bergmark/feed";
       description = "Interfacing with RSS (v 0.9x, 2.x, 1.0) + Atom feeds.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "feed_0_3_10_1" = callPackage
    ({ mkDerivation, base, HUnit, old-locale, old-time, test-framework
     , test-framework-hunit, time, time-locale-compat, utf8-string, xml
     }:
     mkDerivation {
       pname = "feed";
       version = "0.3.10.1";
       sha256 = "103205cc503211596f11257bdb34ed999fddf9d9f2a7b937e81f2a500f832a9b";
       libraryHaskellDepends = [
         base old-locale old-time time time-locale-compat utf8-string xml
       ];
       testHaskellDepends = [
         base HUnit old-locale old-time test-framework test-framework-hunit
         time time-locale-compat utf8-string xml
       ];
       homepage = "https://github.com/bergmark/feed";
       description = "Interfacing with RSS (v 0.9x, 2.x, 1.0) + Atom feeds.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "feed_0_3_10_2" = callPackage
    ({ mkDerivation, base, HUnit, old-locale, old-time, test-framework
     , test-framework-hunit, time, time-locale-compat, utf8-string, xml
     }:
     mkDerivation {
       pname = "feed";
       version = "0.3.10.2";
       sha256 = "763c6ed7a7cfa2ebb61ca3bf84fe3bcce4f2b1a8681acca7b004fa06e2fd3159";
       libraryHaskellDepends = [
         base old-locale old-time time time-locale-compat utf8-string xml
       ];
       testHaskellDepends = [
         base HUnit old-locale old-time test-framework test-framework-hunit
         time time-locale-compat utf8-string xml
       ];
       homepage = "https://github.com/bergmark/feed";
       description = "Interfacing with RSS (v 0.9x, 2.x, 1.0) + Atom feeds.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "feed_0_3_10_3" = callPackage
    ({ mkDerivation, base, HUnit, old-locale, old-time, test-framework
     , test-framework-hunit, time, time-locale-compat, utf8-string, xml
     }:
     mkDerivation {
       pname = "feed";
       version = "0.3.10.3";
       sha256 = "83af8320f10ce4b92c16ba33b22c74e5a188cb76e06f421705030fcff25ac378";
       libraryHaskellDepends = [
         base old-locale old-time time time-locale-compat utf8-string xml
       ];
       testHaskellDepends = [
         base HUnit old-locale old-time test-framework test-framework-hunit
         time time-locale-compat utf8-string xml
       ];
       homepage = "https://github.com/bergmark/feed";
       description = "Interfacing with RSS (v 0.9x, 2.x, 1.0) + Atom feeds.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "feed_0_3_10_4" = callPackage
    ({ mkDerivation, base, HUnit, old-locale, old-time, test-framework
     , test-framework-hunit, time, time-locale-compat, utf8-string, xml
     }:
     mkDerivation {
       pname = "feed";
       version = "0.3.10.4";
       sha256 = "7dd14b46330b8026ae6dabddddf881abbd0465e59bda53bfe0315b6954607a63";
       libraryHaskellDepends = [
         base old-locale old-time time time-locale-compat utf8-string xml
       ];
       testHaskellDepends = [
         base HUnit old-locale old-time test-framework test-framework-hunit
         time time-locale-compat utf8-string xml
       ];
       homepage = "https://github.com/bergmark/feed";
       description = "Interfacing with RSS (v 0.9x, 2.x, 1.0) + Atom feeds.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "feed" = callPackage
    ({ mkDerivation, base, HUnit, old-locale, old-time, test-framework
     , test-framework-hunit, time, time-locale-compat, utf8-string, xml
     }:
     mkDerivation {
       pname = "feed";
       version = "0.3.11.1";
       sha256 = "ed04d0fc120a4b1b47c7675d395afbb419506431bc6f8e0f2c382c73a4afc983";
       libraryHaskellDepends = [
         base old-locale old-time time time-locale-compat utf8-string xml
       ];
       testHaskellDepends = [
         base HUnit old-locale old-time test-framework test-framework-hunit
         time time-locale-compat utf8-string xml
       ];
       homepage = "https://github.com/bergmark/feed";
       description = "Interfacing with RSS (v 0.9x, 2.x, 1.0) + Atom feeds.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "feed-cli" = callPackage
    ({ mkDerivation, base, directory, feed, old-locale, old-time, time
     , xml
     }:
     mkDerivation {
       pname = "feed-cli";
       version = "2009.7.5";
       sha256 = "c158e90fef39477e9243a4c298a910d80a19c816f18c09b7e98dae2a0331143f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory feed old-locale old-time time xml
       ];
       jailbreak = true;
       homepage = "http://www.syntaxpolice.org/darcs_repos/feed-cli";
       description = "A simple command line interface for creating and updating feeds like RSS";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "feed-collect" = callPackage
    ({ mkDerivation, base, data-default-class, feed, http-client
     , http-client-tls, time, time-interval, time-units, timerep
     , transformers, utf8-string
     }:
     mkDerivation {
       pname = "feed-collect";
       version = "0.2.0.2";
       sha256 = "87671ac61228d4b40337c5128528550511e05bc84484dabb8188fa16d5cb9b35";
       libraryHaskellDepends = [
         base data-default-class feed http-client http-client-tls time
         time-interval time-units timerep transformers utf8-string
       ];
       homepage = "http://rel4tion.org/projects/feed-collect/";
       description = "Watch RSS/Atom feeds (and do with them whatever you like)";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "feed-crawl" = callPackage
    ({ mkDerivation, base, bytestring, conduit, connection
     , http-conduit, http-types, hxt, network-uri, text, transformers
     }:
     mkDerivation {
       pname = "feed-crawl";
       version = "0.1.2.0";
       sha256 = "ecbcd02bd7ba6f12420922027884d648444af98cd815a4c7bd9efeafe2747e34";
       libraryHaskellDepends = [
         base bytestring conduit connection http-conduit http-types hxt
         network-uri text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/danchoi/feed-crawl";
       description = "Utility for fetching feeds with redirect info and HTML link detection";
       license = stdenv.lib.licenses.mit;
     }) {};

  "feed-translator" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
     , cmdargs, containers, cryptohash, feed, iso639, lens
     , naver-translate, network-uri, raw-strings-qq, scotty, text
     , transformers, wai, warp, wreq, xml
     }:
     mkDerivation {
       pname = "feed-translator";
       version = "0.1.0.2";
       sha256 = "9c879595e3196cb687d70366207e84b43f2b2e2d7d3d9060f354b9dd7eb2d544";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-html blaze-markup bytestring cmdargs containers
         cryptohash feed iso639 lens naver-translate network-uri
         raw-strings-qq scotty text transformers wai warp wreq xml
       ];
       jailbreak = true;
       homepage = "https://github.com/dahlia/feed-translator";
       description = "Translate syndication feeds";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "feed2lj" = callPackage
    ({ mkDerivation, base, curl, directory, feed, haskell98, HTTP
     , old-locale, pureMD5, regex-posix, tagsoup, time, utf8-string
     }:
     mkDerivation {
       pname = "feed2lj";
       version = "0.0.3.1";
       sha256 = "dbfaa122f2e57b93b8d9b856d9afb765486c866ee356ec66928676879a71a47a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base curl directory feed haskell98 HTTP old-locale pureMD5
         regex-posix tagsoup time utf8-string
       ];
       description = "(unsupported)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "feed2twitter" = callPackage
    ({ mkDerivation, base, bytestring, download-curl, feed, hs-twitter
     }:
     mkDerivation {
       pname = "feed2twitter";
       version = "0.2.0";
       sha256 = "3266b0fd515149975860abf31c2df73b5831ca35c6ab0f60a1607bfa8b3b14fe";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring download-curl feed hs-twitter
       ];
       homepage = "http://github.com/tomlokhorst/feed2twitter";
       description = "Send posts from a feed to Twitter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "feldspar-compiler" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, data-default
     , directory, feldspar-language, filepath, gcc_s, ghc-paths, mtl
     , plugins, plugins-multistage, pretty, process, QuickCheck
     , storable-record, storable-tuple, syntactic, tasty, tasty-golden
     , tasty-quickcheck, template-haskell
     }:
     mkDerivation {
       pname = "feldspar-compiler";
       version = "0.7";
       sha256 = "10eed71aeb482faffc271ae17ca5680d3a03a424afb717b498c37ad297957d4e";
       libraryHaskellDepends = [
         base Cabal containers data-default directory feldspar-language
         filepath ghc-paths mtl plugins plugins-multistage pretty process
         storable-record storable-tuple syntactic template-haskell
       ];
       librarySystemDepends = [ gcc_s ];
       testHaskellDepends = [
         base bytestring Cabal feldspar-language mtl process QuickCheck
         tasty tasty-golden tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "http://feldspar.github.com";
       description = "Compiler for the Feldspar language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gcc_s = null;};

  "feldspar-language" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, data-default
     , data-hash, data-lens, deepseq, monad-par, mtl, patch-combinators
     , QuickCheck, random, syntactic, tagged, tasty, tasty-golden
     , tasty-quickcheck, tasty-th, tuple, utf8-string
     }:
     mkDerivation {
       pname = "feldspar-language";
       version = "0.7";
       sha256 = "3694980b8e9bed849209f33a8500f57b5565a598bc5e9e10279dfdbb1b16fa3f";
       libraryHaskellDepends = [
         array base containers data-default data-hash data-lens deepseq
         monad-par mtl patch-combinators QuickCheck random syntactic tagged
         tuple
       ];
       testHaskellDepends = [
         base bytestring QuickCheck random tasty tasty-golden
         tasty-quickcheck tasty-th utf8-string
       ];
       jailbreak = true;
       homepage = "http://feldspar.github.com";
       description = "A functional embedded language for DSP and parallelism";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "feldspar-signal" = callPackage
    ({ mkDerivation, base, base-compat, feldspar-compiler
     , feldspar-compiler-shim, feldspar-language, imperative-edsl
     , mainland-pretty, monadic-edsl-priv
     }:
     mkDerivation {
       pname = "feldspar-signal";
       version = "0.0.1.0";
       sha256 = "addfcd73ffcd2b2a8093bf4e0471b15590dd2d465e71542f9a4ffd5bbc03fe90";
       libraryHaskellDepends = [
         base base-compat feldspar-compiler feldspar-compiler-shim
         feldspar-language imperative-edsl mainland-pretty monadic-edsl-priv
       ];
       jailbreak = true;
       homepage = "https://github.com/markus-git/feldspar-signal";
       description = "Signal Processing extension for Feldspar";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {feldspar-compiler-shim = null; monadic-edsl-priv = null;};

  "fen2s" = callPackage
    ({ mkDerivation, api-opentheory-unicode, base, opentheory-unicode
     }:
     mkDerivation {
       pname = "fen2s";
       version = "1.2";
       sha256 = "01655c64fbe99f248bddeb274e9f5c6acc633ee97992a2e5c537b5767b0e2104";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         api-opentheory-unicode base opentheory-unicode
       ];
       executableHaskellDepends = [
         api-opentheory-unicode base opentheory-unicode
       ];
       testHaskellDepends = [
         api-opentheory-unicode base opentheory-unicode
       ];
       description = "Converting a chess position from FEN notation to text";
       license = stdenv.lib.licenses.mit;
     }) {};

  "fences" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fences";
       version = "0.1.1";
       sha256 = "ab1146b08a5ff512977f17d44a4995ee2aa04460c1af6dc2b38b5a933fc31f9b";
       libraryHaskellDepends = [ base ];
       doHaddock = false;
       description = "To be written";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "fenfire" = callPackage
    ({ mkDerivation, base, cairo, gtk, harp, HaXml, mtl, raptor
     , template-haskell, unix
     }:
     mkDerivation {
       pname = "fenfire";
       version = "0.1";
       sha256 = "ceb9e5b8e3001f7143ae0c9cbd242bde3e2128d4fc3dd83ea6617ad53478046b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cairo gtk harp HaXml mtl template-haskell unix
       ];
       executableSystemDepends = [ raptor ];
       homepage = "http://fenfire.org/";
       description = "Graph-based notetaking system";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {raptor = null;};

  "fez-conf" = callPackage
    ({ mkDerivation, base, containers, regex-compat }:
     mkDerivation {
       pname = "fez-conf";
       version = "1.0.3";
       sha256 = "0bb871f2bdaa8dd8842d118a384b411f5af465b792cd89a51a15d3f4f85c5abf";
       libraryHaskellDepends = [ base containers regex-compat ];
       homepage = "http://ui3.info/d/proj/fez-conf.html";
       description = "Simple functions for loading config files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ffeed" = callPackage
    ({ mkDerivation, base, HTTP, json, network, pretty, utf8-string }:
     mkDerivation {
       pname = "ffeed";
       version = "0.3.2";
       sha256 = "c27c6cacf6df3b43f10501c33edba2091b7b11a82cc02d36ba9c82026ad9e6a4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base HTTP json network utf8-string ];
       executableHaskellDepends = [ base pretty ];
       description = "Haskell binding to the FriendFeed API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fficxx" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, data-default
     , directory, either, errors, filepath, hashable, HStringTemplate
     , lens, mtl, process, pureMD5, split, template-haskell
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "fficxx";
       version = "0.2.1";
       sha256 = "0d2808a81f75db856bb392a9a3968b86abdbc00b74eec3b93047e83cc1e553ee";
       libraryHaskellDepends = [
         base bytestring Cabal containers data-default directory either
         errors filepath hashable HStringTemplate lens mtl process pureMD5
         split template-haskell transformers unordered-containers
       ];
       jailbreak = true;
       description = "automatic C++ binding generation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fficxx-runtime" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fficxx-runtime";
       version = "0.2.1";
       sha256 = "b3dfb29aff05dba4b0f8f70e93370ead11b012a674aeef51f70356b21a609741";
       libraryHaskellDepends = [ base ];
       description = "Runtime for fficxx-generated library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ffmpeg-light" = callPackage
    ({ mkDerivation, base, either, exceptions, ffmpeg, JuicyPixels
     , libavcodec, libavdevice, libavformat, libswscale, mtl
     , transformers, vector
     }:
     mkDerivation {
       pname = "ffmpeg-light";
       version = "0.10.0";
       sha256 = "4b8347300fbc1c687f9db5a00baa59dc654be11d9299258f5bd2256a61501395";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base either exceptions JuicyPixels mtl transformers vector
       ];
       libraryPkgconfigDepends = [
         ffmpeg libavcodec libavdevice libavformat libswscale
       ];
       executableHaskellDepends = [
         base JuicyPixels mtl transformers vector
       ];
       description = "Minimal bindings to the FFmpeg library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) ffmpeg; libavcodec = null; libavdevice = null; 
         libavformat = null; libswscale = null;};

  "ffmpeg-tutorials" = callPackage
    ({ mkDerivation, base, bytestring, haskell98, hs-ffmpeg, SDL, stm
     }:
     mkDerivation {
       pname = "ffmpeg-tutorials";
       version = "0.3.3";
       sha256 = "1bcf981e0ef809b67e7994d0c10b87ab6db50d0dd2fc5a98bd15f0fed7fd8c8c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring haskell98 hs-ffmpeg SDL stm
       ];
       jailbreak = true;
       homepage = "http://patch-tag.com/r/VasylPasternak/ffmpeg-tutorials";
       description = "Tutorials on ffmpeg usage to play video/audio";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fft_0_1_8_2" = callPackage
    ({ mkDerivation, array, base, carray, fftw, fftwFloat, ix-shapable
     , QuickCheck, storable-complex, syb, transformers
     }:
     mkDerivation {
       pname = "fft";
       version = "0.1.8.2";
       sha256 = "deead91d5fd5ef5ab9a8fec155e661223aa91a8a207dfd70153b6f5491b01e0c";
       libraryHaskellDepends = [
         array base carray ix-shapable storable-complex syb transformers
       ];
       libraryPkgconfigDepends = [ fftw fftwFloat ];
       testHaskellDepends = [ base carray QuickCheck storable-complex ];
       doCheck = false;
       description = "Bindings to the FFTW library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) fftw; inherit (pkgs) fftwFloat;};

  "fft" = callPackage
    ({ mkDerivation, array, base, carray, fftw, fftwFloat, ix-shapable
     , QuickCheck, storable-complex, syb, transformers
     }:
     mkDerivation {
       pname = "fft";
       version = "0.1.8.3";
       sha256 = "73f450978f2b1f2d6d549aa5a81aaeeadfe153bd8f3ce935690b149a036a3896";
       libraryHaskellDepends = [
         array base carray ix-shapable storable-complex syb transformers
       ];
       libraryPkgconfigDepends = [ fftw fftwFloat ];
       testHaskellDepends = [ base carray QuickCheck storable-complex ];
       doCheck = false;
       description = "Bindings to the FFTW library";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) fftw; inherit (pkgs) fftwFloat;};

  "fftwRaw" = callPackage
    ({ mkDerivation, base, fftw }:
     mkDerivation {
       pname = "fftwRaw";
       version = "0.1.0.0";
       sha256 = "24cf427a14bc30d6d333ad71e1e5de25497564016a1d627655322bf2c4b173b6";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ fftw ];
       homepage = "https://github.com/adamwalker/haskell-fftw-simple";
       description = "Low level bindings to FFTW";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) fftw;};

  "fgl_5_5_0_1" = callPackage
    ({ mkDerivation, array, base, containers, mtl }:
     mkDerivation {
       pname = "fgl";
       version = "5.5.0.1";
       sha256 = "aa61664ba38db3e54124b702b1ee92a72a569c981b759e48cfb567078b038763";
       revision = "1";
       editedCabalFile = "3f816c9f86c3320b9a1b93c2830edfc88ca7a27e58b3b7092a2292cf1fd78f65";
       libraryHaskellDepends = [ array base containers mtl ];
       jailbreak = true;
       homepage = "http://web.engr.oregonstate.edu/~erwig/fgl/haskell";
       description = "Martin Erwig's Functional Graph Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fgl_5_5_1_0" = callPackage
    ({ mkDerivation, array, base, containers, mtl }:
     mkDerivation {
       pname = "fgl";
       version = "5.5.1.0";
       sha256 = "ead9d3f94aa32fa35a0246cd14fe0b853e197e124a3a0712913c644f3bf89565";
       libraryHaskellDepends = [ array base containers mtl ];
       description = "Martin Erwig's Functional Graph Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fgl_5_5_2_1" = callPackage
    ({ mkDerivation, array, base, containers, deepseq, hspec
     , QuickCheck, transformers
     }:
     mkDerivation {
       pname = "fgl";
       version = "5.5.2.1";
       sha256 = "0c2e745b7c2532f67b87a1c97ef016dca7444113d3901722c48c3193e71bd5d9";
       libraryHaskellDepends = [
         array base containers deepseq transformers
       ];
       testHaskellDepends = [ base containers hspec QuickCheck ];
       jailbreak = true;
       description = "Martin Erwig's Functional Graph Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fgl" = callPackage
    ({ mkDerivation, array, base, containers, deepseq, hspec
     , QuickCheck, transformers
     }:
     mkDerivation {
       pname = "fgl";
       version = "5.5.2.3";
       sha256 = "f4113b5221917feb6389494bf8b7b6221ee00f322b6c25fc25a25795549f9e20";
       libraryHaskellDepends = [
         array base containers deepseq transformers
       ];
       testHaskellDepends = [ base containers hspec QuickCheck ];
       description = "Martin Erwig's Functional Graph Library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fgl-arbitrary" = callPackage
    ({ mkDerivation, base, containers, fgl, hspec, QuickCheck }:
     mkDerivation {
       pname = "fgl-arbitrary";
       version = "0.2.0.1";
       sha256 = "3e85922a7dde02ee0dac8f93eb233ccb16dfdd1a5a4ec8397fa1d9f7404a6104";
       libraryHaskellDepends = [ base fgl QuickCheck ];
       testHaskellDepends = [ base containers fgl hspec QuickCheck ];
       description = "QuickCheck support for fgl";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fgl-extras-decompositions" = callPackage
    ({ mkDerivation, base, containers, fgl }:
     mkDerivation {
       pname = "fgl-extras-decompositions";
       version = "0.1.1.0";
       sha256 = "5a90cf8212f45dffab2b7397c63fbd3bb46a9dca4441513f965c8481e1d92d5d";
       libraryHaskellDepends = [ base containers fgl ];
       homepage = "http://www.bioinf.uni-leipzig.de/~choener/";
       description = "Graph decomposition algorithms";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fgl-visualize" = callPackage
    ({ mkDerivation, base, dotgen, fgl }:
     mkDerivation {
       pname = "fgl-visualize";
       version = "0.1.0.1";
       sha256 = "b8e7f7b6a123ff22488f77a771cbd2cc285ef41299747662797abe9741778a6f";
       libraryHaskellDepends = [ base dotgen fgl ];
       description = "Convert FGL graphs to dot (graphviz) files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fibon" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, bytestring-lexing
     , Cabal, cereal, containers, directory, filepath, hslogger, mtl
     , old-locale, old-time, process, regex-compat, statistics, syb
     , tabular, time, vector
     }:
     mkDerivation {
       pname = "fibon";
       version = "0.2.0";
       sha256 = "f46f824b90cb246ab3f14e6ea5f7e9234205a31cd375c25bfdbeb6578ce36aca";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base bytestring bytestring-lexing Cabal cereal
         containers directory filepath hslogger mtl old-locale old-time
         process regex-compat statistics syb tabular time vector
       ];
       jailbreak = true;
       homepage = "http://github.com/dmpots/fibon/wiki";
       description = "Tools for running and analyzing Haskell benchmarks";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fibonacci" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fibonacci";
       version = "0.2.0.1";
       sha256 = "f338ff3c14dc2c7ea35186bd3e871e4b66cf0b3df0e3fb9bdfd76a693d5958a2";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/sebfisch/fibonacci";
       description = "Fast computation of Fibonacci numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fields" = callPackage
    ({ mkDerivation, array, base, containers, fclabels, monads-fd
     , transformers
     }:
     mkDerivation {
       pname = "fields";
       version = "0.1.0";
       sha256 = "db60692cfaa106baa85beaa19d99675c29e7d64ffe9acab8bfb71c3f1488b977";
       libraryHaskellDepends = [
         array base containers fclabels monads-fd transformers
       ];
       homepage = "http://github.com/AstraFIN/fields";
       description = "First-class record field combinators with infix record field syntax";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fields-json" = callPackage
    ({ mkDerivation, base, base64-bytestring, containers, json, mtl
     , utf8-string
     }:
     mkDerivation {
       pname = "fields-json";
       version = "0.2.2.3";
       sha256 = "a08580276a6b7357f08b8843120e9eed1f56ca360c2e4747b3698ca64a8a0c73";
       libraryHaskellDepends = [
         base base64-bytestring containers json mtl utf8-string
       ];
       description = "Abusing monadic syntax JSON objects generation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fieldwise" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "fieldwise";
       version = "0.1.0.0";
       sha256 = "47eec77d3f34a55e8a0cab809d9181b36d80c4058ca22b5f128827306de1b4d6";
       libraryHaskellDepends = [ base template-haskell ];
       testHaskellDepends = [ base template-haskell ];
       jailbreak = true;
       description = "Provides Fieldwise typeclass for operations of fields of records treated as independent components";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fig" = callPackage
    ({ mkDerivation, base, containers, parsec, pretty }:
     mkDerivation {
       pname = "fig";
       version = "1.4.0";
       sha256 = "b84f88c6a8716d7c9ab1103399a343960c2de025853cc8c12b2a72b7598c7d0d";
       libraryHaskellDepends = [ base containers parsec pretty ];
       homepage = "http://www.bergsoe.org/fig";
       description = "Manipulation of FIG files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "file-collection" = callPackage
    ({ mkDerivation, base, bytestring, clock, directory, zip-archive }:
     mkDerivation {
       pname = "file-collection";
       version = "0.1.1.9";
       sha256 = "ec192c077b89f4a2b62ffb169e5d2c6f118bcd47c8fe144a45b7203948906c19";
       libraryHaskellDepends = [
         base bytestring clock directory zip-archive
       ];
       jailbreak = true;
       homepage = "https://github.com/joelwilliamson/file-collection";
       description = "Provide a uniform interface over file archives and directories";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "file-command-qq" = callPackage
    ({ mkDerivation, base, parsec, process, system-filepath
     , template-haskell, text
     }:
     mkDerivation {
       pname = "file-command-qq";
       version = "0.1.0.5";
       sha256 = "4b8d26ca3202af411b0fa8709207bead7d4c9f5d7d19f5793a71b8f0ad257119";
       libraryHaskellDepends = [
         base parsec process system-filepath template-haskell text
       ];
       jailbreak = true;
       homepage = "https://github.com/jfischoff/file-command-qq";
       description = "Quasiquoter for system commands involving filepaths";
       license = stdenv.lib.licenses.mit;
     }) {};

  "file-embed_0_0_7" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, HUnit
     , template-haskell
     }:
     mkDerivation {
       pname = "file-embed";
       version = "0.0.7";
       sha256 = "4f4489207dcfeb5eafd699e51442ad4e49f535323c95cebee4e8cce4c0714856";
       libraryHaskellDepends = [
         base bytestring directory filepath template-haskell
       ];
       testHaskellDepends = [ base filepath HUnit ];
       homepage = "https://github.com/snoyberg/file-embed";
       description = "Use Template Haskell to embed file contents directly";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "file-embed_0_0_7_1" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, HUnit
     , template-haskell
     }:
     mkDerivation {
       pname = "file-embed";
       version = "0.0.7.1";
       sha256 = "8ba1c724263d59b399aeb271f4f871e930c1281d7f45b88b4f36fb6e3e6dd8d9";
       libraryHaskellDepends = [
         base bytestring directory filepath template-haskell
       ];
       testHaskellDepends = [ base filepath HUnit ];
       homepage = "https://github.com/snoyberg/file-embed";
       description = "Use Template Haskell to embed file contents directly";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "file-embed_0_0_8" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, HUnit
     , template-haskell
     }:
     mkDerivation {
       pname = "file-embed";
       version = "0.0.8";
       sha256 = "c08cbc83b0e01240b1a76dd597fcfdf0c85b7047a07fb1c073690c1bb9ab103e";
       libraryHaskellDepends = [
         base bytestring directory filepath template-haskell
       ];
       testHaskellDepends = [ base filepath HUnit ];
       homepage = "https://github.com/snoyberg/file-embed";
       description = "Use Template Haskell to embed file contents directly";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "file-embed_0_0_8_1" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, HUnit
     , template-haskell
     }:
     mkDerivation {
       pname = "file-embed";
       version = "0.0.8.1";
       sha256 = "13f0f1387d0191f06e5909238e7dba21536f25ef5d0072012afb2eac074b3792";
       libraryHaskellDepends = [
         base bytestring directory filepath template-haskell
       ];
       testHaskellDepends = [ base filepath HUnit ];
       homepage = "https://github.com/snoyberg/file-embed";
       description = "Use Template Haskell to embed file contents directly";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "file-embed_0_0_8_2" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, HUnit
     , template-haskell
     }:
     mkDerivation {
       pname = "file-embed";
       version = "0.0.8.2";
       sha256 = "9e9cf8d84d5213924eec9d9c829655db74ff02b24a797d5f7450724244fabdbd";
       libraryHaskellDepends = [
         base bytestring directory filepath template-haskell
       ];
       testHaskellDepends = [ base filepath HUnit ];
       homepage = "https://github.com/snoyberg/file-embed";
       description = "Use Template Haskell to embed file contents directly";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "file-embed_0_0_9" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, HUnit
     , template-haskell
     }:
     mkDerivation {
       pname = "file-embed";
       version = "0.0.9";
       sha256 = "58b3a6b0e0566b9f89286ecd456a669273b8333cd39356d4cc88ef897d93d005";
       libraryHaskellDepends = [
         base bytestring directory filepath template-haskell
       ];
       testHaskellDepends = [ base filepath HUnit ];
       homepage = "https://github.com/snoyberg/file-embed";
       description = "Use Template Haskell to embed file contents directly";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "file-embed" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath
     , template-haskell
     }:
     mkDerivation {
       pname = "file-embed";
       version = "0.0.9.1";
       sha256 = "fdbde52cdf03067661944d072d95578ade8a27d709669f4ed40314fc729e460f";
       libraryHaskellDepends = [
         base bytestring directory filepath template-haskell
       ];
       testHaskellDepends = [ base filepath ];
       homepage = "https://github.com/snoyberg/file-embed";
       description = "Use Template Haskell to embed file contents directly";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "file-location_0_4_5_3" = callPackage
    ({ mkDerivation, base, containers, lifted-base, process
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "file-location";
       version = "0.4.5.3";
       sha256 = "092691ada97581f4493acb901ac6bdf2a4ea888a09b2d3c253ec05a61ac43134";
       libraryHaskellDepends = [
         base containers lifted-base template-haskell transformers
       ];
       testHaskellDepends = [
         base containers lifted-base process template-haskell transformers
       ];
       homepage = "https://github.com/gregwebs/FileLocation.hs";
       description = "common functions that show file location information";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "file-location_0_4_6" = callPackage
    ({ mkDerivation, base, containers, lifted-base, process
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "file-location";
       version = "0.4.6";
       sha256 = "77816aa8bd3163f5ecc936e681085f55ec27b8e3b36f67d5576c32f8e5d7bd0c";
       libraryHaskellDepends = [
         base containers lifted-base template-haskell transformers
       ];
       testHaskellDepends = [
         base containers lifted-base process template-haskell transformers
       ];
       homepage = "https://github.com/gregwebs/FileLocation.hs";
       description = "common functions that show file location information";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "file-location_0_4_7_1" = callPackage
    ({ mkDerivation, base, containers, lifted-base, process
     , template-haskell, th-orphans, transformers
     }:
     mkDerivation {
       pname = "file-location";
       version = "0.4.7.1";
       sha256 = "844a7422ee0b70d6eccff7ade71d33ec59cf0526287d61db1a566b2de5918e5c";
       libraryHaskellDepends = [
         base containers lifted-base template-haskell th-orphans
         transformers
       ];
       testHaskellDepends = [ base lifted-base process ];
       homepage = "https://github.com/gregwebs/FileLocation.hs";
       description = "common functions that show file location information";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "file-location" = callPackage
    ({ mkDerivation, base, containers, HUnit, lifted-base, process
     , template-haskell, th-orphans, transformers
     }:
     mkDerivation {
       pname = "file-location";
       version = "0.4.9";
       sha256 = "be29deb3c2267913f642e511deca988cedd287ae519012d01178d37d05f814dc";
       libraryHaskellDepends = [
         base containers HUnit lifted-base template-haskell th-orphans
         transformers
       ];
       testHaskellDepends = [ base lifted-base process ];
       homepage = "https://github.com/gregwebs/FileLocation.hs";
       description = "common functions that show file location information";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "file-modules" = callPackage
    ({ mkDerivation, async, base, directory, filepath, haskell-src-exts
     , MissingH
     }:
     mkDerivation {
       pname = "file-modules";
       version = "0.1.2.2";
       sha256 = "c795b80add210cba9f8aee32a4b5c13fa5c9059763b7e127975fde734a6cb306";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base directory filepath haskell-src-exts MissingH
       ];
       executableHaskellDepends = [
         async base directory filepath haskell-src-exts MissingH
       ];
       homepage = "https://github.com/yamadapc/stack-run-auto";
       description = "Takes a Haskell source-code file and outputs its modules";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "filecache" = callPackage
    ({ mkDerivation, base, directory, exceptions, hashable, hinotify
     , lens, mtl, stm, strict-base-types, temporary
     , unordered-containers
     }:
     mkDerivation {
       pname = "filecache";
       version = "0.2.9";
       sha256 = "02e6cd64adeeab38b7f6425905332deb8f03824cb4f47a8b8855b846e195dd81";
       libraryHaskellDepends = [
         base exceptions hashable hinotify lens mtl stm strict-base-types
         unordered-containers
       ];
       testHaskellDepends = [
         base directory temporary unordered-containers
       ];
       homepage = "http://lpuppet.banquise.net/";
       description = "A Linux-only cache system associating values to files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "filediff" = callPackage
    ({ mkDerivation, base, bytestring, data-default
     , data-memocombinators, directory, either, hashmap, mtl, rainbow
     , tasty, tasty-hunit, text, threads, time, transformers, Zora
     }:
     mkDerivation {
       pname = "filediff";
       version = "2.0.0";
       sha256 = "37310b05b8d27238f8d4edc6b00c9f59e38d8c50bf438e12ee0f62a07c134095";
       libraryHaskellDepends = [
         base bytestring data-default data-memocombinators directory either
         hashmap mtl rainbow tasty tasty-hunit text threads time
         transformers Zora
       ];
       testHaskellDepends = [
         base directory either mtl tasty tasty-hunit text time transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/bgwines/filediff";
       description = "Diffing and patching module";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "filelock" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "filelock";
       version = "0.1.0.1";
       sha256 = "ad8c63f27fec6396ac83981a67d5a799b6b614c119a35ebdf2d82b379795d763";
       libraryHaskellDepends = [ base unix ];
       homepage = "http://github.com/takano-akio/filelock";
       description = "Portable interface to file locking (flock / LockFileEx)";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "filemanip_0_3_6_2" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, mtl
     , unix-compat
     }:
     mkDerivation {
       pname = "filemanip";
       version = "0.3.6.2";
       sha256 = "3f93da5faa33d675b1a64a90a262c2decfd3d28924f0a4bfb7c691053309810e";
       libraryHaskellDepends = [
         base bytestring directory filepath mtl unix-compat
       ];
       homepage = "https://github.com/bos/filemanip";
       description = "Expressive file and directory manipulation for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "filemanip" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, mtl
     , unix-compat
     }:
     mkDerivation {
       pname = "filemanip";
       version = "0.3.6.3";
       sha256 = "8836da17baaaf02ca080c9990ece4e0b0c8d6a128f458f8b64fd07b225ca9846";
       libraryHaskellDepends = [
         base bytestring directory filepath mtl unix-compat
       ];
       homepage = "https://github.com/bos/filemanip";
       description = "Expressive file and directory manipulation for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "filepath_1_4_1_0" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "filepath";
       version = "1.4.1.0";
       sha256 = "bd6dbfd1ecba2322ef166b4805d4276cbde1e551bd5c61fbee396782b9923d00";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base QuickCheck ];
       homepage = "https://github.com/haskell/filepath#readme";
       description = "Library for manipulating FilePaths in a cross platform way";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "filepath-io-access" = callPackage
    ({ mkDerivation, base, base-io-access, filepath }:
     mkDerivation {
       pname = "filepath-io-access";
       version = "0.1.0.0";
       sha256 = "977bff7e3cb4876c67b98a4685fe734ee8000986ad8d68e2e9bb40eb94152b23";
       libraryHaskellDepends = [ base base-io-access filepath ];
       jailbreak = true;
       description = "IO Access for filepath";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "filepather" = callPackage
    ({ mkDerivation, base, comonad, comonad-transformers, data-lens
     , directory, filepath, mtl, transformers
     }:
     mkDerivation {
       pname = "filepather";
       version = "0.3.0";
       sha256 = "3b19c2d177aaefd83c399ec8d0bfff31c923393ee5389f63e1ed6668ab5516bf";
       libraryHaskellDepends = [
         base comonad comonad-transformers data-lens directory filepath mtl
         transformers
       ];
       homepage = "https://github.com/tonymorris/filepather";
       description = "Functions on System.FilePath";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "filestore" = callPackage
    ({ mkDerivation, base, bytestring, containers, Diff, directory
     , filepath, HUnit, mtl, old-locale, parsec, process, split, time
     , utf8-string, xml
     }:
     mkDerivation {
       pname = "filestore";
       version = "0.6.1";
       sha256 = "0009c97f00044d2902209050d3b85a32dbad656ad0bb6276e811d7b0aca5d455";
       libraryHaskellDepends = [
         base bytestring containers Diff directory filepath old-locale
         parsec process split time utf8-string xml
       ];
       testHaskellDepends = [
         base Diff directory filepath HUnit mtl time
       ];
       jailbreak = true;
       description = "Interface for versioning file stores";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "filesystem-conduit" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, conduit
     , containers, hspec, QuickCheck, system-fileio, system-filepath
     , text, transformers, unix
     }:
     mkDerivation {
       pname = "filesystem-conduit";
       version = "1.0.0.2";
       sha256 = "411117244128d1feca8de9b636b0cc34d678e28440adfab4c19149ffd6a0ba15";
       libraryHaskellDepends = [
         base bytestring conduit containers system-fileio system-filepath
         text transformers unix
       ];
       testHaskellDepends = [
         base blaze-builder bytestring conduit hspec QuickCheck text
         transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Use system-filepath data types with conduits. (deprecated)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "filesystem-enumerator" = callPackage
    ({ mkDerivation, base, enumerator, system-fileio, system-filepath
     , transformers, unix
     }:
     mkDerivation {
       pname = "filesystem-enumerator";
       version = "0.1.1";
       sha256 = "2cfb4ebb09b14fc03c60c44eaffe4e0b9c76439f455fccadc2e58134fe2c9a11";
       libraryHaskellDepends = [
         base enumerator system-fileio system-filepath transformers unix
       ];
       homepage = "https://john-millikin.com/software/haskell-filesystem/";
       description = "Enumerator-based API for manipulating the filesystem";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "filesystem-trees" = callPackage
    ({ mkDerivation, base, cond, containers, data-lens-light, deepseq
     , directory, dlist, filepath, mtl, unix
     }:
     mkDerivation {
       pname = "filesystem-trees";
       version = "0.1.0.6";
       sha256 = "50a36bfc69a738ffc71d50c27ff50531448fa234b25bc5ae658fe37b9383ddae";
       libraryHaskellDepends = [
         base cond containers data-lens-light deepseq directory dlist
         filepath mtl unix
       ];
       homepage = "https://github.com/kallisti-dev/filesystem-trees";
       description = "Recursively manipulate and traverse filesystems as lazy rose trees";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "filtrable" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "filtrable";
       version = "0.1.0.4";
       sha256 = "85285317f86c6e4e7329d74bf6b2116ab203f810ac2b5ebde251f920c3098d53";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/strake/filtrable.hs";
       description = "Class of filtrable containers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "final" = callPackage
    ({ mkDerivation, base, stm, transformers }:
     mkDerivation {
       pname = "final";
       version = "0.1";
       sha256 = "c919f346d6b3228f8f3ef3c3899bb51cd1efe7a390256ffe950c9aea8b5f3ba1";
       libraryHaskellDepends = [ base stm transformers ];
       homepage = "http://github.com/errge/final";
       description = "utility to add extra safety to monadic returns";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "find-clumpiness" = callPackage
    ({ mkDerivation, aeson, base, bytestring, clumpiness, containers
     , optparse-applicative, text, text-show, tree-fun
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "find-clumpiness";
       version = "0.2.0.1";
       sha256 = "87db2a011a2662481f59ac03f64e95ef6692519386aee51417c3894c2174da22";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base clumpiness containers text text-show tree-fun
         unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson base bytestring clumpiness containers optparse-applicative
         text tree-fun unordered-containers
       ];
       homepage = "http://github.com/GregorySchwartz/find-clumpiness#readme";
       description = "Find the clumpiness of labels in a tree";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "find-conduit" = callPackage
    ({ mkDerivation, attoparsec, base, conduit, conduit-combinators
     , conduit-extra, directory, doctest, either, exceptions, filepath
     , hspec, mmorph, monad-control, mtl, regex-posix, semigroups
     , streaming-commons, text, time, transformers, transformers-base
     , unix, unix-compat
     }:
     mkDerivation {
       pname = "find-conduit";
       version = "0.4.4";
       sha256 = "5fcffee1299b0a779f2e0e32f5245b5834a097369f238570b6bb4e469154e196";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base conduit conduit-combinators conduit-extra either
         exceptions filepath mmorph monad-control mtl regex-posix semigroups
         streaming-commons text time transformers transformers-base
         unix-compat
       ];
       executableHaskellDepends = [
         attoparsec base conduit conduit-combinators conduit-extra either
         exceptions filepath mmorph monad-control mtl regex-posix semigroups
         streaming-commons text time transformers transformers-base unix
       ];
       testHaskellDepends = [
         attoparsec base conduit conduit-combinators directory doctest
         either exceptions filepath hspec mmorph monad-control mtl
         regex-posix semigroups streaming-commons text time transformers
         transformers-base unix-compat
       ];
       description = "A file-finding conduit that allows user control over traversals";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fingertree_0_1_0_0" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "fingertree";
       version = "0.1.0.0";
       sha256 = "baa601587f8ed614886e02ca8b1eb915e6946e9937f4c4f7565c46fd7dd66530";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       description = "Generic finger-tree structure, with example instances";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fingertree_0_1_0_1" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "fingertree";
       version = "0.1.0.1";
       sha256 = "7d4f85f2975b60ee6acda374387968a8ca5bca078027726c8cfd831f22478408";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       description = "Generic finger-tree structure, with example instances";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fingertree_0_1_0_2" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "fingertree";
       version = "0.1.0.2";
       sha256 = "e6232c5c77afbb8a70dcd898253fdb07f240f71144c8b12118df526376f53acf";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       description = "Generic finger-tree structure, with example instances";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fingertree" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "fingertree";
       version = "0.1.1.0";
       sha256 = "160c5ba370d781dbf2920ddca870ce8596ab76729972535595bef835ee1cddf0";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       description = "Generic finger-tree structure, with example instances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fingertree-psqueue" = callPackage
    ({ mkDerivation, base, fingertree }:
     mkDerivation {
       pname = "fingertree-psqueue";
       version = "0.3";
       sha256 = "9f8c2f1965ea7a618d969db6506c8f373c95e09072b2182de40713d265046c92";
       libraryHaskellDepends = [ base fingertree ];
       description = "Implementation of priority search queues as finger trees";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fingertree-tf" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fingertree-tf";
       version = "0.1.0.0";
       sha256 = "b64da516e0db3c48d352587f0a4ba4e1199294fd035eeed9d27a437c3b6648c9";
       libraryHaskellDepends = [ base ];
       description = "Generic finger-tree structure using type families";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "finite-field" = callPackage
    ({ mkDerivation, base, containers, deepseq, hashable, HUnit, primes
     , QuickCheck, template-haskell, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     , test-framework-th, type-level-numbers
     }:
     mkDerivation {
       pname = "finite-field";
       version = "0.8.0";
       sha256 = "d15294156f47de63f76c9e9a1b1eaaa9cbcac0bd174b6c5b2fa49075dbc18b72";
       libraryHaskellDepends = [
         base deepseq hashable template-haskell type-level-numbers
       ];
       testHaskellDepends = [
         base containers HUnit primes QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 test-framework-th
         type-level-numbers
       ];
       description = "Finite Fields";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "finite-typelits" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "finite-typelits";
       version = "0.1.0.0";
       sha256 = "1729a66604cf852f1370f3575ac7cd74777df17106929c2afa57cf6c8fc78c58";
       libraryHaskellDepends = [ base ];
       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-and-last" = callPackage
    ({ mkDerivation, base, doctest }:
     mkDerivation {
       pname = "first-and-last";
       version = "0.1.0.1";
       sha256 = "f25888d5530a969c40555d3f947d1f5b2254afe33787a040a32663b3e7d3f9da";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base doctest ];
       homepage = "https://github.com/markandrus/first-and-last";
       description = "First and Last generalized to return up to n values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "first-class-patterns" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "first-class-patterns";
       version = "0.3.2.2";
       sha256 = "c8e4ff951a16806ecfecba1739a13b45489ddf742a1bb025ff915164bdaa4735";
       libraryHaskellDepends = [ base transformers ];
       homepage = "https://github.com/reinerp/first-class-patterns";
       description = "First class patterns and pattern matching, using type families";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "firstify" = callPackage
    ({ mkDerivation, base, containers, directory, filepath
     , homeomorphic, mtl, Safe, yhccore
     }:
     mkDerivation {
       pname = "firstify";
       version = "0.1";
       sha256 = "cdba128f045edde74622a139b8cb1b5e1182ea4e5a61d2f5722fe1ae5f0b05bd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory filepath homeomorphic mtl Safe yhccore
       ];
       homepage = "http://www-users.cs.york.ac.uk/~ndm/firstify/";
       description = "Defunctionalisation for Yhc Core";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fishfood" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, factory, mtl
     , QuickCheck, toolshed
     }:
     mkDerivation {
       pname = "fishfood";
       version = "0.0.1.5";
       sha256 = "58fa4da2e7437ba36be2027a9bcd73cc9aceb180599b59b65a771ac3d9155271";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers directory factory mtl toolshed
       ];
       executableHaskellDepends = [ base Cabal mtl toolshed ];
       testHaskellDepends = [
         base Cabal containers mtl QuickCheck toolshed
       ];
       homepage = "http://functionalley.eu";
       description = "Calculates file-size frequency-distribution";
       license = "GPL";
       hydraPlatforms = [ "i686-linux" "x86_64-darwin" ];
     }) {};

  "fit" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , contravariant, hspec, hspec-attoparsec, mtl, QuickCheck, text
     }:
     mkDerivation {
       pname = "fit";
       version = "0.5.1";
       sha256 = "ab192e41436054b04b476670748d43ff486fc90c5f80e01397bf51103fdbf278";
       libraryHaskellDepends = [
         attoparsec base bytestring containers contravariant mtl text
       ];
       testHaskellDepends = [
         attoparsec base bytestring containers hspec hspec-attoparsec mtl
         QuickCheck text
       ];
       description = "FIT file decoder";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fitsio" = callPackage
    ({ mkDerivation, base, cfitsio, filepath, mtl }:
     mkDerivation {
       pname = "fitsio";
       version = "0.2";
       sha256 = "4fe968152b2a60f43ace145ac157fc0c55a54f7a7f92c975b61961660b68fa1f";
       libraryHaskellDepends = [ base filepath mtl ];
       librarySystemDepends = [ cfitsio ];
       homepage = "http://github.com/esessoms/fitsio";
       description = "A library for reading and writing data files in the FITS data format";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) cfitsio;};

  "fix-imports" = callPackage
    ({ mkDerivation, base, containers, cpphs, directory, filepath
     , haskell-src-exts, process, split, text, uniplate
     }:
     mkDerivation {
       pname = "fix-imports";
       version = "1.0.4";
       sha256 = "46da19d982e3470bd28e55f895c3fc6e6e80a6b98f1014f32755b8601cc61e49";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers cpphs directory filepath haskell-src-exts process
         split text uniplate
       ];
       jailbreak = true;
       description = "Program to manage the imports of a haskell module";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fix-parser-simple" = callPackage
    ({ mkDerivation, base, mmtl }:
     mkDerivation {
       pname = "fix-parser-simple";
       version = "15320.3";
       sha256 = "482b98212e17df3cf871b63f11d41bc0801db9d391c0886506cb528179774553";
       libraryHaskellDepends = [ base mmtl ];
       description = "Simple fix-expression parser";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fix-symbols-gitit" = callPackage
    ({ mkDerivation, base, containers, gitit }:
     mkDerivation {
       pname = "fix-symbols-gitit";
       version = "0.1.0";
       sha256 = "dedcf982a893f66aec6c19a18816611b13e6f42d9818b5d405f7632e1afcdd05";
       libraryHaskellDepends = [ base containers gitit ];
       description = "Gitit plugin: Turn some Haskell symbols into pretty math symbols";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fixed_0_2_1" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fixed";
       version = "0.2.1";
       sha256 = "804526340bb10e1e6925d2043a293285c7341a2bd4997122f49e3d2b8cf2ceab";
       revision = "1";
       editedCabalFile = "ebdccc1365c476d64ebe64237dc19d65d2ad11e03c265a88367bdf185f4c6980";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/ekmett/fixed";
       description = "Signed 15.16 precision fixed point arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fixed" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fixed";
       version = "0.2.1.1";
       sha256 = "24a9e1e251998c9d06037bb771d9eab2980a91132de59a19d0166a1c51e715e2";
       libraryHaskellDepends = [ base ];
       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, tfp, utility-ht }:
     mkDerivation {
       pname = "fixed-length";
       version = "0.2";
       sha256 = "3171f2d443171a8e92733b3935805c7d5b54eae1f39f9fd729a766f887a6389b";
       libraryHaskellDepends = [ base non-empty tfp utility-ht ];
       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-list_0_1_5" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fixed-list";
       version = "0.1.5";
       sha256 = "21a401882f8bc3a1a478a0f5be1dea04213a92120b3e7ffa64d224a7fd9f611d";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/jvranish/FixedList/tree/master";
       description = "A fixed length list type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fixed-list" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fixed-list";
       version = "0.1.6";
       sha256 = "abf680e95d06d31eda26d20c7c61a91b30fbdeadc0e50804ceb97edfcf05fbbe";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/jvranish/FixedList/tree/master";
       description = "A fixed length list type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fixed-point" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fixed-point";
       version = "0.5.0.1";
       sha256 = "6af24469e8795e077bd8db05c03712c52b50a06239ff80f12a9691adc4e80f04";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Binary fixed-point arithmetic";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fixed-point-vector" = callPackage
    ({ mkDerivation, base, fixed-point, vector }:
     mkDerivation {
       pname = "fixed-point-vector";
       version = "0.5.0.1";
       sha256 = "03218312eadee2d9dcaae738bd19a01f88655cfd40dd75c322e9c4d008b13509";
       libraryHaskellDepends = [ base fixed-point vector ];
       jailbreak = true;
       description = "Unbox instances for the fixed-point package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fixed-point-vector-space" = callPackage
    ({ mkDerivation, base, fixed-point, vector-space }:
     mkDerivation {
       pname = "fixed-point-vector-space";
       version = "0.5.0.1";
       sha256 = "bd9d36f931bfbc6243cd83cc73c3f57aa24a29b8c52ce17869fce6e1f14b6281";
       libraryHaskellDepends = [ base fixed-point vector-space ];
       jailbreak = true;
       description = "vector-space instances for the fixed-point package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fixed-precision" = callPackage
    ({ mkDerivation, base, hmpfr, integer-gmp, reflection, tagged
     , template-haskell
     }:
     mkDerivation {
       pname = "fixed-precision";
       version = "0.4.0";
       sha256 = "c6a172d9bd01353202508f6fa425a83dba8b41603112733a9e7f6b34b38a6faa";
       libraryHaskellDepends = [
         base hmpfr integer-gmp reflection tagged template-haskell
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/fixed-precision";
       description = "Fixed Precision Arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fixed-storable-array" = callPackage
    ({ mkDerivation, array, base, tagged }:
     mkDerivation {
       pname = "fixed-storable-array";
       version = "0.3.1.1";
       sha256 = "f00a020ce3792737089cd7d544e0b35728c8c4d6f3b815fb6929742cb680656d";
       libraryHaskellDepends = [ array base tagged ];
       jailbreak = true;
       description = "Fixed-size wrapper for StorableArray, providing a Storable instance. Deprecated - use storable-static-array instead.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fixed-vector_0_7_0_3" = callPackage
    ({ mkDerivation, base, doctest, filemanip, primitive }:
     mkDerivation {
       pname = "fixed-vector";
       version = "0.7.0.3";
       sha256 = "0fb9bf8157e1596677c09e51edf5c7f09ba6d15da8843ccf99638bbd96002385";
       libraryHaskellDepends = [ base primitive ];
       testHaskellDepends = [ base doctest filemanip primitive ];
       jailbreak = true;
       description = "Generic vectors with statically known size";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fixed-vector_0_8_0_0" = callPackage
    ({ mkDerivation, base, deepseq, doctest, filemanip, primitive }:
     mkDerivation {
       pname = "fixed-vector";
       version = "0.8.0.0";
       sha256 = "39da25f74a7c0760cb4675b0116eb9581232de57566e7b323e135e1157068fc2";
       libraryHaskellDepends = [ base deepseq primitive ];
       testHaskellDepends = [ base doctest filemanip primitive ];
       jailbreak = true;
       doCheck = false;
       description = "Generic vectors with statically known size";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fixed-vector" = callPackage
    ({ mkDerivation, base, deepseq, doctest, filemanip, primitive }:
     mkDerivation {
       pname = "fixed-vector";
       version = "0.8.1.0";
       sha256 = "3c3c29c7248c08061949843727e83ad234584ca77f8076ecd9537a185ebe3a93";
       libraryHaskellDepends = [ base deepseq primitive ];
       testHaskellDepends = [ base doctest filemanip primitive ];
       doCheck = false;
       description = "Generic vectors with statically known size";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fixed-vector-binary" = callPackage
    ({ mkDerivation, base, binary, fixed-vector, tasty
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "fixed-vector-binary";
       version = "0.6.0.0";
       sha256 = "1e1e4edd907ac648cd1613f3a492db2c7e650a19cf229e1a8f8a8ac478e25efa";
       libraryHaskellDepends = [ base binary fixed-vector ];
       testHaskellDepends = [
         base binary fixed-vector tasty tasty-quickcheck
       ];
       description = "Binary instances for fixed-vector";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fixed-vector-cereal" = callPackage
    ({ mkDerivation, base, cereal, fixed-vector, tasty
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "fixed-vector-cereal";
       version = "0.6.0.0";
       sha256 = "c6da261e2b87b7fb16790b5180285f43545fdaf985ed007574c545e52e68c3cd";
       libraryHaskellDepends = [ base cereal fixed-vector ];
       testHaskellDepends = [
         base cereal fixed-vector tasty tasty-quickcheck
       ];
       description = "Cereal instances for fixed-vector";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fixed-vector-hetero" = callPackage
    ({ mkDerivation, base, deepseq, fixed-vector, ghc-prim, primitive
     , transformers
     }:
     mkDerivation {
       pname = "fixed-vector-hetero";
       version = "0.3.1.0";
       sha256 = "fbd334d836572cd67dd26845021558eed38f4c0af90a425acb2c5250df93ae74";
       libraryHaskellDepends = [
         base deepseq fixed-vector ghc-prim primitive transformers
       ];
       homepage = "http://github.org/Shimuuar/fixed-vector-hetero";
       description = "Generic heterogeneous vectors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fixedprec" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "fixedprec";
       version = "0.2.2.1";
       sha256 = "f17d0d70af22a2b629b909ee793e348ceb4640460464ff39abf4b53aa10d2269";
       libraryHaskellDepends = [ base random ];
       description = "A fixed-precision real number type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fixedwidth-hs" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, text }:
     mkDerivation {
       pname = "fixedwidth-hs";
       version = "0.4.0.1";
       sha256 = "fd8e2f72c2bd2f3b3bbd94f612960f6b10734e6e3d8c51c65164d9925c8b944c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ aeson attoparsec base bytestring text ];
       executableHaskellDepends = [
         aeson attoparsec base bytestring text
       ];
       homepage = "https://github.com/michaelochurch/fixedwidth-hs";
       description = "Quick parsing of fixed-width data formats";
       license = stdenv.lib.licenses.mit;
     }) {};

  "fixfile" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, exceptions, filepath, hashable, hashtables, lens, mtl
     , QuickCheck, tasty, tasty-quickcheck, temporary, vector
     }:
     mkDerivation {
       pname = "fixfile";
       version = "0.2.0.0";
       sha256 = "7cc1313702089f3b559a9e167ff83ea1ab91406f57500c567d69672c3f85ecfe";
       libraryHaskellDepends = [
         array base binary bytestring containers directory filepath hashable
         hashtables lens mtl temporary vector
       ];
       testHaskellDepends = [
         base binary bytestring directory exceptions lens mtl QuickCheck
         tasty tasty-quickcheck temporary
       ];
       homepage = "https://github.com/revnull/fixfile";
       description = "File-backed recursive data structures";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "fixhs" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , bytestring, containers, deepseq, dlist, enumerator, HaXml
     , MissingH, network, old-time, parallel, QuickCheck, text
     }:
     mkDerivation {
       pname = "fixhs";
       version = "0.1.4";
       sha256 = "e2b3ad479e6d18edefaa5495693293bba81861a0c352767439bea326e6e8ae4f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec attoparsec-enumerator base bytestring containers deepseq
         dlist enumerator HaXml MissingH network old-time parallel
         QuickCheck text
       ];
       executableHaskellDepends = [
         attoparsec base bytestring containers deepseq dlist HaXml MissingH
         old-time QuickCheck text
       ];
       homepage = "http://github.com/urv/fixhs";
       description = "FIX (co)parser";
       license = stdenv.lib.licenses.lgpl21;
     }) {};

  "fixplate" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "fixplate";
       version = "0.1.6";
       sha256 = "c3227c94b7ccaf27991384bee8bef3288a4a9a87691b50121da1f4b84edc2e43";
       libraryHaskellDepends = [ base containers ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "Uniplate-style generic traversals for optionally annotated fixed-point types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fixpoint" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fixpoint";
       version = "0.1.1";
       sha256 = "eb7e0da7d9ba67c153b2df95732f529b9533e41194a848250e93dbfb02670116";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.cse.unsw.edu.au/~rl/code/fixpoint.html";
       description = "Data types as fixpoints";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fixtime" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "fixtime";
       version = "1.5.0.2";
       sha256 = "8503b41d8fa684d59f5cd061c4aaf9f9d6f11162280cff36123bf3103deb54f1";
       libraryHaskellDepends = [ base time ];
       homepage = "https://github.com/pharpend/fixtime";
       description = "Some fixes to the time package";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "fizz-buzz" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fizz-buzz";
       version = "0.1.0.1";
       sha256 = "97bca955036b0ae3d33757fdcbb44421f9cd5a49ee0ed0b6ade07f168f543d99";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Functional Fizz/Buzz";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "flaccuraterip" = callPackage
    ({ mkDerivation, base, binary, deepseq, HTTP, optparse-applicative
     , process
     }:
     mkDerivation {
       pname = "flaccuraterip";
       version = "0.3.5";
       sha256 = "fa572869a54dfcea3aac395c9f1e116f9fb69cf04134411d5e8b4a88ea8ff229";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary deepseq HTTP optparse-applicative process
       ];
       homepage = "http://noaxiom.org/flAccurateRip";
       description = "Verify FLAC files ripped form CD using AccurateRip™";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "flamethrower" = callPackage
    ({ mkDerivation, base, template-haskell, text }:
     mkDerivation {
       pname = "flamethrower";
       version = "0.0.5.1";
       sha256 = "1d358cd572792b31ad714e8a799fd90bca098f47822d6afe83419c6b59f06e82";
       libraryHaskellDepends = [ base template-haskell text ];
       jailbreak = true;
       homepage = "https://charmander.me/flamethrower/";
       description = "A template engine for HTML";
       license = stdenv.lib.licenses.mit;
     }) {};

  "flamingra" = callPackage
    ({ mkDerivation, base, either, optparse-applicative, pipes }:
     mkDerivation {
       pname = "flamingra";
       version = "0.1.1.1";
       sha256 = "7bd82580668be11e780f529bcc9495250873ee45cbf6c2e2cc7b8caae47ad8f9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [
         base either optparse-applicative pipes
       ];
       description = "FlameGraphs of profiling";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "flat-maybe" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "flat-maybe";
       version = "0.1.0.0";
       sha256 = "98ee27978642f7f07e48d7d7567e0cd1dc531a4a6e0e515e3f5cd343e6c9be4f";
       libraryHaskellDepends = [ base ghc-prim ];
       homepage = "https://github.com/AndrasKovacs/flat-maybe";
       description = "Strict Maybe without space and indirection overhead";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "flat-mcmc" = callPackage
    ({ mkDerivation, base, monad-par, monad-par-extras, mtl, mwc-random
     , primitive, vector
     }:
     mkDerivation {
       pname = "flat-mcmc";
       version = "0.1.0.0";
       sha256 = "e50ffd58d41a2f2fd4a82a7397b2330eff63f5269578d8cf91734d81d493e5ba";
       libraryHaskellDepends = [
         base monad-par monad-par-extras mtl mwc-random primitive vector
       ];
       jailbreak = true;
       homepage = "http://jtobin.github.com/flat-mcmc";
       description = "Painless general-purpose sampling";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "flat-tex" = callPackage
    ({ mkDerivation, base, directory, parsec }:
     mkDerivation {
       pname = "flat-tex";
       version = "0.3.1";
       sha256 = "574f88448cac7d5a0399e5e7518f5c7003dacf16a2767a6d925cd3606a224ed7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory parsec ];
       homepage = "https://github.com/jwaldmann/flat-tex";
       description = "flatten a latex multi-file latex document";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "flexible-defaults" = callPackage
    ({ mkDerivation, base, containers, template-haskell, th-extras
     , transformers
     }:
     mkDerivation {
       pname = "flexible-defaults";
       version = "0.0.1.1";
       sha256 = "f4c652b03224e3dcc63edfa194816b4431a3d93801a043e1f83d097f16447731";
       libraryHaskellDepends = [
         base containers template-haskell th-extras transformers
       ];
       homepage = "https://github.com/mokus0/flexible-defaults";
       description = "Generate default function implementations for complex type classes";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "flexible-time" = callPackage
    ({ mkDerivation, base, bytestring, unix-time }:
     mkDerivation {
       pname = "flexible-time";
       version = "0.1.0.3";
       sha256 = "14a9f39943ff1a7491177d579b572f0e1f1c051a4b1ded767840978c4a06339d";
       libraryHaskellDepends = [ base bytestring unix-time ];
       jailbreak = true;
       homepage = "https://github.com/tattsun/flexible-time";
       description = "simple extension of Data.UnixTime.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "flexible-unlit" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "flexible-unlit";
       version = "0.2013.314.0";
       sha256 = "4a80ab2d67a35c79cf3dce048644246108740367c777558a6c99f0efb0509a4b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base text ];
       executableHaskellDepends = [ base bytestring text ];
       description = "A configurable reimplementation of unlit";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "flexiwrap" = callPackage
    ({ mkDerivation, base, data-type, mtl, QuickCheck }:
     mkDerivation {
       pname = "flexiwrap";
       version = "0.1.0";
       sha256 = "6a35de47b8f31d4fa605b96d06c374cc25a4e0d26c31ad8138939c11074f746f";
       libraryHaskellDepends = [ base data-type mtl QuickCheck ];
       jailbreak = true;
       description = "Flexible wrappers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "flexiwrap-smallcheck" = callPackage
    ({ mkDerivation, base, data-type, flexiwrap, mtl, smallcheck }:
     mkDerivation {
       pname = "flexiwrap-smallcheck";
       version = "0.0.1";
       sha256 = "a36ad62969cd8260d3fab23b00a6c41875a30c158ede2a0de9dd81f0155059b5";
       libraryHaskellDepends = [
         base data-type flexiwrap mtl smallcheck
       ];
       jailbreak = true;
       description = "SmallCheck (Serial) instances for flexiwrap";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "flickr" = callPackage
    ({ mkDerivation, base, filepath, HTTP, mime, network, random
     , utf8-string, xhtml, xml
     }:
     mkDerivation {
       pname = "flickr";
       version = "0.3.3";
       sha256 = "d49b8e161e7f3bc12545c5de8c9c5f69de103fbd8dbafa8aebeb3d413f19d189";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base filepath HTTP mime network random utf8-string xml
       ];
       executableHaskellDepends = [ xhtml ];
       description = "Haskell binding to the Flickr API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "flippers" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "flippers";
       version = "1.0.1";
       sha256 = "e3e2efcd85e9250cf682f16e65e89261724fb8fecd50d6133c38be635c909eeb";
       revision = "1";
       editedCabalFile = "e908ada5c891a6ac39cefb7e41648606d1a5f1b1048281f93bd496c5f22d73b4";
       libraryHaskellDepends = [ base ];
       description = "Variations on flip for multiple arguments";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "flite" = callPackage
    ({ mkDerivation, array, base, containers, haskell98, parsec }:
     mkDerivation {
       pname = "flite";
       version = "0.1.2";
       sha256 = "8d10ccb77a5ea1da2998f095243574205b9ccafc3a16587a8aff99c759246432";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base containers haskell98 parsec ];
       executableHaskellDepends = [
         array base containers haskell98 parsec
       ];
       jailbreak = true;
       homepage = "http://www.cs.york.ac.uk/fp/reduceron/";
       description = "f-lite compiler, interpreter and libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "flo" = callPackage
    ({ mkDerivation, base, bytestring, mtl, mtl-compat, parsec
     , regex-compat, text
     }:
     mkDerivation {
       pname = "flo";
       version = "0.1.1";
       sha256 = "fde388779f96718c2cb786325a2b4b3daee1110dfde8b0b17c5350726193ba73";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring mtl-compat parsec regex-compat text
       ];
       executableHaskellDepends = [
         base bytestring mtl parsec regex-compat text
       ];
       description = "Generate flow charts from your code base";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "float-binstring" = callPackage
    ({ mkDerivation, attoparsec, base, hspec, HUnit, QuickCheck, split
     , text
     }:
     mkDerivation {
       pname = "float-binstring";
       version = "0.2";
       sha256 = "b8fdaa7ef1ce32170be507e030a1adb6d77f45821e9dd13aa6fade1174989d35";
       libraryHaskellDepends = [ attoparsec base split text ];
       testHaskellDepends = [
         attoparsec base hspec HUnit QuickCheck split text
       ];
       homepage = "https://github.com/llelf/float-binstring";
       description = "C99 printf \"%a\" style formatting and parsing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "floating-bits" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "floating-bits";
       version = "0.3.0.0";
       sha256 = "b2cf891588df5adc6633c26d8e75c582c0cecfcf7f48e3a889e8013d739ae2b2";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       description = "Conversions between floating and integral values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "floatshow" = callPackage
    ({ mkDerivation, array, base, integer-gmp }:
     mkDerivation {
       pname = "floatshow";
       version = "0.2.4";
       sha256 = "0c4e9494df46120942b2078db53c16200b46eff603fca5ab85775a541f975dff";
       libraryHaskellDepends = [ array base integer-gmp ];
       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;
     }) {};

  "flock" = callPackage
    ({ mkDerivation, base, lifted-base, monad-control, transformers
     , unix
     }:
     mkDerivation {
       pname = "flock";
       version = "0.3.1.8";
       sha256 = "9634ce605c3b5579f4f1e53af7d93850ec23ffb2fd5b24e02974626af1712fbc";
       libraryHaskellDepends = [
         base lifted-base monad-control transformers unix
       ];
       homepage = "http://github.com/hesselink/flock";
       description = "Wrapper for flock(2)";
       license = "unknown";
     }) {};

  "flow_1_0_1" = callPackage
    ({ mkDerivation, base, doctest, QuickCheck, template-haskell }:
     mkDerivation {
       pname = "flow";
       version = "1.0.1";
       sha256 = "1e45411e366ddf9c9def18ad3a7d274119bf5187e908f5b4beecf68f9cb82086";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base doctest QuickCheck template-haskell ];
       homepage = "http://taylor.fausak.me/flow/";
       description = "Write more understandable Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "flow" = callPackage
    ({ mkDerivation, base, doctest, QuickCheck, template-haskell }:
     mkDerivation {
       pname = "flow";
       version = "1.0.2";
       sha256 = "20f09c7841b72a90f4dd986f0dd68b0f71f96f12ba84b2097c29eb8f16d256d0";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base doctest QuickCheck template-haskell ];
       homepage = "http://taylor.fausak.me/flow/";
       description = "Write more understandable Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "flow2dot" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec, QuickCheck
     , utf8-string
     }:
     mkDerivation {
       pname = "flow2dot";
       version = "0.9.0.3";
       sha256 = "231871514ff61c7b8d2f3e90d8156afea6ef19c502fef1277ebd6fcd2f07c6dd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl parsec QuickCheck utf8-string
       ];
       homepage = "http://adept.linux.kiev.ua:8080/repos/flow2dot";
       description = "Library and binary to generate sequence/flow diagrams from plain text source";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "flowdock" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , http-client, http-client-tls, lens, lens-action, mtl, network
     , pipes, pipes-aeson, pipes-http, pipes-parse, template-haskell
     , text, unordered-containers, uuid
     }:
     mkDerivation {
       pname = "flowdock";
       version = "0.3.0.1";
       sha256 = "d1e46b71283915c74d5a02a21ae61ecb80029219ffffc86596239e671be7e9ab";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring http-client http-client-tls
         lens lens-action mtl network pipes pipes-aeson pipes-http
         pipes-parse template-haskell text unordered-containers uuid
       ];
       homepage = "https://github.com/brewtown/hs-flowdock";
       description = "Flowdock client library for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "flowdock-api" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, blaze-builder
     , bytestring, data-default, directory, filepath, heredoc, HsOpenSSL
     , hspec, http-streams, http-types, io-streams, monad-logger
     , MonadCatchIO-transformers, optparse-applicative, split
     , template-haskell, text, time, transformers, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "flowdock-api";
       version = "0.1.0.0";
       sha256 = "cf1edb5c55d52c1834f864d1f887b2ed607f9f5b2c4b4053a47b7abfd4050b5c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base64-bytestring blaze-builder bytestring data-default
         HsOpenSSL http-streams http-types io-streams monad-logger
         MonadCatchIO-transformers text time transformers
         unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson base base64-bytestring blaze-builder bytestring data-default
         directory filepath HsOpenSSL http-streams http-types io-streams
         MonadCatchIO-transformers optparse-applicative split text time
         transformers unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base base64-bytestring blaze-builder bytestring data-default
         heredoc HsOpenSSL hspec http-streams http-types io-streams
         monad-logger MonadCatchIO-transformers template-haskell text time
         transformers unordered-containers vector
       ];
       homepage = "https://github.com/gabemc/flowdock-api";
       description = "API integration with Flowdock";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "flowdock-rest" = callPackage
    ({ mkDerivation, aeson, ansi-wl-pprint, base, binary
     , binary-orphans, binary-tagged, bytestring, deepseq, exceptions
     , file-embed, generics-sop, hashable, http-client, http-client-tls
     , lens, semigroups, tagged, tasty, tasty-quickcheck, text, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "flowdock-rest";
       version = "0.1.0.0";
       sha256 = "b9f2590d5a5a30b73b4b43c0e01af88ace3b64fa30a5c7a02221470bddb5fbae";
       libraryHaskellDepends = [
         aeson ansi-wl-pprint base binary binary-orphans binary-tagged
         bytestring deepseq exceptions generics-sop hashable http-client
         http-client-tls lens semigroups tagged text time
         unordered-containers
       ];
       testHaskellDepends = [
         aeson ansi-wl-pprint base binary binary-orphans binary-tagged
         bytestring deepseq exceptions file-embed generics-sop hashable
         http-client http-client-tls lens semigroups tagged tasty
         tasty-quickcheck text time unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/futurice/haskell-flowdock-rest#readme";
       description = "Flowdock REST API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "flower" = callPackage
    ({ mkDerivation, array, base, binary, bio, bytestring, cmdargs
     , containers, mtl, random
     }:
     mkDerivation {
       pname = "flower";
       version = "0.7.2";
       sha256 = "0b8d60e8af5114e496e401af344c3f7338ecb42c1b8b8a96220efa19d21a3465";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base binary bio bytestring cmdargs containers mtl random
       ];
       jailbreak = true;
       homepage = "http://biohaskell.org/Applications/Flower";
       description = "Analyze 454 flowgrams (.SFF files)";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "flowlocks-framework" = callPackage
    ({ mkDerivation, base, containers, QuickCheck, syb }:
     mkDerivation {
       pname = "flowlocks-framework";
       version = "0.1.3.1";
       sha256 = "48f1b40c603f430f6657270372717b2ce7fe900825b233d334dd89e704183fed";
       libraryHaskellDepends = [ base containers syb ];
       testHaskellDepends = [ base QuickCheck ];
       description = "Generalized Flow Locks Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "flowsim" = callPackage
    ({ mkDerivation, array, base, biocore, biofasta, biosff, bytestring
     , cmdargs, containers, directory, MonadRandom, mtl, random
     }:
     mkDerivation {
       pname = "flowsim";
       version = "0.3.5";
       sha256 = "431a1e6219f879cc2d5f051db7216734078c678ca0ed0f5d86708a2c94106250";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base biocore biofasta biosff bytestring cmdargs containers
         directory MonadRandom mtl random
       ];
       homepage = "http://biohaskell.org/Applications/FlowSim";
       description = "Simulate 454 pyrosequencing";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fltkhs" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, directory, filepath, mtl
     , parsec
     }:
     mkDerivation {
       pname = "fltkhs";
       version = "0.4.0.2";
       sha256 = "0ce62c0325a1ec7a9c782b0ead40cdfb3c60cc5f98c13f61f72e329214c06d17";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring ];
       libraryToolDepends = [ c2hs ];
       executableHaskellDepends = [ base directory filepath mtl parsec ];
       homepage = "http://github.com/deech/fltkhs";
       description = "FLTK bindings";
       license = stdenv.lib.licenses.mit;
     }) {};

  "fltkhs-demos" = callPackage
    ({ mkDerivation, base, bytestring, directory, fltkhs, process, stm
     }:
     mkDerivation {
       pname = "fltkhs-demos";
       version = "0.0.0.3";
       sha256 = "c39a9c8378857e4f4c7af7ab98516bb3deffce1e39742eb7f39ce4cf09c1f1b7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory fltkhs process stm
       ];
       homepage = "http://github.com/deech/fltkhs-demos";
       description = "FLTKHS demos. Please scroll to the bottom for more information.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "fltkhs-fluid-examples" = callPackage
    ({ mkDerivation, base, bytestring, fltkhs }:
     mkDerivation {
       pname = "fltkhs-fluid-examples";
       version = "0.0.0.3";
       sha256 = "29d569819feafbe4aa9deb6c78a2e3189780e1cbb4aa350a3e32aa18b6435bf0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bytestring fltkhs ];
       homepage = "http://github.com/deech/fltkhs-fluid-examples";
       description = "Fltkhs Fluid Examples";
       license = stdenv.lib.licenses.mit;
     }) {};

  "fltkhs-hello-world" = callPackage
    ({ mkDerivation, base, fltkhs }:
     mkDerivation {
       pname = "fltkhs-hello-world";
       version = "0.0.0.2";
       sha256 = "c7f8e729ba129ba983624da2d8696629c3e476b80ae5ea76a28e1a37ceedade1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base fltkhs ];
       homepage = "http://github.com/deech/fltkhs-hello-world";
       description = "Fltkhs template project";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fluent-logger" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, cereal
     , cereal-conduit, conduit, conduit-extra, containers, exceptions
     , hspec, messagepack, network, network-socket-options, random, stm
     , text, time, transformers, vector
     }:
     mkDerivation {
       pname = "fluent-logger";
       version = "0.2.3.1";
       sha256 = "b719a5ad910bab70531b597a874de2c70754d6e176f3256f81b5e8ec24852755";
       libraryHaskellDepends = [
         base bytestring cereal containers messagepack network
         network-socket-options random stm text time vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring cereal cereal-conduit conduit
         conduit-extra containers exceptions hspec messagepack network text
         time transformers
       ];
       description = "A structured logger for Fluentd (Haskell)";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "fluent-logger-conduit" = callPackage
    ({ mkDerivation, base, bytestring, conduit, fluent-logger
     , resourcet, transformers
     }:
     mkDerivation {
       pname = "fluent-logger-conduit";
       version = "0.3.0.0";
       sha256 = "383d35fcd9a63574798badab5b76e96d0228c79d25b2b7ef7e0e67e0c36b417c";
       libraryHaskellDepends = [
         base bytestring conduit fluent-logger resourcet transformers
       ];
       description = "Conduit interface for fluent-logger";
       license = "unknown";
     }) {};

  "fluidsynth" = callPackage
    ({ mkDerivation, base, bindings-DSL, containers, directory
     , fluidsynth
     }:
     mkDerivation {
       pname = "fluidsynth";
       version = "0.2.0.0";
       sha256 = "9a1848452f73e9b48b0fbf16c12f5db9eee30c8b8901ed5538599701f5c127a3";
       libraryHaskellDepends = [ base bindings-DSL containers directory ];
       librarySystemDepends = [ fluidsynth ];
       jailbreak = true;
       homepage = "https://github.com/MostAwesomeDude/hsfluidsynth";
       description = "Haskell bindings to FluidSynth";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) fluidsynth;};

  "fmark" = callPackage
    ({ mkDerivation, base, directory, filepath, mtl, process, Unixutils
     }:
     mkDerivation {
       pname = "fmark";
       version = "0.1.1";
       sha256 = "34815c78ae08cc8b87f6824238e2e8dd280c7913054a7f4b5d36f00a529b53ae";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath mtl process Unixutils
       ];
       jailbreak = true;
       homepage = "http://github.com/jabolopes/fmark";
       description = "A Friendly Markup language without syntax";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fmlist" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fmlist";
       version = "0.9";
       sha256 = "581153395a71e3c139365ffbebbeac6d880a6fdfee23e7f5d942ccbeb2aefcbf";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/sjoerdvisscher/fmlist";
       description = "FoldMap lists";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fn_0_2_0_1" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, directory
     , filepath, hspec, http-types, text, unordered-containers, wai
     , wai-extra
     }:
     mkDerivation {
       pname = "fn";
       version = "0.2.0.1";
       sha256 = "8f39132f14a82c280f74b799f39367d9fc7566c9827bb1d4cc10e837ce37e95c";
       libraryHaskellDepends = [
         base blaze-builder bytestring directory filepath http-types text
         unordered-containers wai wai-extra
       ];
       testHaskellDepends = [
         base directory filepath hspec http-types text unordered-containers
         wai wai-extra
       ];
       homepage = "http://github.com/dbp/fn#readme";
       description = "A functional web framework";
       license = stdenv.lib.licenses.isc;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fn" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, directory
     , filepath, hspec, http-types, text, unordered-containers, wai
     , wai-extra
     }:
     mkDerivation {
       pname = "fn";
       version = "0.2.0.2";
       sha256 = "e305abe5735e0bb58a932766ca910371c8352821683c9b574db8de918c8bd612";
       libraryHaskellDepends = [
         base blaze-builder bytestring directory filepath http-types text
         unordered-containers wai wai-extra
       ];
       testHaskellDepends = [
         base directory filepath hspec http-types text unordered-containers
         wai wai-extra
       ];
       homepage = "http://github.com/dbp/fn#readme";
       description = "A functional web framework";
       license = stdenv.lib.licenses.isc;
     }) {};

  "fn-extra_0_2_0_0" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, either, fn, heist
     , http-types, lens, mtl, text, wai, wai-util, xmlhtml
     }:
     mkDerivation {
       pname = "fn-extra";
       version = "0.2.0.0";
       sha256 = "4463c870b596532599fdfcd0dca53420119bf92d422f4344b5859b0108456538";
       libraryHaskellDepends = [
         base blaze-builder bytestring either fn heist http-types lens mtl
         text wai wai-util xmlhtml
       ];
       homepage = "http://github.com/dbp/fn#readme";
       description = "Extras for Fn, a functional web framework";
       license = stdenv.lib.licenses.isc;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fn-extra" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, either, fn, heist
     , http-types, lens, mtl, text, wai, wai-util, xmlhtml
     }:
     mkDerivation {
       pname = "fn-extra";
       version = "0.2.0.1";
       sha256 = "4820af377ee54757dbf027f17c91a83afe122cc65b8d8a63a0d3b5762268da44";
       libraryHaskellDepends = [
         base blaze-builder bytestring either fn heist http-types lens mtl
         text wai wai-util xmlhtml
       ];
       homepage = "http://github.com/dbp/fn#readme";
       description = "Extras for Fn, a functional web framework";
       license = stdenv.lib.licenses.isc;
     }) {};

  "focus_0_1_3" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "focus";
       version = "0.1.3";
       sha256 = "1eab0c24475725b0d29f4ac3cefe07a75b06a48ed77a9758201f542132cd8686";
       libraryHaskellDepends = [ base ];
       doHaddock = false;
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "focus" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "focus";
       version = "0.1.4";
       sha256 = "56447cb6087d7ce3db38a54bb73e6fc456d488f2a674e24ab80132b63c22d840";
       libraryHaskellDepends = [ base ];
       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;
     }) {};

  "fold-debounce" = callPackage
    ({ mkDerivation, base, data-default, hspec, stm, stm-delay, time }:
     mkDerivation {
       pname = "fold-debounce";
       version = "0.2.0.0";
       sha256 = "ab4af7e815cfa2345cdf17c0e765da575f66c0b9b978c8234d620fcf933800db";
       libraryHaskellDepends = [ base data-default stm stm-delay time ];
       testHaskellDepends = [ base hspec stm time ];
       jailbreak = true;
       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;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "fold-debounce-conduit" = callPackage
    ({ mkDerivation, base, conduit, fold-debounce, hspec, resourcet
     , stm, transformers, transformers-base
     }:
     mkDerivation {
       pname = "fold-debounce-conduit";
       version = "0.1.0.0";
       sha256 = "b348a7e2e83e6a98cd95fbc7a967f5a80e3772d6fa0377b8d53acef509e1be34";
       libraryHaskellDepends = [
         base conduit fold-debounce resourcet stm transformers
         transformers-base
       ];
       testHaskellDepends = [
         base conduit hspec resourcet stm transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/debug-ito/fold-debounce-conduit";
       description = "Regulate input traffic from conduit Source with Control.FoldDebounce";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "foldl_1_0_7" = callPackage
    ({ mkDerivation, base, bytestring, containers, primitive, text
     , transformers, vector
     }:
     mkDerivation {
       pname = "foldl";
       version = "1.0.7";
       sha256 = "4991d3a39f10459e47b4c094327e93d437e299cd6225ff57b4d8d1ece28a1d57";
       revision = "1";
       editedCabalFile = "00f694d3c7be565194e9404f4ff8014a2b005866ed70311c869377b2668cceec";
       libraryHaskellDepends = [
         base bytestring containers primitive text transformers vector
       ];
       jailbreak = true;
       description = "Composable, streaming, and efficient left folds";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "foldl_1_0_8" = callPackage
    ({ mkDerivation, base, bytestring, containers, primitive, text
     , transformers, vector
     }:
     mkDerivation {
       pname = "foldl";
       version = "1.0.8";
       sha256 = "77ff4cfbbbc53d628966a481214bce72548a09a9ea8f1c9ac85c727a820d0fed";
       revision = "1";
       editedCabalFile = "b624e24b4204e67106912efde9ce4d6219814f9bd88885b6e05a606c34e601c2";
       libraryHaskellDepends = [
         base bytestring containers primitive text transformers vector
       ];
       jailbreak = true;
       description = "Composable, streaming, and efficient left folds";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "foldl_1_0_9" = callPackage
    ({ mkDerivation, base, bytestring, containers, primitive, text
     , transformers, vector
     }:
     mkDerivation {
       pname = "foldl";
       version = "1.0.9";
       sha256 = "66e4d4b3ddce7f10c4147271b375e49aa44946adc5ebe2ee03ca1a6520c9c983";
       revision = "1";
       editedCabalFile = "affa997426895b4ad248bbfdae6aa01d043bca1109f71508d491cec16f571bcb";
       libraryHaskellDepends = [
         base bytestring containers primitive text transformers vector
       ];
       jailbreak = true;
       description = "Composable, streaming, and efficient left folds";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "foldl_1_0_10" = callPackage
    ({ mkDerivation, base, bytestring, containers, mwc-random
     , primitive, text, transformers, vector
     }:
     mkDerivation {
       pname = "foldl";
       version = "1.0.10";
       sha256 = "38591b038f94921d5c581c2409336fad66f97a5157d29aa648176b888e5df011";
       revision = "1";
       editedCabalFile = "4b17e66a5637a39627fa46cd3898f4225b188bd685491ac8f2a1e3d8510aca41";
       libraryHaskellDepends = [
         base bytestring containers mwc-random primitive text transformers
         vector
       ];
       jailbreak = true;
       description = "Composable, streaming, and efficient left folds";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "foldl_1_0_11" = callPackage
    ({ mkDerivation, base, bytestring, containers, mwc-random
     , primitive, profunctors, text, transformers, vector
     }:
     mkDerivation {
       pname = "foldl";
       version = "1.0.11";
       sha256 = "b9e731d12fad4a515c70202cb9e57d0da7a0c4dd4d1bfee3746a23b764dfea33";
       revision = "1";
       editedCabalFile = "527e91eb4be5fbe35ce0feedb8674cac9d71ae5981723a3515c8a4bff5586132";
       libraryHaskellDepends = [
         base bytestring containers mwc-random primitive profunctors text
         transformers vector
       ];
       jailbreak = true;
       description = "Composable, streaming, and efficient left folds";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "foldl_1_1_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, mwc-random
     , primitive, profunctors, text, transformers, vector
     }:
     mkDerivation {
       pname = "foldl";
       version = "1.1.1";
       sha256 = "ef49feba75c927ab2a6b9afcdbe7730463ed379f1681ae12c15a1608c7a2f807";
       revision = "1";
       editedCabalFile = "641c802c7ad2ba09a68c6c39f7ba5ae2b8cabaa42b32ed8fa1d531981d28344c";
       libraryHaskellDepends = [
         base bytestring containers mwc-random primitive profunctors text
         transformers vector
       ];
       jailbreak = true;
       description = "Composable, streaming, and efficient left folds";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "foldl_1_1_2" = callPackage
    ({ mkDerivation, base, bytestring, comonad, containers, mwc-random
     , primitive, profunctors, text, transformers, vector
     }:
     mkDerivation {
       pname = "foldl";
       version = "1.1.2";
       sha256 = "723b62642b0dd95f0fb8e87102552c76755ad18f300c3429b43fa7b56213c17f";
       revision = "1";
       editedCabalFile = "56f70861e4a386e6677b096c8e6770714ffbef0458347dd2871b533855748522";
       libraryHaskellDepends = [
         base bytestring comonad containers mwc-random primitive profunctors
         text transformers vector
       ];
       jailbreak = true;
       description = "Composable, streaming, and efficient left folds";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "foldl_1_1_3" = callPackage
    ({ mkDerivation, base, bytestring, comonad, containers, mwc-random
     , primitive, profunctors, text, transformers, vector
     }:
     mkDerivation {
       pname = "foldl";
       version = "1.1.3";
       sha256 = "af81eb42e6530f6f0ba992965c337d89483d755b50c7c94b12325dd793435474";
       revision = "1";
       editedCabalFile = "e41df2422bd8adfd40d113d49bbb7cc00e7aa466ee145e11793af4bab944484f";
       libraryHaskellDepends = [
         base bytestring comonad containers mwc-random primitive profunctors
         text transformers vector
       ];
       description = "Composable, streaming, and efficient left folds";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "foldl" = callPackage
    ({ mkDerivation, base, bytestring, comonad, containers, mwc-random
     , primitive, profunctors, text, transformers, vector
     }:
     mkDerivation {
       pname = "foldl";
       version = "1.1.5";
       sha256 = "2053b44ba2a82c247df195f8fdfa159741ffae21c70131bee2e11143577b115a";
       libraryHaskellDepends = [
         base bytestring comonad containers mwc-random primitive profunctors
         text transformers vector
       ];
       description = "Composable, streaming, and efficient left folds";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "foldl-incremental" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, foldl
     , histogram-fill, mwc-random, pipes, QuickCheck, tasty
     , tasty-golden, tasty-hunit, tasty-quickcheck, vector
     }:
     mkDerivation {
       pname = "foldl-incremental";
       version = "0.2.0.0";
       sha256 = "f3c3352c7dc24f78fa25f804647f70e3daf612364d55c717f989c8a1164bae27";
       libraryHaskellDepends = [
         base containers deepseq foldl histogram-fill vector
       ];
       testHaskellDepends = [
         base bytestring containers foldl histogram-fill mwc-random pipes
         QuickCheck tasty tasty-golden tasty-hunit tasty-quickcheck vector
       ];
       homepage = "https://github.com/tonyday567/foldl-incremental";
       description = "incremental folds";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "foldl-transduce" = callPackage
    ({ mkDerivation, base, bifunctors, bytestring, comonad, containers
     , doctest, foldl, free, monoid-subclasses, profunctors
     , semigroupoids, semigroups, split, tasty, tasty-hunit
     , tasty-quickcheck, text, transformers, void
     }:
     mkDerivation {
       pname = "foldl-transduce";
       version = "0.5.2.0";
       sha256 = "c3d8e0ec48ab53c60dac03c7784b508b82da23a6e746b4f856415dbfe359a9b7";
       libraryHaskellDepends = [
         base bifunctors bytestring comonad containers foldl free
         monoid-subclasses profunctors semigroupoids semigroups split text
         transformers void
       ];
       testHaskellDepends = [
         base doctest foldl free monoid-subclasses split tasty tasty-hunit
         tasty-quickcheck text
       ];
       description = "Transducers for foldl folds";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "foldl-transduce-attoparsec" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, doctest, foldl
     , foldl-transduce, monoid-subclasses, tasty, tasty-hunit, text
     , transformers
     }:
     mkDerivation {
       pname = "foldl-transduce-attoparsec";
       version = "0.2.0.0";
       sha256 = "0bd4c213bd949f1aa1f6f849b9c5caee6d20a6756712efcae2e383b24fe62f73";
       libraryHaskellDepends = [
         attoparsec base bytestring foldl-transduce monoid-subclasses text
         transformers
       ];
       testHaskellDepends = [
         attoparsec base doctest foldl foldl-transduce tasty tasty-hunit
         text transformers
       ];
       description = "Attoparsec and foldl-transduce integration";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "folds" = callPackage
    ({ mkDerivation, adjunctions, base, bifunctors, bytestring, comonad
     , constraints, contravariant, data-reify, deepseq, directory
     , distributive, doctest, filepath, lens, mtl, pointed, profunctors
     , reflection, semigroupoids, semigroups, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "folds";
       version = "0.7";
       sha256 = "ec5090f3a11aa18973a239fd8285041e0766df73630864abf5ee3e14ee2ee762";
       configureFlags = [ "-f-test-hlint" ];
       libraryHaskellDepends = [
         adjunctions base bifunctors comonad constraints contravariant
         data-reify distributive lens mtl pointed profunctors reflection
         semigroupoids semigroups transformers unordered-containers vector
       ];
       testHaskellDepends = [
         base bytestring deepseq directory doctest filepath mtl semigroups
       ];
       homepage = "http://github.com/ekmett/folds";
       description = "Beautiful Folding";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "folds-common" = callPackage
    ({ mkDerivation, base, containers, folds, tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "folds-common";
       version = "0.2.0.0";
       sha256 = "acfec09382339b2fe6f6a31efa19a12516efc8755c82dc91ae04cb88d2819eb5";
       libraryHaskellDepends = [ base containers folds ];
       testHaskellDepends = [ base containers tasty tasty-quickcheck ];
       description = "A playground of common folds for folds";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "follower" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, cmdargs, directory, filepath
     , hs-twitter, old-locale, strict, time
     }:
     mkDerivation {
       pname = "follower";
       version = "0.0.1";
       sha256 = "55bfc859d286639ab320188cbb8c8aed9828774934b3663eb103b0eb0cc0c847";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-wl-pprint base cmdargs directory filepath hs-twitter
         old-locale strict time
       ];
       homepage = "http://rebworks.net/projects/follower/";
       description = "Follow Tweets anonymously";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "foma" = callPackage
    ({ mkDerivation, base, foma }:
     mkDerivation {
       pname = "foma";
       version = "0.1.1.0";
       sha256 = "63791467c24e9092d9ec5b295a4702f0ef9e89f01d75bae941aff4ffe3223eaa";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ foma ];
       homepage = "http://github.com/joom/foma.hs";
       description = "Simple Haskell bindings for Foma";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {foma = null;};

  "font-opengl-basic4x6" = callPackage
    ({ mkDerivation, base, GLFW-b, OpenGL }:
     mkDerivation {
       pname = "font-opengl-basic4x6";
       version = "0.0.3";
       sha256 = "a9b3d1712ccb2dd9a100dd2a0b37fba09f729645285709e84148c73a1e5ad257";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base OpenGL ];
       executableHaskellDepends = [ base GLFW-b OpenGL ];
       jailbreak = true;
       description = "Basic4x6 font for OpenGL";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "foo" = callPackage
    ({ mkDerivation, base, containers, GLUT, haskell98, OpenGL }:
     mkDerivation {
       pname = "foo";
       version = "1.0";
       sha256 = "686fe0cb53b97ba9830c55a557a9c6eba671c9240927bed79bd56ed7645c2ab8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers GLUT haskell98 OpenGL
       ];
       homepage = "http://sourceforge.net/projects/fooengine/?abmode=1";
       description = "Paper soccer, an OpenGL game";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "for-free" = callPackage
    ({ mkDerivation, base, comonad, comonad-transformers, containers
     , contravariant, transformers
     }:
     mkDerivation {
       pname = "for-free";
       version = "0.1";
       sha256 = "146b503614dca73dc2821790b1cbc56afdc3468205c752f29d074bf474491511";
       libraryHaskellDepends = [
         base comonad comonad-transformers containers contravariant
         transformers
       ];
       jailbreak = true;
       description = "Functor, Monad, MonadPlus, etc for free";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "forbidden-fruit" = callPackage
    ({ mkDerivation, base, control-monad-loop, hashable, hashtables
     , hspec, primitive, transformers, transformers-base, vector
     }:
     mkDerivation {
       pname = "forbidden-fruit";
       version = "0.1.0";
       sha256 = "ada14657c2281f4e34973ca909b808bd4c4aee76b1cb89bea4409a7fa950aa6b";
       libraryHaskellDepends = [
         base control-monad-loop hashable hashtables primitive transformers
         transformers-base vector
       ];
       testHaskellDepends = [
         base control-monad-loop hashable hashtables hspec primitive
         transformers vector
       ];
       jailbreak = true;
       homepage = "http://github.com/minpou/forbidden-fruit";
       description = "A library accelerates imperative style programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "force-layout_0_3_0_8" = callPackage
    ({ mkDerivation, base, containers, data-default-class, lens
     , vector-space, vector-space-points
     }:
     mkDerivation {
       pname = "force-layout";
       version = "0.3.0.8";
       sha256 = "af2be575190363b77ef35243afe2e70ef0500a1f14833116e874649268186801";
       libraryHaskellDepends = [
         base containers data-default-class lens vector-space
         vector-space-points
       ];
       jailbreak = true;
       description = "Simple force-directed layout";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "force-layout_0_3_0_9" = callPackage
    ({ mkDerivation, base, containers, data-default-class, lens
     , vector-space, vector-space-points
     }:
     mkDerivation {
       pname = "force-layout";
       version = "0.3.0.9";
       sha256 = "a52d12a82ab5912d7f0a3b9060690032b0fa83598a6d2281d237afcb69063681";
       libraryHaskellDepends = [
         base containers data-default-class lens vector-space
         vector-space-points
       ];
       jailbreak = true;
       description = "Simple force-directed layout";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "force-layout_0_3_0_10" = callPackage
    ({ mkDerivation, base, containers, data-default-class, lens
     , vector-space, vector-space-points
     }:
     mkDerivation {
       pname = "force-layout";
       version = "0.3.0.10";
       sha256 = "664ca3390d37aa9524ae365defc967b7aa47da69e36b9b8e9da16f07be0a7868";
       libraryHaskellDepends = [
         base containers data-default-class lens vector-space
         vector-space-points
       ];
       jailbreak = true;
       description = "Simple force-directed layout";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "force-layout_0_3_0_11" = callPackage
    ({ mkDerivation, base, containers, data-default-class, lens
     , vector-space, vector-space-points
     }:
     mkDerivation {
       pname = "force-layout";
       version = "0.3.0.11";
       sha256 = "1052dfe0c232cfb8b6dd75608e13f537dc7fbcceeb8269113b920cd7c1909205";
       libraryHaskellDepends = [
         base containers data-default-class lens vector-space
         vector-space-points
       ];
       jailbreak = true;
       description = "Simple force-directed layout";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "force-layout_0_4_0_2" = callPackage
    ({ mkDerivation, base, containers, data-default-class, lens, linear
     }:
     mkDerivation {
       pname = "force-layout";
       version = "0.4.0.2";
       sha256 = "0f7010fb55c2712d9f8a8044b7c5a530088969d98bd11d8b8ba5dc1f7164cc52";
       libraryHaskellDepends = [
         base containers data-default-class lens linear
       ];
       jailbreak = true;
       description = "Simple force-directed layout";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "force-layout" = callPackage
    ({ mkDerivation, base, containers, data-default-class, lens, linear
     }:
     mkDerivation {
       pname = "force-layout";
       version = "0.4.0.3";
       sha256 = "7268d9a57cad2e834e080b9fb02a9834481e62235a401bf39e60ba3da1c4e487";
       libraryHaskellDepends = [
         base containers data-default-class lens linear
       ];
       description = "Simple force-directed layout";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fordo" = callPackage
    ({ mkDerivation, base, process, transformers }:
     mkDerivation {
       pname = "fordo";
       version = "0.1";
       sha256 = "59e9a76e1ada36b31f55fca0c0d99ebaec2781e0eb56b7de881bd9615d2e906e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base process transformers ];
       description = "Run a command on files with magic substituion support (sequencing and regexp)";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "forecast-io" = callPackage
    ({ mkDerivation, aeson, base, text }:
     mkDerivation {
       pname = "forecast-io";
       version = "0.2.0.0";
       sha256 = "7ed54091d063fdf9ffca57c05a24769345b88a9e5bbb6c1f4037e01f70c69a9f";
       libraryHaskellDepends = [ aeson base text ];
       homepage = "https://github.com/stormont/forecast-io";
       description = "A Haskell library for working with forecast.io data.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "foreign-storable-asymmetric" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "foreign-storable-asymmetric";
       version = "0.0.1";
       sha256 = "b2ef068e1870698eece8bb813c2073cdaaabcd9693b0f44b9208dbf2cf0543de";
       libraryHaskellDepends = [ base ];
       description = "Types and instances for implementing a Storable with different peek and poke";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "foreign-store_0_1" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "foreign-store";
       version = "0.1";
       sha256 = "afd0ea51c6f8b012259411858c966d34dbcbd7c128b044313fc6843743d6f0dc";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/chrisdone/foreign-store";
       description = "Store a stable pointer in a foreign context to be retrieved later. Persists through GHCi reloads.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "foreign-store" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "foreign-store";
       version = "0.2";
       sha256 = "06718a214d068eaa494cc82376f23b2059a141b01048cd7efcf2176a6c3383dc";
       libraryHaskellDepends = [ base ];
       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;
     }) {};

  "foreign-var_0_0_0_1" = callPackage
    ({ mkDerivation, base, stm, transformers }:
     mkDerivation {
       pname = "foreign-var";
       version = "0.0.0.1";
       sha256 = "89448dfc938b082a6b14788da199f255b21b867c7e9e8de77fa4f7c5bf9e6467";
       revision = "1";
       editedCabalFile = "0c4981a93acc5fbe5295bb9dcfb0cba769f4a4b3d00d63eeece3aee8ffd9cfbb";
       libraryHaskellDepends = [ base stm transformers ];
       homepage = "http://github.com/ekmett/foreign-var/";
       description = "Encapsulating mutatable state in external libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "foreign-var" = callPackage
    ({ mkDerivation, base, stm, transformers }:
     mkDerivation {
       pname = "foreign-var";
       version = "0.1";
       sha256 = "4d62cebaa790cc5364fdb4c4c6834cebef0d5dc1101714c109415e9bf0afaee7";
       revision = "1";
       editedCabalFile = "f9c906434533279cfa8e2897c6eed6ed9c279f373efc5180bda76b704601fa1c";
       libraryHaskellDepends = [ base stm transformers ];
       homepage = "http://github.com/ekmett/foreign-var/";
       description = "Encapsulating mutatable state in external libraries";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "forger" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "forger";
       version = "0.0.0.0";
       sha256 = "3e1eb8d0c607f6f0d24700570a0908975bdb13d01df258b121df05ad9cd6d3af";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/sfischer13/haskell-forger";
       description = "Library for generating fake placeholder data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "forkable-monad" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "forkable-monad";
       version = "0.1.1";
       sha256 = "3084b8c019ca55774a20380023f81ca151bf0c2bffddc919a07321c74697ac5b";
       libraryHaskellDepends = [ base transformers ];
       jailbreak = true;
       homepage = "http://code.google.com/p/forkable-monad/";
       description = "An implementation of forkIO for monad stacks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "formal" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, containers
     , directory, file-embed, HTTP, indents, interpolatedstring-perl6
     , jmacro, MissingH, mtl, network, pandoc, parsec, process, text
     , transformers, urlencoded, wl-pprint-text
     }:
     mkDerivation {
       pname = "formal";
       version = "0.1.0";
       sha256 = "c520d4c55381a7c2015bb42069fe1b86d20957110841d3034be6d5c3932a0a7d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base bytestring containers directory file-embed HTTP
         indents interpolatedstring-perl6 jmacro MissingH mtl network pandoc
         parsec process text transformers urlencoded wl-pprint-text
       ];
       jailbreak = true;
       description = "A statically typed, functional programming language";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "format" = callPackage
    ({ mkDerivation, haskell2010, parsec, QuickCheck }:
     mkDerivation {
       pname = "format";
       version = "0.1.0.0";
       sha256 = "f0d6174b92f9394ca8a87435daa397d3cd5a5641d2d8d0a61c111617215869ef";
       libraryHaskellDepends = [ haskell2010 parsec ];
       testHaskellDepends = [ haskell2010 parsec QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/bytbox/hs-format";
       description = "Rendering from and scanning to format strings";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "format-status" = callPackage
    ({ mkDerivation, base, data-concurrent-queue, old-locale, stm, text
     , time
     }:
     mkDerivation {
       pname = "format-status";
       version = "0.2.0.0";
       sha256 = "58e8bd948b9961cfc749f99ce03cbd6a381dabac3610de584106b103c695d535";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base data-concurrent-queue old-locale stm text time
       ];
       jailbreak = true;
       description = "A utility for writing the date to dzen2";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "formattable" = callPackage
    ({ mkDerivation, base, bytestring, data-default-class
     , double-conversion, hspec, HUnit, lens, old-locale, QuickCheck
     , text, time
     }:
     mkDerivation {
       pname = "formattable";
       version = "0.1.1";
       sha256 = "a717a8ba375c2f098d814bba93941dce960904c3767eff8d11cf501a840c372f";
       libraryHaskellDepends = [
         base bytestring data-default-class old-locale text time
       ];
       testHaskellDepends = [
         base bytestring data-default-class double-conversion hspec HUnit
         lens old-locale QuickCheck text time
       ];
       jailbreak = true;
       homepage = "https://github.com/Soostone/formattable";
       description = "Business-quality formatting of numbers, dates, and other things";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "formatting_5_4" = callPackage
    ({ mkDerivation, base, old-locale, scientific, text, text-format
     , time
     }:
     mkDerivation {
       pname = "formatting";
       version = "5.4";
       sha256 = "69e6b683cf646fa4d0e676c3e577878198b51939b9d15b31bbd88a8cefa8ee04";
       revision = "1";
       editedCabalFile = "7c0fa4cf498c0a44892d9fc22309b516d78503ce074632cf439de8e336c3a087";
       libraryHaskellDepends = [
         base old-locale scientific text text-format time
       ];
       jailbreak = true;
       description = "Combinator-based type-safe formatting (like printf() or FORMAT)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "formatting_6_0_0" = callPackage
    ({ mkDerivation, base, old-locale, scientific, text, text-format
     , time
     }:
     mkDerivation {
       pname = "formatting";
       version = "6.0.0";
       sha256 = "ac4e3b420c205ea5667c2591955d059fcd7bb23b002afd5fe4de22e61e7cf107";
       revision = "1";
       editedCabalFile = "555c734c3d6962a300c710eb0ef3ed2e3ef9cdbda5263d47eaf80273019ca524";
       libraryHaskellDepends = [
         base old-locale scientific text text-format time
       ];
       jailbreak = true;
       description = "Combinator-based type-safe formatting (like printf() or FORMAT)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "formatting_6_2_0" = callPackage
    ({ mkDerivation, base, clock, old-locale, scientific, text
     , text-format, time
     }:
     mkDerivation {
       pname = "formatting";
       version = "6.2.0";
       sha256 = "bb6c5a156058b2fe7ee1c1c31d13bb05aecc9e759c22e21b96ca39d98418828f";
       revision = "1";
       editedCabalFile = "299d43483dfe38a5e95061fb943cb63fa252d7fd38212c42e9bb022f49407a89";
       libraryHaskellDepends = [
         base clock old-locale scientific text text-format time
       ];
       description = "Combinator-based type-safe formatting (like printf() or FORMAT)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "formatting" = callPackage
    ({ mkDerivation, base, clock, old-locale, scientific, text
     , text-format, time
     }:
     mkDerivation {
       pname = "formatting";
       version = "6.2.2";
       sha256 = "4fdcd7e30c48e67e64be04bbf4fc315996898aba9fcdb2491f4bcd3f3fba3412";
       libraryHaskellDepends = [
         base clock old-locale scientific text text-format time
       ];
       description = "Combinator-based type-safe formatting (like printf() or FORMAT)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "forml" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, cereal
     , containers, directory, file-embed, ghc-prim, GraphSCC, hslogger
     , HTTP, indents, interpolatedstring-perl6, jmacro, MissingH, mtl
     , network, pandoc, parsec, process, text, urlencoded, utf8-string
     , zlib
     }:
     mkDerivation {
       pname = "forml";
       version = "0.2";
       sha256 = "7bed2017895dceb0acd67e7290eea7ee79f92d06049df176b47f5503e0e00eaf";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base bytestring cereal containers directory
         file-embed ghc-prim GraphSCC hslogger HTTP indents
         interpolatedstring-perl6 jmacro MissingH mtl network pandoc parsec
         process text urlencoded utf8-string zlib
       ];
       jailbreak = true;
       homepage = "http://texodus.github.com/forml";
       description = "A statically typed, functional programming language";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "formlets" = callPackage
    ({ mkDerivation, applicative-extras, base, blaze-html, bytestring
     , haskell98, syb, transformers, xhtml
     }:
     mkDerivation {
       pname = "formlets";
       version = "0.8";
       sha256 = "8987fb8dd8adb29e7be13f6720b62d896b5de945e3dc97c7508cb39fe136a54b";
       libraryHaskellDepends = [
         applicative-extras base blaze-html bytestring haskell98 syb
         transformers xhtml
       ];
       jailbreak = true;
       homepage = "http://github.com/chriseidhof/formlets/tree/master";
       description = "Formlets implemented in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "formlets-hsp" = callPackage
    ({ mkDerivation, applicative-extras, base, formlets, haskell98, hsp
     , hsx, mtl, trhsx
     }:
     mkDerivation {
       pname = "formlets-hsp";
       version = "2.3.1";
       sha256 = "825f07e61a911e696e01b42eed3034837f26ab7aa3ebf3f56301ea997db6a0a6";
       libraryHaskellDepends = [
         applicative-extras base formlets haskell98 hsp hsx mtl
       ];
       libraryToolDepends = [ trhsx ];
       description = "HSP support for Formlets";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "formura" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, containers, either, lattices
     , lens, mmorph, mtl, parsers, QuickCheck, text, trifecta, vector
     }:
     mkDerivation {
       pname = "formura";
       version = "1.0";
       sha256 = "85f87237328c583f9178a37223def73ac394be919cbb91896c54340a69cadc8c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-wl-pprint base containers either lattices lens mmorph mtl
         parsers QuickCheck text trifecta vector
       ];
       executableHaskellDepends = [
         ansi-wl-pprint base containers lens text trifecta
       ];
       homepage = "http://nushio3.github.io";
       description = "Formura is a simple language to describe stencil computation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "forth-hll" = callPackage
    ({ mkDerivation, array-forth, base, free, mtl }:
     mkDerivation {
       pname = "forth-hll";
       version = "0.1.0.0";
       sha256 = "e385e0be9de25f5a37cf94408c38ebfd7e79f50c6fcd16214b89b26e3b8bacc2";
       libraryHaskellDepends = [ array-forth base free mtl ];
       jailbreak = true;
       description = "A simple eDSL for generating arrayForth code";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "foscam-directory" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath
     , foscam-filename, lens, pretty, QuickCheck, template-haskell
     , trifecta, utf8-string
     }:
     mkDerivation {
       pname = "foscam-directory";
       version = "0.0.7";
       sha256 = "ae30ec2b2a5f737436d4438ed1071a549a0d37bbf8871014aabe702046382312";
       libraryHaskellDepends = [
         base directory foscam-filename lens pretty trifecta utf8-string
       ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck template-haskell
       ];
       homepage = "https://github.com/tonymorris/foscam-directory";
       description = "Foscam File format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "foscam-filename" = callPackage
    ({ mkDerivation, base, bifunctors, digit, directory, doctest
     , filepath, lens, parsec, parsers, QuickCheck, semigroupoids
     , semigroups, template-haskell
     }:
     mkDerivation {
       pname = "foscam-filename";
       version = "0.0.4";
       sha256 = "6df1e49071483b6e0fcb3a3ab5d24f3c4b23b7e18d5a33cef001a00d677d8fd2";
       libraryHaskellDepends = [
         base bifunctors digit lens parsers semigroupoids semigroups
       ];
       testHaskellDepends = [
         base directory doctest filepath parsec QuickCheck template-haskell
       ];
       homepage = "https://github.com/tonymorris/foscam-filename";
       description = "Foscam File format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "foscam-sort" = callPackage
    ({ mkDerivation, base, digit, directory, doctest, filepath
     , foscam-directory, foscam-filename, lens, QuickCheck
     , template-haskell, unix
     }:
     mkDerivation {
       pname = "foscam-sort";
       version = "0.0.2";
       sha256 = "a1f76b3c3772098a7d843e955e84e4e6d41d23c197522eed23baa402de724145";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base digit directory filepath foscam-directory foscam-filename lens
         unix
       ];
       executableHaskellDepends = [
         base digit directory filepath foscam-directory foscam-filename lens
         unix
       ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck template-haskell
       ];
       homepage = "https://github.com/tonymorris/foscam-sort";
       description = "Foscam File format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fountain" = callPackage
    ({ mkDerivation, base, containers, random }:
     mkDerivation {
       pname = "fountain";
       version = "0.1";
       sha256 = "f7181514a2d4b98353e32a3c1793458d45e2d86c954e4a85b01c8ba7f2cebf57";
       libraryHaskellDepends = [ base containers random ];
       homepage = "http://tomahawkins.org";
       description = "A fountain codec";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fpco-api_1_2_0_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, bytestring, cereal, containers, data-default, deepseq
     , deepseq-generics, directory, failure, fay, filepath, ghc-prim
     , hashable, http-conduit, http-types, ini, lifted-async
     , lifted-base, monad-control, monad-extras, monad-logger, mtl
     , network, optparse-applicative, persistent, persistent-template
     , pretty-show, process, random, resourcet, safe, semigroups
     , shakespeare, shakespeare-i18n, stm, syb, template-haskell, text
     , time, transformers, transformers-base, unordered-containers
     , vector, yesod-core
     }:
     mkDerivation {
       pname = "fpco-api";
       version = "1.2.0.4";
       sha256 = "5b54187845a5ceb33041845c6770945dfc548d73f67e6007c4f2b00054b6dbc3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         cereal containers data-default deepseq deepseq-generics directory
         failure fay filepath ghc-prim hashable http-conduit http-types
         lifted-async lifted-base monad-control monad-extras monad-logger
         mtl network persistent persistent-template pretty-show random
         resourcet safe semigroups shakespeare shakespeare-i18n stm syb
         template-haskell text time transformers transformers-base
         unordered-containers vector yesod-core
       ];
       executableHaskellDepends = [
         aeson base bytestring data-default directory filepath ini network
         optparse-applicative process safe text unordered-containers
       ];
       homepage = "https://www.fpcomplete.com/page/api";
       description = "Simple interface to the FP Complete IDE API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fpco-api" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, bytestring, cereal, containers, data-default, deepseq
     , deepseq-generics, directory, failure, fay, filepath, ghc-prim
     , hashable, http-conduit, http-types, ini, lifted-async
     , lifted-base, monad-control, monad-extras, monad-logger, mtl
     , network, optparse-applicative, persistent, persistent-template
     , pretty-show, process, random, resourcet, safe, semigroups
     , shakespeare, shakespeare-i18n, stm, syb, template-haskell, text
     , time, transformers, transformers-base, unordered-containers
     , vector, yesod-core
     }:
     mkDerivation {
       pname = "fpco-api";
       version = "1.2.0.5";
       sha256 = "42c14a8d2cca593bca6befc33d5ee6888abb2361c2d0a9e3b6c4df1ab75100e5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         cereal containers data-default deepseq deepseq-generics directory
         failure fay filepath ghc-prim hashable http-conduit http-types
         lifted-async lifted-base monad-control monad-extras monad-logger
         mtl network persistent persistent-template pretty-show random
         resourcet safe semigroups shakespeare shakespeare-i18n stm syb
         template-haskell text time transformers transformers-base
         unordered-containers vector yesod-core
       ];
       executableHaskellDepends = [
         aeson base bytestring data-default directory filepath ini network
         optparse-applicative process safe text unordered-containers
       ];
       homepage = "https://www.fpcomplete.com/page/api";
       description = "Simple interface to the FP Complete IDE API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fpipe" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fpipe";
       version = "0.0.1";
       sha256 = "28f3eea9ee9c8bb47139296ce5dfb4f27b2c9aee522ab03ae205f2e47d0ad9ac";
       libraryHaskellDepends = [ base ];
       description = "F#-style composition and application";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fpnla" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fpnla";
       version = "0.1.1";
       sha256 = "64ef9ae47c812b94a693dabffc728abb480ab3b6c4f8814fa8d7eeb446741797";
       libraryHaskellDepends = [ base ];
       description = "A library for NLA operations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fpnla-examples" = callPackage
    ({ mkDerivation, accelerate, array, base, data-default, deepseq
     , fpnla, hmatrix, HUnit, linear-algebra-cblas, monad-par, parallel
     , QuickCheck, random, repa, tagged, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time, vector
     }:
     mkDerivation {
       pname = "fpnla-examples";
       version = "0.1.1";
       sha256 = "62dd137960e012f83450f67101b6f1d2a7ad7cfc814521bc5d19b327412e60dc";
       libraryHaskellDepends = [
         accelerate array base deepseq fpnla hmatrix linear-algebra-cblas
         monad-par parallel repa vector
       ];
       testHaskellDepends = [
         accelerate array base data-default deepseq fpnla hmatrix HUnit
         linear-algebra-cblas monad-par parallel QuickCheck random repa
         tagged test-framework test-framework-hunit
         test-framework-quickcheck2 time vector
       ];
       description = "Example implementations for FPNLA library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fptest" = callPackage
    ({ mkDerivation, base, doctest, Glob, hlint, HUnit, parsec
     , parsec3-numbers, process, QuickCheck, regex-compat
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "fptest";
       version = "0.2.1.0";
       sha256 = "70d855b3f61de5666cb070132e5d9d8248b4a5b3a5ceb349247b897930d27c3d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base HUnit parsec parsec3-numbers QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       testHaskellDepends = [
         base doctest Glob hlint HUnit parsec parsec3-numbers process
         QuickCheck regex-compat test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/jrp2014/fptest";
       description = "IEEE754r floating point conformance tests";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fquery" = callPackage
    ({ mkDerivation, base, directory, filepath, hashtables, parsec
     , process, regex-compat, unix
     }:
     mkDerivation {
       pname = "fquery";
       version = "0.2.2";
       sha256 = "5641c8748ff11e5ba37175eac76ee4b14739a3d4d4711ea5ce023bc8d8559cbe";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath hashtables parsec process regex-compat unix
       ];
       description = "Installed package query tool for Gentoo Linux";
       license = "unknown";
     }) {};

  "fractal" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fractal";
       version = "0.0.1";
       sha256 = "ba9d99f042e31646ab11d2f1be6a9221539331cd28842a0c1fba825849218547";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       description = "Draw Newton, Julia and Mandelbrot fractals";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fractals" = callPackage
    ({ mkDerivation, base, integer-gmp, QuickCheck }:
     mkDerivation {
       pname = "fractals";
       version = "0.1.0.0";
       sha256 = "3dbca177023352014cb5c61205a9a90a640a75a0557935126800e25f38f2424a";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base integer-gmp QuickCheck ];
       description = "A collection of useful fractal curve encoders";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fraction" = callPackage
    ({ mkDerivation, base, semigroups }:
     mkDerivation {
       pname = "fraction";
       version = "0.1.0.4";
       sha256 = "aeedbb9fa8520d8f17f68840336b895c81df16120dcefab82dc4ae1c98de9b2e";
       libraryHaskellDepends = [ base semigroups ];
       jailbreak = true;
       homepage = "http://darcs.wolfgang.jeltsch.info/haskell/fraction";
       description = "Fractions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "frag" = callPackage
    ({ mkDerivation, array, base, GLUT, OpenGL, random }:
     mkDerivation {
       pname = "frag";
       version = "1.1.2";
       sha256 = "20edd8b22badd08e12e17c4b0e15a3f29c989d1a8e4d423d0c26224d19b9f6f5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base GLUT OpenGL random ];
       homepage = "http://haskell.org/haskellwiki/Frag";
       description = "A 3-D First Person Shooter Game";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "frame" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory
     , ghc-binary, happstack-fastcgi, happstack-server, haskell98
     , haskelldb, haskelldb-hdbc, haskelldb-hdbc-odbc, HDBC, HDBC-odbc
     , HTTP, MissingH, mtl, old-time, pretty, utf8-string
     }:
     mkDerivation {
       pname = "frame";
       version = "0.1";
       sha256 = "4a36bdd3daa0c5af0e3a9898fc876096f8c6a030fced884169645ae62266b651";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers directory ghc-binary happstack-fastcgi
         happstack-server haskell98 haskelldb haskelldb-hdbc
         haskelldb-hdbc-odbc HDBC HDBC-odbc HTTP MissingH mtl old-time
         utf8-string
       ];
       executableHaskellDepends = [ pretty ];
       jailbreak = true;
       description = "A simple web framework";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {ghc-binary = null;};

  "frame-markdown" = callPackage
    ({ mkDerivation, base, frame, pandoc }:
     mkDerivation {
       pname = "frame-markdown";
       version = "0.1";
       sha256 = "ef149e015bd45d73ddf30ba17b82e7cdf18114d541bdc870f5d39bf67a62c173";
       libraryHaskellDepends = [ base frame pandoc ];
       jailbreak = true;
       description = "A markdown to Frame GUI writer for Pandoc";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "franchise" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "franchise";
       version = "0.0.6";
       sha256 = "7913c9681ed5c241b83c719d2ed5ed6fa59035ff9b6f6e402c3d32572ef78e90";
       libraryHaskellDepends = [ base ];
       description = "A package for configuring and building Haskell software";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "free_4_9" = callPackage
    ({ mkDerivation, base, bifunctors, comonad, distributive, mtl
     , prelude-extras, profunctors, semigroupoids, semigroups
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "free";
       version = "4.9";
       sha256 = "dd3292f587e96cf5337aa7d46ca685bbeba34b6f1632555482f39298ba4aea06";
       revision = "1";
       editedCabalFile = "0d84ce7df80001b5855a5362ddb4c22b035eebec587f74d030f33bc71ab4a29f";
       libraryHaskellDepends = [
         base bifunctors comonad distributive mtl prelude-extras profunctors
         semigroupoids semigroups template-haskell transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/free/";
       description = "Monads for free";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "free_4_10_0_1" = callPackage
    ({ mkDerivation, base, bifunctors, comonad, distributive, mtl
     , prelude-extras, profunctors, semigroupoids, semigroups
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "free";
       version = "4.10.0.1";
       sha256 = "78439fbd8b9508bc886d38763891a4b1de0942fb86827f1496cc2eb61640406f";
       libraryHaskellDepends = [
         base bifunctors comonad distributive mtl prelude-extras profunctors
         semigroupoids semigroups template-haskell transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/free/";
       description = "Monads for free";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "free_4_11" = callPackage
    ({ mkDerivation, base, bifunctors, comonad, distributive, mtl
     , prelude-extras, profunctors, semigroupoids, semigroups
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "free";
       version = "4.11";
       sha256 = "be40a10bdd58dd991c84126465d93dc6a75ceb12fb115ea9d02a78ee8d2dc44c";
       libraryHaskellDepends = [
         base bifunctors comonad distributive mtl prelude-extras profunctors
         semigroupoids semigroups template-haskell transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/free/";
       description = "Monads for free";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "free_4_12_1" = callPackage
    ({ mkDerivation, base, bifunctors, comonad, distributive
     , exceptions, mtl, prelude-extras, profunctors, semigroupoids
     , semigroups, template-haskell, transformers
     }:
     mkDerivation {
       pname = "free";
       version = "4.12.1";
       sha256 = "376559042204e56bcd1152f04bf01079118c6ccba5e0cf8344de929537bc286b";
       libraryHaskellDepends = [
         base bifunctors comonad distributive exceptions mtl prelude-extras
         profunctors semigroupoids semigroups template-haskell transformers
       ];
       homepage = "http://github.com/ekmett/free/";
       description = "Monads for free";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "free" = callPackage
    ({ mkDerivation, base, bifunctors, comonad, containers
     , distributive, exceptions, mtl, prelude-extras, profunctors
     , semigroupoids, semigroups, template-haskell, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "free";
       version = "4.12.4";
       sha256 = "c9fe45aae387855626ecb5a0fea6afdb207143cb00af3b1f715d1032d2d08784";
       libraryHaskellDepends = [
         base bifunctors comonad containers distributive exceptions mtl
         prelude-extras profunctors semigroupoids semigroups
         template-haskell transformers transformers-compat
       ];
       homepage = "http://github.com/ekmett/free/";
       description = "Monads for free";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "free-concurrent" = callPackage
    ({ mkDerivation, base, type-aligned }:
     mkDerivation {
       pname = "free-concurrent";
       version = "0.1.0.1";
       sha256 = "9ff2ee86c7a56f0c080e32394a82be129cb0b198fb9327b265a0735161e751b1";
       libraryHaskellDepends = [ base type-aligned ];
       homepage = "https://github.com/srijs/haskell-free-concurrent";
       description = "Free monads suitable for concurrent computation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "free-functors" = callPackage
    ({ mkDerivation, algebraic-classes, base, comonad, constraints
     , template-haskell, transformers, void
     }:
     mkDerivation {
       pname = "free-functors";
       version = "0.6.5";
       sha256 = "be107f1140b11d043e93682e1ab988a4aa7fd00cb460417daca97c90d61f7ddf";
       libraryHaskellDepends = [
         algebraic-classes base comonad constraints template-haskell
         transformers void
       ];
       jailbreak = true;
       homepage = "https://github.com/sjoerdvisscher/free-functors";
       description = "Free functors, adjoint to functors that forget class constraints";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "free-game" = callPackage
    ({ mkDerivation, array, base, boundingboxes, colors, containers
     , control-bool, directory, filepath, free, freetype2, GLFW-b
     , hashable, JuicyPixels, JuicyPixels-util, lens, linear, mtl
     , OpenGL, OpenGLRaw, random, reflection, template-haskell
     , transformers, vector, void
     }:
     mkDerivation {
       pname = "free-game";
       version = "1.1.81";
       sha256 = "d7ef4867a906db76e2342a2c27012d8d1b6f6d86fd409b974c8cad0cce4c14fd";
       libraryHaskellDepends = [
         array base boundingboxes colors containers control-bool directory
         filepath free freetype2 GLFW-b hashable JuicyPixels
         JuicyPixels-util lens linear mtl OpenGL OpenGLRaw random reflection
         template-haskell transformers vector void
       ];
       jailbreak = true;
       homepage = "https://github.com/fumieval/free-game";
       description = "Create games for free";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "free-http" = callPackage
    ({ mkDerivation, base, bytestring, free, http-client, http-types
     , mtl, QuickCheck, text, time, transformers
     }:
     mkDerivation {
       pname = "free-http";
       version = "0.2.0";
       sha256 = "d873e7dcef909cf6ec38e00273531c2831cc9a5ab4f2b73de8ec39441a6454b7";
       libraryHaskellDepends = [
         base bytestring free http-client http-types mtl QuickCheck text
         time transformers
       ];
       homepage = "https://github.com/aaronlevin/free-http";
       description = "An HTTP Client based on Free Monads";
       license = stdenv.lib.licenses.mit;
     }) {};

  "free-operational" = callPackage
    ({ mkDerivation, base, comonad-transformers, free, kan-extensions
     , mtl, transformers
     }:
     mkDerivation {
       pname = "free-operational";
       version = "0.5.0.0";
       sha256 = "ab36043228216c039a4132c6ed7fe39d5f890d7d612ba4cceb5d9b434125353e";
       libraryHaskellDepends = [
         base comonad-transformers free kan-extensions mtl transformers
       ];
       jailbreak = true;
       description = "Operational Applicative, Alternative, Monad and MonadPlus from free types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "free-theorems" = callPackage
    ({ mkDerivation, base, containers, haskell-src, haskell-src-exts
     , mtl, pretty, syb
     }:
     mkDerivation {
       pname = "free-theorems";
       version = "0.3.2.0";
       sha256 = "5cf44dc92a25b80bfa3146b650fc2c1ab40746be358e06e75469498720fa18e4";
       libraryHaskellDepends = [
         base containers haskell-src haskell-src-exts mtl pretty syb
       ];
       description = "Automatic generation of free theorems";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "free-theorems-counterexamples" = callPackage
    ({ mkDerivation, base, cgi, containers, free-theorems, haskell-src
     , haskell-src-exts, HUnit, mtl, pretty, syb, utf8-string, xhtml
     }:
     mkDerivation {
       pname = "free-theorems-counterexamples";
       version = "0.3.1.0";
       sha256 = "63adb51b031de074b8455c3dfe964652e011c98f74241cf6c72271eaeda605f3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers haskell-src haskell-src-exts HUnit mtl pretty syb
       ];
       executableHaskellDepends = [ cgi free-theorems utf8-string xhtml ];
       description = "Automatically Generating Counterexamples to Naive Free Theorems";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "free-theorems-seq" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, free-theorems
     , haskell-src, mtl, old-locale, old-time, parsec, pretty, syb
     , utf8-string, xhtml
     }:
     mkDerivation {
       pname = "free-theorems-seq";
       version = "1.0";
       sha256 = "cf6889cdd4ab3711aa6af9c9e22031dfb640335f6823977ae0c00b06cd9698e9";
       libraryHaskellDepends = [
         array base bytestring containers free-theorems haskell-src mtl
         old-locale old-time parsec pretty syb utf8-string xhtml
       ];
       jailbreak = true;
       description = "Taming Selective Strictness";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "free-theorems-seq-webui" = callPackage
    ({ mkDerivation, base, cgi, containers, free-theorems-seq, mtl
     , network, pretty, syb, utf8-string, xhtml
     }:
     mkDerivation {
       pname = "free-theorems-seq-webui";
       version = "1.0.0.2";
       sha256 = "c5c7119ff7bd248688a88b1afad2e9d899b58b8c58409adf4d94f9d6c273a7af";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cgi containers free-theorems-seq mtl network pretty syb
         utf8-string xhtml
       ];
       description = "Taming Selective Strictness";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "free-theorems-webui" = callPackage
    ({ mkDerivation, base, bytestring, cgi, csv, dataenc, directory
     , filepath, free-theorems, process, time, xhtml
     }:
     mkDerivation {
       pname = "free-theorems-webui";
       version = "0.2.1.1";
       sha256 = "6a1dfa751221bb795fcd4aee8f5db49ffafaee36880ec03906bc8992ff72ade3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cgi csv dataenc directory filepath free-theorems
         process time xhtml
       ];
       description = "CGI-based web interface for the free-theorems package";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "free-vl" = callPackage
    ({ mkDerivation, base, containers, mtl, tasty, tasty-hunit }:
     mkDerivation {
       pname = "free-vl";
       version = "0.1.4";
       sha256 = "57f63ed35b42fc54fefb3cc183d0655e0d6c4a28d5371dba00fc9c9d3fa602bf";
       revision = "1";
       editedCabalFile = "150ba489128fe05a830fe3aad3771e134222a9b7327dc43676ef70b3cc99219c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base containers mtl tasty tasty-hunit ];
       homepage = "http://github.com/aaronlevin/free-vl";
       description = "van Laarhoven encoded Free Monad with Extensible Effects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "freekick2" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, EdisonCore, filepath, FTGL, haskell98, mtl, OpenGL
     , pngload, random, SDL, template-haskell
     }:
     mkDerivation {
       pname = "freekick2";
       version = "0.1.2";
       sha256 = "728072d092ed14ec27144df8d488619824477eb6a8b1af03b2ffc102b47375f9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base binary bytestring containers directory EdisonCore
         filepath FTGL haskell98 mtl OpenGL pngload random SDL
         template-haskell
       ];
       homepage = "http://github.com/anttisalonen/freekick2";
       description = "A soccer game";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "freenect_1_2" = callPackage
    ({ mkDerivation, base, freenect, freenect_sync, vector }:
     mkDerivation {
       pname = "freenect";
       version = "1.2";
       sha256 = "afd0a04d4cea2740007bf04768a2a54002fa052153c28f5c6dceb76b41baef85";
       configureFlags = [
         "--extra-include-dirs=${pkgs.freenect}/include/libfreenect"
         "--extra-lib-dirs=${pkgs.freenect}/lib"
       ];
       libraryHaskellDepends = [ base vector ];
       librarySystemDepends = [ freenect freenect_sync ];
       homepage = "https://github.com/chrisdone/freenect";
       description = "Interface to the Kinect device";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) freenect; freenect_sync = null;};

  "freenect" = callPackage
    ({ mkDerivation, base, freenect, freenect_sync, libfreenect, vector
     }:
     mkDerivation {
       pname = "freenect";
       version = "1.2.1";
       sha256 = "fca7aa958ec04396334b101679f8603850d7c6629770d5206d774e115cd70759";
       libraryHaskellDepends = [ base vector ];
       librarySystemDepends = [ freenect freenect_sync ];
       libraryPkgconfigDepends = [ libfreenect ];
       homepage = "https://github.com/chrisdone/freenect";
       description = "Interface to the Kinect device";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) freenect; freenect_sync = null; 
         libfreenect = null;};

  "freer" = callPackage
    ({ mkDerivation, base, QuickCheck, tasty, tasty-hunit
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "freer";
       version = "0.2.2.2";
       sha256 = "3b5e9bdaeedd66f2a3c8b8128fc01b4e0939d95c3a185c256cc1b3b2729c63f3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       homepage = "https://gitlab.com/cpp.cabrera/freer";
       description = "Implementation of the Freer Monad";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "freesect" = callPackage
    ({ mkDerivation, array, base, cpphs, directory, mtl, parallel
     , pretty, random, syb
     }:
     mkDerivation {
       pname = "freesect";
       version = "0.8";
       sha256 = "08359ee19d661ae9c00056fe4067623a439ca5469f9c050fae548f5e7b800c94";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base cpphs directory mtl parallel pretty random syb
       ];
       jailbreak = true;
       homepage = "http://fremissant.net/freesect";
       description = "A Haskell syntax extension for generalised sections";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "freesound" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, containers
     , data-default, filepath, hspec, hspec-core, http-types, lens, mtl
     , network, network-uri, old-locale, text, time, transformers, wreq
     }:
     mkDerivation {
       pname = "freesound";
       version = "0.3.0";
       sha256 = "be22e47c2e0ff3d72b243003ad21b1817d24e310ea8cdd94818ed5763db43e0f";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring data-default filepath
         http-types lens mtl network network-uri old-locale text time
         transformers wreq
       ];
       testHaskellDepends = [
         aeson base bytestring containers data-default hspec hspec-core
       ];
       homepage = "https://github.com/kaoskorobase/freesound";
       description = "Access the Freesound Project database";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "freetype-simple" = callPackage
    ({ mkDerivation, base, boundingboxes, bytestring, freetype2, linear
     }:
     mkDerivation {
       pname = "freetype-simple";
       version = "0.1.0.1";
       sha256 = "5adbe5ddde58d84bce1c3953c6963334b1a032f0e4b26f5d720a046512f211e2";
       libraryHaskellDepends = [
         base boundingboxes bytestring freetype2 linear
       ];
       jailbreak = true;
       homepage = "https://github.com/capsjac/freetype-simple";
       description = "Single line text rendering for OpenGL ES";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "freetype2" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "freetype2";
       version = "0.1.1";
       sha256 = "da18f9d3047277ba47e162dafa0b2a4777bfb6157b39ad91f9e808ba36f65e99";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       description = "Haskell binding for FreeType 2 library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fresh" = callPackage
    ({ mkDerivation, base, containers, haskell-src-exts, syb }:
     mkDerivation {
       pname = "fresh";
       version = "0.1.1";
       sha256 = "7c3ec0bf64298a386c8e404da204831b61ab42c28c6969b2e5b1f255caf68190";
       libraryHaskellDepends = [ base containers haskell-src-exts syb ];
       homepage = "https://github.com/davidlazar/fresh";
       description = "Introduce fresh variables into Haskell source code";
       license = stdenv.lib.licenses.mit;
     }) {};

  "friday" = callPackage
    ({ mkDerivation, base, convertible, deepseq, primitive, QuickCheck
     , ratio-int, test-framework, test-framework-quickcheck2
     , transformers, vector
     }:
     mkDerivation {
       pname = "friday";
       version = "0.2.2.0";
       sha256 = "d9a59b716eec813d6108d535b2a180d51f152cb04103670535a7ade7e1ab8833";
       libraryHaskellDepends = [
         base convertible deepseq primitive ratio-int transformers vector
       ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2 vector
       ];
       homepage = "https://github.com/RaphaelJ/friday";
       description = "A functional image processing library for Haskell";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "friday-devil" = callPackage
    ({ mkDerivation, base, bytestring, convertible, deepseq, friday
     , libdevil, transformers, vector
     }:
     mkDerivation {
       pname = "friday-devil";
       version = "0.1.1.1";
       sha256 = "522563c7e1ff4dd85f34ad5f85ddb14da693f0fa494f17d0665e69aaee81e1a5";
       libraryHaskellDepends = [
         base bytestring convertible deepseq friday transformers vector
       ];
       librarySystemDepends = [ libdevil ];
       homepage = "https://github.com/RaphaelJ/friday-devil";
       description = "Uses the DevIL C library to read and write images from and to files and memory buffers";
       license = stdenv.lib.licenses.gpl3;
     }) {inherit (pkgs) libdevil;};

  "friday-juicypixels" = callPackage
    ({ mkDerivation, base, bytestring, file-embed, friday, hspec
     , JuicyPixels, vector
     }:
     mkDerivation {
       pname = "friday-juicypixels";
       version = "0.1.1";
       sha256 = "f3a96bab73ddb6a26fd3ac705b7dc21e41b55a3027f4727f1e7307262a89207e";
       libraryHaskellDepends = [ base friday JuicyPixels vector ];
       testHaskellDepends = [
         base bytestring file-embed friday hspec JuicyPixels
       ];
       homepage = "https://github.com/TomMD/friday-juicypixels";
       description = "Converts between the Friday and JuicyPixels image types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "friday-scale-dct" = callPackage
    ({ mkDerivation, base, base-compat, carray, fft, friday, vector }:
     mkDerivation {
       pname = "friday-scale-dct";
       version = "1.0.0.1";
       sha256 = "0a40db255149c553169d8c2cc8f7ae11b511061b45a3e5c810f9be3390951b48";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-compat carray fft friday vector
       ];
       jailbreak = true;
       homepage = "https://github.com/axman6/friday-scale-dct#readme";
       description = "Scale Friday images with DCT";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "friendly-time" = callPackage
    ({ mkDerivation, base, hspec, old-locale, time }:
     mkDerivation {
       pname = "friendly-time";
       version = "0.4";
       sha256 = "05da52b12137473d643798e4f651f7939cef8d3c4775efac0849bdaad394e3f4";
       libraryHaskellDepends = [ base old-locale time ];
       testHaskellDepends = [ base hspec old-locale time ];
       description = "Print time information in friendly ways";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "frisby" = callPackage
    ({ mkDerivation, array, base, containers, mtl }:
     mkDerivation {
       pname = "frisby";
       version = "0.2";
       sha256 = "a3389559849cfc3284923d9b543897abc924c5c076a383890a6a8f21cf4d5247";
       libraryHaskellDepends = [ array base containers mtl ];
       homepage = "http://repetae.net/computer/frisby/";
       description = "Linear time composable parser for PEG grammars";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "frontmatter" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, hspec, QuickCheck
     , text, yaml
     }:
     mkDerivation {
       pname = "frontmatter";
       version = "0.1.0.2";
       sha256 = "66eb97b0d5097397f0238b9af764a8c6ea2bb9a4a16cd1214051719fc313b99d";
       libraryHaskellDepends = [ attoparsec base bytestring yaml ];
       testHaskellDepends = [
         attoparsec base bytestring hspec QuickCheck text yaml
       ];
       homepage = "https://github.com/yamadapc/haskell-frontmatter";
       description = "Parses frontmatter as used in Jekyll markdown files";
       license = stdenv.lib.licenses.mit;
     }) {};

  "frown" = callPackage
    ({ mkDerivation, base, directory }:
     mkDerivation {
       pname = "frown";
       version = "0.6.2.2";
       sha256 = "d061880b6b3fca4f2a5c054f5669d9c0747139386c47ccf57db4d5521c02c447";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory ];
       description = "LALR(k) parser generator";
       license = "GPL";
     }) {};

  "frp-arduino" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "frp-arduino";
       version = "0.1.0.3";
       sha256 = "a5479d681b7886f937266046cc4f1c86e1f7300308695dc4a204b7e24a4fc500";
       libraryHaskellDepends = [ base containers mtl ];
       homepage = "http://github.com/frp-arduino/frp-arduino";
       description = "Arduino programming without the hassle of C";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "frpnow" = callPackage
    ({ mkDerivation, base, containers, mtl, transformers }:
     mkDerivation {
       pname = "frpnow";
       version = "0.18";
       sha256 = "1fafa04d5ec57b49380ad23675075acf03ba63bcf92d52d1341bad265c64b0c7";
       libraryHaskellDepends = [ base containers mtl transformers ];
       homepage = "https://github.com/atzeus/FRPNow";
       description = "Principled practical FRP";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "frpnow-gloss" = callPackage
    ({ mkDerivation, base, containers, frpnow, gloss, mtl, transformers
     }:
     mkDerivation {
       pname = "frpnow-gloss";
       version = "0.12";
       sha256 = "31a508edd53ab44c60960096213751fe8a5bcb3476fcc930e9239be022c3dcf7";
       libraryHaskellDepends = [
         base containers frpnow gloss mtl transformers
       ];
       homepage = "https://github.com/atzeus/FRPNow";
       description = "Program awesome stuff with Gloss and frpnow!";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "frpnow-gtk" = callPackage
    ({ mkDerivation, base, containers, frpnow, glib, gtk, mtl
     , transformers
     }:
     mkDerivation {
       pname = "frpnow-gtk";
       version = "0.11";
       sha256 = "0ca00921ccad223ea0c94cc95b6e13a90ba4a7b0e71f3fd9bfe5fd4ae5bb097b";
       libraryHaskellDepends = [
         base containers frpnow glib gtk mtl transformers
       ];
       homepage = "https://github.com/atzeus/FRPNow";
       description = "Program GUIs with GTK and frpnow!";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "frquotes" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "frquotes";
       version = "0.2.1";
       sha256 = "ccf01fffd0dee0a9662f63b6c22ca1f06d8a569adf960399fbc9bd6e2a58ac68";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       description = "Lexical extension for Quasi-Quotations using French-Quotes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fs-events" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fs-events";
       version = "0.1";
       sha256 = "845fc3e10a326ac14e6213acf0b6e59143f911b6084ba680c848ffef5267864b";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/nkpart/fs-events";
       description = "A haskell binding to the FSEvents API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fsharp" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fsharp";
       version = "0.0.4";
       sha256 = "a382429a5cc2ec186cb206d84f91ebb9a9c3c25b912445a4e90825ab17dc95e9";
       libraryHaskellDepends = [ base ];
       description = "some F# operators, high priority pipes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fsmActions" = callPackage
    ({ mkDerivation, base, containers, fgl, filepath, graphviz
     , MissingH, mtl, parsec, pretty
     }:
     mkDerivation {
       pname = "fsmActions";
       version = "0.4.4";
       sha256 = "4c3748cd7537476ffab0683dc966296a374122becaae89f33a60041d241fe114";
       libraryHaskellDepends = [
         base containers fgl filepath graphviz MissingH mtl parsec pretty
       ];
       homepage = "http://projects.haskell.org/fsmActions/";
       description = "Finite state machines and FSM actions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fsnotify_0_1_0_3" = callPackage
    ({ mkDerivation, async, base, containers, directory, hinotify
     , system-fileio, system-filepath, tasty, tasty-hunit, temporary-rc
     , text, time
     }:
     mkDerivation {
       pname = "fsnotify";
       version = "0.1.0.3";
       sha256 = "1f15cc1380d3feaf12f4d7fed23a2327e0927ac69e3f3ae539637e55c8f3d254";
       libraryHaskellDepends = [
         async base containers hinotify system-fileio system-filepath text
         time
       ];
       testHaskellDepends = [
         async base directory system-fileio system-filepath tasty
         tasty-hunit temporary-rc
       ];
       doHaddock = false;
       doCheck = false;
       description = "Cross platform library for file change notification";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fsnotify" = callPackage
    ({ mkDerivation, async, base, containers, directory, filepath
     , hinotify, tasty, tasty-hunit, temporary-rc, text, time
     , unix-compat
     }:
     mkDerivation {
       pname = "fsnotify";
       version = "0.2.1";
       sha256 = "ebcf1b7bd825f269510850f20508a2ba0f640a41af08de0c171d8ba24618542b";
       libraryHaskellDepends = [
         async base containers directory filepath hinotify text time
         unix-compat
       ];
       testHaskellDepends = [
         async base directory filepath tasty tasty-hunit temporary-rc
         unix-compat
       ];
       doCheck = false;
       homepage = "https://github.com/haskell-fswatch/hfsnotify";
       description = "Cross platform library for file change notification";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fst" = callPackage
    ({ mkDerivation, array, base, haskeline, mtl, QuickCheck
     , transformers
     }:
     mkDerivation {
       pname = "fst";
       version = "0.10.0.1";
       sha256 = "fefef76c1d64c6518d6fb8298974e2372753202a0f6d5baa0160bb4248420aa4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base mtl ];
       executableHaskellDepends = [
         array base haskeline mtl transformers
       ];
       testHaskellDepends = [ base QuickCheck ];
       homepage = "http://www.cse.chalmers.se/alumni/markus/fstStudio/";
       description = "Finite state transducers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fsutils" = callPackage
    ({ mkDerivation, base, directory, filepath }:
     mkDerivation {
       pname = "fsutils";
       version = "0.1.2";
       sha256 = "e8665aace36bdc631cd9abed10164a12eb332194c4cfeaee92d6858644229d1e";
       libraryHaskellDepends = [ base directory filepath ];
       jailbreak = true;
       homepage = "https://github.com/Raynes/fsutils";
       description = "File system utilities for Haskell that are missing from built in libraries";
       license = stdenv.lib.licenses.mit;
     }) {};

  "fswatcher" = callPackage
    ({ mkDerivation, base, directory, fsnotify, optparse-applicative
     , process, regex-pcre-builtin, system-filepath, unix
     }:
     mkDerivation {
       pname = "fswatcher";
       version = "0.2.0";
       sha256 = "dcaa449b48c5c767adeb5bce6fd250982dcc65049dfca9dc79bfc059b14d73bc";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory fsnotify optparse-applicative process
         regex-pcre-builtin system-filepath unix
       ];
       homepage = "http://www.github.com/ehamberg/fswatcher/";
       description = "Watch a file/directory and run a command when it's modified";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ftdi" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, bytestring, safe
     , transformers, usb
     }:
     mkDerivation {
       pname = "ftdi";
       version = "0.2.0.1";
       sha256 = "a892fae6e1c12c3fc1db3f10e84b99c46f6145ac3fb3bcad519bcb619f5dcebe";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-unicode-symbols bytestring safe transformers usb
       ];
       jailbreak = true;
       description = "A thin layer over USB to communicate with FTDI chips";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ftp-conduit" = callPackage
    ({ mkDerivation, base, byteorder, bytestring, conduit, MissingH
     , network, transformers, utf8-string
     }:
     mkDerivation {
       pname = "ftp-conduit";
       version = "0.0.5";
       sha256 = "af99d3cea5dcb06723e7511deb03fada21a026f579b5e1b55730656bc82b663d";
       libraryHaskellDepends = [
         base byteorder bytestring conduit MissingH network transformers
         utf8-string
       ];
       jailbreak = true;
       homepage = "https://github.com/litherum/ftp-conduit";
       description = "FTP client package with conduit interface based off http-conduit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ftphs" = callPackage
    ({ mkDerivation, base, hslogger, MissingH, mtl, network, parsec
     , regex-compat
     }:
     mkDerivation {
       pname = "ftphs";
       version = "1.0.9.1";
       sha256 = "ce0b05b2fc7f93a6195184ed1a8edee69a7a9cf4aa3d15ebeb25421715571bf2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base hslogger MissingH mtl network parsec regex-compat
       ];
       homepage = "http://software.complete.org/ftphs";
       description = "FTP Client and Server Library";
       license = "LGPL";
     }) {};

  "ftree" = callPackage
    ({ mkDerivation, base, ShowF, type-unary }:
     mkDerivation {
       pname = "ftree";
       version = "0.1.3";
       sha256 = "75bc8b829bcb3e9cb6fc623db9b9a722268f411c603065fec9f43fcdad3c48d5";
       libraryHaskellDepends = [ base ShowF type-unary ];
       homepage = "https://github.com/conal/ftree/";
       description = "Depth-typed functor-based trees, both top-down and bottom-up";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ftshell" = callPackage
    ({ mkDerivation, base, containers, free-theorems, mtl, pretty
     , Shellac, Shellac-readline
     }:
     mkDerivation {
       pname = "ftshell";
       version = "0.3.0.1";
       sha256 = "195d3f7ad6ed76a6757246204af449ac8de2c33b4c47bdbbf1fd10fc9b5937cb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers free-theorems mtl pretty Shellac Shellac-readline
       ];
       jailbreak = true;
       description = "Shell interface to the FreeTheorems library";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fugue" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "fugue";
       version = "0.1";
       sha256 = "b98834285984356daf9db715cd30ff095412996d81ba9a75a972f5c828f0183c";
       libraryHaskellDepends = [ base ];
       description = "A recapitulated prelude with minimal dependencies and profligate exports";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "full-sessions" = callPackage
    ({ mkDerivation, base, ghc, network }:
     mkDerivation {
       pname = "full-sessions";
       version = "0.6.2.1";
       sha256 = "20d55ecc9355e5e4d6c87559c4c098013531e41cd4f57f55fe89caf7f20f3547";
       libraryHaskellDepends = [ base ghc network ];
       homepage = "http://www.agusa.i.is.nagoya-u.ac.jp/person/sydney/full-sessions.html";
       description = "a monad for protocol-typed network programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "full-text-search" = callPackage
    ({ mkDerivation, alex, array, base, containers, happy, QuickCheck
     , tasty, tasty-quickcheck, text, vector
     }:
     mkDerivation {
       pname = "full-text-search";
       version = "0.2.1.3";
       sha256 = "f3de82428b67819c1284f18192922e20cda5cb3cdb447297018507b13e3ca368";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base containers text vector ];
       executableToolDepends = [ alex happy ];
       testHaskellDepends = [
         array base containers QuickCheck tasty tasty-quickcheck text vector
       ];
       jailbreak = true;
       description = "In-memory full text search engine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fullstop" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, split, tasty, tasty-hunit
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "fullstop";
       version = "0.1.4";
       sha256 = "6caa4776774bdeed62d41638cde47d675a245fa4622d44bc982fa244db148580";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base split ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/kowey/fullstop";
       description = "Simple sentence segmenter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "funbot" = callPackage
    ({ mkDerivation, aeson, auto-update, base, bytestring
     , case-insensitive, clock, containers, data-default-class, feed
     , feed-collect, formatting, funbot-ext-events, hashable, HTTP
     , http-client, http-client-tls, http-listen, irc-fun-bot
     , irc-fun-client, irc-fun-color, irc-fun-types, json-state
     , network-uri, settings, tagsoup, text, time, time-interval
     , time-units, transformers, unordered-containers, utf8-string
     , vcs-web-hook-parse
     }:
     mkDerivation {
       pname = "funbot";
       version = "0.5";
       sha256 = "7efaf158080ee56dec38b141a7856e872eb58703c2f5d5fa501804bdabb053aa";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson auto-update base bytestring case-insensitive clock containers
         data-default-class feed feed-collect formatting funbot-ext-events
         hashable HTTP http-client http-client-tls http-listen irc-fun-bot
         irc-fun-client irc-fun-color irc-fun-types json-state network-uri
         settings tagsoup text time time-interval time-units transformers
         unordered-containers utf8-string vcs-web-hook-parse
       ];
       homepage = "https://notabug.org/fr33domlover/funbot";
       description = "IRC bot for fun, learning, creativity and collaboration";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "funbot-client" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring
     , funbot-ext-events, HTTP, network-uri
     }:
     mkDerivation {
       pname = "funbot-client";
       version = "0.1.0.1";
       sha256 = "22072804b49929a100e92a067c7e79f6d30b506cbb3f3bb487db02501b33afba";
       revision = "1";
       editedCabalFile = "449437e7cb240595b590cc3d34b0f08471870961bbf9faf9b4344646223c402b";
       libraryHaskellDepends = [
         aeson aeson-pretty base bytestring funbot-ext-events HTTP
         network-uri
       ];
       homepage = "https://notabug.org/fr33domlover/funbot-client/";
       description = "Report events to FunBot over a JSON/HTTP API";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "funbot-ext-events" = callPackage
    ({ mkDerivation, aeson, base, text }:
     mkDerivation {
       pname = "funbot-ext-events";
       version = "0.3.0.0";
       sha256 = "088850454d4b5e0cedd7dd80aab4d5dbfda08b251b9f3d99a0506ea27814b01c";
       libraryHaskellDepends = [ aeson base text ];
       homepage = "https://notabug.org/fr33domlover/funbot-ext-events";
       description = "Interact with FunBot's external events";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "funbot-git-hook" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath
     , funbot-client, funbot-ext-events, hit, network-uri, template
     , text, utf8-string
     }:
     mkDerivation {
       pname = "funbot-git-hook";
       version = "0.1";
       sha256 = "7154955621144511ca6c68a2f56c6cf67f800c1269a4e82b687e6a6473ffa8dd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory filepath funbot-client funbot-ext-events
         hit network-uri template text utf8-string
       ];
       homepage = "https://notabug.org/fr33domlover/funbot-git-hook/";
       description = "Git hook which sends events to FunBot";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "funcmp" = callPackage
    ({ mkDerivation, base, filepath, process }:
     mkDerivation {
       pname = "funcmp";
       version = "1.8";
       sha256 = "33fc37e8c05d665bc6a7a5b4406e433e19fe2c58421a034b76e1b412e8737526";
       libraryHaskellDepends = [ base filepath process ];
       homepage = "http://savannah.nongnu.org/projects/funcmp/";
       description = "Functional MetaPost";
       license = stdenv.lib.licenses.gpl3;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "funcons-tools" = callPackage
    ({ mkDerivation, base, bv, containers, directory, mtl, multiset
     , parsec, split, text, vector
     }:
     mkDerivation {
       pname = "funcons-tools";
       version = "0.1.0.0";
       sha256 = "99f2652af578a482d6f9253f9fffa057ab8fcb4272d32e6a78a23291a4fd96ef";
       revision = "2";
       editedCabalFile = "fee9ad9bc35f0d9b37f5a219ca853dd55ff6baaa761e587b27ab4e6f00716014";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bv containers directory mtl multiset parsec split text vector
       ];
       executableHaskellDepends = [
         base bv containers directory mtl multiset parsec split text vector
       ];
       homepage = "http://plancomps.org";
       description = "A modular interpreter for executing funcons";
       license = stdenv.lib.licenses.mit;
     }) {};

  "function-combine" = callPackage
    ({ mkDerivation, base, data-type }:
     mkDerivation {
       pname = "function-combine";
       version = "0.1.0";
       sha256 = "29a64d9f05fa5ee3091639445aaa19a6fd6994d05888fd911f59cdb43aae0bd5";
       libraryHaskellDepends = [ base data-type ];
       description = "Combining functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "function-instances-algebra" = callPackage
    ({ mkDerivation, base, numeric-prelude }:
     mkDerivation {
       pname = "function-instances-algebra";
       version = "0.1";
       sha256 = "fcf9b3a1c69f80ccaa8ed89cd37bdfdba158ad21225e5d32e2cf529fbba9be37";
       libraryHaskellDepends = [ base numeric-prelude ];
       jailbreak = true;
       homepage = "github.com/kreuzschlitzschraubenzieher/function-instances-algebra";
       description = "Instances of the Algebra.* classes for functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "functional-arrow" = callPackage
    ({ mkDerivation, base, HList }:
     mkDerivation {
       pname = "functional-arrow";
       version = "0.0";
       sha256 = "ba64e0b2ccddd40f9a386b7f067d2ed7740b324fdd73141633cae8572aee49d1";
       libraryHaskellDepends = [ base HList ];
       jailbreak = true;
       description = "Combinators that allow for a more functional/monadic style of Arrow programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "functional-kmp" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "functional-kmp";
       version = "0.1.0.0";
       sha256 = "29de062f7d0d3fec1f6c15143037032bf27a30c313c4aa9befd041f13f70e2d0";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/mniip/functional-kmp";
       description = "KMP implemented on haskell's built-in cons-cell-based lists";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "functor-apply" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "functor-apply";
       version = "0.11";
       sha256 = "793a6a40d6dd10031e164514752f45ce8d4b641fe87f23f00317a066d571504b";
       doHaddock = false;
       homepage = "http://comonad.com/reader/";
       description = "This package has been subsumed by semigroupoids";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "functor-combo" = callPackage
    ({ mkDerivation, base, base-orphans, containers, data-inttrie, lub
     , type-unary, TypeCompose
     }:
     mkDerivation {
       pname = "functor-combo";
       version = "0.3.6";
       sha256 = "6152f1f5302b63fdc1c0de146278945f6f6038bdb1b7c3794cf24a59a3519bca";
       libraryHaskellDepends = [
         base base-orphans containers data-inttrie lub type-unary
         TypeCompose
       ];
       description = "Functor combinators with tries & zippers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "functor-infix" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "functor-infix";
       version = "0.0.3";
       sha256 = "fe01131dcef76a6a1e66424f12757e66724f24bed4c353d4beadf3890a0ef3c2";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "https://github.com/fmap/functor-infix";
       description = "Infix operators for mapping over compositions of functors. Lots of them.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "functor-monadic" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "functor-monadic";
       version = "0.1.0.3";
       sha256 = "8fe599835be9400e8ff70bfb65d3a734c1971afa051c4c8425c96a4cbcb5d9e1";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/ombocomp/FunctorMonadic/";
       description = "Monad-style combinators for functors";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "functor-utils" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "functor-utils";
       version = "1.1";
       sha256 = "a054cbd84686777774b9e2c36c1b5ceaf8ca415a9755e922ff52137eb9ac36ba";
       libraryHaskellDepends = [ base ghc-prim ];
       homepage = "https://github.com/wdanilo/functor-utils";
       description = "Collection of functor utilities, providing handy operators, like generalization of (.).";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "functorm" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "functorm";
       version = "1.0.1";
       sha256 = "3a77ff551fa07141f69b2909e791e575c8f804ef12729d87ce396f72bd7144a9";
       libraryHaskellDepends = [ base ];
       description = "Data.FunctorM (compatibility package)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "functors" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "functors";
       version = "0.1";
       sha256 = "e6b96554d59b924f9960677137f2d4bc2417bac29b87083390d0020b6397d659";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/aristidb/functors";
       description = "(.:) and friends, syntax for Functor and Applicative.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "funion" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, haskell98
     , HFuse, unix
     }:
     mkDerivation {
       pname = "funion";
       version = "0.0.2";
       sha256 = "bbf330e07787adef884fcd3cfe5e119afd4bf189154bdfae78e7f5249e23f45d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory filepath haskell98 HFuse unix
       ];
       jailbreak = true;
       homepage = "http://github.com/nathanwiegand/funion";
       description = "A unioning file-system using HFuse";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "funpat" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "funpat";
       version = "0.1";
       sha256 = "dc2b226bbb72a65a5281e86d766b3f26b0b1a898d08cd53f0c6cb98a9ecb747d";
       libraryHaskellDepends = [ base mtl ];
       jailbreak = true;
       description = "A generalization of pattern matching";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "funsat" = callPackage
    ({ mkDerivation, array, base, bimap, bitset, containers, fgl, mtl
     , parse-dimacs, pretty, QuickCheck, random, time
     }:
     mkDerivation {
       pname = "funsat";
       version = "0.6.2";
       sha256 = "c316ddc611a3504d05b1db7e7412e99c83c6d6c766504fe7d685c3bce3e8dec3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bimap bitset containers fgl mtl parse-dimacs pretty
       ];
       executableHaskellDepends = [
         array base bimap bitset containers fgl mtl parse-dimacs pretty
         QuickCheck random time
       ];
       jailbreak = true;
       homepage = "http://github.com/dbueno/funsat";
       description = "A modern DPLL-style SAT solver";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fusion" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, pipes-safe
     , transformers, void
     }:
     mkDerivation {
       pname = "fusion";
       version = "0.2.0";
       sha256 = "95a8c2a5ee98fa16a548ec55a42c5a7dde2fce688df74cf884a777db654a486f";
       libraryHaskellDepends = [ base pipes-safe transformers void ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "https://github.com/jwiegley/fusion";
       description = "Effectful streaming library based on shortcut fusion techniques";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "futun" = callPackage
    ({ mkDerivation, base, bytestring, network, unix }:
     mkDerivation {
       pname = "futun";
       version = "0.1.0.2";
       sha256 = "6122312b750522313956ddd44d8de70d87ad4f0a033f5e4ed28d824c2b18d1ed";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bytestring network unix ];
       jailbreak = true;
       description = "Simple IP-over-UDP tunnel using TUNTAP";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "future" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "future";
       version = "2.0.0";
       sha256 = "318f8acee3681b60440a1ada300074d6fc0c0d6ce5fe4c2012ac75a74d0d7bbf";
       libraryHaskellDepends = [ base ];
       homepage = "http://hackage.haskell.org/cgi-bin/hackage-scripts/package/future";
       description = "Supposed to mimics and enhance proposed C++ \"future\" features";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "future-resource" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "future-resource";
       version = "0.4.0.0";
       sha256 = "7bb20c997e7d486ef201d67da1116007fe841e63ac3b212b8d2b6413a59e9083";
       libraryHaskellDepends = [ base transformers ];
       description = "realtime resource handling with manual concurrency";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "fuzzcheck" = callPackage
    ({ mkDerivation, base, hspec, hspec-expectations, HUnit
     , lifted-base, monad-control, QuickCheck, random, transformers
     }:
     mkDerivation {
       pname = "fuzzcheck";
       version = "0.1.1";
       sha256 = "ecd664796e9cf5c608ca904897dd9ec18b471a86fcfb4216328382b28023d961";
       libraryHaskellDepends = [
         base lifted-base monad-control QuickCheck random transformers
       ];
       testHaskellDepends = [
         base hspec hspec-expectations HUnit QuickCheck
       ];
       homepage = "https://github.com/fpco/fuzzcheck";
       description = "A simple checker for stress testing monadic code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fuzzy" = callPackage
    ({ mkDerivation, base, HUnit, monoid-subclasses }:
     mkDerivation {
       pname = "fuzzy";
       version = "0.1.0.0";
       sha256 = "820a7a2b52163c1ecf0924780604ec903979560901cc1b9f27a68ff17256e9cb";
       libraryHaskellDepends = [ base monoid-subclasses ];
       testHaskellDepends = [ base HUnit ];
       homepage = "http://github.com/joom/fuzzy";
       description = "Filters a list based on a fuzzy string search";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fuzzy-timings" = callPackage
    ({ mkDerivation, base, containers, glpk-hs, HUnit, mtl, QuickCheck
     , random, test-framework, test-framework-hunit
     , test-framework-quickcheck2, time
     }:
     mkDerivation {
       pname = "fuzzy-timings";
       version = "0.0.1";
       sha256 = "47d64c43601d1fdf3695bf6461d99d624078900d49612d703019d9e40978a4ea";
       libraryHaskellDepends = [
         base containers glpk-hs mtl random time
       ];
       testHaskellDepends = [
         base containers HUnit mtl QuickCheck random test-framework
         test-framework-hunit test-framework-quickcheck2 time
       ];
       jailbreak = true;
       homepage = "https://github.com/tlaitinen/fuzzy-timings";
       description = "Translates high-level definitions of \"fuzzily\" scheduled objects (e.g. play this commercial 10 times per hour between 9:00-13:00) to a list of accurately scheduled objects using glpk-hs.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "fuzzytime" = callPackage
    ({ mkDerivation, base, cmdargs, directory, old-time, process }:
     mkDerivation {
       pname = "fuzzytime";
       version = "0.7.7";
       sha256 = "f98a572c199ad3c5cc9232e83df33b22bf90fd46c48d264e100fa411e7f7cb9b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [
         base cmdargs directory old-time process
       ];
       description = "A 'ten past six' style clock";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "fwgl" = callPackage
    ({ mkDerivation, base, hashable, transformers, unordered-containers
     , vect, vector, Yampa
     }:
     mkDerivation {
       pname = "fwgl";
       version = "0.1.4.0";
       sha256 = "428d265e21b498e90e74a3a695d1940e4264481d3eda0a9f5bb0e70031e15d8f";
       libraryHaskellDepends = [
         base hashable transformers unordered-containers vect vector Yampa
       ];
       jailbreak = true;
       homepage = "https://github.com/ziocroc/FWGL";
       description = "Game engine";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "fwgl-glfw" = callPackage
    ({ mkDerivation, base, fwgl, gl, GLFW-b, hashable, JuicyPixels
     , transformers, unordered-containers, vect, vector
     }:
     mkDerivation {
       pname = "fwgl-glfw";
       version = "0.1.1.1";
       sha256 = "043af8e10112bf529f4734d3337f2f8ae683bf59083d85350eba52c5387ffc1b";
       libraryHaskellDepends = [
         base fwgl gl GLFW-b hashable JuicyPixels transformers
         unordered-containers vect vector
       ];
       homepage = "https://github.com/ziocroc/FWGL";
       description = "FWGL GLFW backend";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "fwgl-javascript" = callPackage
    ({ mkDerivation, base, fwgl, ghcjs-base, hashable
     , unordered-containers, vect
     }:
     mkDerivation {
       pname = "fwgl-javascript";
       version = "0.1.1.1";
       sha256 = "858b6cc2cbba16819464446b174fb36108b76b1c503f20dbf1e41c3a470a7786";
       libraryHaskellDepends = [
         base fwgl ghcjs-base hashable unordered-containers vect
       ];
       jailbreak = true;
       homepage = "https://github.com/ziocroc/FWGL";
       description = "FWGL GHCJS backend";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {ghcjs-base = null;};

  "g-npm" = callPackage
    ({ mkDerivation, base, HTTP, json }:
     mkDerivation {
       pname = "g-npm";
       version = "0.1.0";
       sha256 = "e0633977ce6a89ac5f9a83575c36207e7e3dbcb8ee4db2552aca218b571f99ae";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base HTTP json ];
       description = "Generate Gentoo ebuilds from NodeJS/npm packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gact" = callPackage
    ({ mkDerivation, base, biopsl, bytestring, cmdargs, hashable
     , unordered-containers
     }:
     mkDerivation {
       pname = "gact";
       version = "0.2";
       sha256 = "b8c762f4198bb7ec71ac399f1e97c0ffb93dcc1b64c9e7f3b47236ea8958395c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base biopsl bytestring cmdargs hashable unordered-containers
       ];
       description = "General Alignment Clustering Tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "game-of-life" = callPackage
    ({ mkDerivation, array, base, hscurses, random, text }:
     mkDerivation {
       pname = "game-of-life";
       version = "0.1.0.4";
       sha256 = "5f500e662d6a158853950c69fe729cecdbaf2183275d20d770ffb5b196f050b4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base hscurses random text ];
       jailbreak = true;
       homepage = "http://github.com/marcusbuffett/game-of-life";
       description = "Conway's Game of Life";
       license = stdenv.lib.licenses.mit;
     }) {};

  "game-probability" = callPackage
    ({ mkDerivation, base, containers, probability, random }:
     mkDerivation {
       pname = "game-probability";
       version = "1.1";
       sha256 = "736e9eff22a455286adb2906076f1e52a93370e86528463c9fe93c010e4c82f2";
       libraryHaskellDepends = [ base containers probability random ];
       jailbreak = true;
       description = "Simple probability library for dice rolls, card games and similar";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "game-tree" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "game-tree";
       version = "0.1.0.0";
       sha256 = "a512f90c97a312f8c0d4610d2c5472007ef0787b9046a64135b9a1f0c89d0fbd";
       libraryHaskellDepends = [ base ];
       description = "Searching game trees with alpha-beta pruning";
       license = "GPL";
     }) {};

  "gameclock" = callPackage
    ({ mkDerivation, base, cairo, containers, glib, gtk, time }:
     mkDerivation {
       pname = "gameclock";
       version = "1.0.4";
       sha256 = "14a817789f414bd6b2d9d646e016950ee06f915a1d2b4b23e688c6859ab059a4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base cairo containers glib gtk time ];
       description = "Game clock that shows two analog clock faces";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gamma" = callPackage
    ({ mkDerivation, base, continued-fractions, converge
     , template-haskell, vector
     }:
     mkDerivation {
       pname = "gamma";
       version = "0.9.0.2";
       sha256 = "983ac33f0141f576425ae85b883ba8241bdfc73ff48d7ea8124a05a731a8e427";
       libraryHaskellDepends = [
         base continued-fractions converge template-haskell vector
       ];
       homepage = "https://github.com/mokus0/gamma";
       description = "Gamma function and related functions";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "gang-of-threads" = callPackage
    ({ mkDerivation, base, containers, mtl, stm, transformers }:
     mkDerivation {
       pname = "gang-of-threads";
       version = "3.2.1";
       sha256 = "37d0004e9eba014ac16854c03a4938d87552d037c3500ffbff4705dc81a5473e";
       libraryHaskellDepends = [ base containers mtl stm transformers ];
       description = "Non-deterministic parallelism with bags";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "garepinoh" = callPackage
    ({ mkDerivation, base, haskeline, transformers }:
     mkDerivation {
       pname = "garepinoh";
       version = "0.9.9.2.1";
       sha256 = "a7b2e31484f7df98d7ca4a4084e6ab6a95677a9a84bcc23f93ac3e61a4e2d4b3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base haskeline transformers ];
       executableHaskellDepends = [ base haskeline transformers ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/mekeor/Garepinoh/text/README.md";
       description = "reverse prefix notation calculator and calculation library";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "garsia-wachs" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "garsia-wachs";
       version = "1.2";
       sha256 = "dba83f2c31f67fd7d21d2ba13c3c1102c025a204b0435898e620a6c0b82d7a56";
       libraryHaskellDepends = [ base ];
       description = "A Functional Implementation of the Garsia-Wachs Algorithm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gbu" = callPackage
    ({ mkDerivation, base, containers, fgl, Graphalyze, haskell98, mtl
     , regex-posix
     }:
     mkDerivation {
       pname = "gbu";
       version = "0.1";
       sha256 = "e6b33291f01f504754ce2391bd79f596464e830eaceee06494aaee9161c10f7f";
       libraryHaskellDepends = [
         base containers fgl Graphalyze haskell98 mtl regex-posix
       ];
       homepage = "http://www.daneel0yaitskov.000space.com";
       description = "planar graph embedding into a plane";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gc" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, hlint
     , parallel
     }:
     mkDerivation {
       pname = "gc";
       version = "0";
       sha256 = "0a699181d365bcec3e0da537a595c62ccf6d3a9df8865cb2ac5279421d6e9bcb";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base directory doctest filepath hlint parallel
       ];
       homepage = "http://github.com/ekmett/gc/";
       description = "Poor Richard's Memory Manager";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gc-monitoring-wai" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, conduit, http-types
     , text, transformers, unordered-containers, wai
     }:
     mkDerivation {
       pname = "gc-monitoring-wai";
       version = "0.1.2";
       sha256 = "6a93786225da39924d00f35ea19cc45ee11d7bb6426f3364e94683ff6c352812";
       libraryHaskellDepends = [
         aeson base blaze-builder conduit http-types text transformers
         unordered-containers wai
       ];
       homepage = "https://github.com/yihuang/gc-monitoring-wai";
       description = "a wai application to show GHC.GCStats";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gconf" = callPackage
    ({ mkDerivation, base, GConf, glib, gtk2hs-buildtools, text }:
     mkDerivation {
       pname = "gconf";
       version = "0.13.0.3";
       sha256 = "e8efb705c725ae56486585d0972f9dcec96db89c4d636f1805f7dd3e175d69d2";
       libraryHaskellDepends = [ base glib text ];
       libraryPkgconfigDepends = [ GConf ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the GNOME configuration database system";
       license = stdenv.lib.licenses.lgpl21;
     }) {inherit (pkgs.gnome) GConf;};

  "gd" = callPackage
    ({ mkDerivation, base, bytestring, expat, fontconfig, freetype, gd
     , libjpeg, libpng, zlib
     }:
     mkDerivation {
       pname = "gd";
       version = "3000.7.3";
       sha256 = "14aecb600d9a058b1905dfdef3d51a1eb11fb92f804fbaaa041103a0bfd97fb6";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [
         expat fontconfig freetype gd libjpeg libpng zlib
       ];
       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;};

  "gdiff" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "gdiff";
       version = "1.1";
       sha256 = "0c2b042d177131ec5e691fd70452d5b828d8bed7c697169469f470b790430db4";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/eelco/gdiff";
       description = "Generic diff and patch";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gdiff-ig" = callPackage
    ({ mkDerivation, array, base, ghc-prim, instant-generics
     , template-haskell
     }:
     mkDerivation {
       pname = "gdiff-ig";
       version = "0.1.1";
       sha256 = "a24a546e02759e15a25c8a74175e50b00b9338e3f339caf1dee880797de249d5";
       libraryHaskellDepends = [
         array base ghc-prim instant-generics template-haskell
       ];
       homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/InstantGenerics";
       description = "Generic diff for the instant-generics library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gdiff-th" = callPackage
    ({ mkDerivation, base, containers, gdiff, mtl, template-haskell
     , th-expand-syns, uniplate
     }:
     mkDerivation {
       pname = "gdiff-th";
       version = "0.1.0.7";
       sha256 = "5c6832e0de5b7cb35f388be0f2ef301fce1b4e6f0d86bbeec2f105304bfa0bc6";
       libraryHaskellDepends = [
         base containers gdiff mtl template-haskell th-expand-syns uniplate
       ];
       testHaskellDepends = [
         base containers gdiff mtl template-haskell th-expand-syns uniplate
       ];
       jailbreak = true;
       homepage = "https://github.com/jfischoff/gdiff-th";
       description = "Generate gdiff GADTs and Instances";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gdo" = callPackage
    ({ mkDerivation, base, bytestring, containers, cryptohash
     , directory, filepath, process, transformers
     }:
     mkDerivation {
       pname = "gdo";
       version = "0.1.0";
       sha256 = "762ef322a3702b0ae67cdfa80b56088ab988b3067fcf11255ec434d74152b0fc";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers cryptohash directory filepath process
         transformers
       ];
       description = "recursive atomic build system";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "gearbox" = callPackage
    ({ mkDerivation, base, GLUT, OpenGLRaw, Vec }:
     mkDerivation {
       pname = "gearbox";
       version = "1.0.0.4";
       sha256 = "fdebdad6326aaa5202e1aece1049c06d5c5c91acd57070c5953bf141019723df";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base GLUT OpenGLRaw Vec ];
       jailbreak = true;
       homepage = "http://code.mathr.co.uk/gearbox";
       description = "zooming rotating fractal gears graphics demo";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "geek" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, air, air-extra, air-th, base
     , bytestring, containers, curl, data-default, directory, filepath
     , fsnotify, Glob, hack2, hack2-contrib, miku, moe, mtl, process
     , random, safe, system-filepath, text, text-icu, time
     }:
     mkDerivation {
       pname = "geek";
       version = "1.1.1.0";
       sha256 = "a05cdafc1aa14ba26efe997860da26edd66154b9eb69e8a833a063fc55d1a258";
       libraryHaskellDepends = [
         aeson aeson-pretty air air-extra air-th base bytestring containers
         curl data-default directory filepath fsnotify Glob hack2
         hack2-contrib miku moe mtl process random safe system-filepath text
         text-icu time
       ];
       homepage = "http://github.com/nfjinjing/geek";
       description = "Geek blog engine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "geek-server" = callPackage
    ({ mkDerivation, air, base, bytestring, data-default, geek, hack2
     , hack2-handler-snap-server, pandoc, text
     }:
     mkDerivation {
       pname = "geek-server";
       version = "1.1";
       sha256 = "e2ae31c48c02100878adc408c24261dcc24351421df52b373e2c15451197a1a4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         air base bytestring data-default geek hack2
         hack2-handler-snap-server pandoc text
       ];
       executableHaskellDepends = [
         air base bytestring data-default geek hack2
         hack2-handler-snap-server pandoc text
       ];
       homepage = "http://github.com/nfjinjing/geek";
       description = "Geek blog engine server";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gelatin" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, directory
     , file-embed, FontyFruity, gl, GLFW-b, JuicyPixels, lens, linear
     , time, vector
     }:
     mkDerivation {
       pname = "gelatin";
       version = "0.0.0.3";
       sha256 = "181525849ef7b34b051906d333659623a1be4f981197ea185a0f3bfc60b63d1e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base bytestring containers directory file-embed FontyFruity
         gl GLFW-b JuicyPixels lens linear time vector
       ];
       executableHaskellDepends = [
         async base bytestring containers directory file-embed FontyFruity
         gl GLFW-b JuicyPixels lens linear time vector
       ];
       description = "An experimental real time renderer";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gemstone" = callPackage
    ({ mkDerivation, array, base, bitmap, bitmap-opengl, containers
     , FTGL, lens, linear, OpenGL, random, SDL, SDL-image, stb-image
     , transformers
     }:
     mkDerivation {
       pname = "gemstone";
       version = "0.3.0.1";
       sha256 = "80bcdd94c882e8786f6a5e48e5cd47a74eb98d0b330c3d5b8b822c3f6fa73179";
       libraryHaskellDepends = [
         array base bitmap bitmap-opengl containers FTGL lens linear OpenGL
         random SDL SDL-image stb-image transformers
       ];
       jailbreak = true;
       homepage = "http://corbinsimpson.com/";
       description = "A simple library of helpers for SDL+GL games";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gencheck" = callPackage
    ({ mkDerivation, base, combinat, containers, ieee754, memoize
     , random, template-haskell, transformers
     }:
     mkDerivation {
       pname = "gencheck";
       version = "0.1.1";
       sha256 = "393a785d946ed359cb0d78dcd2c3633912abd5f5e3783615a310e3fa47b841b9";
       libraryHaskellDepends = [
         base combinat containers ieee754 memoize random template-haskell
         transformers
       ];
       homepage = "http://github.com/JacquesCarette/GenCheck";
       description = "A testing framework inspired by QuickCheck and SmallCheck";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gender" = callPackage
    ({ mkDerivation, attoparsec, base, text }:
     mkDerivation {
       pname = "gender";
       version = "0.1.1.0";
       sha256 = "18a8d0f61f9d3d93e6731a5ee56151f253e4b2275b46d4a62f7a809dc419d469";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ attoparsec base text ];
       executableHaskellDepends = [ attoparsec base text ];
       jailbreak = true;
       homepage = "https://github.com/womfoo/gender";
       description = "Identify a persons gender by their first name";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "genders" = callPackage
    ({ mkDerivation, base, bytestring, filepath, genders, hspec
     , network, vector
     }:
     mkDerivation {
       pname = "genders";
       version = "0.1.0.1";
       sha256 = "0f41be1270f74126f887ea18a6737c9116c9e505ccf461190ee37a9d24d6814a";
       libraryHaskellDepends = [ base bytestring filepath vector ];
       librarySystemDepends = [ genders ];
       testHaskellDepends = [ base bytestring hspec network vector ];
       description = "Bindings to libgenders";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {genders = null;};

  "general-prelude" = callPackage
    ({ mkDerivation, base, lens, pointless-fun, strict, system-filepath
     }:
     mkDerivation {
       pname = "general-prelude";
       version = "0.1.2";
       sha256 = "cd1c16d3dfe82833a9b35df1072f98ae266ecdba1d99ef8a4691c67b5ab6a84e";
       libraryHaskellDepends = [
         base lens pointless-fun strict system-filepath
       ];
       description = "Prelude replacement using generalized type classes where possible";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generator" = callPackage
    ({ mkDerivation, base, List, transformers }:
     mkDerivation {
       pname = "generator";
       version = "0.5.5";
       sha256 = "adc10917a37890e50301da83e73e949e57b1a0f91e3c1dc58245cab862169fe7";
       libraryHaskellDepends = [ base List transformers ];
       homepage = "http://github.com/yairchu/generator/tree";
       description = "Python-generators notation for creation of monadic lists";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "generators" = callPackage
    ({ mkDerivation, base, mtl, random }:
     mkDerivation {
       pname = "generators";
       version = "1.0.3";
       sha256 = "587041fb4c32efa99463e1faafcef0d0311944525f0afffd6e124b0845efa144";
       libraryHaskellDepends = [ base mtl random ];
       jailbreak = true;
       homepage = "http://liamoc.net/pdf/Generator.pdf";
       description = "Actually useful monadic random value generators";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generic-accessors" = callPackage
    ({ mkDerivation, base, binary, cereal, HUnit, lens, linear
     , QuickCheck, spatial-math, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "generic-accessors";
       version = "0.6.0.0";
       sha256 = "78f8b96b5633f6f2953e6cda0d236da987743d990d7d9facd254fe10d41fc504";
       libraryHaskellDepends = [
         base binary cereal lens linear spatial-math
       ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
       ];
       description = "stringly-named getters for generic data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "generic-aeson_0_2_0_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, generic-deriving, mtl
     , tagged, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "generic-aeson";
       version = "0.2.0.2";
       sha256 = "f07f1ac26de56ad813c1044fcf15f6576f79ec8cd70563c9d32ab0f6fa61a8f4";
       revision = "2";
       editedCabalFile = "d16bef95c5d285faa03a084b41932ed76ffdb7c02a8bbc424d8bf7ca0d86b5ef";
       libraryHaskellDepends = [
         aeson attoparsec base generic-deriving mtl tagged text
         unordered-containers vector
       ];
       jailbreak = true;
       description = "Derivation of Aeson instances using GHC generics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generic-aeson_0_2_0_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, generic-deriving, mtl
     , tagged, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "generic-aeson";
       version = "0.2.0.3";
       sha256 = "c277c9b5621f5e5e4080e3d3ec3b3e2e2ebcf02a5d7a433204b6cccf6d1baa57";
       revision = "1";
       editedCabalFile = "86864a92753031594d4ec28646d34e4d0614678b358dc359d87c94bbe9980323";
       libraryHaskellDepends = [
         aeson attoparsec base generic-deriving mtl tagged text
         unordered-containers vector
       ];
       jailbreak = true;
       description = "Derivation of Aeson instances using GHC generics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generic-aeson_0_2_0_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, generic-deriving, mtl
     , tagged, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "generic-aeson";
       version = "0.2.0.4";
       sha256 = "7d41eec7915b82b2c3a92cdba53bf720db92541c43459f7454b188de8c91bbc0";
       revision = "1";
       editedCabalFile = "1f690c3d9f5359349399f9409ba65dc79bd5a13301cb98ad0961db1b2241c643";
       libraryHaskellDepends = [
         aeson attoparsec base generic-deriving mtl tagged text
         unordered-containers vector
       ];
       jailbreak = true;
       description = "Derivation of Aeson instances using GHC generics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generic-aeson_0_2_0_5" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, generic-deriving, mtl
     , tagged, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "generic-aeson";
       version = "0.2.0.5";
       sha256 = "c5c3d5f64aabfb63c95c8e4a7c69c1359316dbdb7b883c85d33ce4e16dee3281";
       revision = "1";
       editedCabalFile = "9b825c5d437c1a3a47dfb27781100229b7c535982ad42721414083cab309e461";
       libraryHaskellDepends = [
         aeson attoparsec base generic-deriving mtl tagged text
         unordered-containers vector
       ];
       jailbreak = true;
       description = "Derivation of Aeson instances using GHC generics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generic-aeson_0_2_0_6" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, generic-deriving, mtl
     , tagged, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "generic-aeson";
       version = "0.2.0.6";
       sha256 = "5498fded6a1b09d6a7ec242869574512528a74c70577098f4b1bb4815bca548e";
       libraryHaskellDepends = [
         aeson attoparsec base generic-deriving mtl tagged text
         unordered-containers vector
       ];
       jailbreak = true;
       description = "Derivation of Aeson instances using GHC generics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generic-aeson" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, generic-deriving, mtl
     , tagged, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "generic-aeson";
       version = "0.2.0.7";
       sha256 = "1ff3c270634ba8393ff019d2b2dd47a86d98cc2ec83495324fed6fe3b2fa0c1b";
       revision = "5";
       editedCabalFile = "010bcf68960f2c1eebdde39a33d7159b5b34554163875deddfcca84c25e3e145";
       libraryHaskellDepends = [
         aeson attoparsec base generic-deriving mtl tagged text
         unordered-containers vector
       ];
       description = "Derivation of Aeson instances using GHC generics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "generic-binary" = callPackage
    ({ mkDerivation, base, binary, bytestring, ghc-prim }:
     mkDerivation {
       pname = "generic-binary";
       version = "1.0.1";
       sha256 = "49c00e6cbe0d54fe72db40fedd92978833e78f5a0d0e26eb192194c14cd1ddc0";
       libraryHaskellDepends = [ base binary bytestring ghc-prim ];
       jailbreak = true;
       description = "Generic Data.Binary derivation using GHC generics.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "generic-church" = callPackage
    ({ mkDerivation, base, HUnit, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "generic-church";
       version = "0.3.0.0";
       sha256 = "4c591d9f4c6d46394ce5f0eccd776fe81955edf99af592f7a87659c16d4384b3";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       description = "Automatically convert Generic instances to and from church representations";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generic-deepseq" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "generic-deepseq";
       version = "2.0.1.1";
       sha256 = "3b1a51507a4a3e9a9721126f6ca29fe6f97eb589605b5fec8925e674ee9f52f9";
       revision = "1";
       editedCabalFile = "58ed9aeb48cc2a00e3122780fcbf2732c4d6fc46198434926a8b1bcc91d4a29b";
       libraryHaskellDepends = [ base ghc-prim ];
       description = "Generic deep evaluation of data structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "generic-deriving_1_6_3" = callPackage
    ({ mkDerivation, base, ghc-prim, template-haskell }:
     mkDerivation {
       pname = "generic-deriving";
       version = "1.6.3";
       sha256 = "c738b1947aa2cc86a8baf68b7f0e73a10489738bb51cbb1636c3c1ab0af59211";
       libraryHaskellDepends = [ base ghc-prim template-haskell ];
       description = "Generic programming library for generalised deriving";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generic-deriving_1_8_0" = callPackage
    ({ mkDerivation, base, ghc-prim, template-haskell }:
     mkDerivation {
       pname = "generic-deriving";
       version = "1.8.0";
       sha256 = "26b3d927c1341e372118c976d4d8b33a7c4a42ec657734ef9b4653ab1aa486cd";
       libraryHaskellDepends = [ base ghc-prim template-haskell ];
       description = "Generic programming library for generalised deriving";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generic-deriving_1_9_0" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, template-haskell }:
     mkDerivation {
       pname = "generic-deriving";
       version = "1.9.0";
       sha256 = "f1805c59ae4586ae29736c05d0ee033bf99ec1a6062a375bf3e1ca9651a5bfd7";
       revision = "1";
       editedCabalFile = "ffc03b6a6adb54c6433a7af5956e420d65c151a820047189cf3150b387e769ef";
       libraryHaskellDepends = [
         base containers ghc-prim template-haskell
       ];
       homepage = "https://github.com/dreixel/generic-deriving";
       description = "Generic programming library for generalised deriving";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generic-deriving" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, template-haskell }:
     mkDerivation {
       pname = "generic-deriving";
       version = "1.10.2";
       sha256 = "ac5c16be3ff2484bdc5b0051b5af8ed6e31fee8ede2977904a1535ad56b8d9b8";
       libraryHaskellDepends = [
         base containers ghc-prim template-haskell
       ];
       homepage = "https://github.com/dreixel/generic-deriving";
       description = "Generic programming library for generalised deriving";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "generic-lucid-scaffold" = callPackage
    ({ mkDerivation, base, lucid, text }:
     mkDerivation {
       pname = "generic-lucid-scaffold";
       version = "0.0.1";
       sha256 = "3fcf7c6778d9be507c3854a8ac35f11347703234d8b0967e990f678ce1f0998e";
       libraryHaskellDepends = [ base lucid text ];
       description = "General-purpose web page scaffold for Lucid";
       license = stdenv.lib.licenses.mit;
     }) {};

  "generic-maybe" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, directory
     , doctest, filepath, generic-deriving, ghc-prim, hlint, mtl, nats
     , parallel, semigroups, simple-reflect, split, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "generic-maybe";
       version = "0.3.0.4";
       sha256 = "a18fb3f81ab1a76de60f437ea6869cc2fb8e4cf4455e22aea00889a13f4f48bf";
       libraryHaskellDepends = [ base ghc-prim ];
       testHaskellDepends = [
         base bytestring containers deepseq directory doctest filepath
         generic-deriving hlint mtl nats parallel semigroups simple-reflect
         split text unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/jfischoff/generic-maybe";
       description = "A generic version of Data.Maybe";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "generic-pretty" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, bytestring, containers
     , tasty, tasty-hunit, text, vector
     }:
     mkDerivation {
       pname = "generic-pretty";
       version = "0.1.0";
       sha256 = "c75645a50f32fed0b7745d21b3fbb6e6d5e13f2f7f022968076a0fd757abe755";
       libraryHaskellDepends = [
         ansi-wl-pprint base bytestring containers text vector
       ];
       testHaskellDepends = [
         base bytestring containers tasty tasty-hunit text vector
       ];
       homepage = "https://github.com/tanakh/generic-pretty";
       description = "Pretty printing for Generic value";
       license = stdenv.lib.licenses.mit;
     }) {};

  "generic-server" = callPackage
    ({ mkDerivation, base, bytestring, network }:
     mkDerivation {
       pname = "generic-server";
       version = "0.1";
       sha256 = "668a7619ec0528cea7c589a76b8deb978d41fead7f7e1a15e34d1bdeb07b832e";
       libraryHaskellDepends = [ base bytestring network ];
       description = "Simple generic TCP/IP server";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "generic-storable" = callPackage
    ({ mkDerivation, base, ghc-prim, hspec, QuickCheck }:
     mkDerivation {
       pname = "generic-storable";
       version = "0.1.0.0";
       sha256 = "b23bfe5f0b889e4dd1706260ebd4c312719ecc82e2c995df89a3902c8678cf04";
       libraryHaskellDepends = [ base ghc-prim ];
       testHaskellDepends = [ base ghc-prim hspec QuickCheck ];
       jailbreak = true;
       description = "Generic implementation of Storable";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generic-tree" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "generic-tree";
       version = "15329.2";
       sha256 = "48ace4b95fefe33b154bf0c46401eff97527d1b2483f26b8a50eaa5988e23cbb";
       libraryHaskellDepends = [ base ];
       description = "Generic Tree data type";
       license = "LGPL";
     }) {};

  "generic-trie" = callPackage
    ({ mkDerivation, base, containers, transformers }:
     mkDerivation {
       pname = "generic-trie";
       version = "0.3.0.1";
       sha256 = "e773b951a1b308f1f5a78653af557c700be05f0c22b3a9da895e60c4b5cac425";
       libraryHaskellDepends = [ base containers transformers ];
       homepage = "http://github.com/glguy/tries";
       description = "A map, where the keys may be complex structured data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "generic-xml" = callPackage
    ({ mkDerivation, base, HaXml, mtl, syb-with-class, template-haskell
     }:
     mkDerivation {
       pname = "generic-xml";
       version = "0.1";
       sha256 = "4d5a61c57aea8d28c3452574c8e0cf2f2e90dd1df8e4c5c9c9967190184fde21";
       libraryHaskellDepends = [
         base HaXml mtl syb-with-class template-haskell
       ];
       description = "Marshalling Haskell values to/from XML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generic-xmlpickler_0_1_0_0" = callPackage
    ({ mkDerivation, base, generic-deriving, hxt, text }:
     mkDerivation {
       pname = "generic-xmlpickler";
       version = "0.1.0.0";
       sha256 = "5e82ce401f359ae01af0ef50c7fddb0a95c3112591a205bd3f6eeac8141d7079";
       revision = "1";
       editedCabalFile = "9c435b3241998ab02938283e3a846460f3d5ab7dc6ca4eac2e7640cb3c556ca0";
       libraryHaskellDepends = [ base generic-deriving hxt text ];
       jailbreak = true;
       homepage = "http://github.com/silkapp/generic-xmlpickler";
       description = "Generic generation of HXT XmlPickler instances using GHC Generics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generic-xmlpickler_0_1_0_2" = callPackage
    ({ mkDerivation, base, generic-deriving, hxt, hxt-pickle-utils
     , tasty, tasty-hunit, tasty-th, text
     }:
     mkDerivation {
       pname = "generic-xmlpickler";
       version = "0.1.0.2";
       sha256 = "56aae8d9e9ba806f167b9484c289dd99e841c2f30ba7bdde8e84044f4a7c87d9";
       libraryHaskellDepends = [ base generic-deriving hxt text ];
       testHaskellDepends = [
         base hxt hxt-pickle-utils tasty tasty-hunit tasty-th
       ];
       jailbreak = true;
       homepage = "http://github.com/silkapp/generic-xmlpickler";
       description = "Generic generation of HXT XmlPickler instances using GHC Generics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generic-xmlpickler_0_1_0_3" = callPackage
    ({ mkDerivation, base, generic-deriving, hxt, hxt-pickle-utils
     , tasty, tasty-hunit, tasty-th, text
     }:
     mkDerivation {
       pname = "generic-xmlpickler";
       version = "0.1.0.3";
       sha256 = "fe35b9cc5fe40302256be55a7e44345dee35cd07d05dd3d38ef8a9a2b9766b87";
       revision = "1";
       editedCabalFile = "9011a4c8ce1e1c805d146722d2a6b19acd8c31c661888d78b4ea639ed4e24996";
       libraryHaskellDepends = [ base generic-deriving hxt text ];
       testHaskellDepends = [
         base hxt hxt-pickle-utils tasty tasty-hunit tasty-th
       ];
       jailbreak = true;
       homepage = "http://github.com/silkapp/generic-xmlpickler";
       description = "Generic generation of HXT XmlPickler instances using GHC Generics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generic-xmlpickler" = callPackage
    ({ mkDerivation, base, generic-deriving, hxt, hxt-pickle-utils
     , tasty, tasty-hunit, tasty-th, text
     }:
     mkDerivation {
       pname = "generic-xmlpickler";
       version = "0.1.0.4";
       sha256 = "3bc18f38bdbd0071f424763172ca1117fac10309546e8eac2a29208ded593404";
       revision = "1";
       editedCabalFile = "89fde0e961736eea86ecca91f2c66e2e315523b48e313a6f2f3bc4ec1fc52144";
       libraryHaskellDepends = [ base generic-deriving hxt text ];
       testHaskellDepends = [
         base hxt hxt-pickle-utils tasty tasty-hunit tasty-th
       ];
       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, directory, doctest, filepath, hspec
     , interpolate, markdown-unlit, mockery, QuickCheck, shake
     }:
     mkDerivation {
       pname = "generics-eot";
       version = "0.2.1";
       sha256 = "14281d07d0197d9b4b16a9db164e7158b0260b9c823421fa9adbce5fb44c3682";
       libraryHaskellDepends = [ base markdown-unlit ];
       testHaskellDepends = [
         base directory doctest filepath hspec interpolate markdown-unlit
         mockery QuickCheck shake
       ];
       homepage = "https://github.com/soenkehahn/generics-eot#readme";
       description = "A library for generic programming that aims to be easy to understand";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "generics-sop_0_1_0_3" = callPackage
    ({ mkDerivation, base, ghc-prim, template-haskell }:
     mkDerivation {
       pname = "generics-sop";
       version = "0.1.0.3";
       sha256 = "f4ba8a3d12d43ea148885a91d359c4d7f542560bdaf618cd7557d7acca567973";
       libraryHaskellDepends = [ base ghc-prim template-haskell ];
       jailbreak = true;
       description = "Generic Programming using True Sums of Products";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generics-sop_0_1_0_4" = callPackage
    ({ mkDerivation, base, ghc-prim, template-haskell }:
     mkDerivation {
       pname = "generics-sop";
       version = "0.1.0.4";
       sha256 = "52f48545fa3427e550e85c9c7a9a26aa9c291579dcad0970510b9e2535a63203";
       libraryHaskellDepends = [ base ghc-prim template-haskell ];
       jailbreak = true;
       description = "Generic Programming using True Sums of Products";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generics-sop_0_1_1" = callPackage
    ({ mkDerivation, base, ghc-prim, template-haskell }:
     mkDerivation {
       pname = "generics-sop";
       version = "0.1.1";
       sha256 = "dc9b3474c96a1ae30353473619829f7a471558ba50bc4346cb7574771dac07b1";
       libraryHaskellDepends = [ base ghc-prim template-haskell ];
       jailbreak = true;
       description = "Generic Programming using True Sums of Products";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generics-sop_0_1_1_1" = callPackage
    ({ mkDerivation, base, ghc-prim, template-haskell }:
     mkDerivation {
       pname = "generics-sop";
       version = "0.1.1.1";
       sha256 = "b6306683f132460b81efc8b0cd6c626402013491fc13e8b8dbc73534c315a3bc";
       libraryHaskellDepends = [ base ghc-prim template-haskell ];
       jailbreak = true;
       description = "Generic Programming using True Sums of Products";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generics-sop_0_1_1_2" = callPackage
    ({ mkDerivation, base, ghc-prim, template-haskell }:
     mkDerivation {
       pname = "generics-sop";
       version = "0.1.1.2";
       sha256 = "679b9b10dfa66d45c44f3f98e13e9d4148229d25937be54549ef12e8796731e5";
       libraryHaskellDepends = [ base ghc-prim template-haskell ];
       description = "Generic Programming using True Sums of Products";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generics-sop_0_2_0_0" = callPackage
    ({ mkDerivation, base, ghc-prim, template-haskell }:
     mkDerivation {
       pname = "generics-sop";
       version = "0.2.0.0";
       sha256 = "37c4afc49b68bc79a20b388ce949b7d7df5feedbf6649e2fcddbdfbeaeb55d62";
       libraryHaskellDepends = [ base ghc-prim template-haskell ];
       testHaskellDepends = [ base ];
       description = "Generic Programming using True Sums of Products";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "generics-sop" = callPackage
    ({ mkDerivation, base, ghc-prim, template-haskell }:
     mkDerivation {
       pname = "generics-sop";
       version = "0.2.1.0";
       sha256 = "f5fcdd0e6c509d35971e851d29356f718e907ff4c1bdabe17c25308a69ea9f31";
       libraryHaskellDepends = [ base ghc-prim template-haskell ];
       testHaskellDepends = [ base ];
       description = "Generic Programming using True Sums of Products";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "genericserialize" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "genericserialize";
       version = "0.1";
       sha256 = "94198de08ed780ac414b24c7fb6c6edafc29276304a74b3958daed2f702eeb7e";
       libraryHaskellDepends = [ base ];
       description = "Serialization library using Data.Generics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "genetics" = callPackage
    ({ mkDerivation, base, random-fu }:
     mkDerivation {
       pname = "genetics";
       version = "0.0.2";
       sha256 = "1bb6d305be02d74311861f5cbc08d97234ffb7aefc9d6f6b1959e8adefa90167";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base random-fu ];
       description = "A Genetic Algorithm library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "geni-gui" = callPackage
    ({ mkDerivation, array, base, cabal-macosx, containers, directory
     , filepath, GenI, graphviz, hslogger, json, mtl, process, text
     , transformers, wx, wxcore, yaml-light
     }:
     mkDerivation {
       pname = "geni-gui";
       version = "0.24.1";
       sha256 = "c31ba633f7e7f36ecea30290076fc9806d5561378a45c8f532905585f63acfce";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base cabal-macosx containers directory filepath GenI graphviz
         hslogger json mtl process text transformers wx wxcore yaml-light
       ];
       executableHaskellDepends = [ base GenI ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/GenI";
       description = "GenI graphical user interface";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "geni-util" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
     , cmdargs, directory, filepath, GenI, geniserver, HTTP
     , http-streams, io-streams, json, text
     }:
     mkDerivation {
       pname = "geni-util";
       version = "0.24.1.1";
       sha256 = "d32dcd08b83d394e41c146f8f5c8412981a8245668cd584714602ea34178bdf9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html blaze-markup bytestring directory filepath GenI
         geniserver HTTP http-streams io-streams json text
       ];
       executableHaskellDepends = [
         base bytestring cmdargs directory filepath GenI json text
       ];
       jailbreak = true;
       homepage = "http://kowey.github.io/GenI";
       description = "Companion tools for use with the GenI surface realiser";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "geniconvert" = callPackage
    ({ mkDerivation, base, binary, containers, GenI, haskell98, HaXml
     , HUnit, mtl, parsec, QuickCheck, utf8-string
     }:
     mkDerivation {
       pname = "geniconvert";
       version = "0.20";
       sha256 = "8d17419856e72145f6dd291e1c8d537597b3765bd7d626dd19f6b68f9c81362f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary containers GenI haskell98 HaXml HUnit mtl parsec
         QuickCheck utf8-string
       ];
       jailbreak = true;
       homepage = "http://wiki.loria.fr/wiki/GenI";
       description = "Conversion utility for the GenI generator";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "genifunctors" = callPackage
    ({ mkDerivation, base, containers, mtl, template-haskell }:
     mkDerivation {
       pname = "genifunctors";
       version = "0.3";
       sha256 = "2520632580921ea35be3f5bfb94562abb935f8cc577e0bc8b41886eb5bf15a9a";
       libraryHaskellDepends = [ base containers mtl template-haskell ];
       testHaskellDepends = [ base containers mtl template-haskell ];
       homepage = "https://github.com/danr/genifunctors";
       description = "Generate generalized fmap, foldMap and traverse";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "geniplate" = callPackage
    ({ mkDerivation, base, mtl, template-haskell }:
     mkDerivation {
       pname = "geniplate";
       version = "0.6.0.5";
       sha256 = "ec6bb3509d4882f6382166735c6dcd87faae60bd58eb70cd7190503c8bf39c05";
       libraryHaskellDepends = [ base mtl template-haskell ];
       jailbreak = true;
       description = "Use Template Haskell to generate Uniplate-like functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "geniplate-mirror_0_7_1" = callPackage
    ({ mkDerivation, base, mtl, template-haskell }:
     mkDerivation {
       pname = "geniplate-mirror";
       version = "0.7.1";
       sha256 = "60d4b0a0d01a93ee9188eb52d39803d9c2c814d321f95acfb0fdb8c7c075e773";
       libraryHaskellDepends = [ base mtl template-haskell ];
       homepage = "https://github.com/danr/geniplate";
       description = "Use Template Haskell to generate Uniplate-like functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "geniplate-mirror" = callPackage
    ({ mkDerivation, base, mtl, template-haskell }:
     mkDerivation {
       pname = "geniplate-mirror";
       version = "0.7.2";
       sha256 = "2797766702a57f16739378e6da50e8a074d48318601eb5a3e4528b2819509082";
       libraryHaskellDepends = [ base mtl template-haskell ];
       homepage = "https://github.com/danr/geniplate";
       description = "Use Template Haskell to generate Uniplate-like functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "geniserver" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, GenI, http-types, json
     , snap-core, snap-server, text, transformers, utf8-string
     }:
     mkDerivation {
       pname = "geniserver";
       version = "0.24.1.1";
       sha256 = "6c9424b5fe9609efe5f08338819bd35f6a0861ab7237d431104fe14c0c542795";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cmdargs GenI http-types json snap-core text
         transformers utf8-string
       ];
       executableHaskellDepends = [
         base GenI snap-core snap-server text
       ];
       jailbreak = true;
       description = "Simple HTTP server for GenI results";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "genprog" = callPackage
    ({ mkDerivation, base, MonadRandom, syb, syz }:
     mkDerivation {
       pname = "genprog";
       version = "0.1.0.2";
       sha256 = "f9de4698dc4a96d5619791becb2f322ec5de3a6c5f64cff82f9d3bae09142ba9";
       libraryHaskellDepends = [ base MonadRandom syb syz ];
       jailbreak = true;
       homepage = "http://github.com/jsnajder/genprog";
       description = "Genetic programming library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gentlemark" = callPackage
    ({ mkDerivation, base, HUnit, parsec, transformers }:
     mkDerivation {
       pname = "gentlemark";
       version = "1.0.0";
       sha256 = "b5daab4564d06ce09f77cd5c9c586f3a2293abb0e6ee91500b11f3ae4ad469b1";
       libraryHaskellDepends = [ base parsec transformers ];
       testHaskellDepends = [ base HUnit parsec transformers ];
       jailbreak = true;
       homepage = "http://github.com/andriyp/gentlemark";
       description = "Gentle markup language";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "geo-resolver" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, blaze-builder
     , bytestring, http-conduit, http-types, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, unordered-containers
     }:
     mkDerivation {
       pname = "geo-resolver";
       version = "0.1.0.1";
       sha256 = "b877048487a553e2c0ab8f698ac90e5facb24169d5f0c8cc11f36131a837af1a";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring http-conduit http-types text
         unordered-containers
       ];
       testHaskellDepends = [
         base base64-bytestring bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/markenwerk/haskell-geo-resolver/";
       description = "Performs geo location lookups and parses the results";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "geo-uk" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, template-haskell
     , th-lift
     }:
     mkDerivation {
       pname = "geo-uk";
       version = "0.1.0.1";
       sha256 = "a92648834307b9ac6dde2a581fbf291b36cbd8d005965e7e64512f8bdfb01e70";
       libraryHaskellDepends = [
         array base binary bytestring template-haskell th-lift
       ];
       homepage = "https://github.com/tolysz/geo-uk";
       description = "High precision conversion between GPS and UK Grid";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "geocalc" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "geocalc";
       version = "1.0.0";
       sha256 = "4f7607849b34fc7a536c928aab946991298a4912f7d268d2a9bb21d867de6baf";
       libraryHaskellDepends = [ base ];
       description = "Libary for calculating distances between two coordinates in WSG84";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "geocode-google" = callPackage
    ({ mkDerivation, base, containers, hjson, HTTP, network
     , network-uri
     }:
     mkDerivation {
       pname = "geocode-google";
       version = "0.3";
       sha256 = "9dbdde3c68564bfaf4f1fd9844e9d1119eaef4833eaf6fd6348d9eb0c71cc468";
       libraryHaskellDepends = [
         base containers hjson HTTP network network-uri
       ];
       homepage = "http://github.com/mrd/geocode-google";
       description = "Geocoding using the Google Web API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "geodetic" = callPackage
    ({ mkDerivation, base, coordinate, directory, doctest, filepath
     , lens, optional, QuickCheck, radian, template-haskell
     }:
     mkDerivation {
       pname = "geodetic";
       version = "0.1.4";
       sha256 = "df31e7a6d88b0e25baab02778130a913e94ad94e4052284d830ad03014f4861e";
       libraryHaskellDepends = [ base coordinate lens optional radian ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck template-haskell
       ];
       homepage = "https://github.com/NICTA/geodetic";
       description = "Geodetic calculations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "geodetics" = callPackage
    ({ mkDerivation, array, base, dimensional, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "geodetics";
       version = "0.0.4";
       sha256 = "237ea075d3cc8566d3694cdcbe1733f5fb74c7fe5e43b3a5fe501fb92e4cb4fe";
       libraryHaskellDepends = [ array base dimensional ];
       testHaskellDepends = [
         array base dimensional HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/PaulJohnson/geodetics";
       description = "Terrestrial coordinate systems and geodetic calculations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "geohash" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "geohash";
       version = "1.0.1";
       sha256 = "64173009447070e8dd1720ba82dddf0dbbed56826f81f7aa9c732484ed25bddd";
       libraryHaskellDepends = [ array base ];
       description = "Geohash latitudes and longitudes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "geoip2" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, iproute
     , mmap, reinterpret-cast, text
     }:
     mkDerivation {
       pname = "geoip2";
       version = "0.2.0.0";
       sha256 = "942f7fbb0a5a433d2211a3ffb80911cb1fcef8acd7a5d73f0a25d524cdb0c6e5";
       libraryHaskellDepends = [
         base bytestring cereal containers iproute mmap reinterpret-cast
         text
       ];
       description = "Pure haskell interface to MaxMind GeoIP database";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "geojson" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, doctest
     , filepath, hlint, lens, QuickCheck, semigroups, template-haskell
     , text, transformers, validation, vector
     }:
     mkDerivation {
       pname = "geojson";
       version = "1.3.0";
       sha256 = "1adba5e0bcfc4efad8ed9742279d78cc85d45be845257dd64999f66a872dd9a1";
       libraryHaskellDepends = [
         aeson base lens semigroups text transformers validation vector
       ];
       testHaskellDepends = [
         base bytestring directory doctest filepath hlint QuickCheck
         template-haskell
       ];
       jailbreak = true;
       homepage = "https://github.com/domdere/hs-geojson";
       description = "A thin GeoJSON Layer above the aeson library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "geom2d" = callPackage
    ({ mkDerivation, base, ieee754, linear, QuickCheck }:
     mkDerivation {
       pname = "geom2d";
       version = "0.2.2";
       sha256 = "239ff6b5c7a389022657dd92172fb5ae397c74dc4b0aae15e42cd2b3d3d1543f";
       libraryHaskellDepends = [ base ieee754 linear QuickCheck ];
       testHaskellDepends = [ base ieee754 linear QuickCheck ];
       jailbreak = true;
       description = "package for geometry in euklidean 2d space";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "getemx" = callPackage
    ({ mkDerivation, base, curl, directory, filepath, haskell98, hxt
     , mtl, old-locale, process, time
     }:
     mkDerivation {
       pname = "getemx";
       version = "0.1";
       sha256 = "95dbc2281e7d8f04ae761592187f60bd745cd4b12966357aace093c98a21f8e1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base curl directory filepath haskell98 hxt mtl old-locale process
         time
       ];
       homepage = "http://bitbucket.org/kenko/getemx";
       description = "Fetch from emusic using .emx files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "getflag" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "getflag";
       version = "1.0";
       sha256 = "4c4a71ce5e88b73175eaf374213287f232c374083707b71bd78c52bb2a43594b";
       libraryHaskellDepends = [ base ];
       description = "Command-line parser";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "getopt-generics_0_10_0_1" = callPackage
    ({ mkDerivation, base, base-compat, base-orphans, directory
     , filepath, generics-sop, hspec, process, QuickCheck, silently
     , tagged, temporary
     }:
     mkDerivation {
       pname = "getopt-generics";
       version = "0.10.0.1";
       sha256 = "8e22e94a1f27e0dd2696e0ccd97dde5e2f137e969188dce92aa0866735801b75";
       libraryHaskellDepends = [
         base base-compat base-orphans generics-sop tagged
       ];
       testHaskellDepends = [
         base base-compat base-orphans directory filepath generics-sop hspec
         process QuickCheck silently tagged temporary
       ];
       doCheck = false;
       homepage = "https://github.com/zalora/getopt-generics#readme";
       description = "Create command line interfaces with ease";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "getopt-generics" = callPackage
    ({ mkDerivation, base, base-compat, base-orphans, filepath
     , generics-sop, hspec, QuickCheck, safe, silently, tagged
     }:
     mkDerivation {
       pname = "getopt-generics";
       version = "0.13";
       sha256 = "d193384dca0c9fdd8492ee888b1b8954b247f83ead6e4f3f81ded94377aaa34a";
       libraryHaskellDepends = [
         base base-compat base-orphans generics-sop tagged
       ];
       testHaskellDepends = [
         base base-compat base-orphans filepath generics-sop hspec
         QuickCheck safe silently tagged
       ];
       doCheck = false;
       homepage = "https://github.com/soenkehahn/getopt-generics#readme";
       description = "Create command line interfaces with ease";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "getopt-simple" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "getopt-simple";
       version = "0.1.0.2";
       sha256 = "f79efd9bef4e4f0ce678fdaaf99ca3f1f70f2dc815c16439d9f97e399805c4dd";
       libraryHaskellDepends = [ base containers ];
       homepage = "https://bitbucket.org/dpwiz/getopt-simple";
       description = "A \"System.Console.GetOpt\" wrapper to make simple use case easy.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gf" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, Cabal, cgi
     , containers, directory, exceptions, filepath, happy, haskeline
     , HTF, httpd-shed, HUnit, json, lifted-base, mtl, network
     , network-uri, old-locale, parallel, pretty, process, random
     , terminfo, time, time-compat, unix, utf8-string
     }:
     mkDerivation {
       pname = "gf";
       version = "3.7.1";
       sha256 = "150a9f40718689f7dafe962618a39066687b470dcc8aa6478cbe114a6a0094ab";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cgi containers directory exceptions filepath
         haskeline httpd-shed json mtl network network-uri old-locale
         parallel pretty process random terminfo time time-compat unix
         utf8-string
       ];
       libraryToolDepends = [ alex happy ];
       executableHaskellDepends = [ base containers lifted-base mtl ];
       testHaskellDepends = [
         base Cabal directory filepath HTF HUnit process
       ];
       doCheck = false;
       postPatch = ''
         sed -i "s|\"-s\"|\"\"|" ./Setup.hs
         sed -i "s|numJobs (bf bi)++||" ./Setup.hs
       '';
       preBuild = ''export LD_LIBRARY_PATH=`pwd`/dist/build:$LD_LIBRARY_PATH'';
       homepage = "http://www.grammaticalframework.org/";
       description = "Grammatical Framework";
       license = "unknown";
     }) {};

  "ggtsTC" = callPackage
    ({ mkDerivation, base, containers, parsec }:
     mkDerivation {
       pname = "ggtsTC";
       version = "0.5";
       sha256 = "b2377f72e8cf1a226493ee9aae3fff07dab89bd6857b45ac2f59723a32b0b14c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers parsec ];
       homepage = "http://a319-101.ipm.edu.mo/~wke/ggts/impl/";
       description = "A type checker and runtime system of rCOS/g (impl. of ggts-FCS).";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-core" = callPackage
    ({ mkDerivation, base, colorize-haskell, directory, filepath
     , pcre-light, process
     }:
     mkDerivation {
       pname = "ghc-core";
       version = "0.5.6";
       sha256 = "ec34f3e5892be7c2b52945875cd330397eca3904ae1d9574559855817b8b7e85";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base colorize-haskell directory filepath pcre-light process
       ];
       homepage = "https://github.com/shachaf/ghc-core";
       description = "Display GHC's core and assembly output in a pager";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-core-html" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, containers, mtl
     , parsec, process
     }:
     mkDerivation {
       pname = "ghc-core-html";
       version = "0.1.4";
       sha256 = "657888cb64b681d6131536567848179a578955ae8b465ab715ef8b53d215a2fb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-html bytestring containers mtl parsec process
       ];
       homepage = "https://github.com/vincenthz/ghc-core-html";
       description = "Core to HTML display";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-datasize" = callPackage
    ({ mkDerivation, base, ghc-heap-view }:
     mkDerivation {
       pname = "ghc-datasize";
       version = "0.1.2";
       sha256 = "03509fe6ed477f850e25b4afc0b54c71d50d70000bf0ca93d719e031b3634d2e";
       libraryHaskellDepends = [ base ghc-heap-view ];
       homepage = "http://felsin9.de/nnis/ghc-datasize";
       description = "Determine the size of data structures in GHC's memory";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-dump-tree" = callPackage
    ({ mkDerivation, aeson, base, bytestring, ghc, optparse-applicative
     , pretty, pretty-show, process, unordered-containers, vector
     }:
     mkDerivation {
       pname = "ghc-dump-tree";
       version = "0.2.0.0";
       sha256 = "2b1cf817fcd1727b029a74d393816da936cb49e9048524dc743afb3d9cc65e5e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring ghc pretty pretty-show process
         unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson base bytestring ghc optparse-applicative pretty pretty-show
         process unordered-containers vector
       ];
       homepage = "https://github.com/edsko/ghc-dump-tree";
       description = "Dump GHC's parsed, renamed, and type checked ASTs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-dup" = callPackage
    ({ mkDerivation, base, ghc }:
     mkDerivation {
       pname = "ghc-dup";
       version = "0.1";
       sha256 = "552a865f2fb4c11a52b44124690771a155f13f8997025c710f0370f797e5842b";
       libraryHaskellDepends = [ base ghc ];
       jailbreak = true;
       description = "Explicitly prevent sharing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-events" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers, mtl
     }:
     mkDerivation {
       pname = "ghc-events";
       version = "0.4.4.0";
       sha256 = "ab2bf624848165872375954f6b67379991557a58dff66959f585ee9807c84f6d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers mtl
       ];
       executableHaskellDepends = [
         array base binary bytestring containers mtl
       ];
       testHaskellDepends = [
         array base binary bytestring containers mtl
       ];
       doCheck = false;
       description = "Library and tool for parsing .eventlog files from GHC";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-events-analyze" = callPackage
    ({ mkDerivation, base, containers, diagrams-lib, diagrams-svg
     , filepath, ghc-events, lens, mtl, optparse-applicative, parsec
     , SVGFonts, template-haskell, th-lift, transformers
     }:
     mkDerivation {
       pname = "ghc-events-analyze";
       version = "0.2.2";
       sha256 = "0cbcf66eae454ea672bec6f23b97b295fe9a7312c33f7e6b0272c270a7e8e0f3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers diagrams-lib diagrams-svg filepath ghc-events lens
         mtl optparse-applicative parsec SVGFonts template-haskell th-lift
         transformers
       ];
       jailbreak = true;
       description = "Analyze and visualize event logs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-events-parallel" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , transformers
     }:
     mkDerivation {
       pname = "ghc-events-parallel";
       version = "0.5.0.1";
       sha256 = "7e994b7a184e5c5559e871ff7e8bfb1e1ef90e7ae29de0a8a2f58e5a0db438a0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers transformers
       ];
       executableHaskellDepends = [
         array base binary bytestring containers transformers
       ];
       testHaskellDepends = [
         array base binary bytestring containers transformers
       ];
       description = "Library and tool for parsing .eventlog files from parallel GHC";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-exactprint" = callPackage
    ({ mkDerivation, base, containers, directory, filemanip, filepath
     , free, ghc, ghc-paths, HUnit, mtl, silently, syb
     }:
     mkDerivation {
       pname = "ghc-exactprint";
       version = "0.5.0.1";
       sha256 = "ecdae12d521d0997a48a91507f241f80532df468f09095a50cc6f1629cd43ce8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory filepath free ghc ghc-paths mtl syb
       ];
       testHaskellDepends = [
         base containers directory filemanip filepath ghc ghc-paths HUnit
         mtl silently syb
       ];
       description = "ExactPrint for GHC";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "ghc-gc-tune" = callPackage
    ({ mkDerivation, base, directory, filepath, process }:
     mkDerivation {
       pname = "ghc-gc-tune";
       version = "0.3";
       sha256 = "3c692f4e050361caa22296bec6ed3857e813ce29017f44a7893fa46a901b173e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath process ];
       homepage = "http://code.haskell.org/~dons/code/ghc-gc-tune";
       description = "Graph performance of Haskell programs with different GC flags";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-generic-instances" = callPackage
    ({ mkDerivation, base, ghc }:
     mkDerivation {
       pname = "ghc-generic-instances";
       version = "0.1.0.0";
       sha256 = "f0905739f35dbf7fa133f6f96cc2f421f2a0dd2714b4a7ecf5dc15c481aac408";
       libraryHaskellDepends = [ base ghc ];
       homepage = "https://github.com/alanz/ghc-generic-instances";
       description = "Derived instances of GHC.Generic of the GHC AST";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "ghc-heap-view_0_5_3" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, ghc
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "ghc-heap-view";
       version = "0.5.3";
       sha256 = "008fd158b916929e9a95c020641aed33a5dbd27abc1c0a8369b076a81e8998c9";
       libraryHaskellDepends = [
         base binary bytestring containers ghc template-haskell transformers
       ];
       testHaskellDepends = [ base deepseq ];
       jailbreak = true;
       description = "Extract the heap representation of Haskell values and thunks";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-heap-view" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq, ghc
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "ghc-heap-view";
       version = "0.5.4";
       sha256 = "a1c3fffc4c6645a804c5473d2d1c250d1e1dda155acb3a338dd42c1a2a09c40a";
       libraryHaskellDepends = [
         base binary bytestring containers ghc template-haskell transformers
       ];
       testHaskellDepends = [ base deepseq ];
       description = "Extract the heap representation of Haskell values and thunks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-imported-from" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, filepath, ghc
     , ghc-mod, ghc-paths, ghc-syb-utils, hspec, monad-journal, mtl
     , optparse-applicative, parsec, process, safe, syb, transformers
     }:
     mkDerivation {
       pname = "ghc-imported-from";
       version = "0.2.1.1";
       sha256 = "6ef8612bbcc230323fa844310b504a4174706b99ca769bdcb79168f8f69bc74f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers directory filepath ghc ghc-mod ghc-paths
         ghc-syb-utils monad-journal mtl optparse-applicative parsec process
         safe syb transformers
       ];
       executableHaskellDepends = [
         base Cabal containers directory filepath ghc ghc-mod ghc-paths
         ghc-syb-utils hspec monad-journal mtl optparse-applicative parsec
         process safe syb transformers
       ];
       testHaskellDepends = [
         base Cabal containers directory filepath ghc ghc-mod ghc-paths
         ghc-syb-utils hspec monad-journal mtl optparse-applicative parsec
         process safe syb transformers
       ];
       homepage = "https://github.com/carlohamalainen/ghc-imported-from";
       description = "Find the Haddock documentation for a symbol";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-make" = callPackage
    ({ mkDerivation, base, process, shake, unordered-containers }:
     mkDerivation {
       pname = "ghc-make";
       version = "0.3.2";
       sha256 = "7219fedf1a74c04af08cb177b2d984f4298a6bc12229d8218b6169fdea8a6b83";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base process shake unordered-containers
       ];
       homepage = "https://github.com/ndmitchell/ghc-make#readme";
       description = "Accelerated version of ghc --make";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-man-completion" = callPackage
    ({ mkDerivation, base, parsec, process }:
     mkDerivation {
       pname = "ghc-man-completion";
       version = "0.0.0.3";
       sha256 = "172827e9729068cd7eeae668cd74105b9a04187693419c5ddb01cf7aabb11e23";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base parsec process ];
       jailbreak = true;
       description = "Generate a bash completion from the GHC manpage";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-mod_5_2_1_1" = callPackage
    ({ mkDerivation, async, base, Cabal, containers, data-default
     , deepseq, directory, djinn-ghc, doctest, filepath, ghc, ghc-paths
     , ghc-syb-utils, haskell-src-exts, hlint, hspec, io-choice
     , monad-control, monad-journal, mtl, old-time, pretty, process
     , split, syb, temporary, text, time, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "ghc-mod";
       version = "5.2.1.1";
       sha256 = "46cc0247d61bec5aa1262825ca18b7b264f2842a99aada3b299668701229af25";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers deepseq directory djinn-ghc filepath ghc
         ghc-paths ghc-syb-utils haskell-src-exts hlint io-choice
         monad-control monad-journal mtl old-time pretty process split syb
         temporary text time transformers transformers-base
       ];
       executableHaskellDepends = [
         async base containers data-default directory filepath ghc mtl
         old-time pretty process split time
       ];
       testHaskellDepends = [
         base Cabal containers deepseq directory djinn-ghc doctest filepath
         ghc ghc-paths ghc-syb-utils haskell-src-exts hlint hspec io-choice
         monad-control monad-journal mtl old-time pretty process split syb
         temporary text time transformers transformers-base
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://www.mew.org/~kazu/proj/ghc-mod/";
       description = "Happy Haskell Programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-mod_5_2_1_2" = callPackage
    ({ mkDerivation, async, base, Cabal, containers, data-default
     , deepseq, directory, djinn-ghc, doctest, filepath, ghc, ghc-paths
     , ghc-syb-utils, haskell-src-exts, hlint, hspec, io-choice
     , monad-control, monad-journal, mtl, old-time, pretty, process
     , split, syb, temporary, text, time, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "ghc-mod";
       version = "5.2.1.2";
       sha256 = "3b66b4ab4271ee1a61ab348951d49c38e500535789b469783281d36556cb9687";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers deepseq directory djinn-ghc filepath ghc
         ghc-paths ghc-syb-utils haskell-src-exts hlint io-choice
         monad-control monad-journal mtl old-time pretty process split syb
         temporary text time transformers transformers-base
       ];
       executableHaskellDepends = [
         async base containers data-default directory filepath ghc mtl
         old-time pretty process split time
       ];
       testHaskellDepends = [
         base Cabal containers deepseq directory djinn-ghc doctest filepath
         ghc ghc-paths ghc-syb-utils haskell-src-exts hlint hspec io-choice
         monad-control monad-journal mtl old-time pretty process split syb
         temporary text time transformers transformers-base
       ];
       doCheck = false;
       homepage = "http://www.mew.org/~kazu/proj/ghc-mod/";
       description = "Happy Haskell Programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-mod_5_4_0_0" = callPackage
    ({ mkDerivation, async, base, bytestring, cabal-helper, cereal
     , containers, deepseq, directory, djinn-ghc, doctest, extra
     , fclabels, filepath, ghc, ghc-paths, ghc-syb-utils
     , haskell-src-exts, hlint, hspec, monad-control, monad-journal, mtl
     , old-time, pipes, pretty, process, split, syb, temporary, text
     , time, transformers, transformers-base
     }:
     mkDerivation {
       pname = "ghc-mod";
       version = "5.4.0.0";
       sha256 = "736652a2f63f9e8625c859c94f193ad8ac9f8fe793bbee672b65576309bfb069";
       revision = "4";
       editedCabalFile = "696785aa6bf4878359c6d004ed9c18fd77f3e883eeec55cdc86a07ce18b1a4b0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cabal-helper cereal containers deepseq directory
         djinn-ghc extra fclabels filepath ghc ghc-paths ghc-syb-utils
         haskell-src-exts hlint monad-control monad-journal mtl old-time
         pipes pretty process split syb temporary text time transformers
         transformers-base
       ];
       executableHaskellDepends = [
         async base directory fclabels filepath ghc mtl old-time pretty
         process split time
       ];
       testHaskellDepends = [ base doctest hspec ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.mew.org/~kazu/proj/ghc-mod/";
       description = "Happy Haskell Programming";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-mod" = callPackage
    ({ mkDerivation, base, binary, bytestring, cabal-helper, containers
     , deepseq, directory, djinn-ghc, doctest, extra, fclabels, filepath
     , ghc, ghc-paths, ghc-syb-utils, haskell-src-exts, hlint, hspec
     , monad-control, monad-journal, mtl, old-time, optparse-applicative
     , pipes, pretty, process, safe, split, syb, temporary, text, time
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "ghc-mod";
       version = "5.5.0.0";
       sha256 = "d05be8f3541e875cd4ebefb28968cfc095fc323e49328f2e40581f6f5de70d31";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring cabal-helper containers deepseq directory
         djinn-ghc extra fclabels filepath ghc ghc-paths ghc-syb-utils
         haskell-src-exts hlint monad-control monad-journal mtl old-time
         pipes pretty process safe split syb temporary text time
         transformers transformers-base
       ];
       executableHaskellDepends = [
         base binary deepseq directory fclabels filepath ghc monad-control
         mtl old-time optparse-applicative pretty process split time
       ];
       testHaskellDepends = [ base doctest hspec ];
       doCheck = false;
       homepage = "http://www.mew.org/~kazu/proj/ghc-mod/";
       description = "Happy Haskell Programming";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "ghc-mtl" = callPackage
    ({ mkDerivation, base, exceptions, extensible-exceptions, ghc, mtl
     }:
     mkDerivation {
       pname = "ghc-mtl";
       version = "1.2.1.0";
       sha256 = "934e36c03ae0cbf59d6eb6d626983a3e520c6101417284b0a652db74e333d940";
       libraryHaskellDepends = [
         base exceptions extensible-exceptions ghc mtl
       ];
       doHaddock = false;
       homepage = "http://hub.darcs.net/jcpetruzza/ghc-mtl";
       description = "An mtl compatible version of the Ghc-Api monads and monad-transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-options" = callPackage
    ({ mkDerivation, base, bin-package-db, Cabal, directory, filepath
     , ghc, ghc-paths, process, transformers, unix
     }:
     mkDerivation {
       pname = "ghc-options";
       version = "0.2.0.0";
       sha256 = "75443492d1e6eb65b536087aafc84655bbad6026d28ecda950b3cd67d5d44369";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bin-package-db Cabal directory filepath ghc ghc-paths process
         transformers unix
       ];
       executableHaskellDepends = [
         base bin-package-db Cabal directory filepath ghc ghc-paths process
         transformers unix
       ];
       homepage = "https://github.com/ranjitjhala/ghc-options.git";
       description = "Utilities for extracting GHC options needed to compile a given Haskell target";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ghc-parmake" = callPackage
    ({ mkDerivation, array, base, containers, directory, filepath
     , HUnit, process, QuickCheck, temporary, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "ghc-parmake";
       version = "0.1.9";
       sha256 = "381973ada7fc3e944dab09ff35d3b26070b1585f5a115fc2ddb09508c1e11c5e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers directory filepath process temporary
       ];
       executableHaskellDepends = [
         array base containers directory filepath process temporary
       ];
       testHaskellDepends = [
         base directory filepath HUnit process QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/23Skidoo/ghc-parmake";
       description = "A parallel wrapper for 'ghc --make'";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-parser_0_1_7_0" = callPackage
    ({ mkDerivation, base, cpphs, ghc, happy }:
     mkDerivation {
       pname = "ghc-parser";
       version = "0.1.7.0";
       sha256 = "e3e085bd656c8865d80994ad909960de448719394d1d033b75b4c6fc756a6031";
       libraryHaskellDepends = [ base ghc ];
       libraryToolDepends = [ cpphs happy ];
       homepage = "https://github.com/gibiansky/IHaskell";
       description = "Haskell source parser from GHC";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-parser" = callPackage
    ({ mkDerivation, base, cpphs, ghc, happy }:
     mkDerivation {
       pname = "ghc-parser";
       version = "0.1.8.0";
       sha256 = "494e9df73942c5e77e01c331eaee94438c15c711d78f48c1d1c4d8977ffb5152";
       libraryHaskellDepends = [ base ghc ];
       libraryToolDepends = [ cpphs happy ];
       homepage = "https://github.com/gibiansky/IHaskell";
       description = "Haskell source parser from GHC";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ghc-paths" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ghc-paths";
       version = "0.1.0.9";
       sha256 = "afa68fb86123004c37c1dc354286af2d87a9dcfb12ddcb80e8bd0cd55bc87945";
       libraryHaskellDepends = [ base ];
       description = "Knowledge of GHC's installation directories";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-pkg-autofix" = callPackage
    ({ mkDerivation, base, Cabal, cmdargs, filepath, parsec, process
     , split
     }:
     mkDerivation {
       pname = "ghc-pkg-autofix";
       version = "0.2.0.1";
       sha256 = "e76bd4631e0a10d6db7610caabdfead4afd30a395b4cb4825f77f2eff4dca766";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal cmdargs filepath parsec process split
       ];
       jailbreak = true;
       description = "Simple utility to fix BROKEN package dependencies for cabal-install";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-pkg-lib" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, ghc, ghc-paths
     }:
     mkDerivation {
       pname = "ghc-pkg-lib";
       version = "0.3.1";
       sha256 = "b3e106581e474cb32eb049bc8b49eedce82c8645b80fdf508a21d2c6ce5c7fce";
       libraryHaskellDepends = [
         base Cabal directory filepath ghc ghc-paths
       ];
       homepage = "https://github.com/JPMoresmau/ghc-pkg-lib";
       description = "Provide library support for ghc-pkg information";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-prim_0_4_0_0" = callPackage
    ({ mkDerivation, rts }:
     mkDerivation {
       pname = "ghc-prim";
       version = "0.4.0.0";
       sha256 = "61688f073f20651000781e012da8c42e771b6f4a16bf62e03c263adf039d70f0";
       libraryHaskellDepends = [ rts ];
       description = "GHC primitives";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-prof-flamegraph" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ghc-prof-flamegraph";
       version = "0.1.2.1";
       sha256 = "0ba6b7e36d31c31f6f2e8f6cd54b7a75614aed9c0054618fdad5e2580c1cf35b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       description = "Generates data to be used with flamegraph.pl from .prof files.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ghc-server" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "ghc-server";
       version = "1.2";
       sha256 = "b68988eb8182a2f686738f399d95679d4005e3127e49bc4b8ef020485b8be5c1";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-session_0_1_2_0" = callPackage
    ({ mkDerivation, base, exceptions, ghc, ghc-mtl, ghc-paths
     , transformers, transformers-compat
     }:
     mkDerivation {
       pname = "ghc-session";
       version = "0.1.2.0";
       sha256 = "791a40e9130a3ad09f3226a5cb71ab6ca0492b35345a68078c4e67e7ccd93c94";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base exceptions ghc ghc-mtl ghc-paths transformers
         transformers-compat
       ];
       executableHaskellDepends = [ base transformers ];
       homepage = "http://github.com/pmlodawski/ghc-session";
       description = "Simplified GHC API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-session" = callPackage
    ({ mkDerivation, base, exceptions, ghc, ghc-mtl, ghc-paths
     , transformers, transformers-compat
     }:
     mkDerivation {
       pname = "ghc-session";
       version = "0.1.2.1";
       sha256 = "c1e517fa3fe4fc12ce2d371a8a8b1e50fd1ec22edc94203f0566b23f501e6d0b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base exceptions ghc ghc-mtl ghc-paths transformers
         transformers-compat
       ];
       executableHaskellDepends = [ base transformers ];
       homepage = "http://github.com/pmlodawski/ghc-session";
       description = "Simplified GHC API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ghc-simple" = callPackage
    ({ mkDerivation, base, binary, bytestring, directory, filepath, ghc
     , ghc-paths
     }:
     mkDerivation {
       pname = "ghc-simple";
       version = "0.3";
       sha256 = "937833e77e0468bd546fc0ff7a1ec6d8d3ea1ee775cc5fe8b06373daf58f208c";
       libraryHaskellDepends = [
         base binary bytestring directory filepath ghc ghc-paths
       ];
       homepage = "https://github.com/valderman/ghc-simple";
       description = "Simplified interface to the GHC API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ghc-srcspan-plugin" = callPackage
    ({ mkDerivation, array, base, containers, ghc, hpc }:
     mkDerivation {
       pname = "ghc-srcspan-plugin";
       version = "0.2.1.0";
       sha256 = "918bf8aa5060db5635c8dbc630001247e1efe7188388c44e4f7bc5077f3266b1";
       libraryHaskellDepends = [ array base containers ghc hpc ];
       description = "Generic GHC Plugin for annotating Haskell code with source location data";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ gridaphobe ];
     }) {};

  "ghc-syb" = callPackage
    ({ mkDerivation, base, ghc }:
     mkDerivation {
       pname = "ghc-syb";
       version = "0.2.0.0";
       sha256 = "0052bd2ee4d92fbb010bebc7bcfd533a0b78437f1fb0834288ce979c103d9d67";
       libraryHaskellDepends = [ base ghc ];
       jailbreak = true;
       homepage = "http://github.com/nominolo/ghc-syb";
       description = "Data and Typeable instances for the GHC API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-syb-utils_0_2_2" = callPackage
    ({ mkDerivation, base, ghc, syb }:
     mkDerivation {
       pname = "ghc-syb-utils";
       version = "0.2.2";
       sha256 = "939a176034cf3f1bf43429384c0b82ee5da1d1944370da14ed3b4a48d4e8240f";
       libraryHaskellDepends = [ base ghc syb ];
       homepage = "http://github.com/nominolo/ghc-syb";
       description = "Scrap Your Boilerplate utilities for the GHC API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-syb-utils" = callPackage
    ({ mkDerivation, base, ghc, syb }:
     mkDerivation {
       pname = "ghc-syb-utils";
       version = "0.2.3";
       sha256 = "7ef63fcfe829b621d5b947c6a4567de111976a463f2ffaf0fafc5e76776cbc67";
       libraryHaskellDepends = [ base ghc syb ];
       homepage = "http://github.com/nominolo/ghc-syb";
       description = "Scrap Your Boilerplate utilities for the GHC API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-tcplugins-extra_0_1" = callPackage
    ({ mkDerivation, base, ghc }:
     mkDerivation {
       pname = "ghc-tcplugins-extra";
       version = "0.1";
       sha256 = "6edaff0bb718904438b9e8f6a54cd05443f1b08e6ceaf3b97488abf2f6e823d3";
       libraryHaskellDepends = [ base ghc ];
       homepage = "http://www.clash-lang.org/";
       description = "Utilities for writing GHC type-checker plugins";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-tcplugins-extra" = callPackage
    ({ mkDerivation, base, ghc }:
     mkDerivation {
       pname = "ghc-tcplugins-extra";
       version = "0.2";
       sha256 = "f3542b6734b20e3e25f851589944d1d185533c0f0a5428eee86f422ad3687374";
       libraryHaskellDepends = [ base ghc ];
       homepage = "http://github.com/clash-lang/ghc-tcplugins-extra";
       description = "Utilities for writing GHC type-checker plugins";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "ghc-time-alloc-prof" = callPackage
    ({ mkDerivation, attoparsec, base, containers, text, time }:
     mkDerivation {
       pname = "ghc-time-alloc-prof";
       version = "0.0.0";
       sha256 = "f9b40315889766b53c0ad03b6e4a2af71da558d217afdb1d6072e9672f006828";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ attoparsec base containers text time ];
       executableHaskellDepends = [ attoparsec base containers text ];
       homepage = "https://github.com/maoe/ghc-time-alloc-prof";
       description = "Library for parsing GHC time and allocation profiling reports";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghc-typelits-extra_0_1" = callPackage
    ({ mkDerivation, base, ghc, ghc-tcplugins-extra
     , ghc-typelits-natnormalise, tasty, tasty-hunit
     }:
     mkDerivation {
       pname = "ghc-typelits-extra";
       version = "0.1";
       sha256 = "7dc44b910b211896a144a5cef965a5588f326693c9dcd6f69d5489a23a5f910f";
       libraryHaskellDepends = [ base ghc ghc-tcplugins-extra ];
       testHaskellDepends = [
         base ghc-typelits-natnormalise tasty tasty-hunit
       ];
       homepage = "http://www.clash-lang.org/";
       description = "Additional type-level operations on GHC.TypeLits.Nat";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-typelits-extra" = callPackage
    ({ mkDerivation, base, ghc, ghc-tcplugins-extra
     , ghc-typelits-natnormalise, tasty, tasty-hunit
     }:
     mkDerivation {
       pname = "ghc-typelits-extra";
       version = "0.1.1";
       sha256 = "e9727920a2c00bb8881277af2a6c2df8a46644e292501520e3677f9853691c1e";
       libraryHaskellDepends = [ base ghc ghc-tcplugins-extra ];
       testHaskellDepends = [
         base ghc-typelits-natnormalise tasty tasty-hunit
       ];
       homepage = "http://www.clash-lang.org/";
       description = "Additional type-level operations on GHC.TypeLits.Nat";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "ghc-typelits-natnormalise_0_3" = callPackage
    ({ mkDerivation, base, ghc, ghc-tcplugins-extra, tasty, tasty-hunit
     }:
     mkDerivation {
       pname = "ghc-typelits-natnormalise";
       version = "0.3";
       sha256 = "19c5e3effe09e046e52aedd19ef8ee5bfbaf2d1b1afda7aba204326830ae3199";
       libraryHaskellDepends = [ base ghc ghc-tcplugins-extra ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       homepage = "http://www.clash-lang.org/";
       description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-typelits-natnormalise_0_3_1" = callPackage
    ({ mkDerivation, base, ghc, ghc-tcplugins-extra, tasty, tasty-hunit
     }:
     mkDerivation {
       pname = "ghc-typelits-natnormalise";
       version = "0.3.1";
       sha256 = "8ec5650de2f2c940b7da8961694e14d199788e12111a8f1c1e41dfcdf938f0e2";
       libraryHaskellDepends = [ base ghc ghc-tcplugins-extra ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       homepage = "http://www.clash-lang.org/";
       description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-typelits-natnormalise_0_4" = callPackage
    ({ mkDerivation, base, ghc, ghc-tcplugins-extra, tasty, tasty-hunit
     }:
     mkDerivation {
       pname = "ghc-typelits-natnormalise";
       version = "0.4";
       sha256 = "8b6f0188b3bc04bef2c7083811eeb4c12a32436a95a797e38e4883067b4c3354";
       libraryHaskellDepends = [ base ghc ghc-tcplugins-extra ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       homepage = "http://www.clash-lang.org/";
       description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghc-typelits-natnormalise" = callPackage
    ({ mkDerivation, base, ghc, ghc-tcplugins-extra, tasty, tasty-hunit
     }:
     mkDerivation {
       pname = "ghc-typelits-natnormalise";
       version = "0.4.1";
       sha256 = "d7b1d7059eb0a9254ff6983897141f8fd0ac485dcb2c09eafd19f36dce0e5af7";
       libraryHaskellDepends = [ base ghc ghc-tcplugins-extra ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       homepage = "http://www.clash-lang.org/";
       description = "GHC typechecker plugin for types of kind GHC.TypeLits.Nat";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "ghc-vis" = callPackage
    ({ mkDerivation, base, cairo, containers, deepseq, fgl
     , ghc-heap-view, graphviz, gtk3, mtl, svgcairo, text, transformers
     , xdot
     }:
     mkDerivation {
       pname = "ghc-vis";
       version = "0.8";
       sha256 = "e8e808c0155396ba391da1f3289df042088aa7af432ae554964ea4896e1c870d";
       libraryHaskellDepends = [
         base cairo containers deepseq fgl ghc-heap-view graphviz gtk3 mtl
         svgcairo text transformers xdot
       ];
       homepage = "http://felsin9.de/nnis/ghc-vis";
       description = "Live visualization of data structures in GHCi";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghci-diagrams" = callPackage
    ({ mkDerivation, base, cairo, colour, diagrams, gtk }:
     mkDerivation {
       pname = "ghci-diagrams";
       version = "0.1.1";
       sha256 = "3cec737a321ff8b7c8f16c00847dc14296a654bbc3b9c3dfdc6a902666a99eca";
       libraryHaskellDepends = [ base cairo colour diagrams gtk ];
       jailbreak = true;
       description = "Display simple diagrams from ghci";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghci-haskeline" = callPackage
    ({ mkDerivation, array, base, bytestring, directory, filepath, ghc
     , ghc-paths, haskeline, mtl, process, unix
     }:
     mkDerivation {
       pname = "ghci-haskeline";
       version = "0.2";
       sha256 = "1eeb6af9177667fab653b55f0fecb2834a3be28a7f7b1576fbbfb4dabbcf4206";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring directory filepath ghc ghc-paths haskeline
         mtl process unix
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~judah/ghci-haskeline";
       description = "An implementation of ghci using the Haskeline line-input library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghci-lib" = callPackage
    ({ mkDerivation, base, ghc, MissingH }:
     mkDerivation {
       pname = "ghci-lib";
       version = "0.1.0.0";
       sha256 = "7fccf7e97b1a6fe6823d3beb7e366c3142b5a6b863e8a95080659aac3f0b8f1a";
       libraryHaskellDepends = [ base ghc MissingH ];
       jailbreak = true;
       homepage = "http://github.com/gibiansky/IHaskell";
       description = "A library for interactively evaluating Haskell code";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ghci-ng" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , filepath, ghc, ghc-paths, haskeline, process, syb, time
     , transformers, unix
     }:
     mkDerivation {
       pname = "ghci-ng";
       version = "10.0.0";
       sha256 = "a78909a528b79ec14649c528bb47bbec02c535b75b654978a97359e7c9bd39dd";
       revision = "3";
       editedCabalFile = "0deaf1cd57dd29c65fe31d4679d171336a07382cede88770f36e6d24cb3568cc";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring containers directory filepath ghc ghc-paths
         haskeline process syb time transformers unix
       ];
       homepage = "https://github.com/chrisdone/ghci-ng";
       description = "Next generation GHCi";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghci-pretty" = callPackage
    ({ mkDerivation, base, hscolour, ipprint }:
     mkDerivation {
       pname = "ghci-pretty";
       version = "0.0.2";
       sha256 = "45db55bfae7e9efae3e4f264d005256cb84f4c5cb730391aaa44596558a15e07";
       libraryHaskellDepends = [ base hscolour ipprint ];
       homepage = "https://github.com/larskuhtz/ghci-pretty";
       description = "colored pretty-printing within ghci";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ghcid_0_3_2" = callPackage
    ({ mkDerivation, base, cmdargs, directory, extra, filepath, process
     , tasty, tasty-hunit, terminal-size, time
     }:
     mkDerivation {
       pname = "ghcid";
       version = "0.3.2";
       sha256 = "c32e02f7ad19feba73cf0e3eba2c48fb14bd90fac9f8044e838d5a4d1405a2cf";
       revision = "1";
       editedCabalFile = "58262c601d393d34a65a5e36f2924cd19c18efb7acfefb59544af5acad9160d0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cmdargs directory extra filepath process terminal-size time
       ];
       executableHaskellDepends = [
         base cmdargs directory extra filepath process terminal-size time
       ];
       testHaskellDepends = [
         base cmdargs directory extra filepath process tasty tasty-hunit
         terminal-size time
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/ndmitchell/ghcid#readme";
       description = "GHCi based bare bones IDE";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghcid_0_3_4" = callPackage
    ({ mkDerivation, base, cmdargs, containers, directory, extra
     , filepath, process, tasty, tasty-hunit, terminal-size, time
     }:
     mkDerivation {
       pname = "ghcid";
       version = "0.3.4";
       sha256 = "584e71e58d4958bd53bc43a4acb48be82dacb5cacae3168bdedaa54ef3e857f5";
       revision = "1";
       editedCabalFile = "37edb88b54678d5a6a3aa49b877f71fd149902e5b8e12538ae4156cc846b85c1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cmdargs containers directory extra filepath process
         terminal-size time
       ];
       executableHaskellDepends = [
         base cmdargs containers directory extra filepath process
         terminal-size time
       ];
       testHaskellDepends = [
         base cmdargs containers directory extra filepath process tasty
         tasty-hunit terminal-size time
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/ndmitchell/ghcid#readme";
       description = "GHCi based bare bones IDE";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghcid_0_3_6" = callPackage
    ({ mkDerivation, ansi-terminal, base, cmdargs, directory, extra
     , filepath, process, tasty, tasty-hunit, terminal-size, time
     }:
     mkDerivation {
       pname = "ghcid";
       version = "0.3.6";
       sha256 = "a8cabaa91386004cf8ca1a38419b62956aea26ace0ffd25e8db640e406d64a95";
       revision = "1";
       editedCabalFile = "3a403a6f170cbec00720138692973989a06bd52b2abc4144d52133275be01f09";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cmdargs directory extra filepath process terminal-size time
       ];
       executableHaskellDepends = [
         ansi-terminal base cmdargs directory extra filepath process
         terminal-size time
       ];
       testHaskellDepends = [
         ansi-terminal base cmdargs directory extra filepath process tasty
         tasty-hunit terminal-size time
       ];
       doCheck = false;
       homepage = "https://github.com/ndmitchell/ghcid#readme";
       description = "GHCi based bare bones IDE";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghcid" = callPackage
    ({ mkDerivation, ansi-terminal, base, cmdargs, containers
     , directory, extra, filepath, fsnotify, process, tasty, tasty-hunit
     , terminal-size, time
     }:
     mkDerivation {
       pname = "ghcid";
       version = "0.5";
       sha256 = "d44c8f82aa51ec69dd1ff840d0951a17732cca32b6b1da91e55408121c38adac";
       revision = "1";
       editedCabalFile = "b0d70ae396ce2d8adcec06901c032b2a4f6b689f5b0f6c852902b0d8b534d3f8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cmdargs directory extra filepath process terminal-size time
       ];
       executableHaskellDepends = [
         ansi-terminal base cmdargs containers directory extra filepath
         fsnotify process terminal-size time
       ];
       testHaskellDepends = [
         ansi-terminal base cmdargs containers directory extra filepath
         fsnotify process tasty tasty-hunit terminal-size time
       ];
       doCheck = false;
       homepage = "https://github.com/ndmitchell/ghcid#readme";
       description = "GHCi based bare bones IDE";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ghcjs-codemirror" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ghcjs-codemirror";
       version = "0.0.0.1";
       sha256 = "dcd9f5288d7624c8a2a5bf8440d9de6ab8400707d366180b13cc3f472280a513";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/ghcjs/CodeMirror";
       description = "Installs CodeMirror JavaScript files";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ghcjs-dom" = callPackage
    ({ mkDerivation, base, glib, gtk3, text, transformers, webkitgtk3
     }:
     mkDerivation {
       pname = "ghcjs-dom";
       version = "0.2.3.1";
       sha256 = "dfdee3dcd46ad5707a09488ccf0d2c69dbb47d2044212aeadec0a44f3facee39";
       libraryHaskellDepends = [
         base glib gtk3 text transformers webkitgtk3
       ];
       description = "DOM library that supports both GHCJS and WebKitGTK";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ghcjs-dom-hello" = callPackage
    ({ mkDerivation, base, ghcjs-dom, mtl }:
     mkDerivation {
       pname = "ghcjs-dom-hello";
       version = "2.0.0.0";
       sha256 = "34bd62641aa6913d04baeb1ab347f6f867080e001f7cacfb841a5f14abf46fe7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ghcjs-dom mtl ];
       homepage = "https://github.com/ghcjs/ghcjs-dom-hello";
       description = "GHCJS DOM Hello World, an example package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ghcjs-websockets" = callPackage
    ({ mkDerivation, base, base64-bytestring, binary, bytestring, text
     }:
     mkDerivation {
       pname = "ghcjs-websockets";
       version = "0.3.0.5";
       sha256 = "f879f2ccfd4a98dfbe23b7e12aebda5207acfe10bcf3d67ec7d00ca06e83a7ce";
       libraryHaskellDepends = [
         base base64-bytestring binary bytestring text
       ];
       homepage = "http://github.com/mstksg/ghcjs-websockets";
       description = "GHCJS interface for the Javascript Websocket API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ghclive" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , containers, diagrams-lib, diagrams-svg, directory, file-embed
     , ghc-prim, hint, mtl, text, time, unix, unordered-containers
     , vector, wai, wai-websockets, warp, websockets, yesod
     , yesod-static
     }:
     mkDerivation {
       pname = "ghclive";
       version = "0.1.0.2";
       sha256 = "08bae27ee5b18d232f24a2586d9124d5fd212087489f0c914ff216aa13d8d566";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base blaze-html blaze-markup containers diagrams-lib
         diagrams-svg ghc-prim text
       ];
       executableHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         file-embed hint mtl text time unix unordered-containers vector wai
         wai-websockets warp websockets yesod yesod-static
       ];
       jailbreak = true;
       homepage = "http://github.com/shapr/ghclive/";
       description = "Interactive Haskell interpreter in a browser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ghczdecode" = callPackage
    ({ mkDerivation, base, zenc }:
     mkDerivation {
       pname = "ghczdecode";
       version = "0.1.0.1";
       sha256 = "89165d96224447f3e33dfe71fff83df210cea7d99d159c3fd8af32f6355dc6fa";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base zenc ];
       homepage = "https://github.com/Peaker/ghczdecode";
       description = "Decode Z-encoded strings from GHC";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ght" = callPackage
    ({ mkDerivation, base, binary, bytestring, data-default, directory
     , filepath, iteratee, iteratee-compress, mmap, mtl, old-locale, SHA
     , storable-endian, time, ui-command, unix, zlib
     }:
     mkDerivation {
       pname = "ght";
       version = "0.4.0.1";
       sha256 = "8ca3d8b7310c391f2e3e5aea689d306680310db98b19c85db1adbf74f4b0990e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring data-default iteratee iteratee-compress mmap
         old-locale SHA storable-endian time
       ];
       executableHaskellDepends = [
         base bytestring data-default directory filepath mtl SHA ui-command
         unix zlib
       ];
       description = "Trivial routines for inspecting git repositories";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gi-atk" = callPackage
    ({ mkDerivation, atk, base, bytestring, containers, gi-glib
     , gi-gobject, haskell-gi-base, text, transformers
     }:
     mkDerivation {
       pname = "gi-atk";
       version = "0.2.18.12";
       sha256 = "00f4542fb4da78adbf0a84f5c81f386e645bc82a811d44b32e031df7721fae66";
       libraryHaskellDepends = [
         base bytestring containers gi-glib gi-gobject haskell-gi-base text
         transformers
       ];
       libraryPkgconfigDepends = [ atk ];
       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, cairo-gobject, containers
     , haskell-gi-base, text, transformers
     }:
     mkDerivation {
       pname = "gi-cairo";
       version = "0.1.14.12";
       sha256 = "8d023a70208100d4d8f634bbe408d2f956f3afe8f73dce3411747d753974b173";
       libraryHaskellDepends = [
         base bytestring containers haskell-gi-base text transformers
       ];
       libraryPkgconfigDepends = [ cairo-gobject ];
       homepage = "https://github.com/haskell-gi/haskell-gi";
       description = "cairo bindings";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {cairo-gobject = null;};

  "gi-gdk" = callPackage
    ({ mkDerivation, base, bytestring, containers, gdk3, gi-cairo
     , gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject, gi-pango
     , haskell-gi-base, text, transformers
     }:
     mkDerivation {
       pname = "gi-gdk";
       version = "0.3.18.12";
       sha256 = "9cde9b8e62af1123c134d576c634846514b5e7f9561d5cc0692a68ad64306190";
       libraryHaskellDepends = [
         base bytestring containers gi-cairo gi-gdkpixbuf gi-gio gi-glib
         gi-gobject gi-pango haskell-gi-base text transformers
       ];
       libraryPkgconfigDepends = [ gdk3 ];
       homepage = "https://github.com/haskell-gi/haskell-gi";
       description = "Gdk bindings";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gdk3 = null;};

  "gi-gdkpixbuf" = callPackage
    ({ mkDerivation, base, bytestring, containers, gdk_pixbuf, gi-gio
     , gi-glib, gi-gobject, haskell-gi-base, text, transformers
     }:
     mkDerivation {
       pname = "gi-gdkpixbuf";
       version = "0.2.32.12";
       sha256 = "0b3b3188250602969b06520b82ba3b1a4df52bc303c6a16ec22495b4f3b356e6";
       libraryHaskellDepends = [
         base bytestring containers gi-gio gi-glib gi-gobject
         haskell-gi-base text transformers
       ];
       libraryPkgconfigDepends = [ gdk_pixbuf ];
       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, containers, gi-glib, gi-gobject
     , glib, haskell-gi-base, text, transformers
     }:
     mkDerivation {
       pname = "gi-gio";
       version = "0.2.46.12";
       sha256 = "c200b349cb53e9d52f2592c714a39734f45129c0d94a5a21815630e66e993d1f";
       libraryHaskellDepends = [
         base bytestring containers gi-glib gi-gobject haskell-gi-base text
         transformers
       ];
       libraryPkgconfigDepends = [ glib ];
       homepage = "https://github.com/haskell-gi/haskell-gi";
       description = "Gio bindings";
       license = stdenv.lib.licenses.lgpl21;
     }) {inherit (pkgs) glib;};

  "gi-girepository" = callPackage
    ({ mkDerivation, base, bytestring, containers, gi-gobject
     , gobjectIntrospection, haskell-gi-base, text, transformers
     }:
     mkDerivation {
       pname = "gi-girepository";
       version = "0.1.44.12";
       sha256 = "c7f53dee512511df7a4c8f00d2e5ae37ae52f49859efd83afef77e9c3f71fd80";
       libraryHaskellDepends = [
         base bytestring containers gi-gobject haskell-gi-base text
         transformers
       ];
       libraryPkgconfigDepends = [ gobjectIntrospection ];
       jailbreak = true;
       homepage = "https://github.com/haskell-gi/haskell-gi";
       description = "GIRepository bindings";
       license = stdenv.lib.licenses.lgpl21;
     }) {inherit (pkgs) gobjectIntrospection;};

  "gi-glib" = callPackage
    ({ mkDerivation, base, bytestring, containers, glib
     , haskell-gi-base, text, transformers
     }:
     mkDerivation {
       pname = "gi-glib";
       version = "0.2.46.12";
       sha256 = "5b0bff30b5a1a4cc3f5f55437d357917153e3e6f51f506593543e9e13a103d1b";
       libraryHaskellDepends = [
         base bytestring containers haskell-gi-base text transformers
       ];
       libraryPkgconfigDepends = [ glib ];
       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, containers, gi-glib, glib
     , haskell-gi-base, text, transformers
     }:
     mkDerivation {
       pname = "gi-gobject";
       version = "0.2.46.12";
       sha256 = "990287820c8e0855249d6e5a41ec0ae3d6beaa6594c44d156316670477b508dc";
       libraryHaskellDepends = [
         base bytestring containers gi-glib haskell-gi-base text
         transformers
       ];
       libraryPkgconfigDepends = [ glib ];
       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, containers, gi-atk, gi-cairo
     , gi-gdk, gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject, gi-pango, gtk3
     , haskell-gi-base, text, transformers
     }:
     mkDerivation {
       pname = "gi-gtk";
       version = "0.3.18.12";
       sha256 = "f1bdacb55a80b26ee36f5f1fea6cfdb9f7505429432797389b0bd1b4c22f40f3";
       libraryHaskellDepends = [
         base bytestring containers gi-atk gi-cairo gi-gdk gi-gdkpixbuf
         gi-gio gi-glib gi-gobject gi-pango haskell-gi-base text
         transformers
       ];
       libraryPkgconfigDepends = [ gtk3 ];
       homepage = "https://github.com/haskell-gi/haskell-gi";
       description = "Gtk bindings";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gtk3 = pkgs.gnome2.gtk;};

  "gi-javascriptcore" = callPackage
    ({ mkDerivation, base, bytestring, containers, haskell-gi-base
     , javascriptcoregtk, text, transformers
     }:
     mkDerivation {
       pname = "gi-javascriptcore";
       version = "0.2.10.12";
       sha256 = "e078b90cf16904c7e93e9f6d4274ae2f847597f03137a4ecbb2808a33ec8ad18";
       libraryHaskellDepends = [
         base bytestring containers haskell-gi-base text transformers
       ];
       libraryPkgconfigDepends = [ javascriptcoregtk ];
       homepage = "https://github.com/haskell-gi/haskell-gi";
       description = "JavaScriptCore bindings";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {javascriptcoregtk = null;};

  "gi-notify" = callPackage
    ({ mkDerivation, base, bytestring, containers, gdk_pixbuf
     , gi-gdkpixbuf, gi-glib, gi-gobject, haskell-gi-base, text
     , transformers
     }:
     mkDerivation {
       pname = "gi-notify";
       version = "0.2.32.12";
       sha256 = "fff3910ced837a9bafbc39d3965a06c925976c9c7853286d1234a671e90f5a49";
       libraryHaskellDepends = [
         base bytestring containers gi-gdkpixbuf gi-glib gi-gobject
         haskell-gi-base text transformers
       ];
       libraryPkgconfigDepends = [ gdk_pixbuf ];
       homepage = "https://github.com/haskell-gi/haskell-gi";
       description = "Notify bindings";
       license = stdenv.lib.licenses.lgpl21;
     }) {inherit (pkgs) gdk_pixbuf;};

  "gi-pango" = callPackage
    ({ mkDerivation, base, bytestring, containers, gi-glib, gi-gobject
     , haskell-gi-base, pango, text, transformers
     }:
     mkDerivation {
       pname = "gi-pango";
       version = "0.1.38.12";
       sha256 = "dd542ea85468b8c6188f02e4ec546dc18ad57f498ad0775714edd040cffbe016";
       libraryHaskellDepends = [
         base bytestring containers gi-glib gi-gobject haskell-gi-base text
         transformers
       ];
       libraryPkgconfigDepends = [ pango ];
       homepage = "https://github.com/haskell-gi/haskell-gi";
       description = "Pango bindings";
       license = stdenv.lib.licenses.lgpl21;
     }) {inherit (pkgs.gnome) pango;};

  "gi-poppler" = callPackage
    ({ mkDerivation, base, bytestring, containers, gi-cairo, gi-gio
     , gi-glib, gi-gobject, haskell-gi-base, poppler, text, transformers
     }:
     mkDerivation {
       pname = "gi-poppler";
       version = "0.0.34.12";
       sha256 = "b4f6222d6912232b172481c9cdff2bf94a3e8c88753b5a2549e59e18810aa670";
       libraryHaskellDepends = [
         base bytestring containers gi-cairo gi-gio gi-glib gi-gobject
         haskell-gi-base text transformers
       ];
       libraryPkgconfigDepends = [ poppler ];
       homepage = "https://github.com/haskell-gi/haskell-gi";
       description = "Poppler bindings";
       license = stdenv.lib.licenses.lgpl21;
     }) {inherit (pkgs) poppler;};

  "gi-soup" = callPackage
    ({ mkDerivation, base, bytestring, containers, gi-gio, gi-glib
     , gi-gobject, haskell-gi-base, libsoup, text, transformers
     }:
     mkDerivation {
       pname = "gi-soup";
       version = "0.2.52.12";
       sha256 = "ca5e1f931dba96aa9006cec559316b308f14d427afefbbb221e7a154df755a6d";
       libraryHaskellDepends = [
         base bytestring containers gi-gio gi-glib gi-gobject
         haskell-gi-base text transformers
       ];
       libraryPkgconfigDepends = [ libsoup ];
       homepage = "https://github.com/haskell-gi/haskell-gi";
       description = "Soup bindings";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.gnome) libsoup;};

  "gi-vte" = callPackage
    ({ mkDerivation, base, bytestring, containers, gi-atk, gi-gdk
     , gi-gio, gi-glib, gi-gobject, gi-gtk, gi-pango, haskell-gi-base
     , text, transformers, vte
     }:
     mkDerivation {
       pname = "gi-vte";
       version = "0.0.42.12";
       sha256 = "15e2828c0fefd118e4fd4e3081a99af7b85f7615e5298db86b7f2a01bac2bc88";
       libraryHaskellDepends = [
         base bytestring containers gi-atk gi-gdk gi-gio gi-glib gi-gobject
         gi-gtk gi-pango haskell-gi-base text transformers
       ];
       libraryPkgconfigDepends = [ vte ];
       homepage = "https://github.com/haskell-gi/haskell-gi";
       description = "Vte bindings";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.gnome) vte;};

  "gi-webkit" = callPackage
    ({ mkDerivation, base, bytestring, containers, gi-atk, gi-cairo
     , gi-gdk, gi-gdkpixbuf, gi-gio, gi-glib, gi-gobject, gi-gtk
     , gi-javascriptcore, gi-soup, haskell-gi-base, text, transformers
     , webkit
     }:
     mkDerivation {
       pname = "gi-webkit";
       version = "0.2.4.12";
       sha256 = "3b0cddc3f28d6acd4583224b72c289d3f7239302f4b8d01d79b8e98f8786fc08";
       libraryHaskellDepends = [
         base bytestring containers gi-atk gi-cairo gi-gdk gi-gdkpixbuf
         gi-gio gi-glib gi-gobject gi-gtk gi-javascriptcore gi-soup
         haskell-gi-base text transformers
       ];
       libraryPkgconfigDepends = [ webkit ];
       jailbreak = true;
       homepage = "https://github.com/haskell-gi/haskell-gi";
       description = "WebKit bindings";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) webkit;};

  "gi-webkit2" = callPackage
    ({ mkDerivation, base, bytestring, containers, gi-atk, gi-cairo
     , gi-gdk, gi-gio, gi-glib, gi-gobject, gi-gtk, gi-javascriptcore
     , gi-soup, haskell-gi-base, text, transformers, webkit2gtk
     }:
     mkDerivation {
       pname = "gi-webkit2";
       version = "0.2.10.12";
       sha256 = "71872b4690056320f20ddc4a468f04b525e29bef06137963ca8406da72e2056a";
       libraryHaskellDepends = [
         base bytestring containers gi-atk gi-cairo gi-gdk gi-gio gi-glib
         gi-gobject gi-gtk gi-javascriptcore gi-soup haskell-gi-base text
         transformers
       ];
       libraryPkgconfigDepends = [ webkit2gtk ];
       homepage = "https://github.com/haskell-gi/haskell-gi";
       description = "WebKit2 bindings";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {webkit2gtk = null;};

  "gi-webkit2webextension" = callPackage
    ({ mkDerivation, base, bytestring, containers, gi-gobject, gi-gtk
     , gi-javascriptcore, gi-soup, haskell-gi-base, text, transformers
     , webkit2gtk-web-extension
     }:
     mkDerivation {
       pname = "gi-webkit2webextension";
       version = "0.2.10.12";
       sha256 = "1ca70e16d94719c5a6fc97e198c50ee5d5bb0edb8e956b4f89387fd793530ff2";
       libraryHaskellDepends = [
         base bytestring containers gi-gobject gi-gtk gi-javascriptcore
         gi-soup haskell-gi-base text transformers
       ];
       libraryPkgconfigDepends = [ webkit2gtk-web-extension ];
       homepage = "https://github.com/haskell-gi/haskell-gi";
       description = "WebKit2WebExtension bindings";
       license = stdenv.lib.licenses.lgpl21;
     }) {webkit2gtk-web-extension = null;};

  "gimlh" = callPackage
    ({ mkDerivation, base, split }:
     mkDerivation {
       pname = "gimlh";
       version = "0.1.3.0";
       sha256 = "5468c82185ea26b8660faafeb65021ec49328091cb882bd4b87ef01c9c7badc3";
       libraryHaskellDepends = [ base split ];
       homepage = "https://github.com/gazay/gimlh";
       description = "Haskell parser for GIML";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ginger" = callPackage
    ({ mkDerivation, aeson, base, bytestring, data-default, filepath
     , http-types, mtl, parsec, safe, scientific, text, transformers
     , unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "ginger";
       version = "0.1.2.0";
       sha256 = "ab23b63975f0e6ea9819c303b73bb4633840ecf8fbcd9c4bd6746fed7c61e613";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring data-default filepath http-types mtl parsec
         safe scientific text transformers unordered-containers utf8-string
         vector
       ];
       executableHaskellDepends = [
         aeson base bytestring data-default text transformers
         unordered-containers
       ];
       homepage = "https://bitbucket.org/tdammers/ginger";
       description = "An implementation of the Jinja2 template language in Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ginsu" = callPackage
    ({ mkDerivation, array, async, base, binary, bytestring, containers
     , directory, hashable, hashtables, mtl, network, old-locale
     , old-time, openssl, parsec, pretty, process, random, regex-posix
     , syb, unix, utf8-string
     }:
     mkDerivation {
       pname = "ginsu";
       version = "0.8.2.1";
       sha256 = "74a94b8573cede5665df7ae25dcc5c53312aea7ece9d4d70857b4c0d572dcbd8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array async base binary bytestring containers directory hashable
         hashtables mtl network old-locale old-time parsec pretty process
         random regex-posix syb unix utf8-string
       ];
       executableSystemDepends = [ openssl ];
       homepage = "http://repetae.net/computer/ginsu/";
       description = "Ginsu Gale Client";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) openssl;};

  "gio_0_13_0_3" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, glib
     , gtk2hs-buildtools, mtl
     }:
     mkDerivation {
       pname = "gio";
       version = "0.13.0.3";
       sha256 = "c5e915a1d718349832a634d3127a206a1abdebdf851443b4dcf78568a42c0294";
       libraryHaskellDepends = [
         array base bytestring containers glib mtl
       ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the GIO";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gio_0_13_0_4" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, glib
     , gtk2hs-buildtools, mtl
     }:
     mkDerivation {
       pname = "gio";
       version = "0.13.0.4";
       sha256 = "4a36b8e183660f8c093c99ec198021c630cc51bf31d7c7267a6fb2fc28e556bc";
       libraryHaskellDepends = [
         array base bytestring containers glib mtl
       ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the GIO";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gio_0_13_1_0" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, glib
     , gtk2hs-buildtools, mtl
     }:
     mkDerivation {
       pname = "gio";
       version = "0.13.1.0";
       sha256 = "b274b121b7814d25e0125f3129287a2407c83f458731040297a6fc6ebf6cabe3";
       libraryHaskellDepends = [
         array base bytestring containers glib mtl
       ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the GIO";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gio" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, glib
     , gtk2hs-buildtools, mtl
     }:
     mkDerivation {
       pname = "gio";
       version = "0.13.1.1";
       sha256 = "d04d9b87b43bf12c5917ea561da403f80fe955adf735785ea8afa0915478113b";
       libraryHaskellDepends = [
         array base bytestring containers glib mtl
       ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to GIO";
       license = stdenv.lib.licenses.lgpl21;
     }) {};

  "gipeda_0_1_0_2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cassava, containers
     , directory, filepath, shake, split, text, unordered-containers
     , vector, yaml
     }:
     mkDerivation {
       pname = "gipeda";
       version = "0.1.0.2";
       sha256 = "dfa35636883ced925d8a1a51a1d880f85579ceaf24088426ac9fd666b55e7734";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring cassava containers directory filepath shake
         split text unordered-containers vector yaml
       ];
       jailbreak = true;
       homepage = "https://github.com/nomeata/gipeda";
       description = "Git Performance Dashboard";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gipeda_0_1_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cassava
     , conduit-combinators, containers, directory, extra, filepath
     , gitlib, gitlib-libgit2, scientific, shake, split, tagged, text
     , unordered-containers, vector, yaml
     }:
     mkDerivation {
       pname = "gipeda";
       version = "0.1.1";
       sha256 = "37d2f3d06be79db59de960d6479397a446afa6648f49c73941d4f7f2cb609a6b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring cassava conduit-combinators containers
         directory extra filepath gitlib gitlib-libgit2 scientific shake
         split tagged text unordered-containers vector yaml
       ];
       jailbreak = true;
       homepage = "https://github.com/nomeata/gipeda";
       description = "Git Performance Dashboard";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gipeda_0_1_2_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cassava, containers
     , directory, extra, filepath, gitlib, gitlib-libgit2, scientific
     , shake, split, tagged, text, unordered-containers, vector, yaml
     }:
     mkDerivation {
       pname = "gipeda";
       version = "0.1.2.1";
       sha256 = "46a4878cfc863d9ad5aba58774925ed356febf170e22be8721dd3629da312a73";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring cassava containers directory extra filepath
         gitlib gitlib-libgit2 scientific shake split tagged text
         unordered-containers vector yaml
       ];
       homepage = "https://github.com/nomeata/gipeda";
       description = "Git Performance Dashboard";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gipeda_0_2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cassava, containers
     , directory, extra, filepath, gitlib, gitlib-libgit2, scientific
     , shake, split, tagged, text, unordered-containers, vector, yaml
     }:
     mkDerivation {
       pname = "gipeda";
       version = "0.2";
       sha256 = "ed227acff488ef7778ee9cc78fa3ec5e10edae19ea8ade79440033e29e83f82e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring cassava containers directory extra filepath
         gitlib gitlib-libgit2 scientific shake split tagged text
         unordered-containers vector yaml
       ];
       homepage = "https://github.com/nomeata/gipeda";
       description = "Git Performance Dashboard";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gipeda" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cassava, containers
     , directory, extra, filepath, gitlib, gitlib-libgit2, scientific
     , shake, split, tagged, text, unordered-containers, vector, yaml
     }:
     mkDerivation {
       pname = "gipeda";
       version = "0.2.0.1";
       sha256 = "8b2e6d06a7392b5ce4956a97aa6102213b790e575516c74feeaed371e0f7e12e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring cassava containers directory extra filepath
         gitlib gitlib-libgit2 scientific shake split tagged text
         unordered-containers vector yaml
       ];
       homepage = "https://github.com/nomeata/gipeda";
       description = "Git Performance Dashboard";
       license = stdenv.lib.licenses.mit;
     }) {};

  "gist" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, http-conduit
     , text
     }:
     mkDerivation {
       pname = "gist";
       version = "0.1";
       sha256 = "817a3ff4fa8a57047fd5960d1a63a71998d2d9b3be641bfa346c490cd483edc9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring conduit http-conduit text
       ];
       jailbreak = true;
       homepage = "http://github.com/simonmichael/gist";
       description = "A reliable command-line client for gist.github.com";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "git-all" = callPackage
    ({ mkDerivation, base, cmdargs, hslogger, parallel-io, regex-posix
     , shelly, system-fileio, system-filepath, text, transformers, unix
     }:
     mkDerivation {
       pname = "git-all";
       version = "1.5.0";
       sha256 = "7f30de421293f76b735ac70da794a4104c7fbde18bf4a254f43520cb6b76db71";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs hslogger parallel-io regex-posix shelly system-fileio
         system-filepath text transformers unix
       ];
       homepage = "https://github.com/jwiegley/git-all";
       description = "Determine which Git repositories need actions to be taken";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "git-annex_5_20150727" = callPackage
    ({ mkDerivation, aeson, async, aws, base, blaze-builder
     , bloomfilter, bup, byteable, bytestring, case-insensitive
     , clientsession, conduit, conduit-extra, containers, crypto-api
     , cryptohash, curl, data-default, DAV, dbus, directory, dlist, dns
     , edit-distance, esqueleto, exceptions, fdo-notify, feed, filepath
     , git, gnupg, gnutls, hinotify, hslogger, http-client, http-conduit
     , http-types, IfElse, json, lsof, MissingH, monad-control
     , monad-logger, mtl, network, network-info, network-multicast
     , network-protocol-xmpp, network-uri, old-locale, openssh
     , optparse-applicative, path-pieces, perl, persistent
     , persistent-sqlite, persistent-template, process, QuickCheck
     , random, regex-tdfa, resourcet, rsync, SafeSemaphore, sandi
     , securemem, shakespeare, stm, tasty, tasty-hunit, tasty-quickcheck
     , tasty-rerun, template-haskell, text, time, torrent, transformers
     , unix, unix-compat, utf8-string, uuid, wai, wai-extra, warp
     , warp-tls, wget, which, xml-types, yesod, yesod-core
     , yesod-default, yesod-form, yesod-static
     }:
     mkDerivation {
       pname = "git-annex";
       version = "5.20150727";
       sha256 = "9826836bd0eb4e35be8664862405afbf2ff4dff9a643b2f8ec61c295bd16099f";
       revision = "1";
       editedCabalFile = "a9a36ed856cc4b973682e147a107ade4b55542f832c655445c4f2da570398840";
       configureFlags = [
         "-fassistant" "-fcryptonite" "-fdbus" "-fdesktopnotify" "-fdns"
         "-ffeed" "-finotify" "-fpairing" "-fproduction" "-fquvi" "-fs3"
         "-ftahoe" "-ftdfa" "-ftestsuite" "-ftorrentparser" "-fwebapp"
         "-fwebapp-secure" "-fwebdav" "-fxmpp"
       ];
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson async aws base blaze-builder bloomfilter byteable bytestring
         case-insensitive clientsession conduit conduit-extra containers
         crypto-api cryptohash data-default DAV dbus directory dlist dns
         edit-distance esqueleto exceptions fdo-notify feed filepath gnutls
         hinotify hslogger http-client http-conduit http-types IfElse json
         MissingH monad-control monad-logger mtl network network-info
         network-multicast network-protocol-xmpp network-uri old-locale
         optparse-applicative path-pieces persistent persistent-sqlite
         persistent-template process QuickCheck random regex-tdfa resourcet
         SafeSemaphore sandi securemem shakespeare stm tasty tasty-hunit
         tasty-quickcheck tasty-rerun template-haskell text time torrent
         transformers unix unix-compat utf8-string uuid wai wai-extra warp
         warp-tls xml-types yesod yesod-core yesod-default yesod-form
         yesod-static
       ];
       executableSystemDepends = [
         bup curl git gnupg lsof openssh perl rsync wget which
       ];
       jailbreak = true;
       preConfigure = "export HOME=$TEMPDIR; patchShebangs .";
       postBuild = "ln -sf dist/build/git-annex/git-annex git-annex";
       installPhase = "make PREFIX=$out CABAL=./Setup BUILDER=./Setup install";
       checkPhase = "./git-annex test";
       enableSharedExecutables = false;
       homepage = "http://git-annex.branchable.com/";
       description = "manage files with git, without checking their contents into git";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {inherit (pkgs) bup; inherit (pkgs) curl; inherit (pkgs) git; 
         inherit (pkgs) gnupg; inherit (pkgs) lsof; inherit (pkgs) openssh; 
         inherit (pkgs) perl; inherit (pkgs) rsync; inherit (pkgs) wget; 
         inherit (pkgs) which;};

  "git-annex_5_20151218" = callPackage
    ({ mkDerivation, aeson, async, aws, base, blaze-builder
     , bloomfilter, bup, byteable, bytestring, case-insensitive
     , clientsession, concurrent-output, conduit, conduit-extra
     , containers, crypto-api, cryptonite, curl, data-default, DAV, dbus
     , directory, dlist, dns, edit-distance, esqueleto, exceptions
     , fdo-notify, feed, filepath, git, gnupg, gnutls, hinotify
     , hslogger, http-client, http-conduit, http-types, IfElse, json
     , lsof, MissingH, monad-control, monad-logger, mtl, network
     , network-info, network-multicast, network-protocol-xmpp
     , network-uri, old-locale, openssh, optparse-applicative
     , path-pieces, perl, persistent, persistent-sqlite
     , persistent-template, process, QuickCheck, random, regex-tdfa
     , resourcet, rsync, SafeSemaphore, sandi, securemem, shakespeare
     , stm, tasty, tasty-hunit, tasty-quickcheck, tasty-rerun
     , template-haskell, text, time, torrent, transformers, unix
     , unix-compat, utf8-string, uuid, wai, wai-extra, warp, warp-tls
     , wget, which, xml-types, yesod, yesod-core, yesod-default
     , yesod-form, yesod-static
     }:
     mkDerivation {
       pname = "git-annex";
       version = "5.20151218";
       sha256 = "d8aed73cbc1d1eefcbe6de7790c83f1d6458b4ac1e910d9a34b22782d16142ca";
       configureFlags = [
         "-fassistant" "-fcryptonite" "-fdbus" "-fdesktopnotify" "-fdns"
         "-ffeed" "-finotify" "-fpairing" "-fproduction" "-fquvi" "-fs3"
         "-ftahoe" "-ftdfa" "-ftestsuite" "-ftorrentparser" "-fwebapp"
         "-fwebapp-secure" "-fwebdav" "-fxmpp"
       ];
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson async aws base blaze-builder bloomfilter byteable bytestring
         case-insensitive clientsession concurrent-output conduit
         conduit-extra containers crypto-api cryptonite data-default DAV
         dbus directory dlist dns edit-distance esqueleto exceptions
         fdo-notify feed filepath gnutls hinotify hslogger http-client
         http-conduit http-types IfElse json MissingH monad-control
         monad-logger mtl network network-info network-multicast
         network-protocol-xmpp network-uri old-locale optparse-applicative
         path-pieces persistent persistent-sqlite persistent-template
         process QuickCheck random regex-tdfa resourcet SafeSemaphore sandi
         securemem shakespeare stm tasty tasty-hunit tasty-quickcheck
         tasty-rerun template-haskell text time torrent transformers unix
         unix-compat utf8-string uuid wai wai-extra warp warp-tls xml-types
         yesod yesod-core yesod-default yesod-form yesod-static
       ];
       executableSystemDepends = [
         bup curl git gnupg lsof openssh perl rsync wget which
       ];
       preConfigure = "export HOME=$TEMPDIR; patchShebangs .";
       postBuild = "ln -sf dist/build/git-annex/git-annex git-annex";
       installPhase = "make PREFIX=$out CABAL=./Setup BUILDER=./Setup install";
       checkPhase = "./git-annex test";
       enableSharedExecutables = false;
       homepage = "http://git-annex.branchable.com/";
       description = "manage files with git, without checking their contents into git";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {inherit (pkgs) bup; inherit (pkgs) curl; inherit (pkgs) git; 
         inherit (pkgs) gnupg; inherit (pkgs) lsof; inherit (pkgs) openssh; 
         inherit (pkgs) perl; inherit (pkgs) rsync; inherit (pkgs) wget; 
         inherit (pkgs) which;};

  "git-annex_6_20160114" = callPackage
    ({ mkDerivation, aeson, async, aws, base, blaze-builder
     , bloomfilter, bup, byteable, bytestring, case-insensitive
     , clientsession, concurrent-output, conduit, conduit-extra
     , containers, crypto-api, cryptonite, curl, data-default, DAV, dbus
     , directory, dlist, dns, edit-distance, esqueleto, exceptions
     , fdo-notify, feed, filepath, git, gnupg, gnutls, hinotify
     , hslogger, http-client, http-conduit, http-types, IfElse, json
     , lsof, MissingH, monad-control, monad-logger, mtl, network
     , network-info, network-multicast, network-protocol-xmpp
     , network-uri, old-locale, openssh, optparse-applicative
     , path-pieces, perl, persistent, persistent-sqlite
     , persistent-template, process, QuickCheck, random, regex-tdfa
     , resourcet, rsync, SafeSemaphore, sandi, securemem, shakespeare
     , stm, tasty, tasty-hunit, tasty-quickcheck, tasty-rerun
     , template-haskell, text, time, torrent, transformers, unix
     , unix-compat, utf8-string, uuid, wai, wai-extra, warp, warp-tls
     , wget, which, xml-types, yesod, yesod-core, yesod-default
     , yesod-form, yesod-static
     }:
     mkDerivation {
       pname = "git-annex";
       version = "6.20160114";
       sha256 = "671d165f9ea583b9a86060b60741c6aa54dbfde0673a2b278d82d761b7500181";
       configureFlags = [
         "-fassistant" "-fcryptonite" "-fdbus" "-fdesktopnotify" "-fdns"
         "-ffeed" "-finotify" "-fpairing" "-fproduction" "-fquvi" "-fs3"
         "-ftahoe" "-ftdfa" "-ftestsuite" "-ftorrentparser" "-fwebapp"
         "-fwebapp-secure" "-fwebdav" "-fxmpp"
       ];
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson async aws base blaze-builder bloomfilter byteable bytestring
         case-insensitive clientsession concurrent-output conduit
         conduit-extra containers crypto-api cryptonite data-default DAV
         dbus directory dlist dns edit-distance esqueleto exceptions
         fdo-notify feed filepath gnutls hinotify hslogger http-client
         http-conduit http-types IfElse json MissingH monad-control
         monad-logger mtl network network-info network-multicast
         network-protocol-xmpp network-uri old-locale optparse-applicative
         path-pieces persistent persistent-sqlite persistent-template
         process QuickCheck random regex-tdfa resourcet SafeSemaphore sandi
         securemem shakespeare stm tasty tasty-hunit tasty-quickcheck
         tasty-rerun template-haskell text time torrent transformers unix
         unix-compat utf8-string uuid wai wai-extra warp warp-tls xml-types
         yesod yesod-core yesod-default yesod-form yesod-static
       ];
       executableSystemDepends = [
         bup curl git gnupg lsof openssh perl rsync wget which
       ];
       preConfigure = "export HOME=$TEMPDIR; patchShebangs .";
       postBuild = "ln -sf dist/build/git-annex/git-annex git-annex";
       installPhase = "make PREFIX=$out CABAL=./Setup BUILDER=./Setup install";
       checkPhase = "./git-annex test";
       enableSharedExecutables = false;
       homepage = "http://git-annex.branchable.com/";
       description = "manage files with git, without checking their contents into git";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {inherit (pkgs) bup; inherit (pkgs) curl; inherit (pkgs) git; 
         inherit (pkgs) gnupg; inherit (pkgs) lsof; inherit (pkgs) openssh; 
         inherit (pkgs) perl; inherit (pkgs) rsync; inherit (pkgs) wget; 
         inherit (pkgs) which;};

  "git-annex" = callPackage
    ({ mkDerivation, aeson, async, aws, base, blaze-builder
     , bloomfilter, bup, byteable, bytestring, case-insensitive
     , clientsession, concurrent-output, conduit, conduit-extra
     , containers, crypto-api, cryptonite, curl, data-default, DAV, dbus
     , directory, dlist, dns, edit-distance, esqueleto, exceptions
     , fdo-notify, feed, filepath, git, gnupg, gnutls, hinotify
     , hslogger, http-client, http-conduit, http-types, IfElse, json
     , lsof, magic, MissingH, monad-control, monad-logger, mtl, network
     , network-info, network-multicast, network-protocol-xmpp
     , network-uri, old-locale, openssh, optparse-applicative
     , path-pieces, perl, persistent, persistent-sqlite
     , persistent-template, process, QuickCheck, random, regex-tdfa
     , resourcet, rsync, SafeSemaphore, sandi, securemem, shakespeare
     , stm, tasty, tasty-hunit, tasty-quickcheck, tasty-rerun
     , template-haskell, text, time, torrent, transformers, unix
     , unix-compat, utf8-string, uuid, wai, wai-extra, warp, warp-tls
     , wget, which, xml-types, yesod, yesod-core, yesod-default
     , yesod-form, yesod-static
     }:
     mkDerivation {
       pname = "git-annex";
       version = "6.20160211";
       sha256 = "0a7d2dab17df27c06a935c469ced47a68d3c018cbb9254c9a735b584d413fb42";
       configureFlags = [
         "-fassistant" "-fcryptonite" "-fdbus" "-fdesktopnotify" "-fdns"
         "-ffeed" "-finotify" "-fpairing" "-fproduction" "-fquvi" "-fs3"
         "-ftahoe" "-ftdfa" "-ftestsuite" "-ftorrentparser" "-fwebapp"
         "-fwebapp-secure" "-fwebdav" "-fxmpp"
       ];
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson async aws base blaze-builder bloomfilter byteable bytestring
         case-insensitive clientsession concurrent-output conduit
         conduit-extra containers crypto-api cryptonite data-default DAV
         dbus directory dlist dns edit-distance esqueleto exceptions
         fdo-notify feed filepath gnutls hinotify hslogger http-client
         http-conduit http-types IfElse json magic MissingH monad-control
         monad-logger mtl network network-info network-multicast
         network-protocol-xmpp network-uri old-locale optparse-applicative
         path-pieces persistent persistent-sqlite persistent-template
         process QuickCheck random regex-tdfa resourcet SafeSemaphore sandi
         securemem shakespeare stm tasty tasty-hunit tasty-quickcheck
         tasty-rerun template-haskell text time torrent transformers unix
         unix-compat utf8-string uuid wai wai-extra warp warp-tls xml-types
         yesod yesod-core yesod-default yesod-form yesod-static
       ];
       executableSystemDepends = [
         bup curl git gnupg lsof openssh perl rsync wget which
       ];
       preConfigure = "export HOME=$TEMPDIR; patchShebangs .";
       postBuild = "ln -sf dist/build/git-annex/git-annex git-annex";
       installPhase = "make PREFIX=$out CABAL=./Setup BUILDER=./Setup install";
       checkPhase = "./git-annex test";
       enableSharedExecutables = false;
       homepage = "http://git-annex.branchable.com/";
       description = "manage files with git, without checking their contents into git";
       license = stdenv.lib.licenses.gpl3;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {inherit (pkgs) bup; inherit (pkgs) curl; inherit (pkgs) git; 
         inherit (pkgs) gnupg; inherit (pkgs) lsof; inherit (pkgs) openssh; 
         inherit (pkgs) perl; inherit (pkgs) rsync; inherit (pkgs) wget; 
         inherit (pkgs) which;};

  "git-checklist" = callPackage
    ({ mkDerivation, base, directory, filepath, optparse-applicative
     , parsec, pretty, process
     }:
     mkDerivation {
       pname = "git-checklist";
       version = "1.0.0.0";
       sha256 = "c218a7b14140a33a9dc8aa467b7a03c6ffa7aff6a6b20646994531d9ee5e8ee0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath optparse-applicative parsec pretty process
       ];
       jailbreak = true;
       homepage = "https://github.com/dougalstanton/git-checklist";
       description = "Maintain per-branch checklists in Git";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "git-date" = callPackage
    ({ mkDerivation, base, bytestring, old-locale, QuickCheck
     , test-framework, test-framework-quickcheck2, time, utf8-string
     }:
     mkDerivation {
       pname = "git-date";
       version = "0.2.2";
       sha256 = "94e56e2abd30951ae711a7ff47f3ab2072ebc7cfb14e1bc48711e027cf458d7a";
       libraryHaskellDepends = [ base bytestring time utf8-string ];
       testHaskellDepends = [
         base bytestring old-locale QuickCheck test-framework
         test-framework-quickcheck2 time utf8-string
       ];
       homepage = "https://github.com/singpolyma/git-date-haskell";
       description = "Bindings to the date parsing from Git";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "git-embed" = callPackage
    ({ mkDerivation, base, directory, filepath, process
     , template-haskell
     }:
     mkDerivation {
       pname = "git-embed";
       version = "0.1.0";
       sha256 = "76cbc25c114ec69ab7c291cdca0c1fb703642dce9564d9409afa17e195013d7b";
       libraryHaskellDepends = [
         base directory filepath process template-haskell
       ];
       homepage = "https://github.com/borsboom/git-embed";
       description = "Use TH to embed Git repo information";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "git-fmt" = callPackage
    ({ mkDerivation, base, exceptions, extra, fast-logger, filepath
     , monad-logger, monad-parallel, mtl, omnifmt, optparse-applicative
     , pipes, pipes-concurrency, process, temporary, text, time
     }:
     mkDerivation {
       pname = "git-fmt";
       version = "0.4.1.0";
       sha256 = "a9c10f79f92b6a1650f4eac002542a35dda0048ed68d670602e97615b879e97d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base exceptions extra fast-logger filepath monad-logger
         monad-parallel mtl omnifmt optparse-applicative pipes
         pipes-concurrency process temporary text time
       ];
       homepage = "https://github.com/hjwylde/git-fmt";
       description = "Custom git command for formatting code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "git-freq" = callPackage
    ({ mkDerivation, base, bytestring, containers, hspec, io-streams
     , optparse-applicative, process, text
     }:
     mkDerivation {
       pname = "git-freq";
       version = "0.0.3";
       sha256 = "a237869ac82825596f90169d46ed2b95f16c6350bf53f1861671214c173d3be3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers io-streams optparse-applicative process
         text
       ];
       testHaskellDepends = [
         base bytestring containers hspec io-streams optparse-applicative
         process text
       ];
       homepage = "https://github.com/fujimura/git-freq";
       description = "A Git subcommand to show total addition, deletion per file";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "git-gpush" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , gitlib, gitlib-cmdline, hslogger, old-locale
     , optparse-applicative, shelly, tagged, text, time, transformers
     }:
     mkDerivation {
       pname = "git-gpush";
       version = "3.1.0.1";
       sha256 = "cf8c8058f4f7f280e02d8ebb93e18a08b519c2679c4acc943b74d723842ca98e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory filepath gitlib gitlib-cmdline
         hslogger old-locale optparse-applicative shelly tagged text time
         transformers
       ];
       homepage = "http://github.com/jwiegley/gitlib";
       description = "More intelligent push-to-GitHub utility";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "git-jump" = callPackage
    ({ mkDerivation, base, base-compat, process }:
     mkDerivation {
       pname = "git-jump";
       version = "0.1.0.3";
       sha256 = "5eca5084dd2796d41d1e18d95465016c41b4ea7270d0fc17b769e492bc58e3c2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base base-compat process ];
       jailbreak = true;
       homepage = "https://github.com/Peaker/git-jump";
       description = "Move a git branch";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "git-monitor" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , gitlib, gitlib-libgit2, lifted-async, logging, old-locale
     , optparse-applicative, shelly, tagged, template-haskell, text
     , time, transformers, unix, unordered-containers
     }:
     mkDerivation {
       pname = "git-monitor";
       version = "3.1.1.5";
       sha256 = "52a6c8360c32ad1bfc21dedf03177e36f587412284cb31d4070d066a1b65154b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory filepath gitlib gitlib-libgit2
         lifted-async logging old-locale optparse-applicative shelly tagged
         template-haskell text time transformers unix unordered-containers
       ];
       homepage = "http://github.com/jwiegley/gitlib";
       description = "Passively snapshots working tree changes efficiently";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "git-object" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , bytestring, directory, enumerator, filepath, zlib-enum
     }:
     mkDerivation {
       pname = "git-object";
       version = "0.0.2";
       sha256 = "550631462687e4e1b6b04aa91ad0eaa9abad467b1bf2e0e308cbd4686ca19ac3";
       libraryHaskellDepends = [
         attoparsec attoparsec-enumerator base bytestring directory
         enumerator filepath zlib-enum
       ];
       homepage = "http://www.mew.org/~kazu/";
       description = "Git object and its parser";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "git-repair" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, directory
     , exceptions, filepath, hslogger, IfElse, MissingH, mtl, network
     , network-uri, optparse-applicative, process, QuickCheck, text
     , time, transformers, unix, unix-compat, utf8-string
     }:
     mkDerivation {
       pname = "git-repair";
       version = "1.20151215";
       sha256 = "e1e5756f7ffba86a36abcdc296e0730b2a74e0f5e7711b0b6b89a09eb6f10463";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async base bytestring containers directory exceptions filepath
         hslogger IfElse MissingH mtl network network-uri
         optparse-applicative process QuickCheck text time transformers unix
         unix-compat utf8-string
       ];
       homepage = "http://git-repair.branchable.com/";
       description = "repairs a damanged git repisitory";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "git-sanity" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, machines, machines-io
     , machines-process, process, safe, transformers
     }:
     mkDerivation {
       pname = "git-sanity";
       version = "0.1.0.0";
       sha256 = "82a36d28e63e8f6c0e0f5f110a421817caa60874e1dee12891f95069d5ebdcfb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring machines machines-io machines-process process safe
         transformers
       ];
       executableHaskellDepends = [ base Cabal ];
       jailbreak = true;
       homepage = "github.com/aloiscochard/git-sanity";
       description = "A sanity checker for your git history";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "git-vogue" = callPackage
    ({ mkDerivation, base, bifunctors, Cabal, containers, cpphs, Diff
     , directory, filepath, formatting, ghc-mod, haskell-src-exts, hlint
     , hscolour, hspec, optparse-applicative, process, split, strict
     , stylish-haskell, temporary, text, transformers, unix
     }:
     mkDerivation {
       pname = "git-vogue";
       version = "0.2.1.0";
       sha256 = "cb42012a44e2b106963c3f4ee94dfbd5efba05715eda6753f9b4485e9a45bcd9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory filepath formatting optparse-applicative
         process split text transformers unix
       ];
       executableHaskellDepends = [
         base bifunctors Cabal cpphs Diff directory ghc-mod haskell-src-exts
         hlint hscolour optparse-applicative strict stylish-haskell text
       ];
       testHaskellDepends = [
         base containers directory filepath hspec process temporary
       ];
       jailbreak = true;
       homepage = "https://github.com/oswynb/git-vogue";
       description = "A framework for pre-commit checks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gitHUD" = callPackage
    ({ mkDerivation, base, mtl, parsec, process, tasty, tasty-hunit
     , tasty-quickcheck, tasty-smallcheck, unix
     }:
     mkDerivation {
       pname = "gitHUD";
       version = "1.3.1";
       sha256 = "d770a57be1e746ed39e1c34ae6464ac4fd66599503a8b4e92f1b8a69cf986ccb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl parsec process unix ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base mtl parsec tasty tasty-hunit tasty-quickcheck tasty-smallcheck
       ];
       homepage = "http://github.com/gbataille/gitHUD#readme";
       description = "More efficient replacement to the great git-radar";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gitcache" = callPackage
    ({ mkDerivation, base, cryptohash, directory, filepath, process
     , utf8-string
     }:
     mkDerivation {
       pname = "gitcache";
       version = "0.2";
       sha256 = "fe69fd3f8ec4bff1dfb85d67279d71161c6cf6e6f05fe93df33776162640a56d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cryptohash directory filepath process utf8-string
       ];
       homepage = "https://github.com/vincenthz/gitcache";
       description = "Simple git utility to use and manage clone cache";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gitdo" = callPackage
    ({ mkDerivation, aeson, aeson-lens, base, bytestring, foldl, lens
     , mtl, optparse-applicative, sqlite-simple, system-filepath, text
     , turtle, wreq
     }:
     mkDerivation {
       pname = "gitdo";
       version = "0.1.0.0";
       sha256 = "b4f58c6569168fa04e39685a5a7898bf9da61ec1379e6650cb96e986b350364f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson aeson-lens base bytestring foldl lens mtl
         optparse-applicative sqlite-simple system-filepath text turtle wreq
       ];
       jailbreak = true;
       homepage = "https://github.com/mattyhall/gitdo";
       description = "Create Github issues out of TODO comments in code";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "github_0_14_0" = callPackage
    ({ mkDerivation, aeson, aeson-compat, attoparsec, base, base-compat
     , base16-bytestring, binary, binary-orphans, byteable, bytestring
     , containers, cryptohash, deepseq, deepseq-generics, exceptions
     , file-embed, hashable, hspec, http-client, http-client-tls
     , http-link-header, http-types, iso8601-time, mtl, network-uri
     , semigroups, text, time, transformers, transformers-compat
     , unordered-containers, vector, vector-instances
     }:
     mkDerivation {
       pname = "github";
       version = "0.14.0";
       sha256 = "33309bc81e33238b0cff333098a754aca625458f69c88778d76e62e2287e3685";
       libraryHaskellDepends = [
         aeson aeson-compat attoparsec 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 transformers transformers-compat
         unordered-containers vector vector-instances
       ];
       testHaskellDepends = [
         aeson-compat base base-compat file-embed hspec unordered-containers
         vector
       ];
       homepage = "https://github.com/phadej/github";
       description = "Access to the GitHub API, v3";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "github" = callPackage
    ({ mkDerivation, aeson, aeson-compat, attoparsec, base, base-compat
     , base16-bytestring, binary, binary-orphans, byteable, bytestring
     , containers, cryptohash, deepseq, deepseq-generics, exceptions
     , file-embed, hashable, hspec, http-client, http-client-tls
     , http-link-header, http-types, iso8601-time, mtl, network-uri
     , semigroups, text, time, transformers, transformers-compat
     , unordered-containers, vector, vector-instances
     }:
     mkDerivation {
       pname = "github";
       version = "0.14.1";
       sha256 = "fcd5f8957855e4a110db2dc411916309fd7afb7105534ebe378a5698f409fa7d";
       revision = "1";
       editedCabalFile = "a03fc2c579eb4451933e82486f705a81480c030eb17c47c4bccd07fb1e302584";
       libraryHaskellDepends = [
         aeson aeson-compat attoparsec 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 transformers transformers-compat
         unordered-containers vector vector-instances
       ];
       testHaskellDepends = [
         aeson-compat base base-compat file-embed hspec unordered-containers
         vector
       ];
       homepage = "https://github.com/phadej/github";
       description = "Access to the GitHub API, v3";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "github-backup" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory
     , exceptions, filepath, git, github, hslogger, IfElse, MissingH
     , mtl, network, network-uri, optparse-applicative, pretty-show
     , process, text, transformers, unix, unix-compat
     }:
     mkDerivation {
       pname = "github-backup";
       version = "1.20160207";
       sha256 = "7502179fe38bc00b21f9352a013334bfb9ca51488854bd9c01092cedf2330c64";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory exceptions filepath github
         hslogger IfElse MissingH mtl network network-uri
         optparse-applicative pretty-show process text transformers unix
         unix-compat
       ];
       executableToolDepends = [ git ];
       jailbreak = true;
       homepage = "https://github.com/joeyh/github-backup";
       description = "backs up everything github knows about a repository, to the repository";
       license = stdenv.lib.licenses.gpl3;
     }) {inherit (pkgs) git;};

  "github-post-receive" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , email-validate, http-types, text, wai, wai-logger, warp
     }:
     mkDerivation {
       pname = "github-post-receive";
       version = "1.2.0.1";
       sha256 = "1898710f45cce786e9ea8b252b4052d3b6a2d91ccd70c3ac567cf4916d4e6d93";
       libraryHaskellDepends = [
         aeson base bytestring containers email-validate http-types text wai
         wai-logger warp
       ];
       homepage = "https://github.com/amutake/github-post-receive";
       description = "GitHub webhooks library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "github-types" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, hspec, hspec-smallcheck
     , http-conduit, smallcheck, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "github-types";
       version = "0.2.0";
       sha256 = "3f3675dff4076ddc64021bb5cbe89e5b609c65d2f08463a3d12d760b779ee4d8";
       libraryHaskellDepends = [ aeson base text time ];
       testHaskellDepends = [
         aeson aeson-pretty base hspec hspec-smallcheck http-conduit
         smallcheck text time unordered-containers vector
       ];
       description = "Type definitions for objects used by the GitHub v3 API";
       license = "unknown";
     }) {};

  "github-utils" = callPackage
    ({ mkDerivation, base, basic-prelude, github, text }:
     mkDerivation {
       pname = "github-utils";
       version = "0.1.0";
       sha256 = "458940e4566ef14b14d6700e2fd581e99f115b6f6ce31d085b293cac7e0eefb4";
       libraryHaskellDepends = [ base basic-prelude github text ];
       jailbreak = true;
       homepage = "https://github.com/greenrd/github-utils";
       description = "Useful functions that use the GitHub API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "github-webhook-handler" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cryptohash, github-types
     , text, transformers, uuid, vector
     }:
     mkDerivation {
       pname = "github-webhook-handler";
       version = "0.0.7";
       sha256 = "b80ff37df283fe72e9b933b05aa4159adba8aac4ae242bbd78e40ddd45f8cce0";
       libraryHaskellDepends = [
         aeson base bytestring cryptohash github-types text transformers
         uuid vector
       ];
       description = "GitHub WebHook Handler";
       license = stdenv.lib.licenses.mit;
     }) {};

  "github-webhook-handler-snap" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, github-types
     , github-webhook-handler, snap-core, uuid
     }:
     mkDerivation {
       pname = "github-webhook-handler-snap";
       version = "0.0.6";
       sha256 = "ec62b61aeb429492b347ed327b14a4c1bcf44d3791ac61ee6989f8a0a608a80e";
       libraryHaskellDepends = [
         base bytestring case-insensitive github-types
         github-webhook-handler snap-core uuid
       ];
       description = "GitHub WebHook Handler implementation for Snap";
       license = stdenv.lib.licenses.mit;
     }) {};

  "gitignore" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , http-conduit, network, safe, text
     }:
     mkDerivation {
       pname = "gitignore";
       version = "1.0.1";
       sha256 = "14bf2fb4a56ec53514986536c1b63bd5c0b1404f5c9f7b7d645cf7733585520f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base base64-bytestring bytestring http-conduit network safe
         text
       ];
       jailbreak = true;
       homepage = "https://github.com/relrod/gitignore";
       description = "Apply GitHub .gitignore templates to already existing repositories.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gitit" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, blaze-html
     , bytestring, ConfigFile, containers, directory, feed, filepath
     , filestore, ghc, ghc-paths, happstack-server, highlighting-kate
     , hoauth2, hslogger, HStringTemplate, HTTP, http-client-tls
     , http-conduit, json, mtl, network, network-uri, old-locale
     , old-time, pandoc, pandoc-types, parsec, pretty, process, random
     , recaptcha, safe, SHA, split, syb, tagsoup, text, time, uri, url
     , utf8-string, uuid, xhtml, xml, xss-sanitize, zlib
     }:
     mkDerivation {
       pname = "gitit";
       version = "0.12.1";
       sha256 = "c2cf094e7553e1ad6eefe59b4b7d924fe42f31dd51545193b56bcd0596f57d73";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base64-bytestring blaze-html bytestring ConfigFile
         containers directory feed filepath filestore ghc ghc-paths
         happstack-server highlighting-kate hoauth2 hslogger HStringTemplate
         HTTP http-client-tls http-conduit json mtl network network-uri
         old-locale old-time pandoc pandoc-types parsec pretty process
         random recaptcha safe SHA split syb tagsoup text time uri url
         utf8-string uuid xhtml xml xss-sanitize zlib
       ];
       executableHaskellDepends = [
         base bytestring directory filepath hslogger HTTP mtl network
         network-uri syb url utf8-string
       ];
       homepage = "http://gitit.net";
       description = "Wiki using happstack, git or darcs, and pandoc";
       license = "GPL";
     }) {};

  "gitlib_3_1_0_1" = callPackage
    ({ mkDerivation, base, base16-bytestring, bytestring, conduit
     , conduit-combinators, containers, directory, exceptions, filepath
     , hashable, lifted-async, lifted-base, monad-control, monad-logger
     , mtl, resourcet, semigroups, system-filepath, tagged, text, time
     , transformers, unix, unordered-containers
     }:
     mkDerivation {
       pname = "gitlib";
       version = "3.1.0.1";
       sha256 = "4ff0dae4f23498d5a7ef841b522250345a7eb1ea869795b8b68359b43acfcd40";
       libraryHaskellDepends = [
         base base16-bytestring bytestring conduit conduit-combinators
         containers directory exceptions filepath hashable lifted-async
         lifted-base monad-control monad-logger mtl resourcet semigroups
         system-filepath tagged text time transformers unix
         unordered-containers
       ];
       description = "API library for working with Git repositories";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gitlib_3_1_0_2" = callPackage
    ({ mkDerivation, base, base16-bytestring, bytestring, conduit
     , conduit-combinators, containers, directory, exceptions, filepath
     , hashable, lifted-async, lifted-base, monad-control, monad-logger
     , mtl, resourcet, semigroups, tagged, text, time, transformers
     , unix, unordered-containers
     }:
     mkDerivation {
       pname = "gitlib";
       version = "3.1.0.2";
       sha256 = "5071d6fd8a2e791d7e78c61d86eb0b386c6995b4291bfed7e85a0401b4888516";
       libraryHaskellDepends = [
         base base16-bytestring bytestring conduit conduit-combinators
         containers directory exceptions filepath hashable lifted-async
         lifted-base monad-control monad-logger mtl resourcet semigroups
         tagged text time transformers unix unordered-containers
       ];
       description = "API library for working with Git repositories";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gitlib" = callPackage
    ({ mkDerivation, base, base16-bytestring, bytestring, conduit
     , conduit-combinators, containers, directory, exceptions, filepath
     , hashable, lifted-async, lifted-base, monad-control, mtl
     , resourcet, semigroups, tagged, text, time, transformers, unix
     , unordered-containers
     }:
     mkDerivation {
       pname = "gitlib";
       version = "3.1.1";
       sha256 = "dd68758b62fb0ca52f3ed851d2e68779770b1d83f2dd846528c3538aabf395ef";
       libraryHaskellDepends = [
         base base16-bytestring bytestring conduit conduit-combinators
         containers directory exceptions filepath hashable lifted-async
         lifted-base monad-control mtl resourcet semigroups tagged text time
         transformers unix unordered-containers
       ];
       description = "API library for working with Git repositories";
       license = stdenv.lib.licenses.mit;
     }) {};

  "gitlib-cmdline" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-combinators
     , containers, directory, exceptions, gitlib, gitlib-test, hspec
     , hspec-expectations, monad-control, mtl, old-locale, parsec
     , process-extras, shelly, system-filepath, tagged, text, time
     , time-locale-compat, transformers, transformers-base
     , unordered-containers
     }:
     mkDerivation {
       pname = "gitlib-cmdline";
       version = "3.1.0.2";
       sha256 = "13dc42fc66f1a99519b7efb818f00cb6b820e806487daa533680d762f46d31b7";
       libraryHaskellDepends = [
         base bytestring conduit conduit-combinators containers directory
         exceptions gitlib monad-control mtl old-locale parsec
         process-extras shelly system-filepath tagged text time
         time-locale-compat transformers transformers-base
         unordered-containers
       ];
       testHaskellDepends = [
         base gitlib gitlib-test hspec hspec-expectations system-filepath
         tagged text transformers
       ];
       description = "Gitlib repository backend that uses the git command-line tool";
       license = stdenv.lib.licenses.mit;
     }) {};

  "gitlib-cross" = callPackage
    ({ mkDerivation, base, gitlib, gitlib-cmdline, gitlib-libgit2
     , gitlib-test, hspec, hspec-expectations, HUnit
     }:
     mkDerivation {
       pname = "gitlib-cross";
       version = "3.1.0";
       sha256 = "30c4418f394ffe0db3ff4de627a08b19aaab9c5ad79f997421ca2da7e6994c45";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base gitlib gitlib-cmdline gitlib-libgit2 gitlib-test hspec
         hspec-expectations HUnit
       ];
       description = "Run tests between repositories";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gitlib-libgit2_3_1_0_3" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-combinators
     , containers, directory, exceptions, fast-logger, filepath, gitlib
     , gitlib-test, hlibgit2, hspec, hspec-expectations, HUnit
     , lifted-async, lifted-base, missing-foreign, mmorph, monad-control
     , monad-logger, monad-loops, mtl, resourcet, stm, stm-conduit
     , tagged, template-haskell, text, text-icu, time, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "gitlib-libgit2";
       version = "3.1.0.3";
       sha256 = "d1e566fed1a6c9e09112fbbd0c8882c5d49a026907a15d8d7c05a89e6df194a6";
       libraryHaskellDepends = [
         base bytestring conduit conduit-combinators containers directory
         exceptions fast-logger filepath gitlib hlibgit2 lifted-async
         lifted-base missing-foreign mmorph monad-control monad-logger
         monad-loops mtl resourcet stm stm-conduit tagged template-haskell
         text text-icu time transformers transformers-base
       ];
       testHaskellDepends = [
         base exceptions gitlib gitlib-test hspec hspec-expectations HUnit
         monad-logger transformers
       ];
       description = "Libgit2 backend for gitlib";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gitlib-libgit2_3_1_0_4" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-combinators
     , containers, directory, exceptions, fast-logger, filepath, gitlib
     , gitlib-test, hlibgit2, hspec, hspec-expectations, HUnit
     , lifted-async, lifted-base, mmorph, monad-control, monad-logger
     , monad-loops, mtl, resourcet, stm, stm-conduit, tagged
     , template-haskell, text, text-icu, time, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "gitlib-libgit2";
       version = "3.1.0.4";
       sha256 = "67bb3df054b7c0840de0876c60832a08da84c011bbc1ef6f26652edf85a8a718";
       libraryHaskellDepends = [
         base bytestring conduit conduit-combinators containers directory
         exceptions fast-logger filepath gitlib hlibgit2 lifted-async
         lifted-base mmorph monad-control monad-logger monad-loops mtl
         resourcet stm stm-conduit tagged template-haskell text text-icu
         time transformers transformers-base
       ];
       testHaskellDepends = [
         base exceptions gitlib gitlib-test hspec hspec-expectations HUnit
         monad-logger transformers
       ];
       description = "Libgit2 backend for gitlib";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gitlib-libgit2_3_1_0_5" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-combinators
     , containers, directory, exceptions, fast-logger, filepath, gitlib
     , gitlib-test, hlibgit2, hspec, hspec-expectations, HUnit
     , lifted-async, lifted-base, mmorph, monad-control, monad-logger
     , monad-loops, mtl, resourcet, stm, stm-conduit, tagged
     , template-haskell, text, text-icu, time, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "gitlib-libgit2";
       version = "3.1.0.5";
       sha256 = "25c1f6e630c02245f31d4767b9f1b03e58e2707de93f7c5c07ed502e8f9edff6";
       libraryHaskellDepends = [
         base bytestring conduit conduit-combinators containers directory
         exceptions fast-logger filepath gitlib hlibgit2 lifted-async
         lifted-base mmorph monad-control monad-logger monad-loops mtl
         resourcet stm stm-conduit tagged template-haskell text text-icu
         time transformers transformers-base
       ];
       testHaskellDepends = [
         base exceptions gitlib gitlib-test hspec hspec-expectations HUnit
         monad-logger transformers
       ];
       description = "Libgit2 backend for gitlib";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gitlib-libgit2" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-combinators
     , containers, directory, exceptions, fast-logger, filepath, gitlib
     , gitlib-test, hlibgit2, hspec, hspec-expectations, HUnit
     , lifted-async, lifted-base, mmorph, monad-control, monad-loops
     , mtl, resourcet, stm, stm-conduit, tagged, template-haskell, text
     , text-icu, time, transformers, transformers-base
     }:
     mkDerivation {
       pname = "gitlib-libgit2";
       version = "3.1.1";
       sha256 = "fc2806ebc1bb51f5043a0d5091c5045be40bf82cae3296213b353507b8c868bb";
       libraryHaskellDepends = [
         base bytestring conduit conduit-combinators containers directory
         exceptions fast-logger filepath gitlib hlibgit2 lifted-async
         lifted-base mmorph monad-control monad-loops mtl resourcet stm
         stm-conduit tagged template-haskell text text-icu time transformers
         transformers-base
       ];
       testHaskellDepends = [
         base exceptions gitlib gitlib-test hspec hspec-expectations HUnit
         transformers
       ];
       description = "Libgit2 backend for gitlib";
       license = stdenv.lib.licenses.mit;
     }) {};

  "gitlib-s3" = callPackage
    ({ mkDerivation, aeson, attempt, aws, base, bifunctors, binary
     , bytestring, conduit, conduit-combinators, data-default, directory
     , exceptions, filepath, ghc-prim, gitlib, gitlib-libgit2
     , gitlib-test, hlibgit2, hspec, hspec-expectations, http-conduit
     , HUnit, lens, lifted-base, monad-control, monad-logger, resourcet
     , retry, split, stm, template-haskell, temporary, text, time
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "gitlib-s3";
       version = "3.1.0.1";
       sha256 = "1559a3d7a3716a0f4f34cc2089e73eb08ba6f01e91e6603125f21e6f9b119ded";
       libraryHaskellDepends = [
         aeson attempt aws base bifunctors binary bytestring conduit
         conduit-combinators data-default directory exceptions filepath
         ghc-prim gitlib gitlib-libgit2 hlibgit2 http-conduit lens
         lifted-base monad-control monad-logger resourcet retry split stm
         template-haskell text time transformers unordered-containers
       ];
       testHaskellDepends = [
         aws base data-default directory exceptions filepath gitlib
         gitlib-libgit2 gitlib-test hlibgit2 hspec hspec-expectations HUnit
         monad-logger resourcet temporary text transformers
       ];
       description = "Gitlib repository backend for storing Git objects in Amazon S3";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gitlib-sample" = callPackage
    ({ mkDerivation, base, exceptions, gitlib, mtl, transformers }:
     mkDerivation {
       pname = "gitlib-sample";
       version = "3.1.0";
       sha256 = "acbad8151ca6e337ec03cf946f7fe7e8cf27dfca4d06eef8ab33e4d9a7f6a3df";
       libraryHaskellDepends = [
         base exceptions gitlib mtl transformers
       ];
       description = "Sample backend for gitlib showing the basic structure for any backend";
       license = stdenv.lib.licenses.mit;
     }) {};

  "gitlib-test_3_1_0_2" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-combinators
     , exceptions, gitlib, hspec, hspec-expectations, HUnit
     , monad-control, tagged, text, time, transformers
     }:
     mkDerivation {
       pname = "gitlib-test";
       version = "3.1.0.2";
       sha256 = "424d5f505928aad7b0db2abdd9a527c7f69c31e3d4e2a9bb76e50d19ae03de5a";
       libraryHaskellDepends = [
         base bytestring conduit conduit-combinators exceptions gitlib hspec
         hspec-expectations HUnit monad-control tagged text time
         transformers
       ];
       description = "Test library for confirming gitlib backend compliance";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gitlib-test" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-combinators
     , exceptions, gitlib, hspec, hspec-expectations, HUnit
     , monad-control, tagged, text, time, transformers
     }:
     mkDerivation {
       pname = "gitlib-test";
       version = "3.1.0.3";
       sha256 = "fe0abfa269dabd63d60f856db0a82c88d6bd059de1d4d84dccaf846a1a38291f";
       libraryHaskellDepends = [
         base bytestring conduit conduit-combinators exceptions gitlib hspec
         hspec-expectations HUnit monad-control tagged text time
         transformers
       ];
       description = "Test library for confirming gitlib backend compliance";
       license = stdenv.lib.licenses.mit;
     }) {};

  "gitlib-utils" = callPackage
    ({ mkDerivation, base, bytestring, conduit, data-default, failure
     , gitlib, hex, lifted-base, system-fileio, system-filepath, tagged
     , text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "gitlib-utils";
       version = "1.2.0";
       sha256 = "166a6e4c709319aedb314515a04300ba0586a815c4a78cf181931a47eb533b20";
       libraryHaskellDepends = [
         base bytestring conduit data-default failure gitlib hex lifted-base
         system-fileio system-filepath tagged text transformers
         unordered-containers
       ];
       description = "Generic utility functions for working with Git repositories";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gitrev_1_0_0" = callPackage
    ({ mkDerivation, base, directory, filepath, process
     , template-haskell
     }:
     mkDerivation {
       pname = "gitrev";
       version = "1.0.0";
       sha256 = "cd592849e91bbe1008e5289c64092f5be8cfbef0a921a59a2e36b52f2ffc5d16";
       libraryHaskellDepends = [
         base directory filepath process template-haskell
       ];
       homepage = "https://github.com/acfoltzer/gitrev";
       description = "Compile git revision info into Haskell projects";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gitrev_1_1_0" = callPackage
    ({ mkDerivation, base, directory, filepath, process
     , template-haskell
     }:
     mkDerivation {
       pname = "gitrev";
       version = "1.1.0";
       sha256 = "aabc77851c0de49bd3495fb2cf933170a5d566a19cfb230e1cc758f5775de120";
       libraryHaskellDepends = [
         base directory filepath process template-haskell
       ];
       homepage = "https://github.com/acfoltzer/gitrev";
       description = "Compile git revision info into Haskell projects";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gitrev" = callPackage
    ({ mkDerivation, base, directory, filepath, process
     , template-haskell
     }:
     mkDerivation {
       pname = "gitrev";
       version = "1.2.0";
       sha256 = "4391e34edb5caaab901c6faa4369b246b6896c747869f6ab85b6db5524003102";
       libraryHaskellDepends = [
         base directory filepath process template-haskell
       ];
       homepage = "https://github.com/acfoltzer/gitrev";
       description = "Compile git revision info into Haskell projects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gitson" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, directory
     , doctest, errors, filepath, flock, Glob, hspec, monad-control
     , process, transformers
     }:
     mkDerivation {
       pname = "gitson";
       version = "0.5.1";
       sha256 = "5efabd7b86a7866bb5179a298bccf3492b814e4c69d1b8073c63b1c1e615b29c";
       libraryHaskellDepends = [
         aeson aeson-pretty base bytestring directory errors filepath flock
         monad-control process transformers
       ];
       testHaskellDepends = [
         aeson base directory doctest Glob hspec process transformers
       ];
       doCheck = false;
       homepage = "https://github.com/myfreeweb/gitson";
       description = "A document store library for Git + JSON";
       license = "unknown";
     }) {};

  "gitter" = callPackage
    ({ mkDerivation, aeson, base, bytestring, exceptions, lens
     , lens-aeson, mtl, text, wreq
     }:
     mkDerivation {
       pname = "gitter";
       version = "0.0.0.1";
       sha256 = "cc755243b8be4a235aaf8ed3dc4aa6d1b5dcecf602c3457131ac96e6bd665a97";
       libraryHaskellDepends = [
         aeson base bytestring exceptions lens lens-aeson mtl text wreq
       ];
       jailbreak = true;
       description = "Gitter.im API client";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "gl_0_6_1" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, fixed, half
     , hxt, mesa, split, transformers
     }:
     mkDerivation {
       pname = "gl";
       version = "0.6.1";
       sha256 = "7e3cbd45fc5c6470e6ef329c5319a776936ec3fec5b81ccbdfe625732d5f1a73";
       libraryHaskellDepends = [
         base containers directory filepath fixed half hxt split
         transformers
       ];
       librarySystemDepends = [ mesa ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       description = "Complete OpenGL raw bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mesa;};

  "gl_0_6_2" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, fixed, half
     , hxt, mesa, split, transformers
     }:
     mkDerivation {
       pname = "gl";
       version = "0.6.2";
       sha256 = "03ca6c28d7a8cc82a0843c0886983b93562abf8c4b84cc36b9780ac27da87f4a";
       libraryHaskellDepends = [
         base containers directory filepath fixed half hxt split
         transformers
       ];
       librarySystemDepends = [ mesa ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       description = "Complete OpenGL raw bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mesa;};

  "gl_0_6_3" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, fixed, half
     , hxt, mesa, split, transformers
     }:
     mkDerivation {
       pname = "gl";
       version = "0.6.3";
       sha256 = "04fcfa9fe6beb82d942637a14ef2c59e592dfac5915278387304e49f1140457b";
       libraryHaskellDepends = [
         base containers directory filepath fixed half hxt split
         transformers
       ];
       librarySystemDepends = [ mesa ];
       doHaddock = false;
       jailbreak = true;
       description = "Complete OpenGL raw bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mesa;};

  "gl_0_7_4" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, fixed, half
     , hxt, mesa, split, transformers
     }:
     mkDerivation {
       pname = "gl";
       version = "0.7.4";
       sha256 = "e749d8b7ad2719826cdf5549176d14b4805a8fca087e9133a6cae1d0bcaa6721";
       libraryHaskellDepends = [
         base containers directory filepath fixed half hxt split
         transformers
       ];
       librarySystemDepends = [ mesa ];
       description = "Complete OpenGL raw bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mesa;};

  "gl_0_7_5" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, fixed, half
     , hxt, mesa, split, transformers
     }:
     mkDerivation {
       pname = "gl";
       version = "0.7.5";
       sha256 = "b1ab52ff9fe6a03555b4c2e6e9bf5245105f9d47b43d7f0f64a4b9a0274dcc39";
       libraryHaskellDepends = [
         base containers directory filepath fixed half hxt split
         transformers
       ];
       librarySystemDepends = [ mesa ];
       description = "Complete OpenGL raw bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mesa;};

  "gl_0_7_6" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, fixed, half
     , hxt, mesa, split, transformers
     }:
     mkDerivation {
       pname = "gl";
       version = "0.7.6";
       sha256 = "4dd67e54ea81563e50ac8bed2fe8e4e6d477da45feade7b54e65338270b9b0f1";
       libraryHaskellDepends = [
         base containers directory filepath fixed half hxt split
         transformers
       ];
       librarySystemDepends = [ mesa ];
       description = "Complete OpenGL raw bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mesa;};

  "gl_0_7_7" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, fixed, half
     , hxt, mesa, split, transformers
     }:
     mkDerivation {
       pname = "gl";
       version = "0.7.7";
       sha256 = "ef8a2e5aac8aa7c921f6120c318c4f2aaf58521dd976089336705636f0435f53";
       libraryHaskellDepends = [
         base containers directory filepath fixed half hxt split
         transformers
       ];
       librarySystemDepends = [ mesa ];
       description = "Complete OpenGL raw bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mesa;};

  "gl" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, fixed, half
     , hxt, mesa, split, transformers
     }:
     mkDerivation {
       pname = "gl";
       version = "0.7.8.1";
       sha256 = "ed792ee75d32489857295ef9ae6a4a49900e2ed4a01cd2bac9fdd17959a6219a";
       libraryHaskellDepends = [
         base containers directory filepath fixed half hxt split
         transformers
       ];
       librarySystemDepends = [ mesa ];
       description = "Complete OpenGL raw bindings";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) mesa;};

  "gl-capture" = callPackage
    ({ mkDerivation, base, bytestring, OpenGL }:
     mkDerivation {
       pname = "gl-capture";
       version = "0.1.0.0";
       sha256 = "039579a83a8a359466aedb87515b4e67ab96db451fb96454e3ae86751db08a5d";
       libraryHaskellDepends = [ base bytestring OpenGL ];
       description = "simple image capture from OpenGL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "glade" = callPackage
    ({ mkDerivation, base, glib, gtk, gtk2hs-buildtools, libglade }:
     mkDerivation {
       pname = "glade";
       version = "0.12.5.0";
       sha256 = "79eea09019429ba552b49ae11cf287577937234bd54713aa82ecf3968b3f7435";
       libraryHaskellDepends = [ base glib gtk ];
       libraryPkgconfigDepends = [ libglade ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the glade library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.gnome) libglade;};

  "gladexml-accessor" = callPackage
    ({ mkDerivation, base, glade, HaXml, template-haskell }:
     mkDerivation {
       pname = "gladexml-accessor";
       version = "0.0";
       sha256 = "c317d2d1db4c2270b606c940db32aff4a5c6860215230dfa938d56adf7547f1a";
       libraryHaskellDepends = [ base glade HaXml template-haskell ];
       description = "Automagically declares getters for widget handles in specified interface file";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "glambda" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, containers, directory
     , either, haskeline, mtl, parsec, tasty, tasty-hunit
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "glambda";
       version = "1.0.1";
       sha256 = "da42696d4ad985cd10d249457d801a234c04a29ef08acdbbd91544dabce2d16f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-wl-pprint base containers directory either haskeline mtl
         parsec transformers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         ansi-wl-pprint base either mtl parsec tasty tasty-hunit
         template-haskell
       ];
       homepage = "https://github.com/goldfirere/glambda";
       description = "A simply typed lambda calculus interpreter, written with GADTs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "glapp" = callPackage
    ({ mkDerivation, base, containers, GLFW-b, lens, mtl, OpenGL }:
     mkDerivation {
       pname = "glapp";
       version = "0.1.0.1";
       sha256 = "1f563f7be9ad067166ffc6b1d7ca454c4b2b22057583103a44b28574013cdb1c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers GLFW-b lens mtl OpenGL ];
       executableHaskellDepends = [
         base containers GLFW-b lens mtl OpenGL
       ];
       jailbreak = true;
       homepage = "zyghost.com";
       description = "An OpenGL micro framework";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "glasso" = callPackage
    ({ mkDerivation, base, vector }:
     mkDerivation {
       pname = "glasso";
       version = "0.1.0";
       sha256 = "683dc39377d9a8e51667deef16e2b215d20d393f1eb323f6b06ec217dddb73c5";
       revision = "1";
       editedCabalFile = "abf1b0cb0b9cc8c106f833a2549e2be95111a58296d6cc01c39e18c03abef797";
       libraryHaskellDepends = [ base vector ];
       description = "Graphical Lasso algorithm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "glib_0_13_0_6" = callPackage
    ({ mkDerivation, base, bytestring, containers, glib
     , gtk2hs-buildtools, text, utf8-string
     }:
     mkDerivation {
       pname = "glib";
       version = "0.13.0.6";
       sha256 = "3b434abc2d981f183fa022d57ec14cc2fd880cb74443b9ceaccf9c9f37a0c3c2";
       libraryHaskellDepends = [
         base bytestring containers text utf8-string
       ];
       libraryPkgconfigDepends = [ glib ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the GLIB library for Gtk2Hs";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) glib;};

  "glib_0_13_0_7" = callPackage
    ({ mkDerivation, base, bytestring, containers, glib
     , gtk2hs-buildtools, text, utf8-string
     }:
     mkDerivation {
       pname = "glib";
       version = "0.13.0.7";
       sha256 = "fe5fb5339a7694c915a388bced3b8d934d78cf51c5369f348fa6f52815dea69b";
       libraryHaskellDepends = [
         base bytestring containers text utf8-string
       ];
       libraryPkgconfigDepends = [ glib ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the GLIB library for Gtk2Hs";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) glib;};

  "glib_0_13_1_0" = callPackage
    ({ mkDerivation, base, bytestring, containers, glib
     , gtk2hs-buildtools, text, utf8-string
     }:
     mkDerivation {
       pname = "glib";
       version = "0.13.1.0";
       sha256 = "df1d250f1f2aeba208b7cb71f7201189b9939f6a5224739e35d94a5aa3d84c87";
       libraryHaskellDepends = [
         base bytestring containers text utf8-string
       ];
       libraryPkgconfigDepends = [ glib ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the GLIB library for Gtk2Hs";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) glib;};

  "glib_0_13_1_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, glib
     , gtk2hs-buildtools, text, utf8-string
     }:
     mkDerivation {
       pname = "glib";
       version = "0.13.1.1";
       sha256 = "e494b416ee7b80743af586edf5f7f497b4ce5eae6c070ec12b0e9ec5b99b43f1";
       libraryHaskellDepends = [
         base bytestring containers text utf8-string
       ];
       libraryPkgconfigDepends = [ glib ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the GLIB library for Gtk2Hs";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) glib;};

  "glib_0_13_2_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, glib
     , gtk2hs-buildtools, text, utf8-string
     }:
     mkDerivation {
       pname = "glib";
       version = "0.13.2.1";
       sha256 = "9763884736aa7ef2f0bb9e716aba5f87d50e6d068134e486f359490b8112acdf";
       libraryHaskellDepends = [
         base bytestring containers text utf8-string
       ];
       libraryPkgconfigDepends = [ glib ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the GLIB library for Gtk2Hs";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) glib;};

  "glib" = callPackage
    ({ mkDerivation, base, bytestring, containers, glib
     , gtk2hs-buildtools, text, utf8-string
     }:
     mkDerivation {
       pname = "glib";
       version = "0.13.2.2";
       sha256 = "16bc6710ac195778e514c6ba1da3b22a057854d4db0929b4835172ec42e0497f";
       libraryHaskellDepends = [
         base bytestring containers text utf8-string
       ];
       libraryPkgconfigDepends = [ glib ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the GLIB library for Gtk2Hs";
       license = stdenv.lib.licenses.lgpl21;
     }) {inherit (pkgs) glib;};

  "glicko" = callPackage
    ({ mkDerivation, base, containers, data-default, deepseq, hspec
     , lens, parallel, QuickCheck, statistics
     }:
     mkDerivation {
       pname = "glicko";
       version = "0.1.1.0";
       sha256 = "740b5850982ea36f750c137930bf6e070b365618a547a520fcdab34fd4f913e9";
       libraryHaskellDepends = [
         base containers data-default deepseq lens parallel statistics
       ];
       testHaskellDepends = [ base data-default hspec lens QuickCheck ];
       description = "Glicko-2 implementation in Haskell";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "glider-nlp" = callPackage
    ({ mkDerivation, base, Cabal, containers, HUnit, text }:
     mkDerivation {
       pname = "glider-nlp";
       version = "0.1";
       sha256 = "cba1bce586c0bf71c9e4a7111928c7fa92060474cf68c5dac84b693de423c0c4";
       libraryHaskellDepends = [ base containers text ];
       testHaskellDepends = [ base Cabal containers HUnit text ];
       jailbreak = true;
       homepage = "https://github.com/klangner/glider-nlp";
       description = "Natural Language Processing library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "glintcollider" = callPackage
    ({ mkDerivation, base, ppm, split }:
     mkDerivation {
       pname = "glintcollider";
       version = "0.0.2";
       sha256 = "51125933afe1acd62a5577c168ed418ca5bdfea584509ed2d688dddd9900fdf5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ppm split ];
       description = "A simple ray tracer in an early stage of development";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gll" = callPackage
    ({ mkDerivation, array, base, containers, pretty, TypeCompose }:
     mkDerivation {
       pname = "gll";
       version = "0.3.0.1";
       sha256 = "a488ef62504c0259cde1daaeb9b240bb7ce75a2deeadcb763417e7fea8f0937b";
       libraryHaskellDepends = [
         array base containers pretty TypeCompose
       ];
       jailbreak = true;
       description = "GLL parser with simple combinator interface";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "global" = callPackage
    ({ mkDerivation, base, haskell-src-exts, haskell-src-exts-qq
     , loch-th, SafeSemaphore, stm, syntax-trees-fork-bairyn, tagged
     , template-haskell
     }:
     mkDerivation {
       pname = "global";
       version = "0.2.1.0";
       sha256 = "2890cbcc2bbd64570998e43f4e60f23f462c80993ab61a02c9dd270ba0c6a901";
       libraryHaskellDepends = [
         base haskell-src-exts haskell-src-exts-qq loch-th SafeSemaphore stm
         syntax-trees-fork-bairyn tagged template-haskell
       ];
       homepage = "https://github.com/bairyn/global";
       description = "Library enabling unique top-level declarations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "global-config" = callPackage
    ({ mkDerivation, base, bytestring, data-default, global-variables
     , HUnit, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "global-config";
       version = "0.3.1";
       sha256 = "0aff4ba14b837e8c2eba87e75c1ce60b20a8a088bce0003a12a5ff0c6429e8e6";
       libraryHaskellDepends = [
         base data-default global-variables transformers
       ];
       testHaskellDepends = [
         base bytestring data-default HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 transformers
       ];
       homepage = "https://github.com/akaspin/global-config";
       description = "Global mutable configuration";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "global-lock" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "global-lock";
       version = "0.1";
       sha256 = "b76b112d9976e8f438313b2768b5552e2f22d2a108f4fcaa029971f354fa5a2c";
       libraryHaskellDepends = [ base ];
       description = "A global lock implemented without unsafePerformIO";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "global-variables" = callPackage
    ({ mkDerivation, base, containers, stm }:
     mkDerivation {
       pname = "global-variables";
       version = "1.0.1.1";
       sha256 = "f7ef3f7f9aa26f4f13590785939c321d3a4c33ec9fc35ca2c724846fb081703b";
       libraryHaskellDepends = [ base containers stm ];
       jailbreak = true;
       description = "Namespaced, global, and top-level mutable variables without unsafePerformIO";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "glome-hs" = callPackage
    ({ mkDerivation, array, base, GlomeTrace, GlomeVec, GLUT, haskell98
     , OpenGL, parallel, random, time
     }:
     mkDerivation {
       pname = "glome-hs";
       version = "0.61";
       sha256 = "486fb6ca0bd4e348e047b96bd523f3737b0a1467010230deec69800277273219";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base GlomeTrace GlomeVec GLUT haskell98 OpenGL parallel
         random time
       ];
       executableHaskellDepends = [
         array base GlomeTrace GlomeVec GLUT haskell98 OpenGL parallel
         random time
       ];
       doHaddock = false;
       jailbreak = true;
       homepage = "http://haskell.org/haskellwiki/Glome";
       description = "ray tracer";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gloss_1_9_2_1" = callPackage
    ({ mkDerivation, base, bmp, bytestring, containers, ghc-prim
     , gloss-rendering, GLUT, OpenGL
     }:
     mkDerivation {
       pname = "gloss";
       version = "1.9.2.1";
       sha256 = "142075276d59889cd86db181765c095b858f94ad643b62f60bc2104ec52167ba";
       libraryHaskellDepends = [
         base bmp bytestring containers ghc-prim gloss-rendering GLUT OpenGL
       ];
       jailbreak = true;
       homepage = "http://gloss.ouroborus.net";
       description = "Painless 2D vector graphics, animations and simulations";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gloss" = callPackage
    ({ mkDerivation, base, bmp, bytestring, containers, ghc-prim
     , gloss-rendering, GLUT, OpenGL
     }:
     mkDerivation {
       pname = "gloss";
       version = "1.9.4.1";
       sha256 = "b16094797ba377372bb492cb04dc50e60a77687bd7300bf57e9fab2ad366afe5";
       libraryHaskellDepends = [
         base bmp bytestring containers ghc-prim gloss-rendering GLUT OpenGL
       ];
       jailbreak = true;
       homepage = "http://gloss.ouroborus.net";
       description = "Painless 2D vector graphics, animations and simulations";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "gloss-accelerate" = callPackage
    ({ mkDerivation, accelerate, base, gloss, gloss-rendering }:
     mkDerivation {
       pname = "gloss-accelerate";
       version = "1.9.0.0";
       sha256 = "3bf746a687ed23fbb19d6ac358cad52dfeb06301315ac4e69d221c6a5139798f";
       revision = "1";
       editedCabalFile = "cddab61d37317ec1a15ad7da65d909b8668b284dcf182a7a348d234bff7d30ff";
       libraryHaskellDepends = [ accelerate base gloss gloss-rendering ];
       description = "Extras to interface Gloss and Accelerate";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "gloss-algorithms" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, gloss }:
     mkDerivation {
       pname = "gloss-algorithms";
       version = "1.9.4.1";
       sha256 = "40cbf7b28182e17ae86091aa108489848aff8d5ae4e2c5719e112493cc011649";
       libraryHaskellDepends = [ base containers ghc-prim gloss ];
       homepage = "http://gloss.ouroborus.net";
       description = "Data structures and algorithms for working with 2D graphics";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "gloss-banana" = callPackage
    ({ mkDerivation, base, gloss, reactive-banana }:
     mkDerivation {
       pname = "gloss-banana";
       version = "0.1.0.4";
       sha256 = "43bead428a366f7b13b2c33dfcb7cf497d2beadcbafa51f6bf7d63e67c6ef77f";
       revision = "1";
       editedCabalFile = "232cec279cb20afd92056320c24d3d3041199b014981492ddbbe57eeff312a5a";
       libraryHaskellDepends = [ base gloss reactive-banana ];
       jailbreak = true;
       homepage = "https://github.com/Twey/gloss-banana";
       description = "An Interface for gloss in terms of a reactive-banana Behavior";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gloss-devil" = callPackage
    ({ mkDerivation, base, bytestring, gloss, repa, repa-devil }:
     mkDerivation {
       pname = "gloss-devil";
       version = "0.2";
       sha256 = "557fdd1f79cc3d46116f92dd992c7e2805ca6024d808795baad553f247f0fc9d";
       libraryHaskellDepends = [ base bytestring gloss repa repa-devil ];
       description = "Display images in Gloss using libdevil for decoding";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gloss-examples" = callPackage
    ({ mkDerivation, base, bmp, bytestring, containers, ghc-prim
     , GLFW-b, gloss, gloss-algorithms, gloss-raster, gloss-rendering
     , random, repa, repa-algorithms, repa-io, vector
     }:
     mkDerivation {
       pname = "gloss-examples";
       version = "1.9.4.1";
       sha256 = "9e16dbd092cfc6586a13639550f2701e2727e850734856d118a4a19757ef1a0b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bmp bytestring containers ghc-prim GLFW-b gloss
         gloss-algorithms gloss-raster gloss-rendering random repa
         repa-algorithms repa-io vector
       ];
       jailbreak = true;
       homepage = "http://gloss.ouroborus.net";
       description = "Examples using the gloss library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "gloss-game" = callPackage
    ({ mkDerivation, base, gloss, gloss-juicy }:
     mkDerivation {
       pname = "gloss-game";
       version = "0.3.3.0";
       sha256 = "00a50dcb84a14f323dfadd1d51597a8f04cafe03648bb8922d66d3e400306906";
       libraryHaskellDepends = [ base gloss gloss-juicy ];
       homepage = "https://github.com/mchakravarty/gloss-game";
       description = "Gloss wrapper that simplifies writing games";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "gloss-juicy" = callPackage
    ({ mkDerivation, base, bmp, bytestring, gloss, JuicyPixels, vector
     }:
     mkDerivation {
       pname = "gloss-juicy";
       version = "0.2";
       sha256 = "18cf706cf7bfaac1f37d4d031d00faccddb0fba711a1f6de4f0f6336262ba2f8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bmp bytestring gloss JuicyPixels vector
       ];
       executableHaskellDepends = [
         base bmp bytestring gloss JuicyPixels vector
       ];
       homepage = "http://github.com/alpmestan/gloss-juicy";
       description = "Load any image supported by Juicy.Pixels in your gloss application";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "gloss-raster" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, gloss, gloss-rendering
     , repa
     }:
     mkDerivation {
       pname = "gloss-raster";
       version = "1.9.4.1";
       sha256 = "697325d17ff549f8092ccb08fa6d8b51fc2ae6b704e7a150f7a2bf11ebc3d560";
       libraryHaskellDepends = [
         base containers ghc-prim gloss gloss-rendering repa
       ];
       homepage = "http://gloss.ouroborus.net";
       description = "Parallel rendering of raster images";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "gloss-raster-accelerate" = callPackage
    ({ mkDerivation, accelerate, accelerate-cuda, base, gloss
     , gloss-accelerate
     }:
     mkDerivation {
       pname = "gloss-raster-accelerate";
       version = "1.9.0.0";
       sha256 = "288e1937da8a28e947bafd55624bffb469c84ef031b23b895589deac205ef24d";
       libraryHaskellDepends = [
         accelerate accelerate-cuda base gloss gloss-accelerate
       ];
       description = "Parallel rendering of raster images using Accelerate";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gloss-rendering" = callPackage
    ({ mkDerivation, base, bmp, bytestring, containers, GLUT, OpenGL }:
     mkDerivation {
       pname = "gloss-rendering";
       version = "1.9.3.1";
       sha256 = "fefbab161f3aa797416f63cd3ae029883470c7be6ab4f67803beefc95dea49db";
       libraryHaskellDepends = [
         base bmp bytestring containers GLUT OpenGL
       ];
       jailbreak = true;
       description = "Gloss picture data types and rendering functions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "gloss-sodium" = callPackage
    ({ mkDerivation, base, gloss, sodium }:
     mkDerivation {
       pname = "gloss-sodium";
       version = "0.1.0.0";
       sha256 = "eaa725c9ddafd54386ea2f4875376d1990b45b879c3dd0801409d81bd6c7f279";
       libraryHaskellDepends = [ base gloss sodium ];
       jailbreak = true;
       homepage = "https://github.com/Twey/gloss-sodium";
       description = "A Sodium interface to the Gloss drawing package";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "glpk-hs" = callPackage
    ({ mkDerivation, array, base, containers, deepseq, glpk, mtl }:
     mkDerivation {
       pname = "glpk-hs";
       version = "0.3.5";
       sha256 = "5714be0c2eacc1500438838fabf9535cfd94afc3007ced040c9225003caba0db";
       libraryHaskellDepends = [ array base containers deepseq mtl ];
       librarySystemDepends = [ glpk ];
       description = "Comprehensive GLPK linear programming bindings";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) glpk;};

  "glue" = callPackage
    ({ mkDerivation, async, base, ekg-core, hashable, hspec
     , lifted-base, monad-control, monad-loops, QuickCheck
     , quickcheck-instances, text, time, transformers, transformers-base
     , unordered-containers
     }:
     mkDerivation {
       pname = "glue";
       version = "0.2.0";
       sha256 = "784692e29ea1f5effe4ca98732431b77b2595baa5220394c1561b803e4309b2a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base ekg-core hashable lifted-base monad-control text time
         transformers transformers-base unordered-containers
       ];
       executableHaskellDepends = [
         async base ekg-core hashable lifted-base monad-control monad-loops
         text time transformers transformers-base unordered-containers
       ];
       testHaskellDepends = [
         async base ekg-core hashable hspec lifted-base monad-control
         QuickCheck quickcheck-instances text time transformers
         transformers-base unordered-containers
       ];
       description = "Make better services";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "glue-common" = callPackage
    ({ mkDerivation, async, base, ekg-core, hashable, hspec
     , lifted-base, monad-control, QuickCheck, quickcheck-instances
     , text, time, transformers, transformers-base, unordered-containers
     }:
     mkDerivation {
       pname = "glue-common";
       version = "0.4.6";
       sha256 = "bca26c14be41205c86082e303885bd2c031634dbb7b31336ab71f37efc4f654b";
       libraryHaskellDepends = [
         base hashable lifted-base monad-control text time transformers
         transformers-base unordered-containers
       ];
       testHaskellDepends = [
         async base ekg-core hashable hspec lifted-base monad-control
         QuickCheck quickcheck-instances text time transformers
         transformers-base unordered-containers
       ];
       description = "Make better services and clients";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "glue-core" = callPackage
    ({ mkDerivation, async, base, ekg-core, glue-common, hashable
     , hspec, lifted-base, monad-control, QuickCheck
     , quickcheck-instances, text, time, transformers, transformers-base
     , unordered-containers
     }:
     mkDerivation {
       pname = "glue-core";
       version = "0.4.6";
       sha256 = "d4cecdff03ee9d1b30a804a17a186b2fc1ad84bde59031285cd21e9f550db1ff";
       libraryHaskellDepends = [
         base glue-common hashable lifted-base monad-control text time
         transformers transformers-base unordered-containers
       ];
       testHaskellDepends = [
         async base ekg-core glue-common hashable hspec lifted-base
         monad-control QuickCheck quickcheck-instances text time
         transformers transformers-base unordered-containers
       ];
       description = "Make better services and clients";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "glue-ekg" = callPackage
    ({ mkDerivation, async, base, ekg-core, glue-common, hashable
     , hspec, lifted-base, monad-control, QuickCheck
     , quickcheck-instances, text, time, transformers, transformers-base
     , unordered-containers
     }:
     mkDerivation {
       pname = "glue-ekg";
       version = "0.4.6";
       sha256 = "c22a6f59bf4e3eddcdfd00500eaef16a9065113b52f97252c1270fdd29e1ad27";
       libraryHaskellDepends = [
         base ekg-core glue-common hashable lifted-base monad-control text
         time transformers transformers-base unordered-containers
       ];
       testHaskellDepends = [
         async base ekg-core glue-common hashable hspec lifted-base
         monad-control QuickCheck quickcheck-instances text time
         transformers transformers-base unordered-containers
       ];
       description = "Make better services and clients";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "glue-example" = callPackage
    ({ mkDerivation, async, base, ekg-core, glue-common, glue-core
     , glue-ekg, hashable, lifted-base, monad-control, monad-loops, text
     , time, transformers, transformers-base, unordered-containers
     }:
     mkDerivation {
       pname = "glue-example";
       version = "0.4.6";
       sha256 = "595d107c5153ed6ac93b2b0f27fb154e76975f05c6780b78ffa2618cc395dc62";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async base ekg-core glue-common glue-core glue-ekg hashable
         lifted-base monad-control monad-loops text time transformers
         transformers-base unordered-containers
       ];
       description = "Make better services and clients";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gluturtle" = callPackage
    ({ mkDerivation, base, convertible, GLUT, stm, yjsvg, yjtools }:
     mkDerivation {
       pname = "gluturtle";
       version = "0.0.58.1";
       sha256 = "178658ce4f76ac0a855ca9123cdc8bda0ecc5531356551c00ba6de98dcbd934b";
       libraryHaskellDepends = [
         base convertible GLUT stm yjsvg yjtools
       ];
       description = "turtle like LOGO with glut";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "gmap" = callPackage
    ({ mkDerivation, array, AvlTree, base, COrdering, QuickCheck
     , random
     }:
     mkDerivation {
       pname = "gmap";
       version = "0.1";
       sha256 = "f974492f3d58cebf13e81f7d525a0535ad317eb4f0c2e4e405aadd6ee7079d4f";
       libraryHaskellDepends = [
         array AvlTree base COrdering QuickCheck random
       ];
       description = "Composable maps and generic tries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gmndl" = callPackage
    ({ mkDerivation, ad, array, base, gtk, gtkglext, mtl, OpenGL
     , OpenGLRaw, parsec, priority-queue, qd, reflection, Vec
     }:
     mkDerivation {
       pname = "gmndl";
       version = "0.4.0.2";
       sha256 = "a8fe331eadf12cd74be57d5f31ff805996a782a4819296427cef612b89b02713";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ad array base gtk gtkglext mtl OpenGL OpenGLRaw parsec
         priority-queue qd reflection Vec
       ];
       jailbreak = true;
       description = "Mandelbrot Set explorer using GTK";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gnome-desktop" = callPackage
    ({ mkDerivation, base, directory, gconf, glib, gtk, random }:
     mkDerivation {
       pname = "gnome-desktop";
       version = "1.0.0.0";
       sha256 = "0617c537bdc13fbc426d4f658ca18a71c1819798b699dd066bc353a22644fd46";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory gconf glib gtk random
       ];
       description = "Randomly set a picture as the GNOME desktop background";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gnome-keyring" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, gnome_keyring, text, time
     }:
     mkDerivation {
       pname = "gnome-keyring";
       version = "0.3.1";
       sha256 = "880a62a69025a1b8ceae8eb896adf1e78cabfcd0a2fb4e8f8ddfe31e49f4ca21";
       libraryHaskellDepends = [ base bytestring text time ];
       librarySystemDepends = [ gnome_keyring ];
       libraryPkgconfigDepends = [ gnome_keyring ];
       libraryToolDepends = [ c2hs ];
       homepage = "https://john-millikin.com/software/haskell-gnome-keyring/";
       description = "Bindings for libgnome-keyring";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.gnome) gnome_keyring;};

  "gnomevfs" = callPackage
    ({ mkDerivation, array, base, containers, glib, gnome_vfs
     , gnome_vfs_module, gtk, gtk2hs-buildtools, haskell98, mtl
     }:
     mkDerivation {
       pname = "gnomevfs";
       version = "0.11.0";
       sha256 = "b74ef051b47371f74f31f69265a90c2a6f21b5218ca949761082b030138b8d3c";
       libraryHaskellDepends = [
         array base containers glib gtk haskell98 mtl
       ];
       libraryPkgconfigDepends = [ gnome_vfs gnome_vfs_module ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       jailbreak = true;
       homepage = "http://www.haskell.org/gtk2hs/";
       description = "Binding to the GNOME Virtual File System library";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.gnome) gnome_vfs; gnome_vfs_module = null;};

  "gnss-converters" = callPackage
    ({ mkDerivation, base, basic-prelude, binary-conduit, conduit
     , conduit-extra, lens, resourcet, rtcm, sbp, tasty, tasty-hunit
     , time
     }:
     mkDerivation {
       pname = "gnss-converters";
       version = "0.1.4";
       sha256 = "82aaaade8f41cbe7d2093db80186c7919f1786187739c8cc307864d1f2717987";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base basic-prelude conduit-extra lens rtcm sbp time
       ];
       executableHaskellDepends = [
         base basic-prelude binary-conduit conduit conduit-extra resourcet
       ];
       testHaskellDepends = [ base basic-prelude tasty tasty-hunit ];
       homepage = "http://github.com/swift-nav/gnss-converters";
       description = "GNSS Converters";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gnuidn_0_2_1" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, libidn, text }:
     mkDerivation {
       pname = "gnuidn";
       version = "0.2.1";
       sha256 = "67744c8559ed5c722c53c7a4c2a37821b59ede4b9288ceb995410ec6cb3031ca";
       libraryHaskellDepends = [ base bytestring text ];
       librarySystemDepends = [ libidn ];
       libraryPkgconfigDepends = [ libidn ];
       libraryToolDepends = [ c2hs ];
       homepage = "https://john-millikin.com/software/haskell-gnuidn/";
       description = "Bindings for GNU IDN";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libidn;};

  "gnuidn" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, chell, chell-quickcheck
     , libidn, QuickCheck, text
     }:
     mkDerivation {
       pname = "gnuidn";
       version = "0.2.2";
       sha256 = "61346b1f764cead5633bdc83f7dc9836b1627f484984094cdffa95dfd365b96f";
       libraryHaskellDepends = [ base bytestring text ];
       librarySystemDepends = [ libidn ];
       libraryPkgconfigDepends = [ libidn ];
       libraryToolDepends = [ c2hs ];
       testHaskellDepends = [
         base bytestring chell chell-quickcheck QuickCheck text
       ];
       testSystemDepends = [ libidn ];
       testPkgconfigDepends = [ libidn ];
       testToolDepends = [ c2hs ];
       homepage = "https://john-millikin.com/software/haskell-gnuidn/";
       description = "Bindings for GNU IDN";
       license = stdenv.lib.licenses.gpl3;
     }) {inherit (pkgs) libidn;};

  "gnuplot" = callPackage
    ({ mkDerivation, array, base, containers, data-accessor
     , data-accessor-transformers, deepseq, filepath, process, temporary
     , time, transformers, utility-ht
     }:
     mkDerivation {
       pname = "gnuplot";
       version = "0.5.4.1";
       sha256 = "fa54c95f5dad96e3af6a13429cf6852bffe97bd52bdd99bdce60ca9e78bee8f7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers data-accessor data-accessor-transformers
         deepseq filepath process temporary time transformers utility-ht
       ];
       homepage = "http://www.haskell.org/haskellwiki/Gnuplot";
       description = "2D and 3D plots using gnuplot";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gnutls" = callPackage
    ({ mkDerivation, base, bytestring, gnutls, monads-tf, transformers
     }:
     mkDerivation {
       pname = "gnutls";
       version = "0.2";
       sha256 = "c0e6fddf92d48d1e6ab0d93af8104cc83d250eab7b3d369780ef72801aa8b7b0";
       libraryHaskellDepends = [ base bytestring monads-tf transformers ];
       librarySystemDepends = [ gnutls ];
       libraryPkgconfigDepends = [ gnutls ];
       homepage = "https://john-millikin.com/software/haskell-gnutls/";
       description = "Bindings for GNU libgnutls";
       license = stdenv.lib.licenses.gpl3;
     }) {inherit (pkgs) gnutls;};

  "goa" = callPackage
    ({ mkDerivation, base, directory, filepath, process }:
     mkDerivation {
       pname = "goa";
       version = "3.3";
       sha256 = "f3d73cd8ad48749890c42fddc154e30eeaa29f70bd6ab78da4a162e24584357c";
       revision = "1";
       editedCabalFile = "5ae2bd1f4c29e22070fa32e5c126066813467ffe71a912148304d6f30d200137";
       libraryHaskellDepends = [ base directory filepath process ];
       description = "GHCi bindings to lambdabot";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "goal-core" = callPackage
    ({ mkDerivation, base, cairo, Chart, Chart-cairo, Chart-gtk, colour
     , containers, data-default-class, gtk, lens
     }:
     mkDerivation {
       pname = "goal-core";
       version = "0.1";
       sha256 = "84b932f82d35eeb3908f5c0c63c7f801de0307439794a1f2049d26bf8e346686";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cairo Chart Chart-cairo Chart-gtk colour containers
         data-default-class gtk lens
       ];
       executableHaskellDepends = [ base ];
       description = "Core imports for Geometric Optimization Libraries";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "goal-geometry" = callPackage
    ({ mkDerivation, base, goal-core, hmatrix, vector }:
     mkDerivation {
       pname = "goal-geometry";
       version = "0.1";
       sha256 = "e0bf529b38ea7fa1ed9405db3386bd5206cced8fcc33761cfcbb220d373edc74";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base goal-core hmatrix vector ];
       executableHaskellDepends = [ base goal-core ];
       description = "Scientific computing on geometric objects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "goal-probability" = callPackage
    ({ mkDerivation, base, goal-core, goal-geometry, hmatrix
     , math-functions, mwc-random, mwc-random-monad, statistics, vector
     }:
     mkDerivation {
       pname = "goal-probability";
       version = "0.1";
       sha256 = "d48a3518ef4de905dc0cf402dc1b658151e4394af5fc6cd23b39b3831915902d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base goal-core goal-geometry hmatrix math-functions mwc-random
         mwc-random-monad statistics vector
       ];
       executableHaskellDepends = [ base goal-core goal-geometry vector ];
       description = "Manifolds of probability distributions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "goal-simulation" = callPackage
    ({ mkDerivation, base, cairo, clock, directory, goal-core
     , goal-geometry, goal-probability, gtk, hmatrix, machines, mtl
     , vector
     }:
     mkDerivation {
       pname = "goal-simulation";
       version = "0.1";
       sha256 = "5787cc79ee00478faa9e89ac39c04b8589834c1635f31ba184f70df349678201";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cairo clock goal-core goal-geometry goal-probability gtk
         hmatrix machines vector
       ];
       executableHaskellDepends = [
         base directory goal-core goal-geometry goal-probability hmatrix mtl
         vector
       ];
       description = "Mealy based simulation tools";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "goatee" = callPackage
    ({ mkDerivation, base, containers, HUnit, mtl, parsec
     , template-haskell
     }:
     mkDerivation {
       pname = "goatee";
       version = "0.3.1.1";
       sha256 = "88837cda9add9a05ca6f8bf8c0547f6cc629253f6e033b198e27142735074ce2";
       libraryHaskellDepends = [
         base containers mtl parsec template-haskell
       ];
       testHaskellDepends = [ base containers HUnit mtl parsec ];
       jailbreak = true;
       homepage = "http://khumba.net/projects/goatee";
       description = "A monadic take on a 2,500-year-old board game - library";
       license = stdenv.lib.licenses.agpl3;
       maintainers = with stdenv.lib.maintainers; [ khumba ];
     }) {};

  "goatee-gtk" = callPackage
    ({ mkDerivation, base, cairo, containers, directory, filepath, glib
     , goatee, gtk, HUnit, mtl, parsec
     }:
     mkDerivation {
       pname = "goatee-gtk";
       version = "0.3.1";
       sha256 = "ee87d1764a413f03f73e6a99e04a1bb7c1dfefa597ba46a21e1dc9864d1511ef";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cairo containers directory filepath glib goatee gtk mtl parsec
       ];
       executableHaskellDepends = [ base gtk ];
       testHaskellDepends = [ base HUnit ];
       jailbreak = true;
       homepage = "http://khumba.net/projects/goatee";
       description = "A monadic take on a 2,500-year-old board game - GTK+ UI";
       license = stdenv.lib.licenses.agpl3;
       maintainers = with stdenv.lib.maintainers; [ khumba ];
     }) {};

  "gofer-prelude" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "gofer-prelude";
       version = "2.30.3";
       sha256 = "8e987b680ecb6dd76a325bd3ee0b0f09515eb5a479194a96b646c0ceb71b14f2";
       libraryHaskellDepends = [ base ghc-prim ];
       homepage = "http://code.haskell.org/~dons/code/gofer-prelude";
       description = "The Gofer 2.30 standard prelude";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gogol" = callPackage
    ({ mkDerivation, aeson, base, bytestring, case-insensitive
     , cryptonite, data-default-class, directory, exceptions, filepath
     , gogol-core, http-client, http-conduit, http-media, http-types
     , lens, memory, monad-control, mtl, resourcet, text, time
     , transformers, transformers-base, unordered-containers, x509
     , x509-store
     }:
     mkDerivation {
       pname = "gogol";
       version = "0.0.1";
       sha256 = "0e72e4cafcbf21db821f0c38f954baff9f7c5c530feb2f6709ac4848759e252f";
       libraryHaskellDepends = [
         aeson base bytestring case-insensitive cryptonite
         data-default-class directory exceptions filepath gogol-core
         http-client http-conduit http-media http-types lens memory
         monad-control mtl resourcet text time transformers
         transformers-base unordered-containers x509 x509-store
       ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Comprehensive Google Services SDK";
       license = "unknown";
     }) {};

  "gogol-adexchange-buyer" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-adexchange-buyer";
       version = "0.0.1";
       sha256 = "3ae32fa142150010a668095978c340ab13f128d3819ce9e2c79be5f56305c854";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Ad Exchange Buyer SDK";
       license = "unknown";
     }) {};

  "gogol-adexchange-seller" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-adexchange-seller";
       version = "0.0.1";
       sha256 = "77f2a4c22cdfc407d35f3e59646d79653bd81ff6fa24335222bc6c603e0eadf9";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Ad Exchange Seller SDK";
       license = "unknown";
     }) {};

  "gogol-admin-datatransfer" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-admin-datatransfer";
       version = "0.0.1";
       sha256 = "6143254e54c045a46afd4ecd70881510e87f24768360bd665ce928897b95c450";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Admin Data Transfer SDK";
       license = "unknown";
     }) {};

  "gogol-admin-directory" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-admin-directory";
       version = "0.0.1";
       sha256 = "1d8ff33bf3504f792e24e0a436149c1f100493467d07c8815381f7048576855d";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Admin Directory SDK";
       license = "unknown";
     }) {};

  "gogol-admin-emailmigration" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-admin-emailmigration";
       version = "0.0.1";
       sha256 = "5d167cd5406e43ab99ac522de352a3c3dcc493104b262c6c8b2710c1a23cc3cd";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Email Migration API v2 SDK";
       license = "unknown";
     }) {};

  "gogol-admin-reports" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-admin-reports";
       version = "0.0.1";
       sha256 = "1868f5f7ba8e0e90e1c0a74718366fe297c281f8236ac496b1a722727ea4b82f";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Admin Reports SDK";
       license = "unknown";
     }) {};

  "gogol-adsense" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-adsense";
       version = "0.0.1";
       sha256 = "2f3d17374c10b04546f455a351b798beae2969f49e4df3c975e4b1f74d9c11c8";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google AdSense Management SDK";
       license = "unknown";
     }) {};

  "gogol-adsense-host" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-adsense-host";
       version = "0.0.1";
       sha256 = "2bf0e157cb703e266efcfde3ca73c64c822c9a9c418be912b26604f8b2abba63";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google AdSense Host SDK";
       license = "unknown";
     }) {};

  "gogol-affiliates" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-affiliates";
       version = "0.0.1";
       sha256 = "e49f76204abd9c3d070061c6825a8db2607b506fb125cbfab2663f3b78b99b27";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Affiliate Network SDK";
       license = "unknown";
     }) {};

  "gogol-analytics" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-analytics";
       version = "0.0.1";
       sha256 = "c72f26573b2530322675bc8cf34cf2b4ffdd8e7bf2ddcd3b175a51dbc4dc058c";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Analytics SDK";
       license = "unknown";
     }) {};

  "gogol-android-enterprise" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-android-enterprise";
       version = "0.0.1";
       sha256 = "8ffd8352435e2133873322b20bce2c39b80539448bdff9290828602eea73650b";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Play EMM SDK";
       license = "unknown";
     }) {};

  "gogol-android-publisher" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-android-publisher";
       version = "0.0.1";
       sha256 = "deacfbb32041843d93da6352ee9b75b879a235b2b5b4b08475dbd37179cb20c9";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Play Developer SDK";
       license = "unknown";
     }) {};

  "gogol-appengine" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-appengine";
       version = "0.0.1";
       sha256 = "fde28097b13904a0fdca738f2e25aef6ee3c3e9c329d36f0904eb1f36914a523";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google App Engine Admin SDK";
       license = "unknown";
     }) {};

  "gogol-apps-activity" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-apps-activity";
       version = "0.0.1";
       sha256 = "f4d6ba2f8d19b9adba8fd80c3675bb446c505079e02623a81f308f2bfd6bd920";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Apps Activity SDK";
       license = "unknown";
     }) {};

  "gogol-apps-calendar" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-apps-calendar";
       version = "0.0.1";
       sha256 = "853497acc5477ebf072c67bafb38f7ce9d77e8331a4ee3bf011a8c47a55cae3a";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Calendar SDK";
       license = "unknown";
     }) {};

  "gogol-apps-licensing" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-apps-licensing";
       version = "0.0.1";
       sha256 = "952de2e69668e608e2afe4234dc3190b34eeb0b375c4578b89bece82161d502a";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Enterprise License Manager SDK";
       license = "unknown";
     }) {};

  "gogol-apps-reseller" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-apps-reseller";
       version = "0.0.1";
       sha256 = "d92ca7bd951f1042e403b52f895b813a73b2ed08cb670b30a99c29f42179d875";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Enterprise Apps Reseller SDK";
       license = "unknown";
     }) {};

  "gogol-apps-tasks" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-apps-tasks";
       version = "0.0.1";
       sha256 = "e7af4dee84142c118cd677213e463cffaec46130c6fe32dad5fee0d02bc84825";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Tasks SDK";
       license = "unknown";
     }) {};

  "gogol-appstate" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-appstate";
       version = "0.0.1";
       sha256 = "334e67d5cbae7ac12d5ec00fb7c1a3d66fdbf9efaa8bd9812e090a6790b88e25";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google App State SDK";
       license = "unknown";
     }) {};

  "gogol-autoscaler" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-autoscaler";
       version = "0.0.1";
       sha256 = "0337f8d46c6b52cce6752c0f5c0b58b39af43398ea2e76379ea4001355f08acc";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Compute Engine Autoscaler SDK";
       license = "unknown";
     }) {};

  "gogol-bigquery" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-bigquery";
       version = "0.0.1";
       sha256 = "d2c8db1661bd63ccd7e2bce741fa98aedc38ebeaaa006feaf437f9bff8b1e0b5";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google BigQuery SDK";
       license = "unknown";
     }) {};

  "gogol-billing" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-billing";
       version = "0.0.1";
       sha256 = "00f95d2a7457ff464891d502589c66c3328796900ff94884004be9e22a645598";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Cloud Billing SDK";
       license = "unknown";
     }) {};

  "gogol-blogger" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-blogger";
       version = "0.0.1";
       sha256 = "f201528036f3b1f66e4b246c6f23d58f25172c86c45d762c099ff3f9b650f15b";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Blogger SDK";
       license = "unknown";
     }) {};

  "gogol-books" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-books";
       version = "0.0.1";
       sha256 = "ed6bba0c502edeb1f10c8d98bfd0d4127152e07967c705e63a64b86ec162d6c4";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Books SDK";
       license = "unknown";
     }) {};

  "gogol-civicinfo" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-civicinfo";
       version = "0.0.1";
       sha256 = "0dfe03f89a34317e0c78abdbc84d3b7b105a14b78cc3c53b4407556d21e3a1bf";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Civic Information SDK";
       license = "unknown";
     }) {};

  "gogol-classroom" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-classroom";
       version = "0.0.1";
       sha256 = "7e0e277670d037827a4b5fc6bb8fe0ede3cc9adffe116587ffbf6b318d6cdd21";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Classroom SDK";
       license = "unknown";
     }) {};

  "gogol-cloudtrace" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-cloudtrace";
       version = "0.0.1";
       sha256 = "b0a308a10e6f366aa72b79db52281b953a0239932ba2287d3971271a1d9d1a03";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Cloud Trace SDK";
       license = "unknown";
     }) {};

  "gogol-compute" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-compute";
       version = "0.0.1";
       sha256 = "19444c4066b1ccb3900f893f05bfd35926701004a46aa4df2cd37976fa31eb19";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Compute Engine SDK";
       license = "unknown";
     }) {};

  "gogol-container" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-container";
       version = "0.0.1";
       sha256 = "a887cb1520240df322ba74b4d8a304209e2269afda16ff390870be3c18f29d1c";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Container Engine SDK";
       license = "unknown";
     }) {};

  "gogol-core" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , case-insensitive, conduit, dlist, exceptions, hashable
     , http-client, http-media, http-types, lens, resourcet, scientific
     , servant, tasty, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "gogol-core";
       version = "0.0.1";
       sha256 = "5baad8cb7a646cee9490916096ba71bf75168d7f807d79419d350813fc52ef9b";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring case-insensitive conduit dlist
         exceptions hashable http-client http-media http-types lens
         resourcet scientific servant text time unordered-containers
       ];
       testHaskellDepends = [ base tasty ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Core data types and functionality for Gogol libraries";
       license = "unknown";
     }) {};

  "gogol-customsearch" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-customsearch";
       version = "0.0.1";
       sha256 = "2d8ff2e0b9b881ed586a618dabcf4549c882f5cdfb2a0db3502ead23e5b56544";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google CustomSearch SDK";
       license = "unknown";
     }) {};

  "gogol-dataflow" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-dataflow";
       version = "0.0.1";
       sha256 = "c7d6a8d393143b5d31a212fc0a97e9f36b421e9830072b62869b275fa50da19f";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Dataflow SDK";
       license = "unknown";
     }) {};

  "gogol-datastore" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-datastore";
       version = "0.0.1";
       sha256 = "e7d9cf74351dcb5455ea3dcd543096faa69bfb0fee5e34213dbe9c3b13341905";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Cloud Datastore SDK";
       license = "unknown";
     }) {};

  "gogol-debugger" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-debugger";
       version = "0.0.1";
       sha256 = "42106728da6d66ce926e607f110e34c730deda08460c1d712075b74c4c0f5472";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Cloud Debugger SDK";
       license = "unknown";
     }) {};

  "gogol-deploymentmanager" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-deploymentmanager";
       version = "0.0.1";
       sha256 = "7c135257c4408bc68204bc44867f2dc608c3c2e0d23d9825663f4df744b02c32";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Cloud Deployment Manager SDK";
       license = "unknown";
     }) {};

  "gogol-dfareporting" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-dfareporting";
       version = "0.0.1";
       sha256 = "da9ded766d253ae199bbc8481b16ebee41d143dc28ce639893320c60ac30ca11";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google DCM/DFA Reporting And Trafficking SDK";
       license = "unknown";
     }) {};

  "gogol-discovery" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-discovery";
       version = "0.0.1";
       sha256 = "3f25c64ece94a996c96e66fd2520d8a01f7b41c735ddb42e8f83e83d073eee13";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google APIs Discovery Service SDK";
       license = "unknown";
     }) {};

  "gogol-dns" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-dns";
       version = "0.0.1";
       sha256 = "e1d840e711ff29da3dd9f448dcebd45259118f53bb57e793ef69cfe015c28eb8";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Cloud DNS SDK";
       license = "unknown";
     }) {};

  "gogol-doubleclick-bids" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-doubleclick-bids";
       version = "0.0.1";
       sha256 = "4854269786c5bbbc4ecd49473b1b7c63854db3ffb45b9df6e38b5f6a6bcbf2ae";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google DoubleClick Bid Manager SDK";
       license = "unknown";
     }) {};

  "gogol-doubleclick-search" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-doubleclick-search";
       version = "0.0.1";
       sha256 = "4c4daeb8277e635ca04de5849607c8de8f2b85ef9271c398ad9fcd3e09da2e7c";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google DoubleClick Search SDK";
       license = "unknown";
     }) {};

  "gogol-drive" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-drive";
       version = "0.0.1";
       sha256 = "fb3aeda3acf1b43a8fce9abaf69f314b31a5a0b27c8592bfcd644f43ee612268";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Drive SDK";
       license = "unknown";
     }) {};

  "gogol-fitness" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-fitness";
       version = "0.0.1";
       sha256 = "80c90e5bffbfbe5a16df83e8b367bfa9363c94924617a7a7fb78ad4fda29e6c5";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Fitness SDK";
       license = "unknown";
     }) {};

  "gogol-fonts" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-fonts";
       version = "0.0.1";
       sha256 = "33e2bec3a8f4c7b42a88f006e1adc8142eeba87e0b73ef21fddca7ec5e182cd9";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Fonts Developer SDK";
       license = "unknown";
     }) {};

  "gogol-freebasesearch" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-freebasesearch";
       version = "0.0.1";
       sha256 = "ed60a48d748fba875ab7de31b52d69cf1396934f7ace0630248f25b3938292b9";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Freebase Search SDK";
       license = "unknown";
     }) {};

  "gogol-fusiontables" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-fusiontables";
       version = "0.0.1";
       sha256 = "24106717a51ab367400cfd23cac41dbca269a34101ee0df7e3af6da4e37bd29b";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Fusion Tables SDK";
       license = "unknown";
     }) {};

  "gogol-games" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-games";
       version = "0.0.1";
       sha256 = "58a9f71c8c7c78e5221501feff255f8bbecf7d2afd84208d0eaf2fa53e0a29c6";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Play Game Services SDK";
       license = "unknown";
     }) {};

  "gogol-games-configuration" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-games-configuration";
       version = "0.0.1";
       sha256 = "c9a4575a80119969d71a1b14ceb8788ed3b38429176888868717fbe9e7d50af2";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Play Game Services Publishing SDK";
       license = "unknown";
     }) {};

  "gogol-games-management" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-games-management";
       version = "0.0.1";
       sha256 = "de22f2fdcc5a65a335d3844670cb3da61017b282a7fbf4c4312ec861c7dba6b6";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Play Game Services Management SDK";
       license = "unknown";
     }) {};

  "gogol-genomics" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-genomics";
       version = "0.0.1";
       sha256 = "9099d151ddc8944a59b8508530b88ad9324313b566836a86ac6a527819ec2ca3";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Genomics SDK";
       license = "unknown";
     }) {};

  "gogol-gmail" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-gmail";
       version = "0.0.1";
       sha256 = "ca3e03ab9cc5b6afb06a9ba056667b0ebb3b9fb4d28be14d3748244370f73712";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Gmail SDK";
       license = "unknown";
     }) {};

  "gogol-groups-migration" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-groups-migration";
       version = "0.0.1";
       sha256 = "20d4acb5defd318401ccf44213bb151b8bcfe77465b318d034ae875ba9fc7231";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Groups Migration SDK";
       license = "unknown";
     }) {};

  "gogol-groups-settings" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-groups-settings";
       version = "0.0.1";
       sha256 = "76eb21100316ac5599da40c5ca24bf9d9dd02ff5670ca35b9bac89fc64d8dea1";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Groups Settings SDK";
       license = "unknown";
     }) {};

  "gogol-identity-toolkit" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-identity-toolkit";
       version = "0.0.1";
       sha256 = "2329fd4a9bc2c46757b54e983423905203405359d488b4aeded929e5c92816c0";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Identity Toolkit SDK";
       license = "unknown";
     }) {};

  "gogol-latencytest" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-latencytest";
       version = "0.0.1";
       sha256 = "9053dbadc3dc42dc9b3d3cb335f8f84615eb975e41125a4040387023b5db0994";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Cloud Network Performance Monitoring SDK";
       license = "unknown";
     }) {};

  "gogol-logging" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-logging";
       version = "0.0.1";
       sha256 = "68d844661703a24dcb9ebf3ea1607cdc09ac0075fa8cb2ac842939bb54c96f74";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Cloud Logging SDK";
       license = "unknown";
     }) {};

  "gogol-maps-coordinate" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-maps-coordinate";
       version = "0.0.1";
       sha256 = "ebe499c2ec742dca7d9618c73b18ad97d473eda614e5b61c78eb26eaa73a132f";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Maps Coordinate SDK";
       license = "unknown";
     }) {};

  "gogol-maps-engine" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-maps-engine";
       version = "0.0.1";
       sha256 = "c75dfe85f10a2778c2d651e15ee89983937f829230dbe969c0cef0dcaa5a63e6";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Maps Engine SDK";
       license = "unknown";
     }) {};

  "gogol-mirror" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-mirror";
       version = "0.0.1";
       sha256 = "a6b89df933913229ebcfc1ada46415efe75a842386e6b1b9d1a099180f4360e3";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Mirror SDK";
       license = "unknown";
     }) {};

  "gogol-monitoring" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-monitoring";
       version = "0.0.1";
       sha256 = "0231edada11ac42a76026527afdf4a00f44840a53496c5b52aa5311ce68e90b9";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Cloud Monitoring SDK";
       license = "unknown";
     }) {};

  "gogol-oauth2" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-oauth2";
       version = "0.0.1";
       sha256 = "18f1309ee669a677a1d08d9a82b24b7f51d09d14c600ee9ef913999e49ede266";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google OAuth2 SDK";
       license = "unknown";
     }) {};

  "gogol-pagespeed" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-pagespeed";
       version = "0.0.1";
       sha256 = "3c1425945e75c91f15dd3d24fa52c691c40e0b9def486e115982a7e99038552c";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google PageSpeed Insights SDK";
       license = "unknown";
     }) {};

  "gogol-partners" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-partners";
       version = "0.0.1";
       sha256 = "ff0da512eefdfa4879815ba0b96d66426169d57a1ab9a470114e9ddbf7a939ce";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Partners SDK";
       license = "unknown";
     }) {};

  "gogol-play-moviespartner" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-play-moviespartner";
       version = "0.0.1";
       sha256 = "48b428ed66ac669a371829342753f5756497403d15efcd5cc753ff3d144b3bcd";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Play Movies Partner SDK";
       license = "unknown";
     }) {};

  "gogol-plus" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-plus";
       version = "0.0.1";
       sha256 = "b6f0db7f3f507c6044a27194dd7bec0f8bbcfc42fee520cd78baad9157cefe1f";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google + SDK";
       license = "unknown";
     }) {};

  "gogol-plus-domains" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-plus-domains";
       version = "0.0.1";
       sha256 = "49b78f294fe8d254202cfb3cfcdafd33d3c85b4cfa342bbfe5e7c1e9f8034e91";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google + Domains SDK";
       license = "unknown";
     }) {};

  "gogol-prediction" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-prediction";
       version = "0.0.1";
       sha256 = "1441bd802f43c5689d366be3000734439a67a12e37508694534c1c0c9b3c8570";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Prediction SDK";
       license = "unknown";
     }) {};

  "gogol-proximitybeacon" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-proximitybeacon";
       version = "0.0.1";
       sha256 = "4689e35edf0353a425b0f6d527811d004db28f84d6d9d8a283175da978897ba3";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Proximity Beacon SDK";
       license = "unknown";
     }) {};

  "gogol-pubsub" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-pubsub";
       version = "0.0.1";
       sha256 = "72f44527f893200922141d53aa3dd525f8b5b912651d476b0676f4ed5fa15f84";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Cloud Pub/Sub SDK";
       license = "unknown";
     }) {};

  "gogol-qpxexpress" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-qpxexpress";
       version = "0.0.1";
       sha256 = "92797cb6ffeae44d86dc7fe714ccc0b544dc4370b9d20154896b6679c682b215";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google QPX Express SDK";
       license = "unknown";
     }) {};

  "gogol-replicapool" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-replicapool";
       version = "0.0.1";
       sha256 = "d7090d8110b52411749fd550d5dc3dd29740229712b78328a30d2ddb42502663";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Compute Engine Instance Group Manager SDK";
       license = "unknown";
     }) {};

  "gogol-replicapool-updater" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-replicapool-updater";
       version = "0.0.1";
       sha256 = "fd3a0b55a94dff0f4620a3cdbdd1db40a154c7261a9d45ecd31309becb07db20";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Compute Engine Instance Group Updater SDK";
       license = "unknown";
     }) {};

  "gogol-resourcemanager" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-resourcemanager";
       version = "0.0.1";
       sha256 = "f3805aa21239efe89e9af8669c8205b2442d554c4decedd17607b1ca4e090089";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Cloud Resource Manager SDK";
       license = "unknown";
     }) {};

  "gogol-resourceviews" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-resourceviews";
       version = "0.0.1";
       sha256 = "f2ea54233f74c09ba05e9f329535d2be2a668d3592afbfe16b3f4a3bf1d29ed1";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Compute Engine Instance Groups SDK";
       license = "unknown";
     }) {};

  "gogol-shopping-content" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-shopping-content";
       version = "0.0.1";
       sha256 = "6165d7ee5203e64a6635eeed5ae27984e30281b2cea38234a9be51409297a25f";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Content API for Shopping SDK";
       license = "unknown";
     }) {};

  "gogol-siteverification" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-siteverification";
       version = "0.0.1";
       sha256 = "22ddf6341858e4009e5056d630627eded3324cf0a400c20b419c22e16e4b3cc8";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Site Verification SDK";
       license = "unknown";
     }) {};

  "gogol-spectrum" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-spectrum";
       version = "0.0.1";
       sha256 = "8b0007e225762bdc5c28e83b69e2b5ab153a24c0c3cdced67fa940083d4cfb0a";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Spectrum Database SDK";
       license = "unknown";
     }) {};

  "gogol-sqladmin" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-sqladmin";
       version = "0.0.1";
       sha256 = "41f81cc67cc6d6ffc93d8045c27e7b3e3b6aba09f4952f63924fcd8f46baa155";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Cloud SQL Administration SDK";
       license = "unknown";
     }) {};

  "gogol-storage" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-storage";
       version = "0.0.1";
       sha256 = "b43519eaf4a0dd0d258400770678f4108dc25a05ca1287b93409983f83f88ca3";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Cloud Storage JSON SDK";
       license = "unknown";
     }) {};

  "gogol-storage-transfer" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-storage-transfer";
       version = "0.0.1";
       sha256 = "3b46706ec9d4aae071a08926d1c85c699b03a26eb34f0ee61ec2c4eba7522d4e";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Storage Transfer SDK";
       license = "unknown";
     }) {};

  "gogol-tagmanager" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-tagmanager";
       version = "0.0.1";
       sha256 = "80bc33801f376c0005fc847311bf82e2b85a95ac7d35f47134ced4c21cdee274";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Tag Manager SDK";
       license = "unknown";
     }) {};

  "gogol-taskqueue" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-taskqueue";
       version = "0.0.1";
       sha256 = "173bf8bb20081e15c7985090561fdb35ddd0392640df3ba26952c750d094785d";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google TaskQueue SDK";
       license = "unknown";
     }) {};

  "gogol-translate" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-translate";
       version = "0.0.1";
       sha256 = "53204a24700da7c3eabc1bd53b9a77c151043c0c9ae0a1a70117fb4a859bc3ed";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Translate SDK";
       license = "unknown";
     }) {};

  "gogol-urlshortener" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-urlshortener";
       version = "0.0.1";
       sha256 = "30fac0dc638cbfb3685d628d63367f0abd20aa8fcff22b9f9632ec98cc1bafc2";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google URL Shortener SDK";
       license = "unknown";
     }) {};

  "gogol-useraccounts" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-useraccounts";
       version = "0.0.1";
       sha256 = "5417c683af4fd8692385f95aa8e7ae4d1b8519cd0d153718859f4be42aceecb4";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Cloud User Accounts SDK";
       license = "unknown";
     }) {};

  "gogol-webmaster-tools" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-webmaster-tools";
       version = "0.0.1";
       sha256 = "2b2b393b6968094e746e0ea23b8c65bb6ff3ed830992aac5347a21f409d64cce";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google Webmaster Tools SDK";
       license = "unknown";
     }) {};

  "gogol-youtube" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-youtube";
       version = "0.0.1";
       sha256 = "36ec1c1f4e4e7b7cda15a1a13eb3a8ce2980e7b689227dd0dc33b8af22bd49dd";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google YouTube Data SDK";
       license = "unknown";
     }) {};

  "gogol-youtube-analytics" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-youtube-analytics";
       version = "0.0.1";
       sha256 = "f76d4871ecf7c137b204fa46f1bdcad9a16376370237ad1541ca5d5ec57b75c9";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google YouTube Analytics SDK";
       license = "unknown";
     }) {};

  "gogol-youtube-reporting" = callPackage
    ({ mkDerivation, base, gogol-core }:
     mkDerivation {
       pname = "gogol-youtube-reporting";
       version = "0.0.1";
       sha256 = "85bd2bcf66f0a7c732333e85774192c4647fb28f70da091a13d297f9788cc82c";
       libraryHaskellDepends = [ base gogol-core ];
       homepage = "https://github.com/brendanhay/gogol";
       description = "Google YouTube Reporting SDK";
       license = "unknown";
     }) {};

  "gooey" = callPackage
    ({ mkDerivation, base, renderable, transformers, varying }:
     mkDerivation {
       pname = "gooey";
       version = "0.1.0.0";
       sha256 = "f224cc55134f260e9b5edd908f4534a41a2c47a63388c9b34022d58fe95e545a";
       libraryHaskellDepends = [ base renderable transformers varying ];
       jailbreak = true;
       description = "Graphical user interfaces that are renderable, change over time and eventually produce a value";
       license = stdenv.lib.licenses.mit;
     }) {};

  "google-cloud" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-client
     , http-client-tls, http-types, mtl, random, scientific, stm, text
     , time, unordered-containers
     }:
     mkDerivation {
       pname = "google-cloud";
       version = "0.0.3";
       sha256 = "16462026bc546cf51d453524ce0aae735bdc84f4d0d1f276ccc6606e41b8655f";
       libraryHaskellDepends = [
         aeson base bytestring http-client http-client-tls http-types mtl
         random scientific stm text time unordered-containers
       ];
       description = "Client for the Google Cloud APIs";
       license = stdenv.lib.licenses.mit;
     }) {};

  "google-dictionary" = callPackage
    ({ mkDerivation, aeson, base, bytestring, HTTP, lens, mtl }:
     mkDerivation {
       pname = "google-dictionary";
       version = "0.1.0.2";
       sha256 = "cf3ccd3920cf9325c25201d6be8f6f5cf98d957cdd23ffe3de0d3cc990272b8a";
       libraryHaskellDepends = [ aeson base bytestring HTTP lens mtl ];
       homepage = "https://github.com/mitchellwrosen/google-dictionary-api";
       description = "Simple interface to the google.com/dictionary API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "google-drive" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra
     , directory, filepath, google-oauth2, hspec
     , hspec-expectations-lifted, http-conduit, http-types, load-env
     , mtl, random, resourcet, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "google-drive";
       version = "0.4.1";
       sha256 = "f3f742eccf51897db9da71ea1cad0d2632122e94ee98f160e20fef75b58b17f2";
       libraryHaskellDepends = [
         aeson base bytestring conduit conduit-extra directory filepath
         http-conduit http-types mtl random resourcet text time
         unordered-containers
       ];
       testHaskellDepends = [
         base bytestring conduit conduit-extra directory google-oauth2 hspec
         hspec-expectations-lifted load-env text time
       ];
       description = "Google Drive API access";
       license = stdenv.lib.licenses.mit;
     }) {};

  "google-html5-slide" = callPackage
    ({ mkDerivation, base, blaze-html, cmdargs, data-default, hamlet
     , pandoc, shakespeare-css, syb, text, time
     }:
     mkDerivation {
       pname = "google-html5-slide";
       version = "2011.0";
       sha256 = "f4d7b8b06cc9b23c6e6401ebb58741c1842131a34cb8a69036dc511281a36b72";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-html cmdargs data-default hamlet pandoc shakespeare-css
         syb text time
       ];
       jailbreak = true;
       description = "Google HTML5 Slide generator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "google-mail-filters" = callPackage
    ({ mkDerivation, base, containers, google-search, old-locale, text
     , time, xml-conduit
     }:
     mkDerivation {
       pname = "google-mail-filters";
       version = "0.0.1.1";
       sha256 = "21588dbfdcd5de6a5cfc307846532dfd541ab4c826e8b70936a3406140a6ba33";
       libraryHaskellDepends = [
         base containers google-search old-locale text time xml-conduit
       ];
       testHaskellDepends = [ base google-search text time xml-conduit ];
       homepage = "https://github.com/liyang/google-mail-filters";
       description = "Write GMail filters and output to importable XML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "google-oauth2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, hspec, HTTP, http-conduit
     , http-types, load-env
     }:
     mkDerivation {
       pname = "google-oauth2";
       version = "0.2.0";
       sha256 = "087c6429fafea6c80eb83488ff874eeda090dd7663820cfc872f2c8ef2e25895";
       libraryHaskellDepends = [
         aeson base bytestring HTTP http-conduit
       ];
       testHaskellDepends = [
         base bytestring hspec http-conduit http-types load-env
       ];
       jailbreak = true;
       description = "Google OAuth2 token negotiation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "google-search" = callPackage
    ({ mkDerivation, base, free, nats, old-locale, text, time }:
     mkDerivation {
       pname = "google-search";
       version = "0.1.0.1";
       sha256 = "a7960a8421976aad8f3f06d25fdf2fcd2c936bdebd7cb3319c7538f9cbdd775a";
       libraryHaskellDepends = [ base free nats old-locale text time ];
       homepage = "https://github.com/liyang/google-search";
       description = "EDSL for Google and GMail search expressions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "google-translate" = callPackage
    ({ mkDerivation, aeson, base, bytestring, either, servant
     , servant-client, text
     }:
     mkDerivation {
       pname = "google-translate";
       version = "0.1.1.2";
       sha256 = "cf5f09f94fe6b938390a4e48865b15bf47aba4d6a03071631666b81c162c5cdc";
       libraryHaskellDepends = [
         aeson base bytestring either servant servant-client text
       ];
       description = "Google Translate API bindings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "googleplus" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , enumerator, haskell98, http-enumerator, http-types, mtl, text
     , time, timerep, transformers, url
     }:
     mkDerivation {
       pname = "googleplus";
       version = "0.3.1.1";
       sha256 = "4f8a695b9a92c042242c1be8e58e5e18cd2e6819bd6dd29fe2003c8672dece10";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers enumerator haskell98
         http-enumerator http-types mtl text time timerep transformers url
       ];
       jailbreak = true;
       homepage = "http://github.com/michaelxavier/GooglePlus";
       description = "Haskell implementation of the Google+ API v1";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "googlepolyline" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text
     }:
     mkDerivation {
       pname = "googlepolyline";
       version = "0.1.0.1";
       sha256 = "b16915544bfe4656fdf6104e769df8bac4a3e6c5f4ffd0c622d09fffb5f68717";
       libraryHaskellDepends = [ base bytestring text ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "https://github.com/lornap/googlepolyline";
       description = "Google Polyline Encoder/Decoder";
       license = stdenv.lib.licenses.mit;
     }) {};

  "gopherbot" = callPackage
    ({ mkDerivation, base, HDBC, HDBC-postgresql, MissingH, network
     , parsec, unix
     }:
     mkDerivation {
       pname = "gopherbot";
       version = "0.1.0";
       sha256 = "cfca9d1268eba520c14e24093b0f459d58c822045e307e89bbba9c7480ee4461";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base HDBC HDBC-postgresql MissingH network parsec unix
       ];
       description = "Spidering robot to download files from Gopherspace";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gore-and-ash" = callPackage
    ({ mkDerivation, base, containers, deepseq, exceptions, hashable
     , linear, mtl, parallel, profunctors, random, semigroups, time
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "gore-and-ash";
       version = "1.1.0.1";
       sha256 = "3fc41721e92097558f4247a5b195bac9d9d9bd9313b2d92f402d3535aa90d149";
       libraryHaskellDepends = [
         base containers deepseq exceptions hashable linear mtl parallel
         profunctors random semigroups time transformers
         unordered-containers
       ];
       homepage = "https://github.com/Teaspot-Studio/gore-and-ash";
       description = "Core of FRP game engine called Gore&Ash";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gore-and-ash-actor" = callPackage
    ({ mkDerivation, base, containers, deepseq, exceptions
     , gore-and-ash, hashable, mtl, resourcet, transformers
     , transformers-base, unordered-containers
     }:
     mkDerivation {
       pname = "gore-and-ash-actor";
       version = "1.2.1.0";
       sha256 = "7769718f402328fb3ae3ea268d8da5398f897cd7c3702372b8a9a1f560cc9360";
       libraryHaskellDepends = [
         base containers deepseq exceptions gore-and-ash hashable mtl
         resourcet transformers transformers-base unordered-containers
       ];
       homepage = "https://github.com/Teaspot-Studio/gore-and-ash-actor";
       description = "Gore&Ash engine extension that implements actor style of programming";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gore-and-ash-async" = callPackage
    ({ mkDerivation, async, base, containers, deepseq, exceptions
     , gore-and-ash, hashable, HUnit, mtl, resourcet, test-framework
     , test-framework-hunit, transformers, transformers-base
     , unordered-containers
     }:
     mkDerivation {
       pname = "gore-and-ash-async";
       version = "1.1.0.0";
       sha256 = "8ed161f2d598e3f84c1ee3a2abe2ed0b8d41f4bcb526467bfbe00ba3cf6edf74";
       libraryHaskellDepends = [
         async base containers deepseq exceptions gore-and-ash hashable mtl
         resourcet transformers transformers-base unordered-containers
       ];
       testHaskellDepends = [
         base containers deepseq exceptions gore-and-ash HUnit mtl
         test-framework test-framework-hunit transformers
       ];
       homepage = "https://github.com/TeaspotStudio/gore-and-ash-async#readme";
       description = "Core module for Gore&Ash engine that embeds async IO actions into game loop";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gore-and-ash-demo" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, deepseq
     , exception-transformers, exceptions, GLFW-b, gore-and-ash
     , gore-and-ash-actor, gore-and-ash-logging, gore-and-ash-network
     , gore-and-ash-sdl, gore-and-ash-sync, hashable, lens, linear
     , network, OpenGL, sdl2, text, text-show, time, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "gore-and-ash-demo";
       version = "1.1.0.0";
       sha256 = "08d6fa2861a03281dee03e0baa5c23a54e7366f1d5cb1390e921b90fe8c7ab3b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cereal containers deepseq exception-transformers
         exceptions GLFW-b gore-and-ash gore-and-ash-actor
         gore-and-ash-logging gore-and-ash-network gore-and-ash-sdl
         gore-and-ash-sync hashable lens linear network OpenGL sdl2 text
         text-show time transformers unordered-containers vector
       ];
       homepage = "https://github.com/Teaspot-Studio/gore-and-ash-demo";
       description = "Demonstration game for Gore&Ash game engine";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gore-and-ash-glfw" = callPackage
    ({ mkDerivation, base, deepseq, exceptions, extra, GLFW-b
     , gore-and-ash, hashable, mtl, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "gore-and-ash-glfw";
       version = "1.1.0.0";
       sha256 = "e953449a6d07626dddcd347e52d20610b82a89e3ff0eb6e70166dc3e098bb504";
       libraryHaskellDepends = [
         base deepseq exceptions extra GLFW-b gore-and-ash hashable mtl
         transformers unordered-containers
       ];
       homepage = "https://github.com/Teaspot-Studio/gore-and-ash-glfw";
       description = "Core module for Gore&Ash engine for GLFW input events";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gore-and-ash-logging" = callPackage
    ({ mkDerivation, base, containers, deepseq, exceptions
     , gore-and-ash, mtl, resourcet, text, text-show, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "gore-and-ash-logging";
       version = "1.2.1.0";
       sha256 = "e036991edeaf1ba9eefa57a8668d1793a63bba816ffbf856a001fb5674881293";
       libraryHaskellDepends = [
         base containers deepseq exceptions gore-and-ash mtl resourcet text
         text-show transformers transformers-base
       ];
       homepage = "https://github.com/Teaspot-Studio/gore-and-ash-logging";
       description = "Core module for gore-and-ash with logging utilities";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gore-and-ash-network" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, exceptions
     , extra, ghc-prim, gore-and-ash, gore-and-ash-logging, hashable
     , integer-gmp, mtl, network, resourcet, text, text-show
     , transformers, transformers-base, typesafe-endian
     , unordered-containers
     }:
     mkDerivation {
       pname = "gore-and-ash-network";
       version = "1.3.2.0";
       sha256 = "7093854a9ceb887bd7b58cad8d79d46ed632609f54bdfb2c7a2dcefe7296f4d2";
       libraryHaskellDepends = [
         base bytestring containers deepseq exceptions extra ghc-prim
         gore-and-ash gore-and-ash-logging hashable integer-gmp mtl network
         resourcet text text-show transformers transformers-base
         typesafe-endian unordered-containers
       ];
       homepage = "https://github.com/Teaspot-Studio/gore-and-ash-network";
       description = "Core module for Gore&Ash engine with low level network API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gore-and-ash-sdl" = callPackage
    ({ mkDerivation, base, containers, deepseq, exceptions
     , gore-and-ash, lens, linear, mtl, resourcet, sdl2, text
     , transformers, transformers-base, unordered-containers
     }:
     mkDerivation {
       pname = "gore-and-ash-sdl";
       version = "2.1.0.0";
       sha256 = "2c8ec109e234cbaef34ac6b72a7a5182437a0f0473006d033cd51102d868294d";
       libraryHaskellDepends = [
         base containers deepseq exceptions gore-and-ash lens linear mtl
         resourcet sdl2 text transformers transformers-base
         unordered-containers
       ];
       homepage = "git@github.com:Teaspot-Studio/gore-and-ash-sdl.git";
       description = "Gore&Ash core module for integration with SDL library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gore-and-ash-sync" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, deepseq
     , exceptions, gore-and-ash, gore-and-ash-actor
     , gore-and-ash-logging, gore-and-ash-network, hashable, mtl
     , resourcet, text, transformers, transformers-base
     , unordered-containers
     }:
     mkDerivation {
       pname = "gore-and-ash-sync";
       version = "1.2.0.0";
       sha256 = "719827da28924991b85d8d3aca1ca5fe1ebdb77d3d32154bdfc1790928015769";
       libraryHaskellDepends = [
         base bytestring cereal containers deepseq exceptions gore-and-ash
         gore-and-ash-actor gore-and-ash-logging gore-and-ash-network
         hashable mtl resourcet text transformers transformers-base
         unordered-containers
       ];
       homepage = "https://github.com/Teaspot-Studio/gore-and-ash-sync";
       description = "Gore&Ash module for high level network synchronization";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gpah" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, cmdargs, containers, csv
     , deepseq, directory, filepath, haskell-src-exts, hint, HTTP
     , network, process, syb, tar, uniplate, uu-parsinglib, zlib
     }:
     mkDerivation {
       pname = "gpah";
       version = "0.0.2";
       sha256 = "b92f0c4e15a1b0401294277a77d25817870b527ed19c046d0273bce68a019fff";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal cmdargs containers csv deepseq directory
         filepath haskell-src-exts hint HTTP network process syb tar
         uniplate uu-parsinglib zlib
       ];
       description = "Generic Programming Use in Hackage";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gpcsets" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "gpcsets";
       version = "0.9.2.0";
       sha256 = "4827ff862df2f527eb175e2c66c2eeaee9813f99868a55371faa2c67ac99a0ba";
       libraryHaskellDepends = [ base ];
       description = "Generalized Pitch Class Sets for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gpolyline" = callPackage
    ({ mkDerivation, base, split }:
     mkDerivation {
       pname = "gpolyline";
       version = "0.1.0.1";
       sha256 = "28b3a644853ba6f0a7d6465d8d62646a10c995008a799ae67e728c8cf4a17a05";
       libraryHaskellDepends = [ base split ];
       homepage = "https://github.com/fegu/gpolyline";
       description = "Pure module for encoding/decoding Google Polyline";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gps" = callPackage
    ({ mkDerivation, base, gpx-conduit, pretty, prettyclass, QuickCheck
     , statistics, test-framework, test-framework-quickcheck2, text
     , time, vector
     }:
     mkDerivation {
       pname = "gps";
       version = "1.2";
       sha256 = "1984c24bbec7214b1adcda48b53ded59fdb21d2eeb19793ac59c2e9cb63638cf";
       libraryHaskellDepends = [
         base pretty prettyclass statistics text time vector
       ];
       testHaskellDepends = [
         base gpx-conduit QuickCheck statistics test-framework
         test-framework-quickcheck2 time vector
       ];
       description = "For manipulating GPS coordinates and trails";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gps2htmlReport" = callPackage
    ({ mkDerivation, base, bytestring, cairo, Chart, cmdargs, colour
     , data-accessor, directory, filepath, gd, gps, GPX, hsmagick, html
     , http-enumerator, process, random, tar, time, xsd
     }:
     mkDerivation {
       pname = "gps2htmlReport";
       version = "0.3.1";
       sha256 = "e8f5bdaba6dd7b45a06a8e3f0e88df1e2568c6ccb4fa611556bef2c10d0bcad8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cairo Chart cmdargs colour data-accessor directory
         filepath gd gps GPX hsmagick html http-enumerator process random
         tar time xsd
       ];
       jailbreak = true;
       homepage = "https://github.com/robstewart57/Gps2HtmlReport";
       description = "GPS to HTML Summary Report";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gpx-conduit" = callPackage
    ({ mkDerivation, attoparsec, base, conduit, filepath, monad-control
     , old-locale, text, time, void, xml-conduit, xml-types
     }:
     mkDerivation {
       pname = "gpx-conduit";
       version = "0.1.1";
       sha256 = "44d6933bf085085ab2f0ffb67dd417577e33f8edf637d63a4e6679d0af05cb39";
       libraryHaskellDepends = [
         attoparsec base conduit filepath monad-control old-locale text time
         void xml-conduit xml-types
       ];
       jailbreak = true;
       description = "Read GPX files using conduits";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graceful" = callPackage
    ({ mkDerivation, base, directory, filepath, hspec, network, process
     , stm, unix
     }:
     mkDerivation {
       pname = "graceful";
       version = "0.1.1.5";
       sha256 = "19ae6a0ca0cb26c6453520ccec8e5f29b57d1a18c84991cff181176f03f084ce";
       libraryHaskellDepends = [ base directory network stm unix ];
       testHaskellDepends = [
         base directory filepath hspec network process stm unix
       ];
       description = "Library to write graceful shutdown / upgrade service";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "grammar-combinators" = callPackage
    ({ mkDerivation, base, containers, enumerable, fgl, graphviz
     , MaybeT, mtl, multirec, parsec, template-haskell, text
     , uu-parsinglib
     }:
     mkDerivation {
       pname = "grammar-combinators";
       version = "0.2.7";
       sha256 = "ad4d785dc98ba645f815ca3fb846b0744357c555ee71534e7829a4078e08f1fc";
       libraryHaskellDepends = [
         base containers enumerable fgl graphviz MaybeT mtl multirec parsec
         template-haskell text uu-parsinglib
       ];
       homepage = "http://projects.haskell.org/grammar-combinators/";
       description = "A parsing library of context-free grammar combinators";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "grapefruit-examples" = callPackage
    ({ mkDerivation, base, colour, containers, fraction, grapefruit-frp
     , grapefruit-records, grapefruit-ui
     }:
     mkDerivation {
       pname = "grapefruit-examples";
       version = "0.1.0.5";
       sha256 = "994a75f551cfe8c1a91eb83c5100abb6177acc3fdcd13c643ef08573ad24a629";
       libraryHaskellDepends = [
         base colour containers fraction grapefruit-frp grapefruit-records
         grapefruit-ui
       ];
       homepage = "http://grapefruit-project.org/";
       description = "Examples using the Grapefruit library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "grapefruit-frp" = callPackage
    ({ mkDerivation, arrows, base, containers, fingertree, semigroups
     , TypeCompose
     }:
     mkDerivation {
       pname = "grapefruit-frp";
       version = "0.1.0.5";
       sha256 = "15b626d8eaa352f3ad891cf7a235a71161791797326400d630a4fe4a9dacb094";
       libraryHaskellDepends = [
         arrows base containers fingertree semigroups TypeCompose
       ];
       jailbreak = true;
       homepage = "http://grapefruit-project.org/";
       description = "Functional Reactive Programming core";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "grapefruit-records" = callPackage
    ({ mkDerivation, arrows, base, grapefruit-frp }:
     mkDerivation {
       pname = "grapefruit-records";
       version = "0.1.0.5";
       sha256 = "011af70c436e6463b0fa43e873fcdbe584ac7a29546deb6d4dd401f1f5ca1e0a";
       libraryHaskellDepends = [ arrows base grapefruit-frp ];
       homepage = "http://grapefruit-project.org/";
       description = "A record system for Functional Reactive Programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "grapefruit-ui" = callPackage
    ({ mkDerivation, arrows, base, colour, containers, fraction
     , grapefruit-frp, grapefruit-records
     }:
     mkDerivation {
       pname = "grapefruit-ui";
       version = "0.1.0.5";
       sha256 = "58264c0628092bef6ecaa148de601a267bea6c352a8488f8fd7e1f82c4dbbd87";
       libraryHaskellDepends = [
         arrows base colour containers fraction grapefruit-frp
         grapefruit-records
       ];
       homepage = "http://grapefruit-project.org/";
       description = "Declarative user interface programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "grapefruit-ui-gtk" = callPackage
    ({ mkDerivation, base, colour, containers, fraction, glib
     , grapefruit-frp, grapefruit-records, grapefruit-ui, gtk
     }:
     mkDerivation {
       pname = "grapefruit-ui-gtk";
       version = "0.1.0.5";
       sha256 = "3f91385bada888f49f9b61b8c0bc289675fcd447f875c766044e9c6da5dfda80";
       libraryHaskellDepends = [
         base colour containers fraction glib grapefruit-frp
         grapefruit-records grapefruit-ui gtk
       ];
       jailbreak = true;
       homepage = "http://grapefruit-project.org/";
       description = "GTK+-based backend for declarative user interface programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graph-core_0_2_1_0" = callPackage
    ({ mkDerivation, base, containers, deepseq, hashable, HTF, mtl
     , QuickCheck, safe, unordered-containers, vector
     }:
     mkDerivation {
       pname = "graph-core";
       version = "0.2.1.0";
       sha256 = "ee783ae89a04fbcebd96166de2813ec7a75c6e136b42006f4ee7d910c54da977";
       revision = "1";
       editedCabalFile = "cd8cb2bd5155841338cb527029e919c4320620e3be93ad4c86e1cd2dfecd0629";
       libraryHaskellDepends = [
         base containers deepseq hashable mtl QuickCheck safe
         unordered-containers vector
       ];
       testHaskellDepends = [
         base containers deepseq hashable HTF mtl QuickCheck safe
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/factisresearch/graph-core";
       description = "Fast, memory efficient and persistent graph implementation";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graph-core_0_2_2_0" = callPackage
    ({ mkDerivation, base, containers, deepseq, hashable, HTF, mtl
     , QuickCheck, safe, unordered-containers, vector
     }:
     mkDerivation {
       pname = "graph-core";
       version = "0.2.2.0";
       sha256 = "291b63c29296ae9aec1b2c2ed9ea4fc7163b4ba069a531e83b541d7e5e63f833";
       revision = "1";
       editedCabalFile = "d9314f075fecb0674ef9c6ee42d4b2224407e2da959add39eb8651cd8a97d5d3";
       libraryHaskellDepends = [
         base containers deepseq hashable mtl QuickCheck safe
         unordered-containers vector
       ];
       testHaskellDepends = [
         base containers deepseq hashable HTF mtl QuickCheck safe
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/factisresearch/graph-core";
       description = "Fast, memory efficient and persistent graph implementation";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graph-core" = callPackage
    ({ mkDerivation, base, containers, deepseq, hashable, HTF, mtl
     , QuickCheck, safe, unordered-containers, vector
     }:
     mkDerivation {
       pname = "graph-core";
       version = "0.3.0.0";
       sha256 = "378f0baa40ebbb78e8c389f79e363eb573cdf182f799684d2f3d6ac51b10e854";
       libraryHaskellDepends = [
         base containers deepseq hashable mtl safe unordered-containers
         vector
       ];
       testHaskellDepends = [
         base containers deepseq hashable HTF mtl QuickCheck safe
         unordered-containers vector
       ];
       homepage = "https://github.com/factisresearch/graph-core";
       description = "Fast, memory efficient and persistent graph implementation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "graph-generators" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, fgl, hspec
     , hspec-expectations, multiset, mwc-random, QuickCheck
     }:
     mkDerivation {
       pname = "graph-generators";
       version = "0.1.3.0";
       sha256 = "1fe09712b7c52b18da467facf0ffb78e7de515113401b5c2d8adf7fb13603d50";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers fgl multiset mwc-random
       ];
       executableHaskellDepends = [
         base containers directory fgl multiset mwc-random
       ];
       testHaskellDepends = [
         base Cabal containers fgl hspec hspec-expectations multiset
         mwc-random QuickCheck
       ];
       homepage = "https://github.com/ulikoehler/graph-random";
       description = "Functions for generating structured or random FGL graphs";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "graph-matchings" = callPackage
    ({ mkDerivation, base, containers, fgl }:
     mkDerivation {
       pname = "graph-matchings";
       version = "0.1.0.0";
       sha256 = "7b155de108fc4abf89143c1be095600260bda7be74adb9c5eb131ac047d8f337";
       libraryHaskellDepends = [ base containers fgl ];
       description = "An implementation of algorithms for matchings in graphs";
       license = stdenv.lib.licenses.lgpl21;
     }) {};

  "graph-rewriting" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, containers, mtl }:
     mkDerivation {
       pname = "graph-rewriting";
       version = "0.7.8";
       sha256 = "cece8e180698771b872f2ab18cf73eafa4704fcd0e1b0e94a1924d6f9cc2b688";
       libraryHaskellDepends = [
         base base-unicode-symbols containers mtl
       ];
       homepage = "http://rochel.info/#graph-rewriting";
       description = "Monadic graph rewriting of hypergraphs with ports and multiedges";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graph-rewriting-cl" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, GLUT, graph-rewriting
     , graph-rewriting-gl, graph-rewriting-layout, OpenGL, parsec
     }:
     mkDerivation {
       pname = "graph-rewriting-cl";
       version = "0.2.2";
       sha256 = "2033b1f4a3c39f6f64ea1a7a9ca6975c683382190806042a57c97fbb87669e67";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base base-unicode-symbols GLUT graph-rewriting graph-rewriting-gl
         graph-rewriting-layout OpenGL parsec
       ];
       jailbreak = true;
       homepage = "http://rochel.info/#graph-rewriting";
       description = "Interactive graph rewriting system implementing various well-known combinators";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graph-rewriting-gl" = callPackage
    ({ mkDerivation, AC-Vector, base, base-unicode-symbols, containers
     , GLUT, graph-rewriting, graph-rewriting-layout, OpenGL
     }:
     mkDerivation {
       pname = "graph-rewriting-gl";
       version = "0.7.6";
       sha256 = "a6157c17e07fbf167b64ebfa51e256794fd99ce1fff4ede88035d8c9e4299239";
       libraryHaskellDepends = [
         AC-Vector base base-unicode-symbols containers GLUT graph-rewriting
         graph-rewriting-layout OpenGL
       ];
       homepage = "http://rochel.info/#graph-rewriting";
       description = "OpenGL interface for interactive port graph rewriting";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graph-rewriting-lambdascope" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, GLUT, graph-rewriting
     , graph-rewriting-gl, graph-rewriting-layout
     , graph-rewriting-strategies, IndentParser, OpenGL, parsec
     }:
     mkDerivation {
       pname = "graph-rewriting-lambdascope";
       version = "0.5.8";
       sha256 = "e56293febd459060627af0912e7c1d0a0d6840fa31c2d5e9fcc1ca9bf9914db1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base base-unicode-symbols GLUT graph-rewriting graph-rewriting-gl
         graph-rewriting-layout graph-rewriting-strategies IndentParser
         OpenGL parsec
       ];
       homepage = "http://rochel.info/#graph-rewriting";
       description = "Lambdascope, an optimal evaluator of the lambda calculus, as an interactive graph-rewriting system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graph-rewriting-layout" = callPackage
    ({ mkDerivation, AC-Vector, base, base-unicode-symbols
     , graph-rewriting
     }:
     mkDerivation {
       pname = "graph-rewriting-layout";
       version = "0.5.4";
       sha256 = "052f1d481edf398cfd486849d981de20a298842a75a20864190b921af8fd7d92";
       libraryHaskellDepends = [
         AC-Vector base base-unicode-symbols graph-rewriting
       ];
       homepage = "http://rochel.info/#graph-rewriting";
       description = "Force-directed node placement intended for incremental graph drawing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graph-rewriting-ski" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, GLUT, graph-rewriting
     , graph-rewriting-gl, graph-rewriting-layout, OpenGL, parsec
     }:
     mkDerivation {
       pname = "graph-rewriting-ski";
       version = "0.6.5";
       sha256 = "019378940fb886e668a57a580b2df65309ab80def00555c77cf75b224923ac1a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base base-unicode-symbols GLUT graph-rewriting graph-rewriting-gl
         graph-rewriting-layout OpenGL parsec
       ];
       homepage = "http://rochel.info/#graph-rewriting";
       description = "Two evalutors of the SKI combinator calculus as interactive graph rewrite systems";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graph-rewriting-strategies" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, containers
     , graph-rewriting
     }:
     mkDerivation {
       pname = "graph-rewriting-strategies";
       version = "0.2.4";
       sha256 = "6230a111c89e765aba002eaf62db138e7ec848474f78b300c21b7d7e087caa57";
       libraryHaskellDepends = [
         base base-unicode-symbols containers graph-rewriting
       ];
       homepage = "http://rochel.info/#graph-rewriting";
       description = "Evaluation strategies for port-graph rewriting systems";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graph-rewriting-trs" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, containers, directory
     , filepath, GLUT, graph-rewriting, graph-rewriting-gl
     , graph-rewriting-layout, OpenGL, uu-parsinglib
     }:
     mkDerivation {
       pname = "graph-rewriting-trs";
       version = "0.1.7";
       sha256 = "e5e3a8e1bf70e39a933cd0b4d395eaf4c912cdbb547926b6a26472163fdbe92e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base base-unicode-symbols containers directory filepath GLUT
         graph-rewriting graph-rewriting-gl graph-rewriting-layout OpenGL
         uu-parsinglib
       ];
       homepage = "http://rochel.info/#graph-rewriting";
       description = "Evaluate first-order applicative term rewrite systems interactively using graph reduction";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graph-rewriting-ww" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, GLUT, graph-rewriting
     , graph-rewriting-gl, graph-rewriting-layout, IndentParser, OpenGL
     , parsec
     }:
     mkDerivation {
       pname = "graph-rewriting-ww";
       version = "0.3.5";
       sha256 = "649160c0315861f275012e891a074a96aa6f59a3890f2e69f9612a1d91dece5a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base base-unicode-symbols GLUT graph-rewriting graph-rewriting-gl
         graph-rewriting-layout IndentParser OpenGL parsec
       ];
       homepage = "http://rochel.info/#graph-rewriting";
       description = "Evaluator of the lambda-calculus in an interactive graph rewriting system with explicit sharing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graph-serialize" = callPackage
    ({ mkDerivation, array, base, bytestring, containers }:
     mkDerivation {
       pname = "graph-serialize";
       version = "0.2";
       sha256 = "e434c40477bc664da18a6ff3dbf796dcf3109c6d54cea1a491e6757f5fc138a9";
       libraryHaskellDepends = [ array base bytestring containers ];
       homepage = "http://github.com/nominolo/graph-serialize";
       description = "Serialization of data structures with references";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "graph-utils" = callPackage
    ({ mkDerivation, base, containers, fgl, mtl, parsec, syb
     , template-haskell
     }:
     mkDerivation {
       pname = "graph-utils";
       version = "0.3.7";
       sha256 = "4e53e6355b1b72d1465e8ba516e2e62b9f836008fa9667526ed63df05134941b";
       libraryHaskellDepends = [
         base containers fgl mtl parsec syb template-haskell
       ];
       jailbreak = true;
       homepage = "http://github.com/konn/graph-utils/";
       description = "A simple wrapper & quasi quoter for fgl";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graph-visit" = callPackage
    ({ mkDerivation, base, containers, data-lens, data-lens-template
     , mtl
     }:
     mkDerivation {
       pname = "graph-visit";
       version = "0.1.0.2";
       sha256 = "1858477f514df85d7eb5ae51d6ab9da605dd335d0c6fa23bb08994793107d229";
       libraryHaskellDepends = [
         base containers data-lens data-lens-template mtl
       ];
       homepage = "https://github.com/atzedijkstra/graph-visit";
       description = "Graph walk abstraction";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "graph-wrapper" = callPackage
    ({ mkDerivation, array, base, containers, deepseq, hspec
     , QuickCheck
     }:
     mkDerivation {
       pname = "graph-wrapper";
       version = "0.2.5.1";
       sha256 = "8361853fca2d2251bd233e18393053dd391d21ca6f210b2bc861b0e0f4c2e113";
       libraryHaskellDepends = [ array base containers ];
       testHaskellDepends = [
         array base containers deepseq hspec QuickCheck
       ];
       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;
     }) {};

  "graphbuilder" = callPackage
    ({ mkDerivation, base, containers, mtl, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "graphbuilder";
       version = "0.1.0.0";
       sha256 = "4b887840c5d12efbf45dfeb3f488771c0a9d5deb4a62668d6f462a3ccafa127e";
       libraryHaskellDepends = [ base containers mtl ];
       testHaskellDepends = [
         base containers mtl QuickCheck test-framework
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/tel/graphbuilder";
       description = "A declarative, monadic graph construction language for small graphs";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graphene" = callPackage
    ({ mkDerivation, base, bifunctors, containers, hashable
     , lens-family, lens-family-core, mtl, transformers
     }:
     mkDerivation {
       pname = "graphene";
       version = "0.1.0.4";
       sha256 = "0680af897f76bf5831bf73705ece15b9543d93e2e9586ed6f049e8e1303c0527";
       libraryHaskellDepends = [
         base bifunctors containers hashable lens-family lens-family-core
         mtl transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/5outh/graphene";
       description = "A minimal Graph Theory library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "graphics-drawingcombinators" = callPackage
    ({ mkDerivation, base, bitmap, bitmap-opengl, FTGL, OpenGL
     , stb-image
     }:
     mkDerivation {
       pname = "graphics-drawingcombinators";
       version = "1.5.1";
       sha256 = "4e8ffecad64bc9529869059a62c3dc2ca177465dc8c3890e0be6b74b4aa61148";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bitmap bitmap-opengl FTGL OpenGL stb-image
       ];
       jailbreak = true;
       homepage = "http://github.com/luqui/graphics-drawingcombinators";
       description = "A functional interface to 2D drawing in OpenGL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "graphics-formats-collada" = callPackage
    ({ mkDerivation, base, bitmap-opengl, containers, hxt, OpenGL
     , stb-image, transformers
     }:
     mkDerivation {
       pname = "graphics-formats-collada";
       version = "0.3.1";
       sha256 = "7bed3e6e9075dc8963b0b3c3c7b43b9c100be13b1b4709273b516cd4050bddcd";
       libraryHaskellDepends = [
         base bitmap-opengl containers hxt OpenGL stb-image transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/luqui/collada";
       description = "Load 3D geometry in the COLLADA format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graphicsFormats" = callPackage
    ({ mkDerivation, base, haskell98, OpenGL, QuickCheck }:
     mkDerivation {
       pname = "graphicsFormats";
       version = "0.1";
       sha256 = "d0a2959f88ce429c81970d314df1a0fde1123572f3e1206c7658618c2c90982d";
       libraryHaskellDepends = [ base haskell98 OpenGL QuickCheck ];
       description = "Classes for renderable objects";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graphicstools" = callPackage
    ({ mkDerivation, base, bindings-DSL, containers, CV, directory
     , ghc-prim, wx, wxcore
     }:
     mkDerivation {
       pname = "graphicstools";
       version = "0.2.2";
       sha256 = "e8ea7bc869663f487cd1abe06168035b7b21348cb344b035d1b41de70d479f41";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bindings-DSL containers CV directory ghc-prim wx wxcore
       ];
       executableHaskellDepends = [ base CV wx wxcore ];
       homepage = "https://yousource.it.jyu.fi/cvlab/pages/GraphicsTools";
       description = "Tools for creating graphical UIs, based on wxHaskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graphmod" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, dotgen
     , filepath, haskell-lexer
     }:
     mkDerivation {
       pname = "graphmod";
       version = "1.2.9";
       sha256 = "2e9af4e92a2cad0fc4132060bcf61bdbed28bde50b3ca5d1cadb9db37d1493d9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers directory dotgen filepath haskell-lexer
       ];
       homepage = "http://github.com/yav/graphmod/wiki";
       description = "Present the module dependencies of a program as a \"dot\" graph";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "graphql" = callPackage
    ({ mkDerivation, attoparsec, base, tasty, tasty-hunit, text }:
     mkDerivation {
       pname = "graphql";
       version = "0.3";
       sha256 = "7f141c9507c135baf49491461060333e30128b49287f9b72de2875cef8420ba2";
       libraryHaskellDepends = [ attoparsec base text ];
       testHaskellDepends = [ attoparsec base tasty tasty-hunit text ];
       homepage = "https://github.com/jdnavarro/graphql-haskell";
       description = "Haskell GraphQL implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "graphs_0_5_0_1" = callPackage
    ({ mkDerivation, array, base, containers, transformers, void }:
     mkDerivation {
       pname = "graphs";
       version = "0.5.0.1";
       sha256 = "2e392501ae459062c464fca9b20e08d1f52c450c5419373037d82f631c8c25e3";
       libraryHaskellDepends = [
         array base containers transformers void
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/graphs";
       description = "A simple monadic graph library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graphs_0_6_0_1" = callPackage
    ({ mkDerivation, array, base, containers, transformers, void }:
     mkDerivation {
       pname = "graphs";
       version = "0.6.0.1";
       sha256 = "53cb3a6425e2c4078a105d80a48899417f48aa1f9075cfcf51f747b3cb0c3618";
       libraryHaskellDepends = [
         array base containers transformers void
       ];
       homepage = "http://github.com/ekmett/graphs";
       description = "A simple monadic graph library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graphs" = callPackage
    ({ mkDerivation, array, base, containers, transformers
     , transformers-compat, void
     }:
     mkDerivation {
       pname = "graphs";
       version = "0.7";
       sha256 = "eea656ac6092eac99bafc0b7817efa34529b895408fc1267a5b573fb332f6f4c";
       libraryHaskellDepends = [
         array base containers transformers transformers-compat void
       ];
       homepage = "http://github.com/ekmett/graphs";
       description = "A simple monadic graph library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "graphtype" = callPackage
    ({ mkDerivation, base, containers, dotgen, haskell-src-exts
     , haskell98, uniplate
     }:
     mkDerivation {
       pname = "graphtype";
       version = "0.2.0";
       sha256 = "71b964e4d634a09131a07a3f24f718c251811d296ded1611bffc8e45daa3cb8e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers dotgen haskell-src-exts haskell98 uniplate
       ];
       homepage = "http://github.com/explicitcall/graphtype";
       description = "A simple tool to illustrate dependencies between Haskell types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graphviz_2999_17_0_1" = callPackage
    ({ mkDerivation, base, bytestring, colour, containers, directory
     , dlist, fgl, filepath, polyparse, process, QuickCheck, temporary
     , text, transformers, wl-pprint-text
     }:
     mkDerivation {
       pname = "graphviz";
       version = "2999.17.0.1";
       sha256 = "bbc721a46515cf16961aa67285d274502a64347bd400b64fa799d28d690dd468";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring colour containers directory dlist fgl filepath
         polyparse process temporary text transformers wl-pprint-text
       ];
       executableHaskellDepends = [
         base bytestring directory filepath text
       ];
       testHaskellDepends = [
         base containers fgl filepath QuickCheck text
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://projects.haskell.org/graphviz/";
       description = "Bindings to Graphviz for graph visualisation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graphviz_2999_17_0_2" = callPackage
    ({ mkDerivation, base, bytestring, colour, containers, directory
     , dlist, fgl, filepath, polyparse, process, QuickCheck, temporary
     , text, transformers, wl-pprint-text
     }:
     mkDerivation {
       pname = "graphviz";
       version = "2999.17.0.2";
       sha256 = "23c8626061e85eb09021e93e69bad3fc83619187e5f5e55fb6a3f35b8b6bd6fd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring colour containers directory dlist fgl filepath
         polyparse process temporary text transformers wl-pprint-text
       ];
       executableHaskellDepends = [
         base bytestring directory filepath text
       ];
       testHaskellDepends = [
         base containers fgl filepath QuickCheck text
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://projects.haskell.org/graphviz/";
       description = "Bindings to Graphviz for graph visualisation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "graphviz" = callPackage
    ({ mkDerivation, base, bytestring, colour, containers, directory
     , dlist, fgl, fgl-arbitrary, filepath, polyparse, process
     , QuickCheck, temporary, text, transformers, wl-pprint-text
     }:
     mkDerivation {
       pname = "graphviz";
       version = "2999.18.0.2";
       sha256 = "0ce1dca248e549b005798472cc6b906143369d987cf482fc0435b1029e5cc567";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring colour containers directory dlist fgl filepath
         polyparse process temporary text transformers wl-pprint-text
       ];
       executableHaskellDepends = [
         base bytestring directory filepath text
       ];
       testHaskellDepends = [
         base containers fgl fgl-arbitrary filepath QuickCheck text
       ];
       doCheck = false;
       homepage = "http://projects.haskell.org/graphviz/";
       description = "Bindings to Graphviz for graph visualisation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "grasp" = callPackage
    ({ mkDerivation, base, clock, directory, extra, filepath, hashable
     , lens, megaparsec, MonadRandom, mtl, pcre-heavy, primitive
     , process, random-shuffle, safe, split, system-filepath, text
     , transformers, turtle, unordered-containers, vector
     }:
     mkDerivation {
       pname = "grasp";
       version = "0.1.0.0";
       sha256 = "54a2bae281c97f655b025bd50c0fd27f09eb7d6926ed9b57807b4e5d96ab5a2f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base clock directory extra filepath hashable lens megaparsec
         MonadRandom mtl pcre-heavy primitive process random-shuffle safe
         split system-filepath text transformers turtle unordered-containers
         vector
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       homepage = "https://bitbucket.org/janmasrovira/am3-project/overview";
       description = "GRASP implementation for the AMMM project";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gravatar_0_6" = callPackage
    ({ mkDerivation, base, bytestring, data-default, HTTP, pureMD5
     , text
     }:
     mkDerivation {
       pname = "gravatar";
       version = "0.6";
       sha256 = "83bb2bad02c5212f9be4e4d7ac84bdf7a194053f9244b97bda77110d6686b80c";
       libraryHaskellDepends = [
         base bytestring data-default HTTP pureMD5 text
       ];
       homepage = "http://github.com/pbrisbin/gravatar";
       description = "Look up gravatar image urls by email address";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gravatar" = callPackage
    ({ mkDerivation, base, bytestring, data-default, hspec, HTTP
     , pureMD5, text
     }:
     mkDerivation {
       pname = "gravatar";
       version = "0.8.0";
       sha256 = "6f6000acaea47f3fc8711f5a2a62d5fbe96f5bb698fcb997f9f07ffe3102f4d7";
       libraryHaskellDepends = [
         base bytestring data-default HTTP pureMD5 text
       ];
       testHaskellDepends = [ base hspec text ];
       description = "Generate Gravatar image URLs";
       license = stdenv.lib.licenses.mit;
     }) {};

  "gray-code" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "gray-code";
       version = "0.3.1";
       sha256 = "5b0d04f6fe4c90157d669119c39da6d349a06eca3a7a834b7a5dcb5e89a8172c";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base QuickCheck ];
       homepage = "http://bitbucket.org/astanin/hs-gray-code";
       description = "Gray code encoder/decoder";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gray-extended" = callPackage
    ({ mkDerivation, base, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "gray-extended";
       version = "1.5.1";
       sha256 = "588c64add3715a78cac2e80ccd37ba501d03d27f43acbf8b98a4a5cb2c8a55d1";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/mhwombat/gray-extended";
       description = "Gray encoding schemes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "greencard" = callPackage
    ({ mkDerivation, array, base, containers, pretty }:
     mkDerivation {
       pname = "greencard";
       version = "3.0.4.2";
       sha256 = "be6423983f12b4e24bc3293102844b10ba83433d394a8b9d24b9688dabb989ee";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ array base containers pretty ];
       homepage = "https://github.com/sof/greencard";
       description = "GreenCard, a foreign function pre-processor for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "greencard-lib" = callPackage
    ({ mkDerivation, array, base, containers, greencard, pretty }:
     mkDerivation {
       pname = "greencard-lib";
       version = "3.0.1";
       sha256 = "6d122277ead225b67f0fa25e693937ca787e0524eb06efe659ad2ccaa61910a9";
       libraryHaskellDepends = [ array base containers greencard pretty ];
       homepage = "http://www.haskell.org/greencard/";
       description = "A foreign function interface pre-processor library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "greg-client" = callPackage
    ({ mkDerivation, base, binary, bytestring, clock, hostname, network
     , stm, system-uuid, time
     }:
     mkDerivation {
       pname = "greg-client";
       version = "1.0.2";
       sha256 = "3692e75904ed52ef6dfd1a76ffe989ac81dbaf8f5901a16c2529c4621f2ec4dc";
       libraryHaskellDepends = [
         base binary bytestring clock hostname network stm system-uuid time
       ];
       homepage = "http://code.google.com/p/greg/";
       description = "A scalable distributed logger with a high-precision global time axis";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gremlin-haskell" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, containers, hspec, lens
     , lens-aeson, mtl, stm, text, transformers, unordered-containers
     , uuid, websockets
     }:
     mkDerivation {
       pname = "gremlin-haskell";
       version = "0.1.0.2";
       sha256 = "3e33c59fb09c435d89c30fe7ae7dff88246f05d6ad43bd9fcf27c47bd68353aa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-qq base containers lens mtl stm text transformers uuid
         websockets
       ];
       executableHaskellDepends = [
         aeson base lens lens-aeson mtl text unordered-containers
       ];
       testHaskellDepends = [ aeson-qq base hspec lens lens-aeson mtl ];
       homepage = "http://github.com/nakaji-dayo/gremlin-haskell";
       description = "Graph database client for TinkerPop3 Gremlin Server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "greplicate" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, lens
     , QuickCheck, template-haskell
     }:
     mkDerivation {
       pname = "greplicate";
       version = "0.0.2";
       sha256 = "c73d6b8f586e6004d3d66bb7b5d1402941021ce8d29a309fbb61c45f28753ce5";
       libraryHaskellDepends = [ base lens ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck template-haskell
       ];
       homepage = "https://github.com/NICTA/greplicate";
       description = "Generalised replicate functions";
       license = "unknown";
     }) {};

  "grid" = callPackage
    ({ mkDerivation, base, cereal, containers, QuickCheck
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "grid";
       version = "7.8.5";
       sha256 = "dc5841ddffcc2dacd6667031fc78d2c0df86a7c8e112b76ba134831e84741fb8";
       libraryHaskellDepends = [ base cereal containers ];
       testHaskellDepends = [
         base containers QuickCheck test-framework
         test-framework-quickcheck2
       ];
       homepage = "https://github.com/mhwombat/grid";
       description = "Tools for working with regular grids (graphs, lattices)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gridfs" = callPackage
    ({ mkDerivation, base, bson, bytestring, conduit, conduit-extra
     , monad-control, mongoDB, mtl, pureMD5, resourcet, tagged, text
     , time, transformers
     }:
     mkDerivation {
       pname = "gridfs";
       version = "0.1.0.2";
       sha256 = "e5230fd91b586e3760f56e7f94ab334886784302395cf392246d452ce3c248c5";
       libraryHaskellDepends = [
         base bson bytestring conduit conduit-extra monad-control mongoDB
         mtl pureMD5 resourcet tagged text time transformers
       ];
       homepage = "http://github.com/btubbs/haskell-gridfs#readme";
       description = "GridFS (MongoDB file storage) implementation";
       license = "unknown";
     }) {};

  "gridland" = callPackage
    ({ mkDerivation, array, astar, base, containers, grid, htiled, mtl
     , random, safe, SDL, SDL-gfx, SDL-image, SDL-mixer, tuple, vector
     }:
     mkDerivation {
       pname = "gridland";
       version = "0.1.0.3";
       sha256 = "2936472e5eb065e1fe28bd5d2f9d524be8d63f6eba0627527acf1668ec38b760";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array astar base containers grid htiled mtl random safe SDL SDL-gfx
         SDL-image SDL-mixer tuple vector
       ];
       description = "Grid-based multimedia engine";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "grm" = callPackage
    ({ mkDerivation, base, Cabal, cmdargs, directory, filepath, happy
     , parsec, process, syb, wl-pprint
     }:
     mkDerivation {
       pname = "grm";
       version = "0.1.1";
       sha256 = "fda67b7be712ecf94798b74f6466e3d5a571a8539137b33af65b1916462a44fd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory filepath process syb wl-pprint
       ];
       executableHaskellDepends = [
         base Cabal cmdargs directory filepath parsec process syb wl-pprint
       ];
       executableToolDepends = [ happy ];
       description = "grm grammar converter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "groom" = callPackage
    ({ mkDerivation, base, haskell-src-exts }:
     mkDerivation {
       pname = "groom";
       version = "0.1.2";
       sha256 = "0e820122cad388f31c3ef0815d7ff93b9e95a8fdec0d6c560c379fe0ecfdb010";
       libraryHaskellDepends = [ base haskell-src-exts ];
       description = "Pretty printing for well-behaved Show instances";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "groundhog_0_7_0" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers
     , monad-control, monad-logger, mtl, text, time, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "groundhog";
       version = "0.7.0";
       sha256 = "668bc8f4841e1ec9f23f51543d69b432b620f9cf02fc26e1a83b16c80c690651";
       revision = "2";
       editedCabalFile = "44d84afe8c6f603f9945a6bc609f3612d903c173f08e260f30d9828a7da2947a";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers monad-control monad-logger
         mtl text time transformers transformers-base
       ];
       jailbreak = true;
       homepage = "http://github.com/lykahb/groundhog";
       description = "Type-safe datatype-database mapping library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "groundhog_0_7_0_1" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers
     , monad-control, monad-logger, mtl, text, time, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "groundhog";
       version = "0.7.0.1";
       sha256 = "3dacc27932c49b2d02f93b7d6b7ca795292742c6db2082727829a5db39c7a0bc";
       revision = "2";
       editedCabalFile = "a9f51b82fadf30959632f8a50d31d913b322fc11a88352f48e61d78ae3542aa3";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers monad-control monad-logger
         mtl text time transformers transformers-base
       ];
       jailbreak = true;
       homepage = "http://github.com/lykahb/groundhog";
       description = "Type-safe datatype-database mapping library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "groundhog_0_7_0_2" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, blaze-builder
     , bytestring, containers, monad-control, monad-logger, mtl
     , scientific, text, time, transformers, transformers-base
     }:
     mkDerivation {
       pname = "groundhog";
       version = "0.7.0.2";
       sha256 = "7e019d08287abc64db970c7a802dbf86502d099b2de7beec08bcb6ca2f869e27";
       revision = "2";
       editedCabalFile = "29ff5009d51d7e5e07781c94348999f91152c84daa5143e188c326ab32e968e3";
       libraryHaskellDepends = [
         aeson base base64-bytestring blaze-builder bytestring containers
         monad-control monad-logger mtl scientific text time transformers
         transformers-base
       ];
       homepage = "http://github.com/lykahb/groundhog";
       description = "Type-safe datatype-database mapping library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "groundhog" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, containers, monad-control
     , monad-logger, mtl, scientific, text, time, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "groundhog";
       version = "0.7.0.3";
       sha256 = "39713e7b3423ea34a5ac803d4a563d7f9674bbf72700e263a00c7bc70328ac58";
       revision = "2";
       editedCabalFile = "b4a2f7876feaaf6ad8d4589989902d4452468910c0f3f01a04827a001036f3ff";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-builder bytestring
         containers monad-control monad-logger mtl scientific text time
         transformers transformers-base
       ];
       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, syb, template-haskell, text, time, transformers
     }:
     mkDerivation {
       pname = "groundhog-inspector";
       version = "0.7.1.2";
       sha256 = "909e4c47c8c58d57bd286b71db86526dfdf3eba12dfba9e61602908f82ad9d93";
       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
       ];
       jailbreak = true;
       homepage = "http://github.com/lykahb/groundhog";
       description = "Type-safe datatype-database mapping library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "groundhog-mysql_0_7_0" = callPackage
    ({ mkDerivation, base, bytestring, containers, groundhog
     , monad-control, monad-logger, mysql, mysql-simple, resource-pool
     , text, time, transformers
     }:
     mkDerivation {
       pname = "groundhog-mysql";
       version = "0.7.0";
       sha256 = "e89ba97f30566b722752210fe4ce9970657b13afb43c769571990abcc571b7c6";
       libraryHaskellDepends = [
         base bytestring containers groundhog monad-control monad-logger
         mysql mysql-simple resource-pool text time transformers
       ];
       jailbreak = true;
       description = "MySQL backend for the groundhog library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "groundhog-mysql" = callPackage
    ({ mkDerivation, base, bytestring, containers, groundhog
     , monad-control, monad-logger, mysql, mysql-simple, resource-pool
     , text, time, transformers
     }:
     mkDerivation {
       pname = "groundhog-mysql";
       version = "0.7.0.1";
       sha256 = "ee884137d44cb3f391d402f524d149825477a898b29e99e8056a03b56db4f606";
       libraryHaskellDepends = [
         base bytestring containers groundhog monad-control monad-logger
         mysql mysql-simple resource-pool text time transformers
       ];
       description = "MySQL backend for the groundhog library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "groundhog-postgresql_0_7_0" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , containers, groundhog, monad-control, monad-logger
     , postgresql-libpq, postgresql-simple, resource-pool, text, time
     , transformers
     }:
     mkDerivation {
       pname = "groundhog-postgresql";
       version = "0.7.0";
       sha256 = "8a60d58ad9729d7b881fec7cda1959c48630080c151c713faf0385fa100a4516";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring containers groundhog
         monad-control monad-logger postgresql-libpq postgresql-simple
         resource-pool text time transformers
       ];
       jailbreak = true;
       description = "PostgreSQL backend for the groundhog library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "groundhog-postgresql_0_7_0_1" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , containers, groundhog, monad-control, monad-logger
     , postgresql-libpq, postgresql-simple, resource-pool, text, time
     , transformers
     }:
     mkDerivation {
       pname = "groundhog-postgresql";
       version = "0.7.0.1";
       sha256 = "61262800a97bbb41727f652e8df01430451e3cededc5453c74e6aea2eac15177";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring containers groundhog
         monad-control monad-logger postgresql-libpq postgresql-simple
         resource-pool text time transformers
       ];
       jailbreak = true;
       description = "PostgreSQL backend for the groundhog library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "groundhog-postgresql" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , containers, groundhog, monad-control, monad-logger
     , postgresql-libpq, postgresql-simple, resource-pool, text, time
     , transformers
     }:
     mkDerivation {
       pname = "groundhog-postgresql";
       version = "0.7.0.2";
       sha256 = "312045c39c973596e8e92b8001776bb86898e3c8766e0a42c71e63b343918da3";
       revision = "1";
       editedCabalFile = "014cf49927d870d99d906064fc27ee219f7145e71a409cc69ae3ed0cdc0699ca";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring containers groundhog
         monad-control monad-logger postgresql-libpq postgresql-simple
         resource-pool text time transformers
       ];
       description = "PostgreSQL backend for the groundhog library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "groundhog-sqlite_0_7_0" = callPackage
    ({ mkDerivation, base, bytestring, containers, direct-sqlite
     , groundhog, monad-control, monad-logger, resource-pool, text
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "groundhog-sqlite";
       version = "0.7.0";
       sha256 = "04b558c871bf038d5b0733e8ac082d1a8b8e3f16fc91dd103ce207867a2bd79e";
       libraryHaskellDepends = [
         base bytestring containers direct-sqlite groundhog monad-control
         monad-logger resource-pool text transformers unordered-containers
       ];
       jailbreak = true;
       description = "Sqlite3 backend for the groundhog library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "groundhog-sqlite" = callPackage
    ({ mkDerivation, base, bytestring, containers, direct-sqlite
     , groundhog, monad-control, monad-logger, resource-pool, text
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "groundhog-sqlite";
       version = "0.7.0.1";
       sha256 = "be89709d458bb03a688281fbeab0408cdbc4f7942bf7559c25feb6ab9c4f5553";
       libraryHaskellDepends = [
         base bytestring containers direct-sqlite groundhog monad-control
         monad-logger resource-pool text transformers unordered-containers
       ];
       description = "Sqlite3 backend for the groundhog library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "groundhog-th_0_7_0" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, groundhog
     , template-haskell, text, time, unordered-containers, yaml
     }:
     mkDerivation {
       pname = "groundhog-th";
       version = "0.7.0";
       sha256 = "c76075c21fdff7040adc62daa368899eadf4902477982daa1162e4cc8b31e491";
       revision = "1";
       editedCabalFile = "41d900556041f7158e21190a19eee713bdac3c4cd49017df4cb8e3e7365451ff";
       libraryHaskellDepends = [
         aeson base bytestring containers groundhog template-haskell text
         time unordered-containers yaml
       ];
       jailbreak = true;
       description = "Type-safe datatype-database mapping library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "groundhog-th" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, groundhog
     , template-haskell, text, time, unordered-containers, yaml
     }:
     mkDerivation {
       pname = "groundhog-th";
       version = "0.7.0.1";
       sha256 = "700cd109989bbf4dd8cff72249077035cb2ca8c1d4c9748bfecf4bc17f3ee095";
       libraryHaskellDepends = [
         aeson base bytestring containers groundhog template-haskell text
         time unordered-containers yaml
       ];
       description = "Type-safe datatype-database mapping library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "group-with" = callPackage
    ({ mkDerivation, base, Cabal, containers, hspec, hspec-expectations
     , QuickCheck
     }:
     mkDerivation {
       pname = "group-with";
       version = "0.2.0.3";
       sha256 = "eb179700db93ad736cf13520a105dd344f1c170952bcbdd1ad7e51b3244342de";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [
         base Cabal containers hspec hspec-expectations QuickCheck
       ];
       homepage = "https://github.com/ulikoehler/group-with";
       description = "Classify objects by key-generating function, like SQL GROUP BY";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "grouped-list_0_2_1_0" = callPackage
    ({ mkDerivation, base, containers, deepseq, pointed, QuickCheck
     , tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "grouped-list";
       version = "0.2.1.0";
       sha256 = "cd6275388415de0b0940f0d12a380b9fd4e196c356719f0574cc94e73ec6d004";
       libraryHaskellDepends = [ base containers deepseq pointed ];
       testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
       homepage = "https://github.com/Daniel-Diaz/grouped-list/blob/master/README.md";
       description = "Grouped lists. Equal consecutive elements are grouped.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "grouped-list" = callPackage
    ({ mkDerivation, base, containers, deepseq, pointed, QuickCheck
     , tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "grouped-list";
       version = "0.2.1.1";
       sha256 = "df2db99d9144bfe69b20e245ec53bfa76aa641855042a7fac1f2f601662d8fbb";
       libraryHaskellDepends = [ base containers deepseq pointed ];
       testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
       homepage = "https://github.com/Daniel-Diaz/grouped-list/blob/master/README.md";
       description = "Grouped lists. Equal consecutive elements are grouped.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "groupoid" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "groupoid";
       version = "0.1.0";
       sha256 = "1fe01616b2c1a4296133acbcb84a5c3964295e713a4018cfdd8446e112a6f23e";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.google.com/p/copperbox/";
       description = "A Groupoid class";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "groupoids" = callPackage
    ({ mkDerivation, base, semigroupoids }:
     mkDerivation {
       pname = "groupoids";
       version = "4.0";
       sha256 = "6671953fa0970c13ac8014278fcd6227b4c07e1a69d5a23965e2df1418218a22";
       libraryHaskellDepends = [ base semigroupoids ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://github.com/ekmett/groupoids/";
       description = "This package has been absorbed into semigroupoids 4.0";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "groups" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "groups";
       version = "0.4.0.0";
       sha256 = "d328395164033e310148d57d5be86fc6cc4dbc97b4296b91f235b213cc80e8ce";
       libraryHaskellDepends = [ base ];
       description = "Haskell 98 groups";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "growler" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring
     , case-insensitive, either, http-types, lens, monad-control, mtl
     , pipes, pipes-aeson, pipes-wai, regex-compat, text, transformers
     , transformers-base, unordered-containers, vector, wai, wai-extra
     , warp
     }:
     mkDerivation {
       pname = "growler";
       version = "0.6.0";
       sha256 = "e560344ffae87dd5159bf45e822f1c2970eb0e14031dbcc3439a4d70c59f7e6a";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring case-insensitive either
         http-types lens monad-control mtl pipes pipes-aeson pipes-wai
         regex-compat text transformers transformers-base
         unordered-containers vector wai wai-extra warp
       ];
       doHaddock = false;
       homepage = "http://github.com/iand675/growler";
       description = "A revised version of the scotty library that attempts to be simpler and more performant";
       license = stdenv.lib.licenses.mit;
     }) {};

  "gruff" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , FTGL, gtk, gtkglext, mtl, old-locale, OpenGL, OpenGLRaw, parallel
     , qd, qd-vec, ruff, time, Vec
     }:
     mkDerivation {
       pname = "gruff";
       version = "0.3.4";
       sha256 = "10ec0d3c842911815c204025a98642dc70e26d5dcb5c07c143277baad45d4947";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ruff ];
       executableHaskellDepends = [
         base bytestring containers directory filepath FTGL gtk gtkglext mtl
         old-locale OpenGL OpenGLRaw parallel qd qd-vec ruff time Vec
       ];
       jailbreak = true;
       description = "fractal explorer GUI using the ruff library";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gruff-examples" = callPackage
    ({ mkDerivation, base, containers, data-memocombinators, filepath
     , gruff, qd, qd-vec, random, ruff, Vec
     }:
     mkDerivation {
       pname = "gruff-examples";
       version = "0.3.1";
       sha256 = "e7fda6673da47266fcf7f37ecddc6b643e6bd5fbfefac4df2b6ec6fe115acf0b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers data-memocombinators filepath gruff qd qd-vec
         random ruff Vec
       ];
       jailbreak = true;
       description = "Mandelbrot Set examples using ruff and gruff";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gsasl" = callPackage
    ({ mkDerivation, base, bytestring, gsasl, transformers }:
     mkDerivation {
       pname = "gsasl";
       version = "0.3.6";
       sha256 = "786036025e5d5649c029c1db23c395e1592c073a58848ae4afe4f2797de1f931";
       libraryHaskellDepends = [ base bytestring transformers ];
       libraryPkgconfigDepends = [ gsasl ];
       homepage = "https://john-millikin.com/software/haskell-gsasl/";
       description = "Bindings for GNU libgsasl";
       license = stdenv.lib.licenses.gpl3;
     }) {inherit (pkgs) gsasl;};

  "gsc-weighting" = callPackage
    ({ mkDerivation, base, hierarchical-clustering }:
     mkDerivation {
       pname = "gsc-weighting";
       version = "0.2.2";
       sha256 = "e5a2652a4d32ea292c311c7c6165fcfbae34436a886aad8a492c003371910079";
       libraryHaskellDepends = [ base hierarchical-clustering ];
       description = "Generic implementation of Gerstein/Sonnhammer/Chothia weighting";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gsl-random" = callPackage
    ({ mkDerivation, base, vector }:
     mkDerivation {
       pname = "gsl-random";
       version = "0.5.0";
       sha256 = "d2adccfe625d3cb5046ae5bb3c7a23d23697d1fc2c6a717df75f75aba2881c2e";
       libraryHaskellDepends = [ base vector ];
       jailbreak = true;
       homepage = "http://github.com/patperry/hs-gsl-random";
       description = "Bindings the the GSL random number generation facilities";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gsl-random-fu" = callPackage
    ({ mkDerivation, base, gsl-random, random-fu }:
     mkDerivation {
       pname = "gsl-random-fu";
       version = "0.0.0.1";
       sha256 = "1191092243b4cf6a89e6c1e123bc537ed5d0bcc18be7ad1ead26583dffa8c5e1";
       libraryHaskellDepends = [ base gsl-random random-fu ];
       homepage = "http://code.haskell.org/~mokus/gsl-random-fu";
       description = "Instances for using gsl-random with random-fu";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gsmenu" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec, permute, sindre
     , text, X11
     }:
     mkDerivation {
       pname = "gsmenu";
       version = "3.0";
       sha256 = "8e2012af7393d781a65d1615a852c15534ba5b5500bda2f39c16ccea92a9ad95";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers mtl parsec permute sindre text X11
       ];
       jailbreak = true;
       homepage = "http://sigkill.dk/programs/gsmenu";
       description = "A visual generic menu";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gstreamer" = callPackage
    ({ mkDerivation, array, base, bytestring, directory, glib
     , gst_plugins_base, gstreamer, gtk2hs-buildtools, mtl
     }:
     mkDerivation {
       pname = "gstreamer";
       version = "0.12.5.0";
       sha256 = "c633b67d1a687ce781775cea8bf4a250e823473b7cfae145bdceb7ad39102f3f";
       libraryHaskellDepends = [
         array base bytestring directory glib mtl
       ];
       libraryPkgconfigDepends = [ gst_plugins_base gstreamer ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the GStreamer open source multimedia framework";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gst_plugins_base; inherit (pkgs) gstreamer;};

  "gt-tools" = callPackage
    ({ mkDerivation, base, containers, extensible-exceptions, haskeline
     , HTTP, json, mtl, unix, url, utf8-string
     }:
     mkDerivation {
       pname = "gt-tools";
       version = "0.2.1";
       sha256 = "701daead5b7134c7300ce127882210f183ed83b16c19daf49a5dbe6d5f676cd6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers extensible-exceptions haskeline HTTP json mtl unix
         url utf8-string
       ];
       homepage = "http://github.com/styx/gtc";
       description = "Console and GUI interface for Google Translate service";
       license = "GPL";
     }) {};

  "gtfs" = callPackage
    ({ mkDerivation, base, csv, directory, filepath, rowrecord, split
     }:
     mkDerivation {
       pname = "gtfs";
       version = "0.1";
       sha256 = "51ef576831a83652447a9d89163c703cd26cb788d8f167a7379f2779fb081154";
       libraryHaskellDepends = [
         base csv directory filepath rowrecord split
       ];
       description = "The General Transit Feed Specification format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gtk_0_13_3" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gio
     , glib, gtk2, gtk2hs-buildtools, mtl, pango, text
     }:
     mkDerivation {
       pname = "gtk";
       version = "0.13.3";
       sha256 = "879bbfe5a9b0bda7d1a4a7e695b39173c8a1f766745bd0994dc5f83b4a36db04";
       libraryHaskellDepends = [
         array base bytestring cairo containers gio glib mtl pango text
       ];
       libraryPkgconfigDepends = [ gtk2 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Gtk+ graphical user interface library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gtk2 = pkgs.gnome2.gtk;};

  "gtk_0_13_4" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gio
     , glib, gtk2, gtk2hs-buildtools, mtl, pango, text
     }:
     mkDerivation {
       pname = "gtk";
       version = "0.13.4";
       sha256 = "171ffd0464938b4be3cd161911d8ddbaa71e11afe786abe64b7c787986e4ccf5";
       libraryHaskellDepends = [
         array base bytestring cairo containers gio glib mtl pango text
       ];
       libraryPkgconfigDepends = [ gtk2 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Gtk+ graphical user interface library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gtk2 = pkgs.gnome2.gtk;};

  "gtk_0_13_6" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gio
     , glib, gtk2, gtk2hs-buildtools, mtl, pango, text
     }:
     mkDerivation {
       pname = "gtk";
       version = "0.13.6";
       sha256 = "4c74ab4affda49230c0f98bd67276d114484ac3857f7e8a22d1e66339dda43f6";
       libraryHaskellDepends = [
         array base bytestring cairo containers gio glib mtl pango text
       ];
       libraryPkgconfigDepends = [ gtk2 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       doHaddock = false;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Gtk+ graphical user interface library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gtk2 = pkgs.gnome2.gtk;};

  "gtk_0_13_7" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gio
     , glib, gtk2, gtk2hs-buildtools, mtl, pango, text
     }:
     mkDerivation {
       pname = "gtk";
       version = "0.13.7";
       sha256 = "323a468a71a831802ecc3c98f2d015a79516a2304b3c9f3a2013fa3b216a39d7";
       libraryHaskellDepends = [
         array base bytestring cairo containers gio glib mtl pango text
       ];
       libraryPkgconfigDepends = [ gtk2 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       doHaddock = false;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Gtk+ graphical user interface library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gtk2 = pkgs.gnome2.gtk;};

  "gtk_0_13_8_1" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gio
     , glib, gtk2, gtk2hs-buildtools, mtl, pango, text
     }:
     mkDerivation {
       pname = "gtk";
       version = "0.13.8.1";
       sha256 = "57e21f0e91fcf3e903f968fcffa64088f3ef2b7cf71f40439e0847cdf5313adc";
       libraryHaskellDepends = [
         array base bytestring cairo containers gio glib mtl pango text
       ];
       libraryPkgconfigDepends = [ gtk2 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       doHaddock = false;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Gtk+ graphical user interface library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gtk2 = pkgs.gnome2.gtk;};

  "gtk_0_13_9" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gio
     , glib, gtk2, gtk2hs-buildtools, mtl, pango, text
     }:
     mkDerivation {
       pname = "gtk";
       version = "0.13.9";
       sha256 = "12e0097724002385207b3bb9a0339ad3d7c8d54336bf91d90827193f801ebfd5";
       libraryHaskellDepends = [
         array base bytestring cairo containers gio glib mtl pango text
       ];
       libraryPkgconfigDepends = [ gtk2 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       doHaddock = false;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Gtk+ graphical user interface library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gtk2 = pkgs.gnome2.gtk;};

  "gtk" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gio
     , glib, gtk2, gtk2hs-buildtools, mtl, pango, text
     }:
     mkDerivation {
       pname = "gtk";
       version = "0.14.2";
       sha256 = "58f780c51fe2f3e25939a048bbe7d0b880e6aeb412df2648438f926a2b7b7eb5";
       libraryHaskellDepends = [
         array base bytestring cairo containers gio glib mtl pango text
       ];
       libraryPkgconfigDepends = [ gtk2 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       doHaddock = false;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Gtk+ graphical user interface library";
       license = stdenv.lib.licenses.lgpl21;
     }) {gtk2 = pkgs.gnome2.gtk;};

  "gtk-helpers" = callPackage
    ({ mkDerivation, array, base, gio, glib, gtk, mtl, process
     , template-haskell
     }:
     mkDerivation {
       pname = "gtk-helpers";
       version = "0.0.7";
       sha256 = "671bf6f447083c6a60fb862cd694f3944248167a5291ff58d4f39c9cce1fa433";
       libraryHaskellDepends = [
         array base gio glib gtk mtl process template-haskell
       ];
       homepage = "http://keera.es/blog/community";
       description = "A collection of auxiliary operations and widgets related to Gtk";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "gtk-jsinput" = callPackage
    ({ mkDerivation, base, gtk, json, transformers }:
     mkDerivation {
       pname = "gtk-jsinput";
       version = "0.0.0";
       sha256 = "6071b47725d2b8e3363a3eeb30c1068d171e9c5fef37966619f41c89be99543a";
       libraryHaskellDepends = [ base gtk json transformers ];
       homepage = "http://github.com/timthelion/gtk-jsinput";
       description = "A simple custom form widget for gtk which allows inputing of JSON values";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "gtk-largeTreeStore" = callPackage
    ({ mkDerivation, base, containers, glib, gtk3, hspec, mtl
     , nested-sets
     }:
     mkDerivation {
       pname = "gtk-largeTreeStore";
       version = "0.0.1.0";
       sha256 = "20325ca217f5622cedc86995613777a843dd696999683aaf6c13bf13ea6eed5b";
       libraryHaskellDepends = [
         base containers glib gtk3 mtl nested-sets
       ];
       testHaskellDepends = [ base containers gtk3 hspec ];
       description = "Large TreeStore support for gtk2hs";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "gtk-mac-integration" = callPackage
    ({ mkDerivation, array, base, containers, glib, gtk
     , gtk-mac-integration-gtk2, gtk2hs-buildtools, mtl
     }:
     mkDerivation {
       pname = "gtk-mac-integration";
       version = "0.3.2.1";
       sha256 = "33ae28811e7fbcfe00b1379489c3c73d5023e6b63ebfb19cdea9ddf40c312f06";
       libraryHaskellDepends = [ array base containers glib gtk mtl ];
       libraryPkgconfigDepends = [ gtk-mac-integration-gtk2 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://www.haskell.org/gtk2hs/";
       description = "Bindings for the Gtk/OS X integration library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gtk-mac-integration-gtk2 = null;};

  "gtk-serialized-event" = callPackage
    ({ mkDerivation, array, base, containers, gdk2, glib, gtk
     , haskell98, mtl
     }:
     mkDerivation {
       pname = "gtk-serialized-event";
       version = "0.12.0";
       sha256 = "2eeb454a0ffae025b7c9a5556029b6f5121246cdb0af1e48d21c95931a9f083e";
       libraryHaskellDepends = [
         array base containers glib gtk haskell98 mtl
       ];
       libraryPkgconfigDepends = [ gdk2 ];
       jailbreak = true;
       homepage = "http://www.haskell.org/gtk2hs/";
       description = "GTK+ Serialized event";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gdk2 = null;};

  "gtk-simple-list-view" = callPackage
    ({ mkDerivation, base, gtk }:
     mkDerivation {
       pname = "gtk-simple-list-view";
       version = "0.0.0";
       sha256 = "9a7be4ca800103ed93506b1acb1182b97b38647a6fca014b0026257195820ee3";
       libraryHaskellDepends = [ base gtk ];
       homepage = "http://github.com/timthelion/gtk-simple-list-view";
       description = "A simple custom form widget for gtk which allows single LOC creation/updating of list views";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "gtk-toggle-button-list" = callPackage
    ({ mkDerivation, base, gtk }:
     mkDerivation {
       pname = "gtk-toggle-button-list";
       version = "0.0.0";
       sha256 = "061ca145243fb7d764e43e2bc420248bb1021ba2f437b4143c1850e2ba3d0b92";
       libraryHaskellDepends = [ base gtk ];
       homepage = "http://github.com/timthelion/gtk-toggle-button-list";
       description = "A simple custom form widget for gtk which allows single LOC creation/updating of toggle button lists";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "gtk-toy" = callPackage
    ({ mkDerivation, base, containers, gtk }:
     mkDerivation {
       pname = "gtk-toy";
       version = "0.2.0";
       sha256 = "d83594e48c60f2e088d590976990823631f2df9ee55a94f17c8c17581898c37d";
       libraryHaskellDepends = [ base containers gtk ];
       jailbreak = true;
       description = "Convenient Gtk canvas with mouse and keyboard input";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gtk-traymanager" = callPackage
    ({ mkDerivation, base, glib, gtk, gtk2, x11 }:
     mkDerivation {
       pname = "gtk-traymanager";
       version = "0.1.6";
       sha256 = "cb30f5d55430836032abc876706af0a61de996c9e2b5a4b41c029d3149683642";
       libraryHaskellDepends = [ base glib gtk ];
       libraryPkgconfigDepends = [ gtk2 x11 ];
       homepage = "http://github.com/travitch/gtk-traymanager";
       description = "A wrapper around the eggtraymanager library for Linux system trays";
       license = stdenv.lib.licenses.lgpl21;
     }) {gtk2 = pkgs.gnome2.gtk; inherit (pkgs) x11;};

  "gtk2hs-buildtools_0_13_0_3" = callPackage
    ({ mkDerivation, alex, array, base, containers, directory, filepath
     , happy, hashtables, pretty, process, random
     }:
     mkDerivation {
       pname = "gtk2hs-buildtools";
       version = "0.13.0.3";
       sha256 = "372b02369d398300d601394cb6e7a7d222fc171170bf40ffa52a577425ab4cc6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory filepath hashtables pretty process
         random
       ];
       executableToolDepends = [ alex happy ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Tools to build the Gtk2Hs suite of User Interface libraries";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gtk2hs-buildtools_0_13_0_4" = callPackage
    ({ mkDerivation, alex, array, base, containers, directory, filepath
     , happy, hashtables, pretty, process, random
     }:
     mkDerivation {
       pname = "gtk2hs-buildtools";
       version = "0.13.0.4";
       sha256 = "2a24c2d4124ec046800326922807ab457e2beaf0ffb320162687e1475dbe3510";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory filepath hashtables pretty process
         random
       ];
       executableToolDepends = [ alex happy ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Tools to build the Gtk2Hs suite of User Interface libraries";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gtk2hs-buildtools" = callPackage
    ({ mkDerivation, alex, array, base, containers, directory, filepath
     , happy, hashtables, pretty, process, random
     }:
     mkDerivation {
       pname = "gtk2hs-buildtools";
       version = "0.13.0.5";
       sha256 = "d95811a505ec10e4c82f3ca81c06b317eb9d345e73b6eda7aeaebd1e868f0a93";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory filepath hashtables pretty process
         random
       ];
       executableToolDepends = [ alex happy ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Tools to build the Gtk2Hs suite of User Interface libraries";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "gtk2hs-cast-glade" = callPackage
    ({ mkDerivation, base, glade, gtk, gtk2hs-cast-glib, hint
     , template-haskell
     }:
     mkDerivation {
       pname = "gtk2hs-cast-glade";
       version = "0.10.1.1";
       sha256 = "a64f3baf3fcdb06b540ced7b802bd828908bd3c47b2d63fec6ade451e070fe2b";
       libraryHaskellDepends = [
         base glade gtk gtk2hs-cast-glib hint template-haskell
       ];
       description = "A type class for cast functions of Gtk2hs: glade package";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gtk2hs-cast-glib" = callPackage
    ({ mkDerivation, base, glib }:
     mkDerivation {
       pname = "gtk2hs-cast-glib";
       version = "0.10.1.1";
       sha256 = "b70afb2ba95cba85313441d229534083761e991243e46ef001ae43f1fd0f5faf";
       libraryHaskellDepends = [ base glib ];
       description = "A type class for cast functions of Gtk2hs: glib package";
       license = "unknown";
     }) {};

  "gtk2hs-cast-gnomevfs" = callPackage
    ({ mkDerivation, base, gnomevfs, gtk2hs-cast-glib, gtk2hs-cast-th
     , hint, template-haskell
     }:
     mkDerivation {
       pname = "gtk2hs-cast-gnomevfs";
       version = "0.10.1.2";
       sha256 = "af9c1f5163f92e9b64d4dc35dc334fa03c379842de84056c0ec5eaa7b6ce793a";
       libraryHaskellDepends = [
         base gnomevfs gtk2hs-cast-glib gtk2hs-cast-th hint template-haskell
       ];
       description = "A type class for cast functions of Gtk2hs: gnomevfs package";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gtk2hs-cast-gtk" = callPackage
    ({ mkDerivation, base, gtk, gtk2hs-cast-glib, gtk2hs-cast-th, hint
     , template-haskell
     }:
     mkDerivation {
       pname = "gtk2hs-cast-gtk";
       version = "0.10.1.2";
       sha256 = "72d041d664204d3e1eec9dd913780a606309b89f295810c6badfa6d62a60a695";
       libraryHaskellDepends = [
         base gtk gtk2hs-cast-glib gtk2hs-cast-th hint template-haskell
       ];
       description = "A type class for cast functions of Gtk2hs: gtk package";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gtk2hs-cast-gtkglext" = callPackage
    ({ mkDerivation, base, gtk2hs-cast-glib, gtk2hs-cast-th, gtkglext
     , hint, template-haskell
     }:
     mkDerivation {
       pname = "gtk2hs-cast-gtkglext";
       version = "0.10.1.2";
       sha256 = "a96adb8fe07ba89b23117b26e427489404d9a7234afb9c55e41508043982a416";
       libraryHaskellDepends = [
         base gtk2hs-cast-glib gtk2hs-cast-th gtkglext hint template-haskell
       ];
       description = "A type class for cast functions of Gtk2hs: gtkglext package";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gtk2hs-cast-gtksourceview2" = callPackage
    ({ mkDerivation, base, gtk2hs-cast-glib, gtk2hs-cast-th
     , gtksourceview2, hint, template-haskell
     }:
     mkDerivation {
       pname = "gtk2hs-cast-gtksourceview2";
       version = "0.10.1.2";
       sha256 = "014db9540c4df797c1b6c1d276d52c819c4af087c9428d659a9030c9a750ccbb";
       libraryHaskellDepends = [
         base gtk2hs-cast-glib gtk2hs-cast-th gtksourceview2 hint
         template-haskell
       ];
       description = "A type class for cast functions of Gtk2hs: gtksourceview2 package";
       license = "unknown";
     }) {};

  "gtk2hs-cast-th" = callPackage
    ({ mkDerivation, base, hint, template-haskell }:
     mkDerivation {
       pname = "gtk2hs-cast-th";
       version = "0.10.1.0";
       sha256 = "fd8e81d477d096a7f21a7e536e4050716bbdbeef24d5f39d101c3bdac0c247a5";
       libraryHaskellDepends = [ base hint template-haskell ];
       description = "A type class for cast functions of Gtk2hs: TH package";
       license = "unknown";
     }) {};

  "gtk2hs-hello" = callPackage
    ({ mkDerivation, base, glib, gtk3, transformers }:
     mkDerivation {
       pname = "gtk2hs-hello";
       version = "1.1.0.0";
       sha256 = "44ae9a25b173ccf7f4f8dfb8cb80cbabbafc2f52468cdc512fc84e8e9a37a84e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base glib gtk3 transformers ];
       jailbreak = true;
       homepage = "http://www.haskell.org/hello/";
       description = "Gtk2Hs Hello World, an example package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "gtk2hs-rpn" = callPackage
    ({ mkDerivation, base, cairo, glib, gtk, mtl }:
     mkDerivation {
       pname = "gtk2hs-rpn";
       version = "0.2.1";
       sha256 = "716794f2a620e942b4f50daeae68515fb879a7e3338cb9cd671891054c9b9107";
       libraryHaskellDepends = [ base cairo glib gtk mtl ];
       jailbreak = true;
       description = "Adds a module to gtk2hs allowing layouts to be defined using reverse polish notation";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gtk3_0_13_4" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gio
     , glib, gtk2hs-buildtools, gtk3, mtl, pango, text, time
     , transformers
     }:
     mkDerivation {
       pname = "gtk3";
       version = "0.13.4";
       sha256 = "10abee0435f2d2a2e07d28a44ed81e86d7d8c9b9157d6e7c1cb59e7760783e10";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cairo containers gio glib mtl pango text
       ];
       libraryPkgconfigDepends = [ gtk3 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       executableHaskellDepends = [
         array base cairo text time transformers
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Gtk+ graphical user interface library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gtk3;};

  "gtk3_0_13_6" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gio
     , glib, gtk2hs-buildtools, gtk3, mtl, pango, text, time
     , transformers
     }:
     mkDerivation {
       pname = "gtk3";
       version = "0.13.6";
       sha256 = "00ab7d347ebf1b3f4af8de7ebec8e5f72564a4680acbf376b711b9670a5dda89";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cairo containers gio glib mtl pango text
       ];
       libraryPkgconfigDepends = [ gtk3 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       executableHaskellDepends = [
         array base cairo text time transformers
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Gtk+ graphical user interface library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gtk3;};

  "gtk3_0_13_7" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gio
     , glib, gtk2hs-buildtools, gtk3, mtl, pango, text, time
     , transformers
     }:
     mkDerivation {
       pname = "gtk3";
       version = "0.13.7";
       sha256 = "29bf3dcdb39d01dbbced766ab1d72add67e73e01181668bc3423a71359d94f96";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cairo containers gio glib mtl pango text
       ];
       libraryPkgconfigDepends = [ gtk3 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       executableHaskellDepends = [
         array base cairo text time transformers
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Gtk+ graphical user interface library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gtk3;};

  "gtk3_0_13_8" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gio
     , glib, gtk2hs-buildtools, gtk3, mtl, pango, text, time
     , transformers
     }:
     mkDerivation {
       pname = "gtk3";
       version = "0.13.8";
       sha256 = "f3923ad4471aeea07c8f1fb6ddb24f18f5ae9ae6990a9b95f88382f06c6ee1a3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cairo containers gio glib mtl pango text
       ];
       libraryPkgconfigDepends = [ gtk3 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       executableHaskellDepends = [
         array base cairo text time transformers
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Gtk+ graphical user interface library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gtk3;};

  "gtk3_0_13_9" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gio
     , glib, gtk2hs-buildtools, gtk3, mtl, pango, text, time
     , transformers
     }:
     mkDerivation {
       pname = "gtk3";
       version = "0.13.9";
       sha256 = "79cbf8db4a89f171caf33eda96cee59686c029cbd72651a06076ea92c4ddacfe";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cairo containers gio glib mtl pango text
       ];
       libraryPkgconfigDepends = [ gtk3 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       executableHaskellDepends = [
         array base cairo text time transformers
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Gtk+ graphical user interface library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gtk3;};

  "gtk3_0_14_0" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gio
     , glib, gtk2hs-buildtools, gtk3, mtl, pango, text, time
     , transformers
     }:
     mkDerivation {
       pname = "gtk3";
       version = "0.14.0";
       sha256 = "ec548d8a63caabf449ada2c3f2589c6b15e741572affb8362161fd2ab7e4d6c8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cairo containers gio glib mtl pango text
       ];
       libraryPkgconfigDepends = [ gtk3 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       executableHaskellDepends = [
         array base cairo text time transformers
       ];
       doHaddock = false;
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Gtk+ 3 graphical user interface library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gtk3;};

  "gtk3_0_14_1" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gio
     , glib, gtk2hs-buildtools, gtk3, mtl, pango, text, time
     , transformers
     }:
     mkDerivation {
       pname = "gtk3";
       version = "0.14.1";
       sha256 = "4ebbb02611cbbc2a0ff592afb8cf37ffc6c10ec716464975872f46853c38c5a7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cairo containers gio glib mtl pango text
       ];
       libraryPkgconfigDepends = [ gtk3 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       executableHaskellDepends = [
         array base cairo text time transformers
       ];
       doHaddock = false;
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Gtk+ 3 graphical user interface library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gtk3;};

  "gtk3" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gio
     , glib, gtk2hs-buildtools, gtk3, mtl, pango, text, time
     , transformers
     }:
     mkDerivation {
       pname = "gtk3";
       version = "0.14.2";
       sha256 = "da198906bf3807e61c6d3c85c8537f424d9073d517d511d38197c569a1cb3d1d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cairo containers gio glib mtl pango text
       ];
       libraryPkgconfigDepends = [ gtk3 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       executableHaskellDepends = [
         array base cairo text time transformers
       ];
       doHaddock = 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;};

  "gtk3-mac-integration" = callPackage
    ({ mkDerivation, array, base, containers, glib
     , gtk-mac-integration-gtk3, gtk2hs-buildtools, gtk3, mtl
     }:
     mkDerivation {
       pname = "gtk3-mac-integration";
       version = "0.3.2.1";
       sha256 = "c457a75dff24baf47a17f8763b4549be69305dcbc1cf8da7afa01ca62dd466f5";
       libraryHaskellDepends = [ array base containers glib gtk3 mtl ];
       libraryPkgconfigDepends = [ gtk-mac-integration-gtk3 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://www.haskell.org/gtk2hs/";
       description = "Bindings for the Gtk/OS X integration library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gtk-mac-integration-gtk3 = null;};

  "gtkglext" = callPackage
    ({ mkDerivation, base, glib, gtk, gtk2hs-buildtools, gtkglext
     , pango
     }:
     mkDerivation {
       pname = "gtkglext";
       version = "0.12.5.0";
       sha256 = "13424d5f80e0ba22f2caf233f5a68a07635f6f77c4f48e6fe3fab28216a30af6";
       libraryHaskellDepends = [ base glib gtk pango ];
       libraryPkgconfigDepends = [ gtkglext ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the GTK+ OpenGL Extension";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.gnome) gtkglext;};

  "gtkimageview" = callPackage
    ({ mkDerivation, array, base, containers, glib, gtk
     , gtk2hs-buildtools, gtkimageview, haskell98, mtl
     }:
     mkDerivation {
       pname = "gtkimageview";
       version = "0.12.0";
       sha256 = "43066260e89a0bf1bfb3c2d0f08bfe479e4e505f2a0d05d86c04e257df59ae69";
       libraryHaskellDepends = [
         array base containers glib gtk haskell98 mtl
       ];
       libraryPkgconfigDepends = [ gtkimageview ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       jailbreak = true;
       homepage = "http://www.haskell.org/gtk2hs/";
       description = "Binding to the GtkImageView library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gtkimageview;};

  "gtkrsync" = callPackage
    ({ mkDerivation, base, gconf, glade, gtk, MissingH, process
     , regex-posix, unix
     }:
     mkDerivation {
       pname = "gtkrsync";
       version = "1.0.4";
       sha256 = "bc13dbcb3a30693d8cbf1f7d9df646439b2cfd5339bb954812b2ae2bebe3f57c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base gconf glade gtk MissingH process regex-posix unix
       ];
       homepage = "http://hg.complete.org/gtkrsync";
       description = "Gnome rsync progress display";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gtksourceview2" = callPackage
    ({ mkDerivation, array, base, containers, glib, gtk
     , gtk2hs-buildtools, gtksourceview, mtl, text
     }:
     mkDerivation {
       pname = "gtksourceview2";
       version = "0.13.2.1";
       sha256 = "8a98b0dd60625db232152586f1f73c1e4cfdca30b8af6c155029b532aa75e206";
       libraryHaskellDepends = [
         array base containers glib gtk mtl text
       ];
       libraryPkgconfigDepends = [ gtksourceview ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the GtkSourceView library";
       license = stdenv.lib.licenses.lgpl21;
     }) {inherit (pkgs.gnome) gtksourceview;};

  "gtksourceview3" = callPackage
    ({ mkDerivation, array, base, containers, glib, gtk2hs-buildtools
     , gtk3, gtksourceview, mtl, text
     }:
     mkDerivation {
       pname = "gtksourceview3";
       version = "0.13.2.1";
       sha256 = "61542fc063d948a0487c0fe784f8154d4a9ca66df3e29bbff0047843bb006ceb";
       libraryHaskellDepends = [
         array base containers glib gtk3 mtl text
       ];
       libraryPkgconfigDepends = [ gtksourceview ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the GtkSourceView library";
       license = stdenv.lib.licenses.lgpl21;
     }) {inherit (pkgs.gnome) gtksourceview;};

  "guarded-rewriting" = callPackage
    ({ mkDerivation, base, instant-generics }:
     mkDerivation {
       pname = "guarded-rewriting";
       version = "0.1";
       sha256 = "c96957369ca2e8e9372c8d587f7e636ad0a4f68b9195a80cbfd81346da356910";
       libraryHaskellDepends = [ base instant-generics ];
       homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/GuardedRewriting";
       description = "Datatype-generic rewriting with preconditions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "guess-combinator" = callPackage
    ({ mkDerivation, base, HList }:
     mkDerivation {
       pname = "guess-combinator";
       version = "0.1.1";
       sha256 = "f2d7ae4b4958fa198dacbe7579e9a330e01ec39f766905f2d0f32d66e84752f5";
       libraryHaskellDepends = [ base HList ];
       homepage = "http://code.atnnn.com/project/guess";
       description = "Generate simple combinators given their type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "gulcii" = callPackage
    ({ mkDerivation, base, cairo, containers, filepath, gtk }:
     mkDerivation {
       pname = "gulcii";
       version = "0.2.0.3";
       sha256 = "49d052b38c4684c377d71e28978c0578b196b7b11d861ddec6754307fcdb063d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base cairo containers filepath gtk ];
       jailbreak = true;
       homepage = "http://code.mathr.co.uk/gulcii";
       description = "graphical untyped lambda calculus interactive interpreter";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "gutenberg-fibonaccis" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "gutenberg-fibonaccis";
       version = "1.1.0";
       sha256 = "62a7f3c1fb8fd91d884b8eeb0a9e0684ee8be3056da07d1c962927b8ada37f6f";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/justinhanekom/gutenberg-fibonaccis";
       description = "The first 1001 Fibonacci numbers, retrieved from the Gutenberg Project";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "gyah-bin" = callPackage
    ({ mkDerivation, base, extra, GiveYouAHead }:
     mkDerivation {
       pname = "gyah-bin";
       version = "0.2.2.3";
       sha256 = "88187793a26b91d7ba609886e617db7f55a61d17d0ad2d301f6a905da2de22a7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base extra GiveYouAHead ];
       description = "A binary version of GiveYouAHead";
       license = stdenv.lib.licenses.mit;
     }) {};

  "h-booru" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , http-conduit, hxt, mtl, stm, template-haskell, transformers
     , utf8-string, vinyl
     }:
     mkDerivation {
       pname = "h-booru";
       version = "0.3.0.0";
       sha256 = "861c40c4eb8a0620e1f5e0c045824b2df57a20083d1b9ba418b911598663556c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring filepath http-conduit hxt mtl stm template-haskell
         transformers utf8-string vinyl
       ];
       executableHaskellDepends = [
         base bytestring containers directory filepath http-conduit hxt mtl
         stm template-haskell transformers utf8-string vinyl
       ];
       homepage = "https://github.com/Fuuzetsu/h-booru";
       description = "Haskell library for retrieving data from various booru image sites";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "h-gpgme" = callPackage
    ({ mkDerivation, base, bindings-gpgme, bytestring, either, HUnit
     , QuickCheck, tasty, tasty-hunit, tasty-quickcheck, time
     , transformers, unix
     }:
     mkDerivation {
       pname = "h-gpgme";
       version = "0.3.0.0";
       sha256 = "7dd4cba600967609af287f09bbe5bbb7573032115e226b775c8d7e1412e44a9c";
       libraryHaskellDepends = [
         base bindings-gpgme bytestring either time unix
       ];
       testHaskellDepends = [
         base bindings-gpgme bytestring either HUnit QuickCheck tasty
         tasty-hunit tasty-quickcheck time transformers unix
       ];
       jailbreak = true;
       homepage = "https://github.com/rethab/h-gpgme";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "h2048" = callPackage
    ({ mkDerivation, base, HUnit, MonadRandom, mtl, text, transformers
     , vty, vty-ui
     }:
     mkDerivation {
       pname = "h2048";
       version = "0.2.0.1";
       sha256 = "d9b1d7750e1c7a4de1bf591c548d70af991f94969a581292bcb06eb8cc2119e9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base MonadRandom mtl text transformers vty vty-ui
       ];
       executableHaskellDepends = [
         base MonadRandom mtl text transformers vty vty-ui
       ];
       testHaskellDepends = [ base HUnit MonadRandom mtl transformers ];
       homepage = "https://github.com/Javran/h2048";
       description = "a haskell implementation of Game 2048";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hArduino" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, serialport
     , time
     }:
     mkDerivation {
       pname = "hArduino";
       version = "0.9";
       sha256 = "4400fa234046582d2ad0ef6bbfe7c97afc725c13949ccafe11766cac1203980f";
       libraryHaskellDepends = [
         base bytestring containers mtl serialport time
       ];
       homepage = "http://leventerkok.github.com/hArduino";
       description = "Control your Arduino board from Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hBDD" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hBDD";
       version = "0.0.3";
       sha256 = "f31db3310060c783cfa41720605f6baf52ac89cab0471c2cf0ae24ca918448ca";
       libraryHaskellDepends = [ base ];
       description = "An abstraction layer for BDD libraries";
       license = "LGPL";
     }) {};

  "hBDD-CMUBDD" = callPackage
    ({ mkDerivation, base, bdd, c2hs, containers, deepseq, hBDD, mem
     , unix
     }:
     mkDerivation {
       pname = "hBDD-CMUBDD";
       version = "0.0.3";
       sha256 = "49bd34911f24402a1b05a1a258cc35cd7c6d9ba5e622c0731678446c1289fb9a";
       libraryHaskellDepends = [ base containers deepseq hBDD unix ];
       librarySystemDepends = [ bdd mem ];
       libraryToolDepends = [ c2hs ];
       description = "An FFI binding to CMU/Long's BDD library";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {bdd = null; mem = null;};

  "hBDD-CUDD" = callPackage
    ({ mkDerivation, base, c2hs, containers, cudd, deepseq, epd, hBDD
     , mtr, st, unix, util
     }:
     mkDerivation {
       pname = "hBDD-CUDD";
       version = "0.0.3";
       sha256 = "0a4a48997832ec00ae4fba8b1989656b77f40298b88a55da2223c83b84b424e5";
       libraryHaskellDepends = [ base containers deepseq hBDD unix ];
       librarySystemDepends = [ cudd epd mtr st util ];
       libraryToolDepends = [ c2hs ];
       description = "An FFI binding to the CUDD library";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {cudd = null; epd = null; inherit (pkgs) mtr; 
         inherit (pkgs) st; util = null;};

  "hCsound" = callPackage
    ({ mkDerivation, base, c2hs, csound64, libsndfile, monads-tf
     , transformers, vector
     }:
     mkDerivation {
       pname = "hCsound";
       version = "0.4.2";
       sha256 = "a2795fef85ebeefbab97d974673c00199dee26902fce642632955e098e639f7c";
       libraryHaskellDepends = [ base monads-tf transformers vector ];
       librarySystemDepends = [ csound64 libsndfile ];
       libraryToolDepends = [ c2hs ];
       jailbreak = true;
       description = "interface to CSound API";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {csound64 = null; inherit (pkgs) libsndfile;};

  "hDFA" = callPackage
    ({ mkDerivation, base, containers, directory, process }:
     mkDerivation {
       pname = "hDFA";
       version = "0.0.2";
       sha256 = "15d6ac1259763c8e6b565b82166a982a6c577d4b5e649f138183ea2f3c0edaab";
       libraryHaskellDepends = [ base containers directory process ];
       description = "A simple library for representing and minimising DFAs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hF2" = callPackage
    ({ mkDerivation, base, cereal, vector }:
     mkDerivation {
       pname = "hF2";
       version = "0.2";
       sha256 = "9fc5e73caf796f89a544937ca7acd57893026a099ca4456aba4d78a55d1807f8";
       libraryHaskellDepends = [ base cereal vector ];
       description = "F(2^e) math for cryptography";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hGelf" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cereal, network, old-time
     , pureMD5, QuickCheck, text, time, zlib
     }:
     mkDerivation {
       pname = "hGelf";
       version = "0.1";
       sha256 = "bc63290e1a875c275f59c2a39a7d2f1e21ec18a377de9f210162775435706f4a";
       libraryHaskellDepends = [
         aeson base bytestring cereal network old-time pureMD5 QuickCheck
         text time zlib
       ];
       description = "Haskell GELF library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hLLVM" = callPackage
    ({ mkDerivation, array, base, bytestring, cmdargs, containers
     , data-dword, directory, filepath, hooplext, mtl, parsec, pretty
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "hLLVM";
       version = "0.5.0.1";
       sha256 = "ff73d243cc6f59d49b14e23ce37678372d236144e46781082ea287a8c301c257";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cmdargs containers data-dword directory
         filepath hooplext mtl parsec pretty template-haskell transformers
       ];
       executableHaskellDepends = [
         array base bytestring cmdargs containers data-dword directory
         filepath hooplext mtl parsec pretty template-haskell transformers
       ];
       jailbreak = true;
       description = "A library for analyzing and transforming LLVM (3.5) assembly codes";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {hooplext = null;};

  "hMollom" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, Crypto
     , dataenc, ghc-prim, HTTP, mtl, old-locale, old-time, pureMD5
     , random, time
     }:
     mkDerivation {
       pname = "hMollom";
       version = "0.4.0";
       sha256 = "e555e663f11149e082a4be12d57f8deb918b8e1d113bcc6a7d27fac6ea9e30bf";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring Crypto dataenc ghc-prim HTTP mtl
         old-locale old-time pureMD5 random time
       ];
       homepage = "http://github.com/itkovian/hMollom";
       description = "Library to interact with the @Mollom anti-spam service";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hOpenPGP_1_11" = callPackage
    ({ mkDerivation, ansi-wl-pprint, attoparsec, base
     , base64-bytestring, bytestring, bzlib, cereal, cereal-conduit
     , conduit, conduit-extra, containers, crypto-cipher-types
     , crypto-pubkey, crypto-random, cryptocipher, cryptohash
     , data-default, errors, hashable, incremental-parser, ixset, lens
     , monad-loops, mtl, nettle, openpgp-asciiarmor, QuickCheck
     , quickcheck-instances, resourcet, securemem, semigroups, split
     , tasty, tasty-hunit, tasty-quickcheck, text, time, transformers
     , unordered-containers, zlib
     }:
     mkDerivation {
       pname = "hOpenPGP";
       version = "1.11";
       sha256 = "678574685bc3c7040ca40f57a21d5a9654edba4a2b2f00eb624491283a568caa";
       libraryHaskellDepends = [
         ansi-wl-pprint attoparsec base base64-bytestring bytestring bzlib
         cereal cereal-conduit conduit conduit-extra containers
         crypto-cipher-types crypto-pubkey crypto-random cryptocipher
         cryptohash data-default errors hashable incremental-parser ixset
         lens monad-loops mtl nettle openpgp-asciiarmor resourcet securemem
         semigroups split text time transformers unordered-containers zlib
       ];
       testHaskellDepends = [
         ansi-wl-pprint attoparsec base bytestring bzlib cereal
         cereal-conduit conduit conduit-extra containers crypto-cipher-types
         crypto-pubkey crypto-random cryptocipher cryptohash data-default
         errors hashable incremental-parser ixset lens monad-loops mtl
         nettle QuickCheck quickcheck-instances resourcet securemem
         semigroups split tasty tasty-hunit tasty-quickcheck text time
         transformers unordered-containers zlib
       ];
       homepage = "http://floss.scru.org/hOpenPGP/";
       description = "native Haskell implementation of OpenPGP (RFC4880)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hOpenPGP_2_0" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bifunctors, binary, binary-conduit, byteable, bytestring, bzlib
     , conduit, conduit-extra, containers, crypto-cipher-types
     , crypto-pubkey, crypto-random, cryptocipher, cryptohash
     , data-default-class, errors, hashable, incremental-parser, ixset
     , lens, monad-loops, nettle, network, network-uri, newtype
     , old-locale, openpgp-asciiarmor, QuickCheck, quickcheck-instances
     , resourcet, securemem, semigroups, split, tasty, tasty-hunit
     , tasty-quickcheck, text, time, transformers, unordered-containers
     , wl-pprint-extras, zlib
     }:
     mkDerivation {
       pname = "hOpenPGP";
       version = "2.0";
       sha256 = "bb93e8e0ae73b1069704ede11d4aa0efadf72fa1a5400c7a243d8296020833cf";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring bifunctors binary
         binary-conduit byteable bytestring bzlib conduit conduit-extra
         containers crypto-cipher-types crypto-pubkey crypto-random
         cryptocipher cryptohash data-default-class errors hashable
         incremental-parser ixset lens monad-loops nettle network
         network-uri newtype old-locale openpgp-asciiarmor resourcet
         securemem semigroups split text time transformers
         unordered-containers wl-pprint-extras zlib
       ];
       testHaskellDepends = [
         aeson attoparsec base bifunctors binary binary-conduit byteable
         bytestring bzlib conduit conduit-extra containers
         crypto-cipher-types crypto-pubkey crypto-random cryptocipher
         cryptohash data-default-class errors hashable incremental-parser
         ixset lens monad-loops nettle network network-uri newtype
         old-locale QuickCheck quickcheck-instances resourcet securemem
         semigroups split tasty tasty-hunit tasty-quickcheck text time
         transformers unordered-containers wl-pprint-extras zlib
       ];
       homepage = "http://floss.scru.org/hOpenPGP/";
       description = "native Haskell implementation of OpenPGP (RFC4880)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hOpenPGP_2_2_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bifunctors, binary, binary-conduit, byteable, bytestring, bzlib
     , conduit, conduit-extra, containers, crypto-cipher-types
     , crypto-pubkey, crypto-random, cryptocipher, cryptohash
     , data-default-class, errors, hashable, incremental-parser
     , ixset-typed, lens, monad-loops, nettle, network, network-uri
     , newtype, openpgp-asciiarmor, QuickCheck, quickcheck-instances
     , resourcet, securemem, semigroups, split, tasty, tasty-hunit
     , tasty-quickcheck, text, time, time-locale-compat, transformers
     , unordered-containers, wl-pprint-extras, zlib
     }:
     mkDerivation {
       pname = "hOpenPGP";
       version = "2.2.1";
       sha256 = "48e7bc8f2bc29ab5531b3a75e298aeef4fcd4b50efdb7cb9fcea8ca3f1413567";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring bifunctors binary
         binary-conduit byteable bytestring bzlib conduit conduit-extra
         containers crypto-cipher-types crypto-pubkey crypto-random
         cryptocipher cryptohash data-default-class errors hashable
         incremental-parser ixset-typed lens monad-loops nettle network
         network-uri newtype openpgp-asciiarmor resourcet securemem
         semigroups split text time time-locale-compat transformers
         unordered-containers wl-pprint-extras zlib
       ];
       testHaskellDepends = [
         aeson attoparsec base bifunctors binary binary-conduit byteable
         bytestring bzlib conduit conduit-extra containers
         crypto-cipher-types crypto-pubkey crypto-random cryptocipher
         cryptohash data-default-class errors hashable incremental-parser
         ixset-typed lens monad-loops nettle network network-uri newtype
         QuickCheck quickcheck-instances resourcet securemem semigroups
         split tasty tasty-hunit tasty-quickcheck text time
         time-locale-compat transformers unordered-containers
         wl-pprint-extras zlib
       ];
       homepage = "http://floss.scru.org/hOpenPGP/";
       description = "native Haskell implementation of OpenPGP (RFC4880)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hOpenPGP_2_4_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bifunctors, binary, binary-conduit, byteable, bytestring, bzlib
     , conduit, conduit-extra, containers, crypto-cipher-types
     , cryptonite, data-default-class, errors, hashable
     , incremental-parser, ixset-typed, lens, memory, monad-loops
     , nettle, network, network-uri, newtype, openpgp-asciiarmor
     , QuickCheck, quickcheck-instances, resourcet, securemem
     , semigroups, split, tasty, tasty-hunit, tasty-quickcheck, text
     , time, time-locale-compat, transformers, unordered-containers
     , wl-pprint-extras, zlib
     }:
     mkDerivation {
       pname = "hOpenPGP";
       version = "2.4.1";
       sha256 = "c4a8b3a42381372cb856e2aaf558af7dfefc905ccfc6ea2b06ded2688c2c5dce";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring bifunctors binary
         binary-conduit byteable bytestring bzlib conduit conduit-extra
         containers crypto-cipher-types cryptonite data-default-class errors
         hashable incremental-parser ixset-typed lens memory monad-loops
         nettle network network-uri newtype openpgp-asciiarmor resourcet
         securemem semigroups split text time time-locale-compat
         transformers unordered-containers wl-pprint-extras zlib
       ];
       testHaskellDepends = [
         aeson attoparsec base bifunctors binary binary-conduit byteable
         bytestring bzlib conduit conduit-extra containers
         crypto-cipher-types cryptonite data-default-class errors hashable
         incremental-parser ixset-typed lens memory monad-loops nettle
         network network-uri newtype QuickCheck quickcheck-instances
         resourcet securemem semigroups split tasty tasty-hunit
         tasty-quickcheck text time time-locale-compat transformers
         unordered-containers wl-pprint-extras zlib
       ];
       homepage = "http://floss.scru.org/hOpenPGP/";
       description = "native Haskell implementation of OpenPGP (RFC4880)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hOpenPGP" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bifunctors, binary, binary-conduit, byteable, bytestring, bzlib
     , conduit, conduit-extra, containers, crypto-cipher-types
     , cryptonite, data-default-class, errors, hashable
     , incremental-parser, ixset-typed, lens, memory, monad-loops
     , nettle, network, network-uri, newtype, openpgp-asciiarmor
     , QuickCheck, quickcheck-instances, resourcet, securemem
     , semigroups, split, tasty, tasty-hunit, tasty-quickcheck, text
     , time, time-locale-compat, transformers, unordered-containers
     , wl-pprint-extras, zlib
     }:
     mkDerivation {
       pname = "hOpenPGP";
       version = "2.4.3";
       sha256 = "3e7ff2430415856b2d99d3cba144f9c41fcfe0cceea5d0967909b4033f0a86c9";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring bifunctors binary
         binary-conduit byteable bytestring bzlib conduit conduit-extra
         containers crypto-cipher-types cryptonite data-default-class errors
         hashable incremental-parser ixset-typed lens memory monad-loops
         nettle network network-uri newtype openpgp-asciiarmor resourcet
         securemem semigroups split text time time-locale-compat
         transformers unordered-containers wl-pprint-extras zlib
       ];
       testHaskellDepends = [
         aeson attoparsec base bifunctors binary binary-conduit byteable
         bytestring bzlib conduit conduit-extra containers
         crypto-cipher-types cryptonite data-default-class errors hashable
         incremental-parser ixset-typed lens memory monad-loops nettle
         network network-uri newtype QuickCheck quickcheck-instances
         resourcet securemem semigroups split tasty tasty-hunit
         tasty-quickcheck text time time-locale-compat transformers
         unordered-containers wl-pprint-extras zlib
       ];
       homepage = "http://floss.scru.org/hOpenPGP/";
       description = "native Haskell implementation of OpenPGP (RFC4880)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hPDB_1_2_0" = callPackage
    ({ mkDerivation, AC-Vector, base, bytestring, containers, deepseq
     , directory, ghc-prim, iterable, mmap, mtl, Octree, parallel
     , QuickCheck, tagged, template-haskell, text, text-format, vector
     , zlib
     }:
     mkDerivation {
       pname = "hPDB";
       version = "1.2.0";
       sha256 = "c81b56932456cfaafeff05c62ed38cb7102e4269fba09995ce0a558cb3e4b4a8";
       libraryHaskellDepends = [
         AC-Vector base bytestring containers deepseq directory ghc-prim
         iterable mmap mtl Octree parallel QuickCheck tagged
         template-haskell text text-format vector zlib
       ];
       jailbreak = true;
       homepage = "https://github.com/BioHaskell/hPDB";
       description = "Protein Databank file format library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hPDB_1_2_0_1" = callPackage
    ({ mkDerivation, AC-Vector, base, bytestring, containers, deepseq
     , directory, ghc-prim, iterable, mmap, mtl, Octree, parallel
     , QuickCheck, tagged, template-haskell, text, vector, zlib
     }:
     mkDerivation {
       pname = "hPDB";
       version = "1.2.0.1";
       sha256 = "9bbd22b9615d9fde13c21efc1286ea71ced7dd143e81b9fba5305892f45e6ed7";
       libraryHaskellDepends = [
         AC-Vector base bytestring containers deepseq directory ghc-prim
         iterable mmap mtl Octree parallel QuickCheck tagged
         template-haskell text vector zlib
       ];
       homepage = "https://github.com/BioHaskell/hPDB";
       description = "Protein Databank file format library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hPDB_1_2_0_2" = callPackage
    ({ mkDerivation, AC-Vector, base, bytestring, containers, deepseq
     , directory, ghc-prim, iterable, mmap, mtl, Octree, parallel
     , QuickCheck, tagged, template-haskell, text, vector, zlib
     }:
     mkDerivation {
       pname = "hPDB";
       version = "1.2.0.2";
       sha256 = "73a7e3a14854f0bd20a5cb718e6ef5ee1009a3bfc2ae00d0707a989bdaf6d557";
       libraryHaskellDepends = [
         AC-Vector base bytestring containers deepseq directory ghc-prim
         iterable mmap mtl Octree parallel QuickCheck tagged
         template-haskell text vector zlib
       ];
       homepage = "https://github.com/BioHaskell/hPDB";
       description = "Protein Databank file format library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hPDB_1_2_0_3" = callPackage
    ({ mkDerivation, AC-Vector, base, bytestring, containers, deepseq
     , directory, ghc-prim, iterable, mmap, mtl, Octree, parallel
     , QuickCheck, tagged, template-haskell, text, vector, zlib
     }:
     mkDerivation {
       pname = "hPDB";
       version = "1.2.0.3";
       sha256 = "573771d19c0513e868d17eaf95c100695f22a70ac4459042acef8c609f8c91d1";
       libraryHaskellDepends = [
         AC-Vector base bytestring containers deepseq directory ghc-prim
         iterable mmap mtl Octree parallel QuickCheck tagged
         template-haskell text vector zlib
       ];
       homepage = "https://github.com/BioHaskell/hPDB";
       description = "Protein Databank file format library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hPDB" = callPackage
    ({ mkDerivation, AC-Vector, base, bytestring, containers, deepseq
     , directory, ghc-prim, iterable, mmap, mtl, Octree, parallel
     , QuickCheck, tagged, template-haskell, text, vector, zlib
     }:
     mkDerivation {
       pname = "hPDB";
       version = "1.2.0.4";
       sha256 = "3a10d832b51f975071bd796fdbc11a12316a65661f192a873f849d9e8237f93b";
       libraryHaskellDepends = [
         AC-Vector base bytestring containers deepseq directory ghc-prim
         iterable mmap mtl Octree parallel QuickCheck tagged
         template-haskell text vector zlib
       ];
       homepage = "https://github.com/BioHaskell/hPDB";
       description = "Protein Databank file format library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hPDB-examples_1_1_2" = callPackage
    ({ mkDerivation, AC-Vector, base, bytestring, containers, deepseq
     , directory, ghc-prim, GLUT, hPDB, iterable, mtl, Octree, OpenGL
     , QuickCheck, template-haskell, text, text-format, vector
     }:
     mkDerivation {
       pname = "hPDB-examples";
       version = "1.1.2";
       sha256 = "b2c7792d8987113d520606c64c1aecd4c9e39af249d0fa2523a31284a079b144";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         AC-Vector base bytestring containers deepseq directory ghc-prim
         GLUT hPDB iterable mtl Octree OpenGL QuickCheck template-haskell
         text text-format vector
       ];
       homepage = "https://github.com/BioHaskell/hPDB-examples";
       description = "Examples for hPDB library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hPDB-examples_1_2_0_1" = callPackage
    ({ mkDerivation, AC-Vector, base, bytestring, containers, deepseq
     , directory, ghc-prim, GLUT, hPDB, IfElse, iterable, mtl, Octree
     , OpenGL, process, QuickCheck, template-haskell, text, text-format
     , time, vector
     }:
     mkDerivation {
       pname = "hPDB-examples";
       version = "1.2.0.1";
       sha256 = "da84a04a68d1f19d321dcd3c973edf6ff2e9094b68fe7d7f2eada5a7405dfc5e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         AC-Vector base bytestring containers deepseq directory ghc-prim
         GLUT hPDB iterable mtl Octree OpenGL QuickCheck template-haskell
         text text-format vector
       ];
       testHaskellDepends = [
         AC-Vector base bytestring containers deepseq directory ghc-prim
         hPDB IfElse iterable mtl process template-haskell text time vector
       ];
       homepage = "https://github.com/BioHaskell/hPDB-examples";
       description = "Examples for hPDB library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hPDB-examples" = callPackage
    ({ mkDerivation, AC-Vector, base, bytestring, containers, deepseq
     , directory, ghc-prim, GLUT, hPDB, IfElse, iterable, mtl, Octree
     , OpenGL, process, QuickCheck, template-haskell, text, text-format
     , time, vector
     }:
     mkDerivation {
       pname = "hPDB-examples";
       version = "1.2.0.2";
       sha256 = "8aa3a23bba6503a504115271cc7519dedd88833f0732a37bd397a23e7c0235e8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         AC-Vector base bytestring containers deepseq directory ghc-prim
         GLUT hPDB iterable mtl Octree OpenGL QuickCheck template-haskell
         text text-format vector
       ];
       testHaskellDepends = [
         AC-Vector base bytestring containers deepseq directory ghc-prim
         hPDB IfElse iterable mtl process template-haskell text time vector
       ];
       homepage = "https://github.com/BioHaskell/hPDB-examples";
       description = "Examples for hPDB library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hPushover" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-conduit, network
     , text
     }:
     mkDerivation {
       pname = "hPushover";
       version = "0.2";
       sha256 = "a3a9f127207032dd7aee3c5690b2d5b4c7030205393608b8765601267cd36392";
       libraryHaskellDepends = [
         aeson base bytestring http-conduit network text
       ];
       jailbreak = true;
       homepage = "tot";
       description = "Pushover.net API functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hR" = callPackage
    ({ mkDerivation, array, base, containers, unix }:
     mkDerivation {
       pname = "hR";
       version = "0.1.1";
       sha256 = "8cc67518f63bf56966f069660476309682661dc11c13de77fb5ac6ae5f1d80cd";
       libraryHaskellDepends = [ array base containers unix ];
       description = "R bindings and interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hRESP" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring }:
     mkDerivation {
       pname = "hRESP";
       version = "0.1.0.0";
       sha256 = "3ea116a4ba2a768de90100d515f37025d9982587132f4e185293292f5ed019a1";
       libraryHaskellDepends = [ attoparsec base bytestring ];
       homepage = "https://github.com/yihuang/hresp";
       description = "haskell implementation of RESP (REdis Serialization Protocol)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hS3" = callPackage
    ({ mkDerivation, base, bytestring, Crypto, dataenc, HTTP, hxt
     , MissingH, network, network-uri, old-locale, old-time, random
     , regex-compat, utf8-string
     }:
     mkDerivation {
       pname = "hS3";
       version = "0.5.9";
       sha256 = "7ee0ba24b01cdefc02f683aef16d33ac146928ae75a00e566673be12960cc759";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring Crypto dataenc HTTP hxt MissingH network
         network-uri old-locale old-time random regex-compat utf8-string
       ];
       homepage = "http://gregheartsfield.com/hS3/";
       description = "Interface to Amazon's Simple Storage Service (S3)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hScraper" = callPackage
    ({ mkDerivation, base, bytestring, directory, HTTP, http-conduit
     , http-types, parsec, process, regex-compat, text, transformers
     }:
     mkDerivation {
       pname = "hScraper";
       version = "0.1.0.0";
       sha256 = "955cb0d84ebfcddd252aadb6dcc565de4db2e16324623d25cac7159c79c3c16a";
       libraryHaskellDepends = [
         base bytestring directory HTTP http-conduit http-types parsec
         process regex-compat text transformers
       ];
       description = "A Haskell library to scrape and crawl web-pages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hSimpleDB" = callPackage
    ({ mkDerivation, base, bytestring, Crypto, dataenc, HTTP, hxt
     , network, old-locale, old-time, utf8-string
     }:
     mkDerivation {
       pname = "hSimpleDB";
       version = "0.3";
       sha256 = "4a4da7bf0d7cbdbe546ebc19c218feef22afb958d2221ae367b3f2b3c47bb510";
       libraryHaskellDepends = [
         base bytestring Crypto dataenc HTTP hxt network old-locale old-time
         utf8-string
       ];
       jailbreak = true;
       description = "Interface to Amazon's SimpleDB service";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hTalos" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "hTalos";
       version = "0.2";
       sha256 = "37261526551aa558b33a382a2b90d26a52437a5717918fe4e32fadcb33b58916";
       libraryHaskellDepends = [ base bytestring ];
       testHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/mgajda/hTalos";
       description = "Parser, print and manipulate structures in PDB file format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hTensor" = callPackage
    ({ mkDerivation, base, containers, hmatrix, random }:
     mkDerivation {
       pname = "hTensor";
       version = "0.9.0";
       sha256 = "0abf643e33f0cc10c652d871390e8c5b07f6e549dd0f1bb44f159d61596c0c6a";
       libraryHaskellDepends = [ base containers hmatrix random ];
       homepage = "http://perception.inf.um.es/tensor";
       description = "Multidimensional arrays and simple tensor computations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hVOIDP" = callPackage
    ({ mkDerivation, array, base, blas, hmatrix, liblapack }:
     mkDerivation {
       pname = "hVOIDP";
       version = "1.0.2";
       sha256 = "ccb6682f76b4da00094aeb5fe4704e9b2e13cff8013bf97e9220e73083212a65";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [ array base hmatrix ];
       executableSystemDepends = [ blas liblapack ];
       homepage = "http://dslsrv4.cs.missouri.edu/~qqbm9";
       description = "Optimal variable selection in chain graphical model";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};

  "hXmixer" = callPackage
    ({ mkDerivation, base, directory, gtk3, process, split, text }:
     mkDerivation {
       pname = "hXmixer";
       version = "0.3.0.0";
       sha256 = "9dc090e3a3c914b3f1e2304e28ef2f021372fa5b7705d327f6767f1bcda33cd9";
       revision = "2";
       editedCabalFile = "ba9345a3146b34d0101920f9efd6af7f435188dd7ae53b50d76cc0851f13014f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory gtk3 process split text
       ];
       description = "A Gtk mixer GUI application for FreeBSD";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haar" = callPackage
    ({ mkDerivation, base, QuickCheck, split, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "haar";
       version = "0.1";
       sha256 = "3b58835fc39fa1a54ab3530b5d2dce69beee082f9ed6d93b6045644c5331bff6";
       libraryHaskellDepends = [ base split ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/mhwombat/haar";
       description = "Haar wavelet transforms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hacanon-light" = callPackage
    ({ mkDerivation, base, mtl, template-haskell }:
     mkDerivation {
       pname = "hacanon-light";
       version = "2008.10.28";
       sha256 = "472141ff0559ea44154f34df1cf6298994d6cb4fb0fc469b37ffd649ce731c54";
       libraryHaskellDepends = [ base mtl template-haskell ];
       description = "Template Haskell framework for automatic FFI code generation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hack" = callPackage
    ({ mkDerivation, base, bytestring, data-default }:
     mkDerivation {
       pname = "hack";
       version = "2012.2.6";
       sha256 = "b95559d2571bd1e1ec1973f4c40f7a904d54c98e4689e80a4a746aa35c522e73";
       libraryHaskellDepends = [ base bytestring data-default ];
       homepage = "http://github.com/nfjinjing/hack/tree/master";
       description = "a Haskell Webserver Interface";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hack-contrib" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, bytestring, cgi, containers
     , data-default, directory, filepath, hack, haskell98, mps, network
     , old-locale, old-time, time, utf8-string
     }:
     mkDerivation {
       pname = "hack-contrib";
       version = "2010.9.28";
       sha256 = "e10a8cc3547682cdddec880556a7d678b92ab92acbcba674de249bcf99430fe4";
       libraryHaskellDepends = [
         ansi-wl-pprint base bytestring cgi containers data-default
         directory filepath hack haskell98 mps network old-locale old-time
         time utf8-string
       ];
       homepage = "http://github.com/nfjinjing/hack-contrib";
       description = "Hack contrib";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hack-contrib-press" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-class, containers
     , hack, json, mtl, parsec, press
     }:
     mkDerivation {
       pname = "hack-contrib-press";
       version = "0.1.2";
       sha256 = "5904a8dfddcdea509a2c1db8789da38e1c19a98d13ff65d748b4334408ef678b";
       libraryHaskellDepends = [
         base bytestring bytestring-class containers hack json mtl parsec
         press
       ];
       homepage = "http://github.com/bickfordb/hack-contrib-press";
       description = "Hack helper that renders Press templates";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hack-frontend-happstack" = callPackage
    ({ mkDerivation, base, bytestring, containers, hack
     , happstack-server, network, utf8-string
     }:
     mkDerivation {
       pname = "hack-frontend-happstack";
       version = "2009.6.24.1";
       sha256 = "81c378530edac00e027269e3a78087ddcb9d9133b9bb6baa7e999669895493f4";
       libraryHaskellDepends = [
         base bytestring containers hack happstack-server network
         utf8-string
       ];
       homepage = "http://github.com/nfjinjing/hack/tree/master";
       description = "hack-frontend-happstack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hack-frontend-monadcgi" = callPackage
    ({ mkDerivation, base, bytestring, cgi, containers, hack }:
     mkDerivation {
       pname = "hack-frontend-monadcgi";
       version = "0.0.3.1";
       sha256 = "6290fa77d8ef64be4235a7bb7b31211d37b6b7b5f951118b956d802d09710a54";
       libraryHaskellDepends = [ base bytestring cgi containers hack ];
       description = "Allows programs written against MonadCGI to run with any hack handler. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hack-handler-cgi" = callPackage
    ({ mkDerivation, base, bytestring, hack }:
     mkDerivation {
       pname = "hack-handler-cgi";
       version = "0.2.0.2";
       sha256 = "5d5c3b94664fc81638cd512382adf4f0a52583e2ce39de32864aad4692dea85e";
       libraryHaskellDepends = [ base bytestring hack ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/hack-handler-cgi/tree/master";
       description = "Hack handler using CGI protocol. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hack-handler-epoll" = callPackage
    ({ mkDerivation, base, containers, data-default, epoll, failure
     , hack, HTTP, network, unix, utf8-string
     }:
     mkDerivation {
       pname = "hack-handler-epoll";
       version = "0.1.3";
       sha256 = "02dd1477efcc58da6f790cccb4b0e928d209c13b19723a8a1f89a19ed0e18c60";
       revision = "1";
       editedCabalFile = "e237061a017229aaa9f0afcfed7c3d331b95a992ed71124a0a3131e96887f139";
       libraryHaskellDepends = [
         base containers data-default epoll failure hack HTTP network unix
         utf8-string
       ];
       homepage = "https://gitlab.com/twittner/hack-handler-epoll";
       description = "hack handler implementation using epoll";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hack-handler-evhttp" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-class, containers
     , data-default, event, hack, hack-contrib, network
     }:
     mkDerivation {
       pname = "hack-handler-evhttp";
       version = "2009.8.4";
       sha256 = "9fce27e21919e6fae13825ac06ee25cb6aa1f5f8a57da33cea6daa2793a609a8";
       libraryHaskellDepends = [
         base bytestring bytestring-class containers data-default hack
         hack-contrib network
       ];
       librarySystemDepends = [ event ];
       homepage = "http://github.com/bickfordb/hack-handler-evhttp";
       description = "Hack EvHTTP (libevent) Handler";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {event = null;};

  "hack-handler-fastcgi" = callPackage
    ({ mkDerivation, base, bytestring, fcgi, hack, hack-handler-cgi }:
     mkDerivation {
       pname = "hack-handler-fastcgi";
       version = "0.2.0.1";
       sha256 = "d92ad8b7846aaabe596c3d2e34af2761555adcde44937837c0c8e394c780540b";
       libraryHaskellDepends = [ base bytestring hack hack-handler-cgi ];
       librarySystemDepends = [ fcgi ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/hack-handler-fastcgi/tree/master";
       description = "Hack handler direct to fastcgi (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) fcgi;};

  "hack-handler-happstack" = callPackage
    ({ mkDerivation, base, bytestring, cgi, containers, data-default
     , hack, happstack-server, mtl, network
     }:
     mkDerivation {
       pname = "hack-handler-happstack";
       version = "2009.12.20";
       sha256 = "e4c169c7c4f9e011d0067bff441ecedc82c23fe46d0ceaa88aa95cf5c2656381";
       libraryHaskellDepends = [
         base bytestring cgi containers data-default hack happstack-server
         mtl network
       ];
       homepage = "http://github.com/nfjinjing/hack-handler-happstack";
       description = "Hack Happstack server handler";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hack-handler-hyena" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default, hack
     , hyena, network
     }:
     mkDerivation {
       pname = "hack-handler-hyena";
       version = "2010.3.15";
       sha256 = "582c592a585691d5db1a6bcd24d62cf312a2d55a8502cc6c17ffaa18e2f41fdc";
       libraryHaskellDepends = [
         base bytestring containers data-default hack hyena network
       ];
       homepage = "http://github.com/nfjinjing/hack-handler-hyena";
       description = "Hyena hack handler";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hack-handler-kibro" = callPackage
    ({ mkDerivation, base, cgi, data-default, hack, kibro, network }:
     mkDerivation {
       pname = "hack-handler-kibro";
       version = "2009.5.27";
       sha256 = "221d75aff4a82c5dcfef3e70e76f0104f17019be5b0decf25719927c6e06c35f";
       libraryHaskellDepends = [
         base cgi data-default hack kibro network
       ];
       homepage = "http://github.com/nfjinjing/hack/tree/master";
       description = "Hack Kibro handler";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hack-handler-simpleserver" = callPackage
    ({ mkDerivation, base, bytestring, failure, hack, network
     , web-encodings
     }:
     mkDerivation {
       pname = "hack-handler-simpleserver";
       version = "0.2.2";
       sha256 = "7ee8c60dd571480e5f9e08b31674c7a2af564e6458d8e235c4f3cffef27df1dc";
       libraryHaskellDepends = [
         base bytestring failure hack network web-encodings
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/hack-handler-simpleserver/tree/master";
       description = "A simplistic HTTP server handler for Hack. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hack-middleware-cleanpath" = callPackage
    ({ mkDerivation, base, bytestring, hack, split, web-encodings }:
     mkDerivation {
       pname = "hack-middleware-cleanpath";
       version = "0.0.1.1";
       sha256 = "c4c615d3c5df0a9d9cf1b2b239a9c81ad0de8837a7fc660a1cc34e1ea7540704";
       libraryHaskellDepends = [
         base bytestring hack split web-encodings
       ];
       homepage = "http://github.com/snoyberg/hack-middleware-cleanpath/tree/master";
       description = "Applies some basic redirect rules to get cleaner paths. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hack-middleware-clientsession" = callPackage
    ({ mkDerivation, base, clientsession, hack, old-locale, predicates
     , time, web-encodings
     }:
     mkDerivation {
       pname = "hack-middleware-clientsession";
       version = "0.0.1.1";
       sha256 = "2e1cc4a9eed29fee88a231c37ac024192e9f09a62a7d35c8c32c39a837159440";
       libraryHaskellDepends = [
         base clientsession hack old-locale predicates time web-encodings
       ];
       homepage = "http://github.com/snoyberg/hack-middleware-clientsession/tree/master";
       description = "Middleware for easily keeping session data in client cookies. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hack-middleware-gzip" = callPackage
    ({ mkDerivation, base, hack, split, zlib }:
     mkDerivation {
       pname = "hack-middleware-gzip";
       version = "0.0.0.1";
       sha256 = "e040a672e00a391be308d0b9e87d6680acf68818d333ed3d21efc0349211e5f4";
       libraryHaskellDepends = [ base hack split zlib ];
       homepage = "http://github.com/snoyberg/hack-middleware-gzip/tree/master";
       description = "Automatic gzip compression of responses. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hack-middleware-jsonp" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-class, hack
     , web-encodings
     }:
     mkDerivation {
       pname = "hack-middleware-jsonp";
       version = "0.0.2.1";
       sha256 = "3c820f0d4671ddf5f60ca853c64e0cccda434a154866c15b71c500a00321f43c";
       libraryHaskellDepends = [
         base bytestring bytestring-class hack web-encodings
       ];
       homepage = "http://github.com/snoyberg/hack-middleware-jsonp/tree/master";
       description = "Automatic wrapping of JSON responses to convert into JSONP. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hack2" = callPackage
    ({ mkDerivation, base, bytestring, data-default }:
     mkDerivation {
       pname = "hack2";
       version = "2014.11.17";
       sha256 = "48b84c2c5f9c314e90b36b4d6992045e93f36dc6b0dfb4be671a95ad63fbd2ac";
       libraryHaskellDepends = [ base bytestring data-default ];
       homepage = "https://github.com/nfjinjing/hack2";
       description = "a Haskell Webserver Interface (V2)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hack2-contrib" = callPackage
    ({ mkDerivation, air, base, bytestring, containers, data-default
     , directory, filepath, hack2, network-uri, text, time
     }:
     mkDerivation {
       pname = "hack2-contrib";
       version = "2015.5.4";
       sha256 = "739350c083d429d69f3b06ae47153b7e0c2ed8e271bf5fae0309b8b2d4b26ded";
       libraryHaskellDepends = [
         air base bytestring containers data-default directory filepath
         hack2 network-uri text time
       ];
       homepage = "https://github.com/nfjinjing/hack2-contrib";
       description = "Hack2 contrib";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hack2-contrib-extra" = callPackage
    ({ mkDerivation, air, air-extra, base, bytestring, cgi, containers
     , data-default, directory, filepath, hack2, hack2-contrib, network
     , old-locale, old-time, time
     }:
     mkDerivation {
       pname = "hack2-contrib-extra";
       version = "2014.12.20";
       sha256 = "949765c6186f95fafea5167c460026a494e2385b25db5987289c8d5432ddafd7";
       libraryHaskellDepends = [
         air air-extra base bytestring cgi containers data-default directory
         filepath hack2 hack2-contrib network old-locale old-time time
       ];
       homepage = "https://github.com/nfjinjing/hack2-contrib";
       description = "Hack2 contrib extra";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hack2-handler-happstack-server" = callPackage
    ({ mkDerivation, base, bytestring, cgi, containers, data-default
     , enumerator, hack2, happstack-server, mtl, network
     }:
     mkDerivation {
       pname = "hack2-handler-happstack-server";
       version = "2011.6.20";
       sha256 = "fdcec314674580aed6442c60d21a578111a23b9438006bc261d70803dccfb684";
       libraryHaskellDepends = [
         base bytestring cgi containers data-default enumerator hack2
         happstack-server mtl network
       ];
       jailbreak = true;
       homepage = "https://github.com/nfjinjing/hack2-handler-happstack-server";
       description = "Hack2 Happstack server handler";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hack2-handler-mongrel2-http" = callPackage
    ({ mkDerivation, aeson, air, attoparsec, base, blaze-builder
     , blaze-textual, bytestring, containers, data-default, directory
     , enumerator, hack2, mtl, network, safe, stm, text, unix
     , zeromq-haskell
     }:
     mkDerivation {
       pname = "hack2-handler-mongrel2-http";
       version = "2011.10.31";
       sha256 = "3c14b449b0381e9dab115798e01cb323bd49317717f336ba37c9d8015056d5df";
       libraryHaskellDepends = [
         aeson air attoparsec base blaze-builder blaze-textual bytestring
         containers data-default directory enumerator hack2 mtl network safe
         stm text unix zeromq-haskell
       ];
       homepage = "https://github.com/nfjinjing/hack2-handler-mongrel2-http";
       description = "Hack2 Mongrel2 HTTP handler";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hack2-handler-snap-server" = callPackage
    ({ mkDerivation, air, base, blaze-builder, bytestring
     , case-insensitive, containers, data-default, directory, enumerator
     , hack2, mtl, network, snap-core, snap-server
     }:
     mkDerivation {
       pname = "hack2-handler-snap-server";
       version = "2015.3.9";
       sha256 = "07ae1572e333536bab33e6b12acc472504b4eb7e7741142d08e4124299ad45e3";
       libraryHaskellDepends = [
         air base blaze-builder bytestring case-insensitive containers
         data-default directory enumerator hack2 mtl network snap-core
         snap-server
       ];
       homepage = "https://github.com/nfjinjing/hack2-handler-snap-server";
       description = "Hack2 Snap server handler";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hack2-handler-warp" = callPackage
    ({ mkDerivation, air, base, data-default, hack2
     , hack2-interface-wai, warp
     }:
     mkDerivation {
       pname = "hack2-handler-warp";
       version = "2012.5.25";
       sha256 = "25a78ed33e0d6a609412f257c6164855cd1cd45dd1a7c5aea374f6921c9c14dc";
       libraryHaskellDepends = [
         air base data-default hack2 hack2-interface-wai warp
       ];
       homepage = "https://github.com/nfjinjing/hack2-handler-warp";
       description = "Hack2 warp handler";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hack2-interface-wai" = callPackage
    ({ mkDerivation, air, base, bytestring, case-insensitive
     , containers, data-default, hack2, http-types, mtl, network, safe
     , wai
     }:
     mkDerivation {
       pname = "hack2-interface-wai";
       version = "2012.5.25";
       sha256 = "bcd41cc56d8c21b778083b3efdb34f6d34892b0ee3272c9842e17785c6dadea3";
       libraryHaskellDepends = [
         air base bytestring case-insensitive containers data-default hack2
         http-types mtl network safe wai
       ];
       homepage = "https://github.com/nfjinjing/hack2-interface-wai";
       description = "Hack2 interface of WAI";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hackage-db" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, directory
     , filepath, tar, utf8-string
     }:
     mkDerivation {
       pname = "hackage-db";
       version = "1.22";
       sha256 = "4d32a368f8d41cba824bc7a1869d9b8df0e845496a4610f6e7f32791083f1066";
       revision = "1";
       editedCabalFile = "b5277a8cbbfcfba81f29db4910003c2fa7e34c06bceb4f3e7318510e1ce74376";
       libraryHaskellDepends = [
         base bytestring Cabal containers directory filepath tar utf8-string
       ];
       homepage = "http://github.com/peti/hackage-db";
       description = "access Hackage's package database via Data.Map";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "hackage-diff" = callPackage
    ({ mkDerivation, ansi-terminal, async, attoparsec, base, Cabal
     , cpphs, directory, filepath, haskell-src-exts, HTTP, mtl, process
     , text
     }:
     mkDerivation {
       pname = "hackage-diff";
       version = "0.1.0.1";
       sha256 = "251410eafa7672c817ef5b697798770b37795e9699e42059aeba9e4b82b4d002";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal async attoparsec base Cabal cpphs directory filepath
         haskell-src-exts HTTP mtl process text
       ];
       homepage = "https://github.com/blitzcode/hackage-diff";
       description = "Compare the public API of different versions of a Hackage library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hackage-mirror_0_1_0_0" = callPackage
    ({ mkDerivation, aws, base, bytestring, cereal, conduit
     , conduit-extra, cryptohash, data-default, directory, exceptions
     , fast-logger, filepath, http-conduit, lifted-async, lifted-base
     , mmorph, monad-control, monad-logger, old-locale
     , optparse-applicative, resourcet, retry, shakespeare, stm, tar
     , template-haskell, temporary, text, thyme, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "hackage-mirror";
       version = "0.1.0.0";
       sha256 = "6f638b9ca0698edaa6d3a4e11ccdd2447299b9ba89a1aef494d9694a6ceb4ac5";
       revision = "2";
       editedCabalFile = "d785ec52af5065a15f693ef3f171b7a8508b75d8558ac1bfd68e726c8dfbe90d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aws base bytestring cereal conduit conduit-extra cryptohash
         data-default directory exceptions fast-logger filepath http-conduit
         lifted-async lifted-base mmorph monad-control monad-logger
         old-locale resourcet retry shakespeare stm tar template-haskell
         temporary text thyme transformers unordered-containers
       ];
       executableHaskellDepends = [
         base monad-logger optparse-applicative
       ];
       jailbreak = true;
       homepage = "http://fpcomplete.com";
       description = "Simple mirroring utility for Hackage";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hackage-mirror" = callPackage
    ({ mkDerivation, aws, base, bytestring, cereal, conduit
     , conduit-extra, cryptohash, data-default, directory, exceptions
     , fast-logger, filepath, http-conduit, lifted-async, lifted-base
     , mmorph, monad-control, monad-logger, old-locale
     , optparse-applicative, resourcet, retry, shakespeare, stm, tar
     , template-haskell, temporary, text, thyme, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "hackage-mirror";
       version = "0.1.1.1";
       sha256 = "d710bae7061d831ae6c018691011344dd8cf93b08b950944aed7c119fbee8eae";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aws base bytestring cereal conduit conduit-extra cryptohash
         data-default directory exceptions fast-logger filepath http-conduit
         lifted-async lifted-base mmorph monad-control monad-logger
         old-locale resourcet retry shakespeare stm tar template-haskell
         temporary text thyme transformers unordered-containers
       ];
       executableHaskellDepends = [
         base monad-logger optparse-applicative
       ];
       homepage = "http://fpcomplete.com";
       description = "Simple mirroring utility for Hackage";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hackage-plot" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory
     , download-curl, filepath, gnuplot, old-locale, old-time, parsedate
     }:
     mkDerivation {
       pname = "hackage-plot";
       version = "0.2.1";
       sha256 = "a1aa7276d17c2a9fdb54bcdb0a4a396a51e6037cc82bc223c1e14bdb54b57487";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory download-curl filepath gnuplot
         old-locale old-time parsedate
       ];
       homepage = "http://code.haskell.org/~dons/code/hackage-plot";
       description = "Generate cumulative graphs of hackage uploads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hackage-proxy" = callPackage
    ({ mkDerivation, base, basic-prelude, blaze-builder, bytestring
     , Cabal, case-insensitive, conduit, containers, filepath
     , http-client, http-client-conduit, http-conduit, http-types
     , optparse-applicative, tar, text, transformers
     , unordered-containers, wai, warp, zlib, zlib-conduit
     }:
     mkDerivation {
       pname = "hackage-proxy";
       version = "0.3.0.1";
       sha256 = "d7031df4aeeb2bb49eb6fa869147a039f70cb6267256d7d93767597080ac2cee";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base basic-prelude blaze-builder bytestring Cabal case-insensitive
         conduit containers filepath http-client http-client-conduit
         http-conduit http-types optparse-applicative tar text transformers
         unordered-containers wai warp zlib zlib-conduit
       ];
       homepage = "http://github.com/snoyberg/hackage-proxy";
       description = "Provide a proxy for Hackage which modifies responses in some way. (deprecated)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hackage-repo-tool" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, directory, filepath
     , hackage-security, network, network-uri, optparse-applicative, tar
     , time, unix, zlib
     }:
     mkDerivation {
       pname = "hackage-repo-tool";
       version = "0.1.1";
       sha256 = "23f6c2719d42ce51ae8fe9dc6c8d9c8585265486df81d4ca483b28cc917064f4";
       revision = "1";
       editedCabalFile = "0ff107dc07dc9099ef89c1195c1bc26f482ed25bc0d858422ed3c870e7179d0e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal directory filepath hackage-security network
         network-uri optparse-applicative tar time unix zlib
       ];
       homepage = "https://github.com/well-typed/hackage-security";
       description = "Utility to manage secure file-based package repositories";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hackage-security" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, Cabal
     , containers, cryptohash, directory, ed25519, filepath, ghc-prim
     , HUnit, mtl, network, network-uri, parsec, tar, tasty, tasty-hunit
     , template-haskell, temporary, time, transformers, zlib
     }:
     mkDerivation {
       pname = "hackage-security";
       version = "0.5.0.2";
       sha256 = "4135221bb74e899fde71ff5e878d0401b8c274af6ade996ca7ac15d2b77dbd98";
       libraryHaskellDepends = [
         base base64-bytestring bytestring Cabal containers cryptohash
         directory ed25519 filepath ghc-prim mtl network network-uri parsec
         tar template-haskell time transformers zlib
       ];
       testHaskellDepends = [
         base bytestring Cabal containers HUnit network-uri tar tasty
         tasty-hunit temporary time zlib
       ];
       homepage = "https://github.com/well-typed/hackage-security";
       description = "Hackage security library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hackage-security-HTTP" = callPackage
    ({ mkDerivation, base, bytestring, hackage-security, HTTP, mtl
     , network, network-uri, zlib
     }:
     mkDerivation {
       pname = "hackage-security-HTTP";
       version = "0.1.1";
       sha256 = "cd22ac26027df4a6f9c32f57c18a2fad6b69249e79aeeb4081128fd188cd1332";
       libraryHaskellDepends = [
         base bytestring hackage-security HTTP mtl network network-uri zlib
       ];
       jailbreak = true;
       homepage = "https://github.com/well-typed/hackage-security";
       description = "Hackage security bindings against the HTTP library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hackage-server" = callPackage
    ({ mkDerivation, acid-state, aeson, alex, array, async, attoparsec
     , base, base16-bytestring, base64-bytestring, binary, blaze-builder
     , bytestring, Cabal, cereal, containers, crypto-api, csv, deepseq
     , directory, filepath, happstack-server, happy, HaXml, hscolour
     , hslogger, HStringTemplate, HTTP, lifted-base, mime-mail, mtl
     , network, old-locale, parsec, pretty, process, pureMD5, QuickCheck
     , random, rss, safecopy, snowball, split, stm, tar, text, time
     , tokenize, transformers, unix, unordered-containers, vector, xhtml
     , xml, zlib
     }:
     mkDerivation {
       pname = "hackage-server";
       version = "0.5.0";
       sha256 = "31346fa172d5173c11952ae4872abcb81fde8e5574a7355f877994a729135ef7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         acid-state aeson array async attoparsec base base16-bytestring
         base64-bytestring binary blaze-builder bytestring Cabal cereal
         containers crypto-api csv deepseq directory filepath
         happstack-server HaXml hscolour hslogger HStringTemplate HTTP
         lifted-base mime-mail mtl network old-locale parsec pretty process
         pureMD5 QuickCheck random rss safecopy snowball split stm tar text
         time tokenize transformers unix unordered-containers vector xhtml
         zlib
       ];
       executableToolDepends = [ alex happy ];
       testHaskellDepends = [
         aeson base base64-bytestring bytestring Cabal directory filepath
         HTTP network process random tar text unix unordered-containers
         vector xml zlib
       ];
       jailbreak = true;
       description = "The Hackage web server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hackage-sparks" = callPackage
    ({ mkDerivation, base, bytestring, directory, download, filepath
     , hsparklines, old-locale, old-time, parsedate, tagsoup
     }:
     mkDerivation {
       pname = "hackage-sparks";
       version = "0.5.1";
       sha256 = "dc62a250f7f0415eb941365fb1228719e9c7f8afdeb193fb8e7aa2b042db832c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory download filepath hsparklines old-locale
         old-time parsedate tagsoup
       ];
       homepage = "http://code.haskell.org/~dons/code/hackage-sparks";
       description = "Generate sparkline graphs of hackage statistics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hackage-whatsnew" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, filepath
     , hackage-db, process, temporary
     }:
     mkDerivation {
       pname = "hackage-whatsnew";
       version = "0.1.0.0";
       sha256 = "88346334b73b22ffe551ea4c109645c9dad31929502afb8f81a33a58a9298f20";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers directory filepath hackage-db process
         temporary
       ];
       description = "Check for differences between working directory and hackage";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hackage2hwn" = callPackage
    ({ mkDerivation, base, download, feed, tagsoup }:
     mkDerivation {
       pname = "hackage2hwn";
       version = "0.5.1";
       sha256 = "d8403b64be50b21d3256ed9f57bb2c839230a1030e58dd7b0aa1b7f3023b776d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base download feed tagsoup ];
       homepage = "http://code.haskell.org/~dons/code/hackage2hwn";
       description = "Convert Hackage RSS feeds to wiki format for publishing on Haskell.org";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hackage2twitter" = callPackage
    ({ mkDerivation, base, feed, feed2twitter }:
     mkDerivation {
       pname = "hackage2twitter";
       version = "0.2.1";
       sha256 = "f8497d395dfe466697cf2da21b3ef7ede9e78619a9a2ebe0a018f61a53a1308c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base feed feed2twitter ];
       homepage = "http://github.com/tomlokhorst/hackage2twitter";
       description = "Send new Hackage releases to Twitter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hackager" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, filepath, mtl
     , process, regex-tdfa
     }:
     mkDerivation {
       pname = "hackager";
       version = "1.3.0.1";
       sha256 = "699643e74c114f9b6bfc0f0c517381bb36620f6b5cd0dd2b6a5d57b651e3eb5c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers directory filepath mtl process regex-tdfa
       ];
       homepage = "https://github.com/dterei/Hackager";
       description = "Hackage testing tool";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hackernews" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, either
     , HsOpenSSL, hspec, http-streams, io-streams, text, time
     , transformers
     }:
     mkDerivation {
       pname = "hackernews";
       version = "0.5.0.1";
       sha256 = "dfef879e6256945f2348996dc0c8b8db0d69887e55ef99cae93a46e14c79720e";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either HsOpenSSL http-streams
         io-streams text time transformers
       ];
       testHaskellDepends = [ base hspec transformers ];
       description = "API for Hacker News";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hackertyper" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hackertyper";
       version = "0.1.0.1";
       sha256 = "ee158162d356a3e1422eb994b21db9e9a369b6f8ec57a8b85be4a0838c3b879d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/fgaz/hackertyper";
       description = "\"Hack\" like a programmer in movies and games!";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hackmanager" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, directory, file-embed
     , Glob, hastache, http-client, http-client-tls, http-types, mtl
     , optparse-applicative, process, text
     }:
     mkDerivation {
       pname = "hackmanager";
       version = "0.1.0.0";
       sha256 = "8a5cebf772c8f99b2e56deb9f64a90344ded1528ac1a9967eab2776d72053546";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring Cabal directory file-embed Glob hastache
         http-client http-client-tls http-types mtl process text
       ];
       executableHaskellDepends = [ base optparse-applicative text ];
       homepage = "http://github.com/agrafix/hackmanager";
       description = "Generate useful files for Haskell projects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hackport" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , deepseq, directory, extensible-exceptions, filepath, HTTP, HUnit
     , MissingH, network, network-uri, old-locale, old-time, parsec
     , pretty, process, random, regex-compat, stm, tar, time, unix, xml
     , zlib
     }:
     mkDerivation {
       pname = "hackport";
       version = "0.4.7";
       sha256 = "17dc05163b456dceeb00180a03bb56f4218e5c5e1145c7ad12af13a261b0cf36";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base binary bytestring containers deepseq directory
         extensible-exceptions filepath HTTP MissingH network network-uri
         old-locale old-time parsec pretty process random regex-compat stm
         tar time unix xml zlib
       ];
       testHaskellDepends = [
         base binary bytestring containers deepseq directory
         extensible-exceptions filepath HUnit pretty process time unix xml
       ];
       description = "Hackage and Portage integration tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hactor" = callPackage
    ({ mkDerivation, base, containers, monad-control, mtl, resourcet
     , stm, stm-chans, transformers-base
     }:
     mkDerivation {
       pname = "hactor";
       version = "1.2.0.0";
       sha256 = "1e39fbab2768fae514dc955feb83cd571a034feea6e806288a5775f7b88bf649";
       libraryHaskellDepends = [
         base containers monad-control mtl resourcet stm stm-chans
         transformers-base
       ];
       jailbreak = true;
       homepage = "https://github.com/Forkk/hactor";
       description = "Lightweight Erlang-style actors for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hactors" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "hactors";
       version = "0.0.3.1";
       sha256 = "403651a53a264f6b89ccbd093f73529b7198eb15158c79db97deda97f6a0ac5b";
       libraryHaskellDepends = [ base stm ];
       jailbreak = true;
       homepage = "https://github.com/treep/hactors";
       description = "Practical actors for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "haddock" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, haddock-api
     , process
     }:
     mkDerivation {
       pname = "haddock";
       version = "2.16.1";
       sha256 = "46ecd130cb5ad2b5c7452c843f9b75e976f1416d1cf17e6436d65c2c0bdbd6d6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haddock-api ];
       testHaskellDepends = [ base Cabal directory filepath process ];
       preCheck = "unset GHC_PACKAGE_PATH";
       homepage = "http://www.haskell.org/haddock/";
       description = "A documentation-generation tool for Haskell libraries";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haddock-api_2_15_0" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , deepseq, directory, filepath, ghc, ghc-paths, haddock-library
     , xhtml
     }:
     mkDerivation {
       pname = "haddock-api";
       version = "2.15.0";
       sha256 = "6b1044399ba947fea3a5a6f6816908cf6e2cc14dbf66f32d8e13d8d60081059e";
       libraryHaskellDepends = [
         array base bytestring Cabal containers deepseq directory filepath
         ghc ghc-paths haddock-library xhtml
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haddock/";
       description = "A documentation-generation tool for Haskell libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haddock-api_2_15_0_1" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , deepseq, directory, filepath, ghc, ghc-paths, haddock-library
     , xhtml
     }:
     mkDerivation {
       pname = "haddock-api";
       version = "2.15.0.1";
       sha256 = "551b4485663f86528ebc8c9a268eee97342f83ff07e863226449cdd2a6e745e8";
       libraryHaskellDepends = [
         array base bytestring Cabal containers deepseq directory filepath
         ghc ghc-paths haddock-library xhtml
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haddock/";
       description = "A documentation-generation tool for Haskell libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haddock-api_2_15_0_2" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , deepseq, directory, filepath, ghc, ghc-paths, haddock-library
     , xhtml
     }:
     mkDerivation {
       pname = "haddock-api";
       version = "2.15.0.2";
       sha256 = "87228957b713ed087fdeb1031dc2af5bdf20c24377218100c5063d3c5ae4b5bd";
       libraryHaskellDepends = [
         array base bytestring Cabal containers deepseq directory filepath
         ghc ghc-paths haddock-library xhtml
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haddock/";
       description = "A documentation-generation tool for Haskell libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haddock-api" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , deepseq, directory, filepath, ghc, ghc-paths, haddock-library
     , xhtml
     }:
     mkDerivation {
       pname = "haddock-api";
       version = "2.16.1";
       sha256 = "e2061d67e3de2bb39a98225712f119ef21a62567afac361bd9b2ddf0ba2aedea";
       libraryHaskellDepends = [
         array base bytestring Cabal containers deepseq directory filepath
         ghc ghc-paths haddock-library xhtml
       ];
       homepage = "http://www.haskell.org/haddock/";
       description = "A documentation-generation tool for Haskell libraries";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haddock-leksah" = callPackage
    ({ mkDerivation, array, base, Cabal, containers, directory
     , filepath, ghc, ghc-paths, pretty
     }:
     mkDerivation {
       pname = "haddock-leksah";
       version = "2.6.0";
       sha256 = "106966d5ee7f88e652c81244837a5237926cb8123b9957ca6c74f93e61b4a6a8";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [
         array base Cabal containers directory filepath ghc ghc-paths pretty
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haddock/";
       description = "A documentation-generation tool for Haskell libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haddock-library_1_1_1" = callPackage
    ({ mkDerivation, base, base-compat, bytestring, deepseq, hspec
     , QuickCheck
     }:
     mkDerivation {
       pname = "haddock-library";
       version = "1.1.1";
       sha256 = "350c2dd4f62fc85debe53ea51ce2a7e8ec7c8abb1b5acc664c5adf80ebaa566a";
       libraryHaskellDepends = [ base bytestring deepseq ];
       testHaskellDepends = [
         base base-compat bytestring deepseq hspec QuickCheck
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haddock/";
       description = "Library exposing some functionality of Haddock";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haddock-library" = callPackage
    ({ mkDerivation, base, base-compat, bytestring, deepseq, hspec
     , QuickCheck, transformers
     }:
     mkDerivation {
       pname = "haddock-library";
       version = "1.2.1";
       sha256 = "0fb1a09d2b6f5339bc008a8ebf6519f22d27f65cfcc682488a7b67e8ee151056";
       libraryHaskellDepends = [ base bytestring deepseq transformers ];
       testHaskellDepends = [
         base base-compat bytestring deepseq hspec QuickCheck transformers
       ];
       doCheck = false;
       homepage = "http://www.haskell.org/haddock/";
       description = "Library exposing some functionality of Haddock";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haddocset" = callPackage
    ({ mkDerivation, base, Cabal, conduit, conduit-extra, directory
     , exceptions, filepath, ghc, haddock-api, http-types, mtl
     , optparse-applicative, process, resourcet, sqlite-simple, tagsoup
     , text, transformers
     }:
     mkDerivation {
       pname = "haddocset";
       version = "0.4.1";
       sha256 = "b2e17cb5fc695b28cb036e524e1f58fce30953cf4f3de6fdac88e61142ae9c3e";
       revision = "1";
       editedCabalFile = "8d1369b8ba3da5fcb6661f5fc34ec23de02b79c96ed268f0db946a9ff8b5951b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal conduit conduit-extra directory exceptions filepath ghc
         haddock-api http-types mtl optparse-applicative process resourcet
         sqlite-simple tagsoup text transformers
       ];
       homepage = "https://github.com/philopon/haddocset";
       description = "Generate docset of Dash by Haddock haskell documentation tool";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hadoop-formats" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, filepath, snappy
     , text, vector
     }:
     mkDerivation {
       pname = "hadoop-formats";
       version = "0.2.1.1";
       sha256 = "ea95ddbf658574d2ecb7183cc4cb933027db8e828abb3263fbb0d7f1653268f0";
       revision = "1";
       editedCabalFile = "59248cb9b3f28b9f003d694ee356a13ff1313c8edd3bf2963c154ce7e1de0553";
       libraryHaskellDepends = [ attoparsec base bytestring text vector ];
       librarySystemDepends = [ snappy ];
       testHaskellDepends = [ base bytestring filepath text vector ];
       homepage = "http://github.com/jystic/hadoop-formats";
       description = "Read/write file formats commonly used by Hadoop";
       license = stdenv.lib.licenses.asl20;
     }) {inherit (pkgs) snappy;};

  "hadoop-rpc" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, cereal, exceptions
     , hashable, monad-loops, network, protobuf, random, socks, stm
     , tasty, tasty-hunit, text, transformers, unix
     , unordered-containers, uuid, vector, xmlhtml
     }:
     mkDerivation {
       pname = "hadoop-rpc";
       version = "1.0.0.1";
       sha256 = "21d2650d54b2696aed6b96641b896b8f225ab2560a75f4f0d2a7e819d6eba1da";
       libraryHaskellDepends = [
         attoparsec base bytestring cereal exceptions hashable monad-loops
         network protobuf random socks stm text transformers unix
         unordered-containers uuid vector xmlhtml
       ];
       testHaskellDepends = [ base protobuf tasty tasty-hunit vector ];
       homepage = "http://github.com/jystic/hadoop-rpc";
       description = "Use the Hadoop RPC interface from Haskell";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "hadoop-tools" = callPackage
    ({ mkDerivation, attoparsec, base, boxes, bytestring, configurator
     , exceptions, filepath, hadoop-rpc, old-locale
     , optparse-applicative, protobuf, regex-pcre-builtin, split, stm
     , tasty, tasty-hunit, tasty-quickcheck, text, time, transformers
     , unix, vector
     }:
     mkDerivation {
       pname = "hadoop-tools";
       version = "0.7.2";
       sha256 = "bb7448517d18a68c4aceed0e7d0ebc6f8510d206e19dbfbb43af65d58d883c3f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base boxes bytestring configurator exceptions filepath
         hadoop-rpc old-locale optparse-applicative protobuf
         regex-pcre-builtin split stm text time transformers unix vector
       ];
       testHaskellDepends = [
         attoparsec base bytestring hadoop-rpc tasty tasty-hunit
         tasty-quickcheck vector
       ];
       homepage = "http://github.com/jystic/hadoop-tools";
       description = "Fast command line tools for working with Hadoop";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "haeredes" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, dns, doctest, filemanip
     , iproute, MissingH, parallel-io
     }:
     mkDerivation {
       pname = "haeredes";
       version = "0.4.4";
       sha256 = "bdc2446b176c50d4f0fb5a52aaa7c0f4369999adc50be74935bea59a5f2964ac";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs dns iproute MissingH parallel-io
       ];
       testHaskellDepends = [ base doctest filemanip ];
       homepage = "http://michael.orlitzky.com/code/haeredes.php";
       description = "Confirm delegation of NS and MX records";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "haggis" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, bytestring
     , containers, convertible, directory, filemanip, filepath, HDBC
     , HDBC-sqlite3, hquery, MissingH, network-uri, old-locale
     , optparse-applicative, pandoc, pandoc-types, parsec, rss, split
     , text, time, unix, xmlhtml
     }:
     mkDerivation {
       pname = "haggis";
       version = "0.1.3.0";
       sha256 = "68f91cffb7c2078b5c33daba0d88c46e97f3c245d811d507fa42f06567c0cf38";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder blaze-html bytestring containers convertible
         directory filemanip filepath HDBC HDBC-sqlite3 hquery MissingH
         network-uri old-locale pandoc pandoc-types parsec rss split text
         time unix xmlhtml
       ];
       executableHaskellDepends = [
         base directory filemanip filepath optparse-applicative
       ];
       homepage = "http://github.com/tych0/haggis";
       description = "A static site generator with blogging/comments support";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haha" = callPackage
    ({ mkDerivation, base, containers, time }:
     mkDerivation {
       pname = "haha";
       version = "0.3.1.1";
       sha256 = "203889a745cc8929d46b976fe0cfdcaf6f610c4872aaad36b7dee6a4a7f1daed";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers time ];
       executableHaskellDepends = [ base containers time ];
       description = "A simple library for creating animated ascii art on ANSI terminals";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hahp" = callPackage
    ({ mkDerivation, base, containers, hmatrix, parallel, time }:
     mkDerivation {
       pname = "hahp";
       version = "0.1.2";
       sha256 = "8c13015c685d5abf70ec6fbb7e6b50304f8689bab332d078d53d815e66f9b7fa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers hmatrix parallel time ];
       executableHaskellDepends = [ base time ];
       description = "Analytic Hierarchy Process";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "haiji" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, data-default, doctest
     , filepath, mtl, process-extras, scientific, tagged, tasty
     , tasty-hunit, tasty-th, template-haskell, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "haiji";
       version = "0.1.0.0";
       sha256 = "cb67c5869e5c389808379e681cdd8549ccc2842dba082ed2dbd18bed4a1f7bb8";
       libraryHaskellDepends = [
         aeson attoparsec base data-default mtl scientific tagged
         template-haskell text transformers unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base data-default doctest filepath process-extras tasty
         tasty-hunit tasty-th text
       ];
       description = "A typed template engine, subset of jinja2";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hailgun" = callPackage
    ({ mkDerivation, aeson, base, bytestring, email-validate
     , exceptions, filepath, http-client, http-client-tls, http-types
     , tagsoup, text, time, transformers
     }:
     mkDerivation {
       pname = "hailgun";
       version = "0.4.0.3";
       sha256 = "2cdcc286430fe94c00ea2db6d5588f920bb30ff7ddbb6f27047cc26e42688eb0";
       libraryHaskellDepends = [
         aeson base bytestring email-validate exceptions filepath
         http-client http-client-tls http-types tagsoup text time
         transformers
       ];
       jailbreak = true;
       description = "Mailgun REST api interface for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hailgun-send" = callPackage
    ({ mkDerivation, base, bytestring, configurator, hailgun, text }:
     mkDerivation {
       pname = "hailgun-send";
       version = "0.1.1.1";
       sha256 = "86a154980b751d629e357548a5e3df3bb957a6e53f123193a74d73b7cafbbbb3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring configurator hailgun text
       ];
       jailbreak = true;
       description = "A program to send emails throught the Mailgun api";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hails" = callPackage
    ({ mkDerivation, authenticate, base, base64-bytestring, binary
     , blaze-builder, bson, bytestring, conduit, conduit-extra
     , containers, cookie, directory, exceptions, failure, filepath
     , ghc-paths, hint, http-conduit, http-types, HUnit, lio, mongoDB
     , mtl, network, network-uri, parsec, QuickCheck
     , quickcheck-instances, quickcheck-lio-instances, resourcet, SHA
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, time, transformers, unix, wai, wai-app-static, wai-extra
     , wai-test, warp
     }:
     mkDerivation {
       pname = "hails";
       version = "0.11.2.1";
       sha256 = "ecb8d9a72d3b839c2ae28ec919c36f64e006b1ff711cd43e3a5df7fb703c84e8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         authenticate base base64-bytestring binary blaze-builder bson
         bytestring conduit conduit-extra containers cookie exceptions
         failure http-conduit http-types lio mongoDB mtl network network-uri
         parsec resourcet SHA text time transformers wai wai-app-static
         wai-extra
       ];
       executableHaskellDepends = [
         authenticate base base64-bytestring binary blaze-builder bson
         bytestring conduit conduit-extra containers cookie directory
         exceptions filepath ghc-paths hint http-conduit http-types lio
         mongoDB mtl network network-uri parsec resourcet SHA text time
         transformers unix wai wai-app-static wai-extra warp
       ];
       testHaskellDepends = [
         base bson containers http-types HUnit lio mongoDB QuickCheck
         quickcheck-instances quickcheck-lio-instances test-framework
         test-framework-hunit test-framework-quickcheck2 text time unix wai
         wai-test
       ];
       jailbreak = true;
       description = "Multi-app web platform framework";
       license = stdenv.lib.licenses.mit;
       broken = true;
     }) {quickcheck-lio-instances = null;};

  "hails-bin" = callPackage
    ({ mkDerivation, base, bson, bytestring, containers, ghc-paths
     , hails, iterIO, iterio-server, mongoDB, mtl
     }:
     mkDerivation {
       pname = "hails-bin";
       version = "0.1.1.1";
       sha256 = "793b8b139eb3ce287a9597d3f7135115d379aa8f92df5c93c71f41386bf1d800";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bson bytestring containers ghc-paths hails iterIO
         iterio-server mongoDB mtl
       ];
       jailbreak = true;
       description = "Dynamic launcher of Hails applications";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "hairy" = callPackage
    ({ mkDerivation, aeson, base, data-default, heroku, hspec
     , http-types, monad-logger, mtl, persistent, persistent-postgresql
     , persistent-template, scotty, text, time, transformers, wai
     , wai-extra, warp
     }:
     mkDerivation {
       pname = "hairy";
       version = "0.1.3";
       sha256 = "57d1cb7c8f7efa95ee5e20b9ac7376f1312be204f507e65837a58e96e4f36fa6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base data-default heroku http-types monad-logger mtl
         persistent persistent-postgresql persistent-template scotty text
         time transformers wai wai-extra warp
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base hspec http-types mtl persistent scotty time wai wai-extra
       ];
       jailbreak = true;
       homepage = "https://github.com/tfausak/hairy";
       description = "A JSON REST API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hakaru" = callPackage
    ({ mkDerivation, aeson, array, base, bytestring, Cabal, cassava
     , containers, directory, hmatrix, HUnit, integration, logfloat
     , math-functions, monad-loops, mwc-random, parallel, parsec, pretty
     , primitive, QuickCheck, random, statistics, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     , transformers, vector, zlib
     }:
     mkDerivation {
       pname = "hakaru";
       version = "0.1.4";
       sha256 = "0e0aadcfc3b112603e20837be836ab49f8988181c4f9fa23610fdfc92412750c";
       libraryHaskellDepends = [
         aeson array base bytestring cassava containers directory hmatrix
         integration logfloat math-functions monad-loops mwc-random parallel
         parsec pretty primitive random statistics text transformers vector
         zlib
       ];
       testHaskellDepends = [
         base Cabal containers hmatrix HUnit logfloat math-functions
         monad-loops mwc-random pretty primitive QuickCheck random
         statistics test-framework test-framework-hunit
         test-framework-quickcheck2 vector
       ];
       jailbreak = true;
       homepage = "http://indiana.edu/~ppaml/";
       description = "A probabilistic programming embedded DSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hake" = callPackage
    ({ mkDerivation, base, directory, filepath, mtl, process, regexpr
     , time, yjtools
     }:
     mkDerivation {
       pname = "hake";
       version = "1.3.8.1";
       sha256 = "2ba472d61f8396a237fc52430fc3aa996a46683c0c651862f79d18b38c211e40";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base filepath mtl time ];
       executableHaskellDepends = [ directory process regexpr yjtools ];
       homepage = "http://homepage3.nifty.com/salamander/second/projects/hake/index.xhtml";
       description = "make tool. ruby : rake = haskell : hake";
       license = "GPL";
     }) {};

  "hakismet" = callPackage
    ({ mkDerivation, base, HTTP, network }:
     mkDerivation {
       pname = "hakismet";
       version = "0.1";
       sha256 = "a425893886961e8cdbf54a23be4186307a05558bfab9709703769b60d5b7b5b5";
       libraryHaskellDepends = [ base HTTP network ];
       jailbreak = true;
       homepage = "https://code.reaktor42.de/projects/hakismet";
       description = "Akismet spam protection library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hako" = callPackage
    ({ mkDerivation, base, haskell-src-meta, parsec, QuickCheck
     , template-haskell, text, transformers
     }:
     mkDerivation {
       pname = "hako";
       version = "1.0.0";
       sha256 = "35df93d935c18ebde3f2a4c5127c45b8e242547b231dd58f52007a214a099cbd";
       libraryHaskellDepends = [
         base haskell-src-meta parsec template-haskell text transformers
       ];
       testHaskellDepends = [ base QuickCheck ];
       jailbreak = true;
       description = "A mako-like quasi-quoter template library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hakyll_4_6_7_1" = callPackage
    ({ mkDerivation, base, binary, blaze-html, blaze-markup, bytestring
     , cmdargs, containers, cryptohash, data-default, deepseq, directory
     , filepath, fsnotify, http-conduit, http-types, HUnit, lrucache
     , mtl, network, network-uri, old-locale, old-time, pandoc
     , pandoc-citeproc, parsec, process, QuickCheck, random, regex-base
     , regex-tdfa, snap-core, snap-server, system-filepath, tagsoup
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, time
     }:
     mkDerivation {
       pname = "hakyll";
       version = "4.6.7.1";
       sha256 = "c6b3d535cbda091a5f63b27d67bafbe41ee9c21b7551b59fb121f1f1ecb9be88";
       revision = "1";
       editedCabalFile = "5ca22eb7c9d5bec7cd51f2914dd5726086b282a6f0cafbb2a65d7f031fb786a8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types lrucache mtl network network-uri old-locale
         old-time pandoc pandoc-citeproc parsec process random regex-base
         regex-tdfa snap-core snap-server system-filepath tagsoup text time
       ];
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types HUnit lrucache mtl network network-uri
         old-locale old-time pandoc pandoc-citeproc parsec process
         QuickCheck random regex-base regex-tdfa snap-core snap-server
         system-filepath tagsoup test-framework test-framework-hunit
         test-framework-quickcheck2 text time
       ];
       jailbreak = true;
       homepage = "http://jaspervdj.be/hakyll";
       description = "A static website compiler library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hakyll_4_6_8_0" = callPackage
    ({ mkDerivation, base, binary, blaze-html, blaze-markup, bytestring
     , cmdargs, containers, cryptohash, data-default, deepseq, directory
     , filepath, fsnotify, http-conduit, http-types, HUnit, lrucache
     , mtl, network, network-uri, old-locale, old-time, pandoc
     , pandoc-citeproc, parsec, process, QuickCheck, random, regex-base
     , regex-tdfa, snap-core, snap-server, system-filepath, tagsoup
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, time, time-locale-compat
     }:
     mkDerivation {
       pname = "hakyll";
       version = "4.6.8.0";
       sha256 = "781042f1d2c276f47a0687e7870c2577fad803d62d3a07eba2fa74092cf8978f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types lrucache mtl network network-uri old-locale
         old-time pandoc pandoc-citeproc parsec process random regex-base
         regex-tdfa snap-core snap-server system-filepath tagsoup text time
         time-locale-compat
       ];
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types HUnit lrucache mtl network network-uri
         old-locale old-time pandoc pandoc-citeproc parsec process
         QuickCheck random regex-base regex-tdfa snap-core snap-server
         system-filepath tagsoup test-framework test-framework-hunit
         test-framework-quickcheck2 text time
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://jaspervdj.be/hakyll";
       description = "A static website compiler library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hakyll_4_6_8_1" = callPackage
    ({ mkDerivation, base, binary, blaze-html, blaze-markup, bytestring
     , cmdargs, containers, cryptohash, data-default, deepseq, directory
     , filepath, fsnotify, http-conduit, http-types, HUnit, lrucache
     , mtl, network, network-uri, old-locale, old-time, pandoc
     , pandoc-citeproc, parsec, process, QuickCheck, random, regex-base
     , regex-tdfa, snap-core, snap-server, system-filepath, tagsoup
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, time, time-locale-compat
     }:
     mkDerivation {
       pname = "hakyll";
       version = "4.6.8.1";
       sha256 = "d94702500ec3c8fba2a1133a4e65ae53548db1384bf23a2bd3b714ffd3120c39";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types lrucache mtl network network-uri old-locale
         old-time pandoc pandoc-citeproc parsec process random regex-base
         regex-tdfa snap-core snap-server system-filepath tagsoup text time
         time-locale-compat
       ];
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types HUnit lrucache mtl network network-uri
         old-locale old-time pandoc pandoc-citeproc parsec process
         QuickCheck random regex-base regex-tdfa snap-core snap-server
         system-filepath tagsoup test-framework test-framework-hunit
         test-framework-quickcheck2 text time time-locale-compat
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://jaspervdj.be/hakyll";
       description = "A static website compiler library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hakyll_4_6_9_0" = callPackage
    ({ mkDerivation, base, binary, blaze-html, blaze-markup, bytestring
     , cmdargs, containers, cryptohash, data-default, deepseq, directory
     , filepath, fsnotify, http-conduit, http-types, HUnit, lrucache
     , mtl, network, network-uri, old-locale, old-time, pandoc
     , pandoc-citeproc, parsec, process, QuickCheck, random, regex-base
     , regex-tdfa, snap-core, snap-server, system-filepath, tagsoup
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, time, time-locale-compat
     }:
     mkDerivation {
       pname = "hakyll";
       version = "4.6.9.0";
       sha256 = "54e8e4464a30f618e772afde62159c973fdd64369ddd41da9b99e3cf8e760f7c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types lrucache mtl network network-uri old-locale
         old-time pandoc pandoc-citeproc parsec process random regex-base
         regex-tdfa snap-core snap-server system-filepath tagsoup text time
         time-locale-compat
       ];
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types HUnit lrucache mtl network network-uri
         old-locale old-time pandoc pandoc-citeproc parsec process
         QuickCheck random regex-base regex-tdfa snap-core snap-server
         system-filepath tagsoup test-framework test-framework-hunit
         test-framework-quickcheck2 text time time-locale-compat
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://jaspervdj.be/hakyll";
       description = "A static website compiler library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hakyll_4_7_2_3" = callPackage
    ({ mkDerivation, base, binary, blaze-html, blaze-markup, bytestring
     , cmdargs, containers, cryptohash, data-default, deepseq, directory
     , filepath, fsnotify, http-conduit, http-types, HUnit, lrucache
     , mtl, network, network-uri, pandoc, pandoc-citeproc, parsec
     , process, QuickCheck, random, regex-base, regex-tdfa, snap-core
     , snap-server, system-filepath, tagsoup, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , time-locale-compat
     }:
     mkDerivation {
       pname = "hakyll";
       version = "4.7.2.3";
       sha256 = "66b98d930b1312108bb690200985a273fcec2a39ff7b807f246b82c2609c28b1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types lrucache mtl network network-uri pandoc
         pandoc-citeproc parsec process random regex-base regex-tdfa
         snap-core snap-server system-filepath tagsoup text time
         time-locale-compat
       ];
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types HUnit lrucache mtl network network-uri
         pandoc pandoc-citeproc parsec process QuickCheck random regex-base
         regex-tdfa snap-core snap-server system-filepath tagsoup
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time time-locale-compat
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://jaspervdj.be/hakyll";
       description = "A static website compiler library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hakyll_4_7_3_0" = callPackage
    ({ mkDerivation, base, binary, blaze-html, blaze-markup, bytestring
     , cmdargs, containers, cryptohash, data-default, deepseq, directory
     , filepath, fsnotify, http-conduit, http-types, HUnit, lrucache
     , mtl, network, network-uri, pandoc, pandoc-citeproc, parsec
     , process, QuickCheck, random, regex-base, regex-tdfa, snap-core
     , snap-server, system-filepath, tagsoup, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , time-locale-compat
     }:
     mkDerivation {
       pname = "hakyll";
       version = "4.7.3.0";
       sha256 = "41ab4b9ebe4820570b726c4b19bade756b31a0c339e7c24538a6da17ccfa4444";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types lrucache mtl network network-uri pandoc
         pandoc-citeproc parsec process random regex-base regex-tdfa
         snap-core snap-server system-filepath tagsoup text time
         time-locale-compat
       ];
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types HUnit lrucache mtl network network-uri
         pandoc pandoc-citeproc parsec process QuickCheck random regex-base
         regex-tdfa snap-core snap-server system-filepath tagsoup
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time time-locale-compat
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://jaspervdj.be/hakyll";
       description = "A static website compiler library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hakyll_4_7_3_1" = callPackage
    ({ mkDerivation, base, binary, blaze-html, blaze-markup, bytestring
     , cmdargs, containers, cryptohash, data-default, deepseq, directory
     , filepath, fsnotify, http-conduit, http-types, HUnit, lrucache
     , mtl, network, network-uri, pandoc, pandoc-citeproc, parsec
     , process, QuickCheck, random, regex-base, regex-tdfa, snap-core
     , snap-server, system-filepath, tagsoup, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , time-locale-compat
     }:
     mkDerivation {
       pname = "hakyll";
       version = "4.7.3.1";
       sha256 = "ad8b0bd9fc7508978cef1edd5a4b11432d7bcffa84940472ebe81fa28ad00740";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types lrucache mtl network network-uri pandoc
         pandoc-citeproc parsec process random regex-base regex-tdfa
         snap-core snap-server system-filepath tagsoup text time
         time-locale-compat
       ];
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types HUnit lrucache mtl network network-uri
         pandoc pandoc-citeproc parsec process QuickCheck random regex-base
         regex-tdfa snap-core snap-server system-filepath tagsoup
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time time-locale-compat
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://jaspervdj.be/hakyll";
       description = "A static website compiler library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hakyll_4_7_4_0" = callPackage
    ({ mkDerivation, base, binary, blaze-html, blaze-markup, bytestring
     , cmdargs, containers, cryptohash, data-default, deepseq, directory
     , filepath, fsnotify, http-conduit, http-types, HUnit, lrucache
     , mtl, network, network-uri, pandoc, pandoc-citeproc, parsec
     , process, QuickCheck, random, regex-base, regex-tdfa, snap-core
     , snap-server, system-filepath, tagsoup, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , time-locale-compat
     }:
     mkDerivation {
       pname = "hakyll";
       version = "4.7.4.0";
       sha256 = "bf6a503f8a6e4911c6d2b2480b0e1a2495c568f47f902a43e463d8b2706737d1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types lrucache mtl network network-uri pandoc
         pandoc-citeproc parsec process random regex-base regex-tdfa
         snap-core snap-server system-filepath tagsoup text time
         time-locale-compat
       ];
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types HUnit lrucache mtl network network-uri
         pandoc pandoc-citeproc parsec process QuickCheck random regex-base
         regex-tdfa snap-core snap-server system-filepath tagsoup
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time time-locale-compat
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://jaspervdj.be/hakyll";
       description = "A static website compiler library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hakyll_4_7_5_0" = callPackage
    ({ mkDerivation, base, binary, blaze-html, blaze-markup, bytestring
     , cmdargs, containers, cryptohash, data-default, deepseq, directory
     , filepath, fsnotify, http-conduit, http-types, HUnit, lrucache
     , mtl, network, network-uri, pandoc, pandoc-citeproc, parsec
     , process, QuickCheck, random, regex-base, regex-tdfa, snap-core
     , snap-server, system-filepath, tagsoup, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , time-locale-compat
     }:
     mkDerivation {
       pname = "hakyll";
       version = "4.7.5.0";
       sha256 = "e3079667f07f6355f9dbc0a10623670b323a6bec1fd632d114f5350023b65eb8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types lrucache mtl network network-uri pandoc
         pandoc-citeproc parsec process random regex-base regex-tdfa
         snap-core snap-server system-filepath tagsoup text time
         time-locale-compat
       ];
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types HUnit lrucache mtl network network-uri
         pandoc pandoc-citeproc parsec process QuickCheck random regex-base
         regex-tdfa snap-core snap-server system-filepath tagsoup
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time time-locale-compat
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://jaspervdj.be/hakyll";
       description = "A static website compiler library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hakyll" = callPackage
    ({ mkDerivation, base, binary, blaze-html, blaze-markup, bytestring
     , cmdargs, containers, cryptohash, data-default, deepseq, directory
     , filepath, fsnotify, http-conduit, http-types, HUnit, lrucache
     , mtl, network, network-uri, pandoc, pandoc-citeproc, parsec
     , process, QuickCheck, random, regex-base, regex-tdfa, snap-core
     , snap-server, system-filepath, tagsoup, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , time-locale-compat
     }:
     mkDerivation {
       pname = "hakyll";
       version = "4.7.5.1";
       sha256 = "39efc15d8d9bce1f151587f1556be8daac58c1d3fe6596458f0e9122a659b310";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types lrucache mtl network network-uri pandoc
         pandoc-citeproc parsec process random regex-base regex-tdfa
         snap-core snap-server system-filepath tagsoup text time
         time-locale-compat
       ];
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [
         base binary blaze-html blaze-markup bytestring cmdargs containers
         cryptohash data-default deepseq directory filepath fsnotify
         http-conduit http-types HUnit lrucache mtl network network-uri
         pandoc pandoc-citeproc parsec process QuickCheck random regex-base
         regex-tdfa snap-core snap-server system-filepath tagsoup
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time time-locale-compat
       ];
       doCheck = false;
       homepage = "http://jaspervdj.be/hakyll";
       description = "A static website compiler library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hakyll-R" = callPackage
    ({ mkDerivation, base, directory, filepath, hakyll, pandoc, process
     }:
     mkDerivation {
       pname = "hakyll-R";
       version = "0.1.0.3";
       sha256 = "6365011bd83dd4346ea7cae7f9cd8d1b942436a4dee523c493ea6409fdad206b";
       libraryHaskellDepends = [
         base directory filepath hakyll pandoc process
       ];
       jailbreak = true;
       description = "A package allowing to write Hakyll blog posts in Rmd";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hakyll-agda" = callPackage
    ({ mkDerivation, Agda, base, containers, directory, filepath
     , hakyll, mtl, pandoc, transformers, xhtml
     }:
     mkDerivation {
       pname = "hakyll-agda";
       version = "0.1.10";
       sha256 = "0b9f9ead899ca7fc33b75c8f1838d219143357b892b5132e559e65c1efa14198";
       libraryHaskellDepends = [
         Agda base containers directory filepath hakyll mtl pandoc
         transformers xhtml
       ];
       jailbreak = true;
       homepage = "https://github.com/bitonic/hakyll-agda";
       description = "Wrapper to integrate literate Agda files with Hakyll";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hakyll-blaze-templates" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, hakyll }:
     mkDerivation {
       pname = "hakyll-blaze-templates";
       version = "0.1.1.0";
       sha256 = "32dc93abc20b115b36c97ce92496994d911e59c87d98ce7c9ddd0b4d711eb485";
       libraryHaskellDepends = [ base blaze-html blaze-markup hakyll ];
       jailbreak = true;
       description = "Blaze templates for Hakyll";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hakyll-contrib" = callPackage
    ({ mkDerivation, base, directory, filepath, hakyll, pandoc }:
     mkDerivation {
       pname = "hakyll-contrib";
       version = "0.1.0.1";
       sha256 = "244416d4679e7e61ea6218ddb43ca1a5bb3387dd084b58b0ebb028c3a3a24370";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base hakyll pandoc ];
       executableHaskellDepends = [ base directory filepath hakyll ];
       jailbreak = true;
       homepage = "http://jaspervdj.be/hakyll";
       description = "Extra modules for the hakyll website compiler";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hakyll-contrib-hyphenation" = callPackage
    ({ mkDerivation, base, hakyll, hyphenation, split, tagsoup }:
     mkDerivation {
       pname = "hakyll-contrib-hyphenation";
       version = "0.1.0.3";
       sha256 = "55c9e6a0c47ceb36eb439578ab013c8effa91b585deb932631f13d1777d46b56";
       libraryHaskellDepends = [ base hakyll hyphenation split tagsoup ];
       jailbreak = true;
       homepage = "https://bitbucket.org/rvlm/hakyll-contrib-hyphenation";
       description = "automatic hyphenation for Hakyll";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hakyll-contrib-links" = callPackage
    ({ mkDerivation, base, binary, containers, hakyll, pandoc
     , pandoc-types, parsec, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "hakyll-contrib-links";
       version = "0.2.0.0";
       sha256 = "c5c79903e90dbde4ca8794c5b4c7677d4b2a352342629139269277cc2e42ef3f";
       libraryHaskellDepends = [
         base binary containers hakyll pandoc pandoc-types parsec
       ];
       testHaskellDepends = [
         base binary QuickCheck test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       description = "A hakyll library that helps maintain a separate links database";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hakyll-convert" = callPackage
    ({ mkDerivation, base, binary, bytestring, cmdargs, directory, feed
     , filepath, hakyll, old-locale, text, time, xml
     }:
     mkDerivation {
       pname = "hakyll-convert";
       version = "0.1.0.0";
       sha256 = "a3e7e0f9e59f9e704b2ee464b9e7f8a1a1cb432af1a247e167cedcad8c7071b7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring feed hakyll old-locale text time xml
       ];
       executableHaskellDepends = [
         base bytestring cmdargs directory feed filepath hakyll text xml
       ];
       homepage = "http://github.com/kowey/hakyll-convert";
       description = "Convert from other blog engines to Hakyll";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hakyll-elm" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, Elm, hakyll, mtl
     }:
     mkDerivation {
       pname = "hakyll-elm";
       version = "0.2.1";
       sha256 = "f3e248d6ea8426434f68dc45c2269dfd205f143c8c91b7a95780289d5567fc2d";
       libraryHaskellDepends = [
         base blaze-html blaze-markup Elm hakyll mtl
       ];
       jailbreak = true;
       homepage = "https://github.com/maxsnew/hakyll-elm";
       description = "Hakyll wrapper for the Elm compiler";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hakyll-filestore" = callPackage
    ({ mkDerivation, base, filestore, hakyll, time, time-locale-compat
     }:
     mkDerivation {
       pname = "hakyll-filestore";
       version = "0.1.0";
       sha256 = "3e7c848197a12c83af870000a78ffa89e77eb55b13f957c2a4cc8491d9351b60";
       libraryHaskellDepends = [
         base filestore hakyll time time-locale-compat
       ];
       homepage = "https://gitlab.com/aergus/hakyll-filestore";
       description = "FileStore utilities for Hakyll";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "hakyll-sass" = callPackage
    ({ mkDerivation, base, data-default-class, filepath, hakyll, hsass
     }:
     mkDerivation {
       pname = "hakyll-sass";
       version = "0.2.0";
       sha256 = "1c0b131f3a581aafde543fc9c3211d75c6f17f6b25d0e32cf6032f4c3377dbc5";
       revision = "1";
       editedCabalFile = "afdc3b9e76e09fc1aaf7f9cceb780a2e062ec56aab20659804b8f35d3bb85bb5";
       libraryHaskellDepends = [
         base data-default-class filepath hakyll hsass
       ];
       homepage = "https://github.com/meoblast001/hakyll-sass";
       description = "Hakyll SASS compiler over hsass";
       license = stdenv.lib.licenses.mit;
     }) {};

  "halberd" = callPackage
    ({ mkDerivation, base, Cabal, containers, haskell-names
     , haskell-packages, haskell-src-exts, HUnit, mtl, safe, split, syb
     , tagged, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "halberd";
       version = "0.1.2.9";
       sha256 = "327fd38ee6ab51d7ed7f716c38847829306ba9b168a1bf54e0af269c3e0b19b5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers haskell-names haskell-packages
         haskell-src-exts mtl safe syb
       ];
       executableHaskellDepends = [
         base Cabal haskell-names haskell-packages haskell-src-exts mtl safe
         tagged
       ];
       testHaskellDepends = [
         base Cabal containers haskell-names haskell-packages
         haskell-src-exts HUnit mtl split tagged test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://github.com/haskell-suite/halberd/";
       description = "A tool to generate missing import statements for Haskell modules";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "half_0_2_0_1" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "half";
       version = "0.2.0.1";
       sha256 = "1ca7e015830121fc144a2268c81815106d4762782e7c62f077e9da8bf62a9053";
       revision = "1";
       editedCabalFile = "cfadc0b87a5d9c4cc9a3ab5d7a5524221ae88e962f812eb41beba7b39111ccce";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/ekmett/half";
       description = "Half-precision floating-point";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "half_0_2_2_1" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "half";
       version = "0.2.2.1";
       sha256 = "c109406808786548f8bc32199f6d754acb4cfe10c66b44bb658cf0a2af611c7e";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/ekmett/half";
       description = "Half-precision floating-point";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "half_0_2_2_2" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "half";
       version = "0.2.2.2";
       sha256 = "5be5dbd5279bc921407dd9286a0f82bf77a895ca2e9f7d5169fddca99b58a99f";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/ekmett/half";
       description = "Half-precision floating-point";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "half" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "half";
       version = "0.2.2.3";
       sha256 = "85c244c80d1c889a3d79073a6f5a99d9e769dbe3c574ca11d992b2b4f7599a5c";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/ekmett/half";
       description = "Half-precision floating-point";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "halfs" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, containers
     , directory, filepath, fingertree, HFuse, mtl, QuickCheck, random
     , time, unix
     }:
     mkDerivation {
       pname = "halfs";
       version = "2.0";
       sha256 = "6d2a2125bae7acfde46c554a0ee0d133fd685f43bb42247eafbb327037c087cc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cereal containers directory filepath
         fingertree mtl QuickCheck random time unix
       ];
       executableHaskellDepends = [
         array base bytestring cereal containers directory filepath
         fingertree HFuse mtl QuickCheck random time unix
       ];
       jailbreak = true;
       description = "The HAskelL File System (\"halfs\" -- intended for use on the HaLVM)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "halipeto" = callPackage
    ({ mkDerivation, base, directory, HaXml, pandoc }:
     mkDerivation {
       pname = "halipeto";
       version = "2.4.1";
       sha256 = "ab2d561f56c31bf0dffc77902414987fd4fd3bcb5e690a5491358f00ab71deaa";
       libraryHaskellDepends = [ base directory HaXml pandoc ];
       jailbreak = true;
       homepage = "http://github.com/peti/halipeto";
       description = "Haskell Static Web Page Generator";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "halive" = callPackage
    ({ mkDerivation, base, bin-package-db, containers, directory
     , filepath, foreign-store, fsnotify, ghc, ghc-paths, process
     , transformers
     }:
     mkDerivation {
       pname = "halive";
       version = "0.1.0.7";
       sha256 = "1c0e073e4769fedec470f7518fb1e20eff8d5b7a56fe8a03ec186aaf5ae71398";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers foreign-store ];
       executableHaskellDepends = [
         base bin-package-db directory filepath fsnotify ghc ghc-paths
         process transformers
       ];
       homepage = "https://github.com/lukexi/halive";
       description = "A live recompiler";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "halma" = callPackage
    ({ mkDerivation, async, base, containers, data-default
     , diagrams-cairo, diagrams-gtk, diagrams-lib, grid, gtk, HUnit, mtl
     , mvc, pipes, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, timeit
     }:
     mkDerivation {
       pname = "halma";
       version = "0.2.0.1";
       sha256 = "4c1b2990d2cbe3b46f5895cf9db75aaabbdf3a9e31df09d3c9fc5528a36c6011";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers data-default diagrams-lib grid
       ];
       executableHaskellDepends = [
         async base data-default diagrams-cairo diagrams-gtk diagrams-lib
         gtk mtl mvc pipes timeit
       ];
       testHaskellDepends = [
         base containers grid HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/timjb/halma";
       description = "Library implementing Halma rules";
       license = stdenv.lib.licenses.mit;
     }) {};

  "haltavista" = callPackage
    ({ mkDerivation, base, hint, process }:
     mkDerivation {
       pname = "haltavista";
       version = "0.1.0.1";
       sha256 = "4ef4365228a5e3036e84ab1c90c6ef54c7e746e77a658cb13c16c9ee56a45850";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base hint process ];
       description = "looks for functions given a set of example input/outputs";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "hamid" = callPackage
    ({ mkDerivation, base, HCodecs, newtype }:
     mkDerivation {
       pname = "hamid";
       version = "0.10";
       sha256 = "6873f382abbf70cd81a7c06c77be57966b21f0b200d46e3fe6785e7ed314e9a4";
       libraryHaskellDepends = [ base HCodecs newtype ];
       description = "Binding to the OS level Midi services (fork of system-midi)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hamlet" = callPackage
    ({ mkDerivation, base, shakespeare }:
     mkDerivation {
       pname = "hamlet";
       version = "1.2.0";
       sha256 = "d1c94b259163cb37f5c02ef3418ebf4caf8d95c8ee00588d4493aa3aae1a8a66";
       libraryHaskellDepends = [ base shakespeare ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://www.yesodweb.com/book/shakespearean-templates";
       description = "Haml-like template files that are compile-time checked (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hampp" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , Glob, preprocessor-tools
     }:
     mkDerivation {
       pname = "hampp";
       version = "0.2.1";
       sha256 = "9413abd81035cd51ce1b17f1f819f29a4bd658a30070acddd38fe66e02d4f478";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory filepath Glob
         preprocessor-tools
       ];
       jailbreak = true;
       description = "Haskell macro preprocessor";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hamtmap" = callPackage
    ({ mkDerivation, array, base, deepseq, hashable }:
     mkDerivation {
       pname = "hamtmap";
       version = "0.3";
       sha256 = "d4d107ece7ffa69528a720763a0741dcab4773646df974596220d745250fd911";
       libraryHaskellDepends = [ array base deepseq hashable ];
       homepage = "https://github.com/exclipy/pdata";
       description = "A purely functional and persistent hash map";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hamusic" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, haskore
     , HaXml, musicxml, non-negative, process
     }:
     mkDerivation {
       pname = "hamusic";
       version = "0.1.2.1";
       sha256 = "36027361339369ace8402ac480dc6a23ac1b907f090527a876ce21675ff3dfbd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory haskore HaXml musicxml non-negative
         process
       ];
       executableHaskellDepends = [ filepath ];
       jailbreak = true;
       homepage = "https://troglodita.di.uminho.pt/svn/musica/work/HaMusic";
       description = "Library to handle abstract music";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "handa-gdata" = callPackage
    ({ mkDerivation, base, base64-bytestring, binary, bytestring
     , case-insensitive, cmdargs, data-default, directory, filepath
     , GenericPretty, HTTP, http-conduit, json, network, old-locale
     , pretty, process, pureMD5, random, regex-posix, resourcet, split
     , time, unix-compat, utf8-string, xml
     }:
     mkDerivation {
       pname = "handa-gdata";
       version = "0.7.0.3";
       sha256 = "2141499190ee2342c11da8409ff0ec18b6e11a44c90ba46ec57923bfff0ca6e6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring binary bytestring case-insensitive
         data-default directory filepath GenericPretty HTTP http-conduit
         json network old-locale pretty process pureMD5 random regex-posix
         resourcet split time unix-compat utf8-string xml
       ];
       executableHaskellDepends = [
         base base64-bytestring binary bytestring case-insensitive cmdargs
         directory filepath GenericPretty HTTP http-conduit json network
         old-locale pretty process pureMD5 random regex-posix resourcet
         split time unix-compat utf8-string xml
       ];
       homepage = "http://code.google.com/p/hgdata";
       description = "Library and command-line utility for accessing Google services and APIs";
       license = stdenv.lib.licenses.mit;
     }) {};

  "handa-geodata" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, scientific }:
     mkDerivation {
       pname = "handa-geodata";
       version = "0.2.0.1";
       sha256 = "5644276f84f844f285398f6e2a275d8b659ba38baaa5d9b338615fc68de91174";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers scientific
       ];
       executableHaskellDepends = [
         aeson base bytestring containers scientific
       ];
       homepage = "http://code.bwbush.io/handa-geodata/";
       description = "Geographic and Geometric Data";
       license = stdenv.lib.licenses.mit;
     }) {};

  "handa-opengl" = callPackage
    ({ mkDerivation, aeson, array, base, binary, data-default, GLUT
     , OpenGL, opengl-dlp-stereo, split, vector-space
     }:
     mkDerivation {
       pname = "handa-opengl";
       version = "0.1.13.0";
       sha256 = "b6b357f2795366758cec289a64109e7c6b9c9a54b53f8b24ea8c73dcfe0bbbd5";
       libraryHaskellDepends = [
         aeson array base binary data-default GLUT OpenGL opengl-dlp-stereo
         split vector-space
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/bwbush/handa-opengl";
       description = "Utility functions for OpenGL and GLUT";
       license = stdenv.lib.licenses.mit;
     }) {};

  "handle-like" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "handle-like";
       version = "0.1.0.3";
       sha256 = "edcd3e5084837272dec6a0f6b77f53c148f77290a618c4b38ca37c8b2fa17cc0";
       libraryHaskellDepends = [ base bytestring ];
       description = "HandleLike class";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "handsy" = callPackage
    ({ mkDerivation, base, bytestring, data-default-class, operational
     , process-extras, retry, shell-escape, split, tasty, tasty-hunit
     , tasty-th, transformers
     }:
     mkDerivation {
       pname = "handsy";
       version = "0.0.14";
       sha256 = "be7efb53d3e4b1e20c9f3624db8bf3186bc98ddd52783602b09a0f84e4fd5ea8";
       libraryHaskellDepends = [
         base bytestring data-default-class operational process-extras retry
         shell-escape split transformers
       ];
       testHaskellDepends = [
         base bytestring tasty tasty-hunit tasty-th
       ];
       jailbreak = true;
       homepage = "https://github.com/utdemir/handsy";
       description = "A DSL to describe common shell operations and interpeters for running them locally and remotely";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hangman" = callPackage
    ({ mkDerivation, base, mtl, random, utility-ht }:
     mkDerivation {
       pname = "hangman";
       version = "1.0.3";
       sha256 = "3eae81d96619f167dbfefd8946daf7b62e5f98d263d9a6e131e9ab888ff8064d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base mtl random utility-ht ];
       description = "Hangman implementation in Haskell written in two hours";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hannahci" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, formatting
     , http-types, lens, lens-aeson, process, scotty, text, transformers
     , unix-time, wai-extra, wai-middleware-static, yaml
     }:
     mkDerivation {
       pname = "hannahci";
       version = "0.1.4.2";
       sha256 = "c0def692076e9fa1e0f1a2869a3dcccf2eff3ffbd8bc81b8350fe9ecf44f4e1c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring directory formatting http-types lens
         lens-aeson process scotty text transformers unix-time wai-extra
         wai-middleware-static yaml
       ];
       jailbreak = true;
       description = "Simple Continuous Integration/Deployment System";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hans" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring, cereal
     , containers, fingertree, HTTP, monadLib, network, old-locale
     , random, stm, time, unix
     }:
     mkDerivation {
       pname = "hans";
       version = "2.6.0.0";
       sha256 = "2853847c2d8823e43904ddcd2fa4ad1e1b15178a18e703293459866601c057a5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal containers fingertree monadLib random stm
         time unix
       ];
       executableHaskellDepends = [
         base blaze-html blaze-markup bytestring cereal containers HTTP
         monadLib network old-locale time
       ];
       description = "IPv4 Network Stack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hans-pcap" = callPackage
    ({ mkDerivation, base, bytestring, hans, pcap }:
     mkDerivation {
       pname = "hans-pcap";
       version = "0.1.0.2";
       sha256 = "1a119ed589eb8da99a741b6a8e67927897cd1b543ee8cd54728f50a39308f283";
       libraryHaskellDepends = [ base bytestring hans pcap ];
       jailbreak = true;
       homepage = "https://github.com/tolysz/hans-pcap";
       description = "Driver for real ethernet devices for HaNS";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hans-pfq" = callPackage
    ({ mkDerivation, base, bytestring, hans, pfq }:
     mkDerivation {
       pname = "hans-pfq";
       version = "0.1.0.0";
       sha256 = "0bd42928994193ca980944eb74baacc439851fe12365556ab141248fa2be5a1e";
       libraryHaskellDepends = [ base bytestring hans pfq ];
       jailbreak = true;
       homepage = "https://github.com/tolysz/hans-pfq";
       description = "Driver for real ethernet devices for HaNS";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {pfq = null;};

  "haphviz" = callPackage
    ({ mkDerivation, base, checkers, hspec, mtl, QuickCheck
     , quickcheck-text, text
     }:
     mkDerivation {
       pname = "haphviz";
       version = "0.1.2.0";
       sha256 = "d7dcb9cc3c345a3886206fc2c50ce375fbafea5c44124602a6124d144d172f8e";
       libraryHaskellDepends = [ base mtl text ];
       testHaskellDepends = [
         base checkers hspec QuickCheck quickcheck-text text
       ];
       description = "Graphviz code generation with Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hapistrano" = callPackage
    ({ mkDerivation, base, base-compat, directory, either, filepath
     , hspec, mtl, process, temporary, time, time-locale-compat
     , transformers
     }:
     mkDerivation {
       pname = "hapistrano";
       version = "0.2.1.1";
       sha256 = "dc4c5c8f68ef3ff8eb32f33d9600f4a1478abc0f48a5e75589744ff92e34c5cb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base either filepath mtl process time time-locale-compat
         transformers
       ];
       executableHaskellDepends = [ base base-compat ];
       testHaskellDepends = [
         base directory either filepath hspec mtl process temporary
       ];
       homepage = "https://github.com/stackbuilders/hapistrano";
       description = "A deployment library for Haskell applications";
       license = stdenv.lib.licenses.mit;
     }) {};

  "happindicator" = callPackage
    ({ mkDerivation, appindicator, array, base, bytestring, containers
     , glib, gtk, gtk2hs-buildtools, mtl
     }:
     mkDerivation {
       pname = "happindicator";
       version = "0.0.4";
       sha256 = "839871e4907761a877af82160ada207ae5c16034f168ff1b5a4a7c5afb651eb4";
       libraryHaskellDepends = [
         array base bytestring containers glib gtk mtl
       ];
       libraryPkgconfigDepends = [ appindicator ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       jailbreak = true;
       description = "Binding to the appindicator library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {appindicator = null;};

  "happindicator3" = callPackage
    ({ mkDerivation, appindicator, base, glib, gtk3, text }:
     mkDerivation {
       pname = "happindicator3";
       version = "0.2.1";
       sha256 = "225156270dc7cb2bb399aee76c9273a62683d8835c7045027a7906a3cf010326";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base glib gtk3 ];
       libraryPkgconfigDepends = [ appindicator ];
       executableHaskellDepends = [ base gtk3 text ];
       jailbreak = true;
       homepage = "https://github.com/mlacorte/happindicator3";
       description = "Binding to the appindicator library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {appindicator = null;};

  "happraise" = callPackage
    ({ mkDerivation, base, directory, filepath }:
     mkDerivation {
       pname = "happraise";
       version = "0.1";
       sha256 = "2f5c58ee6d82a0405fe1f7e73a1481018995490276d65cf33e13769e68748bed";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath ];
       description = "A small program for counting the comments in haskell source";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happs-hsp" = callPackage
    ({ mkDerivation, base, bytestring, HAppS-Server, hsp, mtl, plugins
     }:
     mkDerivation {
       pname = "happs-hsp";
       version = "0.1";
       sha256 = "bd677ce5dd13940f9241672b28b7df106cdbf1a20ca3eff1398d560831582f50";
       libraryHaskellDepends = [
         base bytestring HAppS-Server hsp mtl plugins
       ];
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happs-hsp-template" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , HAppS-Server, hinotify, hsp, mtl, network, plugins, RJson
     }:
     mkDerivation {
       pname = "happs-hsp-template";
       version = "0.2";
       sha256 = "e80cc49c31ba6a99d2981607802e83394e77261ef7f2f261b5ffff9fe68d2115";
       libraryHaskellDepends = [
         base bytestring containers directory filepath HAppS-Server hinotify
         hsp mtl network plugins RJson
       ];
       description = "Utilities for using HSP templates in HAppS applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happs-tutorial" = callPackage
    ({ mkDerivation, base, bytestring, containers, DebugTraceHelpers
     , directory, filepath, happstack, happstack-data, happstack-helpers
     , happstack-ixset, happstack-server, happstack-state, hscolour
     , HStringTemplate, HStringTemplateHelpers, HTTP, mtl, old-time
     , parsec, pretty, pureMD5, safe, syb
     }:
     mkDerivation {
       pname = "happs-tutorial";
       version = "0.9.5";
       sha256 = "f67a4cfed5b8dd4ff0b87d529482a94aceb59c91235900b26a26e7772d3a73de";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers DebugTraceHelpers directory filepath
         happstack happstack-data happstack-helpers happstack-ixset
         happstack-server happstack-state hscolour HStringTemplate
         HStringTemplateHelpers HTTP mtl old-time parsec pretty pureMD5 safe
         syb
       ];
       jailbreak = true;
       description = "A Happstack Tutorial that is its own web 2.0-type demo.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack" = callPackage
    ({ mkDerivation, base, happstack-server }:
     mkDerivation {
       pname = "happstack";
       version = "7.0.2";
       sha256 = "d9d4f581718d4f0fedd5d1f41ce127a6e651545a9398619c0bee3debb377d5b5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base happstack-server ];
       doHaddock = false;
       jailbreak = true;
       homepage = "http://happstack.com";
       description = "The haskell application server stack + code generation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happstack-auth" = callPackage
    ({ mkDerivation, base, bytestring, containers, convertible
     , happstack, happstack-data, happstack-ixset, happstack-server
     , happstack-state, mtl, old-time, random
     }:
     mkDerivation {
       pname = "happstack-auth";
       version = "0.2.1.1";
       sha256 = "c46f1112e2754f5227f75bfd047cd658ed8caa5aec051aecd42d20835016cd55";
       libraryHaskellDepends = [
         base bytestring containers convertible happstack happstack-data
         happstack-ixset happstack-server happstack-state mtl old-time
         random
       ];
       jailbreak = true;
       homepage = "http://n-sch.de/happstack-auth";
       description = "A Happstack Authentication Suite";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-authenticate_2_3_2" = callPackage
    ({ mkDerivation, acid-state, aeson, authenticate, base
     , base64-bytestring, boomerang, bytestring, containers
     , data-default, email-validate, filepath, happstack-hsp
     , happstack-jmacro, happstack-server, hsp, hsx-jmacro, hsx2hs
     , http-conduit, http-types, ixset-typed, jmacro, jwt, lens
     , mime-mail, mtl, pwstore-purehaskell, random, safecopy
     , shakespeare, text, time, unordered-containers, userid, web-routes
     , web-routes-boomerang, web-routes-happstack, web-routes-hsp
     , web-routes-th
     }:
     mkDerivation {
       pname = "happstack-authenticate";
       version = "2.3.2";
       sha256 = "41ea80ab11653b9face4978a07a25b4609df42bffcc4d48c5e36ac9923884fb1";
       libraryHaskellDepends = [
         acid-state aeson authenticate base base64-bytestring boomerang
         bytestring containers data-default email-validate filepath
         happstack-hsp happstack-jmacro happstack-server hsp hsx-jmacro
         hsx2hs http-conduit http-types ixset-typed jmacro jwt lens
         mime-mail mtl pwstore-purehaskell random safecopy shakespeare text
         time unordered-containers userid web-routes web-routes-boomerang
         web-routes-happstack web-routes-hsp web-routes-th
       ];
       jailbreak = true;
       homepage = "http://www.happstack.com/";
       description = "Happstack Authentication Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-authenticate_2_3_3" = callPackage
    ({ mkDerivation, acid-state, aeson, authenticate, base
     , base64-bytestring, boomerang, bytestring, containers
     , data-default, email-validate, filepath, happstack-hsp
     , happstack-jmacro, happstack-server, hsp, hsx-jmacro, hsx2hs
     , http-conduit, http-types, ixset-typed, jmacro, jwt, lens
     , mime-mail, mtl, pwstore-purehaskell, random, safecopy
     , shakespeare, text, time, unordered-containers, userid, web-routes
     , web-routes-boomerang, web-routes-happstack, web-routes-hsp
     , web-routes-th
     }:
     mkDerivation {
       pname = "happstack-authenticate";
       version = "2.3.3";
       sha256 = "e8bd1802370ad1d6f3099eb1a6ab4310a52aaaac1a7b0644d574dc71ee7c55d0";
       libraryHaskellDepends = [
         acid-state aeson authenticate base base64-bytestring boomerang
         bytestring containers data-default email-validate filepath
         happstack-hsp happstack-jmacro happstack-server hsp hsx-jmacro
         hsx2hs http-conduit http-types ixset-typed jmacro jwt lens
         mime-mail mtl pwstore-purehaskell random safecopy shakespeare text
         time unordered-containers userid web-routes web-routes-boomerang
         web-routes-happstack web-routes-hsp web-routes-th
       ];
       homepage = "http://www.happstack.com/";
       description = "Happstack Authentication Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-authenticate" = callPackage
    ({ mkDerivation, acid-state, aeson, authenticate, base
     , base64-bytestring, boomerang, bytestring, containers
     , data-default, email-validate, filepath, happstack-hsp
     , happstack-jmacro, happstack-server, hsp, hsx-jmacro, hsx2hs
     , http-conduit, http-types, ixset-typed, jmacro, jwt, lens
     , mime-mail, mtl, pwstore-purehaskell, random, safecopy
     , shakespeare, text, time, unordered-containers, userid, web-routes
     , web-routes-boomerang, web-routes-happstack, web-routes-hsp
     , web-routes-th
     }:
     mkDerivation {
       pname = "happstack-authenticate";
       version = "2.3.4";
       sha256 = "e844770a331e5a9fcd64e62ccaaf5c6509afed01ed871306e6da630b48b8be43";
       libraryHaskellDepends = [
         acid-state aeson authenticate base base64-bytestring boomerang
         bytestring containers data-default email-validate filepath
         happstack-hsp happstack-jmacro happstack-server hsp hsx-jmacro
         hsx2hs http-conduit http-types ixset-typed jmacro jwt lens
         mime-mail mtl pwstore-purehaskell random safecopy shakespeare text
         time unordered-containers userid web-routes web-routes-boomerang
         web-routes-happstack web-routes-hsp web-routes-th
       ];
       homepage = "http://www.happstack.com/";
       description = "Happstack Authentication Library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happstack-clientsession" = callPackage
    ({ mkDerivation, base, bytestring, cereal, clientsession
     , happstack-server, monad-control, mtl, safecopy, transformers-base
     }:
     mkDerivation {
       pname = "happstack-clientsession";
       version = "7.3.1";
       sha256 = "5b83ea0dae41857ec9ba6de68842633e85297660565e15c739d238f51b3f86ea";
       libraryHaskellDepends = [
         base bytestring cereal clientsession happstack-server monad-control
         mtl safecopy transformers-base
       ];
       homepage = "http://happstack.com";
       description = "client-side session data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happstack-contrib" = callPackage
    ({ mkDerivation, base, bytestring, directory, happstack-data
     , happstack-ixset, happstack-server, happstack-state
     , happstack-util, HTTP, HUnit, mtl, network, old-time, syb, unix
     }:
     mkDerivation {
       pname = "happstack-contrib";
       version = "0.2.1";
       sha256 = "e550c0e74b1873ac051a886626f44571cf8543e179096f391f1cbecaa4750d33";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring directory happstack-data happstack-ixset
         happstack-server happstack-state happstack-util HTTP mtl network
         old-time syb unix
       ];
       executableHaskellDepends = [ HUnit ];
       jailbreak = true;
       homepage = "http://happstack.com";
       description = "Web related tools and services";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-data" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, mtl, pretty
     , syb, syb-with-class, syb-with-class-instances-text
     , template-haskell, text, time
     }:
     mkDerivation {
       pname = "happstack-data";
       version = "6.0.1";
       sha256 = "889654ad957d43fd719b4f62a97b943beb622bb2f25701ae388d46db2ab1546c";
       revision = "1";
       editedCabalFile = "dbf53b1d5012ac975d184455269f3d631ba2352e9642b707b98465c47225fd06";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers mtl pretty syb syb-with-class
         syb-with-class-instances-text template-haskell text time
       ];
       jailbreak = true;
       homepage = "http://happstack.com";
       description = "Happstack data manipulation libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-dlg" = callPackage
    ({ mkDerivation, applicative-extras, base, bytestring, containers
     , formlets, happstack-server, mtl, random, template-haskell, time
     , xhtml
     }:
     mkDerivation {
       pname = "happstack-dlg";
       version = "0.1.2";
       sha256 = "170b3b80176648e26c5689b31763183c73cd68011ad1b8a7bfdc824c8470a8fe";
       libraryHaskellDepends = [
         applicative-extras base bytestring containers formlets
         happstack-server mtl random template-haskell time xhtml
       ];
       homepage = "http://patch-tag.com/r/cdsmith/happstack-dlg";
       description = "Cross-request user interactions for Happstack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-facebook" = callPackage
    ({ mkDerivation, applicative-extras, base, bytestring, containers
     , filepath, happstack, happstack-data, happstack-hsp
     , happstack-ixset, happstack-server, happstack-state
     , happstack-util, harp, hsp, hsx, html, HTTP, json, mtl, network
     , old-time, random, RJson, syb, text, time, trhsx, utf8-string
     , web-routes, web-routes-mtl
     }:
     mkDerivation {
       pname = "happstack-facebook";
       version = "0.30";
       sha256 = "0c517c663da5323fe6677fa73f8ba862725e1bb813566af63d38ee1f6716cde5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         applicative-extras base bytestring containers filepath happstack
         happstack-data happstack-hsp happstack-ixset happstack-server
         happstack-state happstack-util harp hsp hsx html HTTP json mtl
         network old-time random RJson syb text time utf8-string web-routes
         web-routes-mtl
       ];
       executableToolDepends = [ trhsx ];
       homepage = "http://src.seereason.com/happstack-facebook/";
       description = "A package for building Facebook applications using Happstack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-fastcgi" = callPackage
    ({ mkDerivation, base, bytestring, cgi, containers, fastcgi
     , happstack-server, mtl, utf8-string
     }:
     mkDerivation {
       pname = "happstack-fastcgi";
       version = "0.1.5";
       sha256 = "10c9cde8a3f01f5cb648c93266fb72ba662c75d4de07eff657c8896e03016b67";
       libraryHaskellDepends = [
         base bytestring cgi containers fastcgi happstack-server mtl
         utf8-string
       ];
       description = "Happstack extension for use with FastCGI";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happstack-fay" = callPackage
    ({ mkDerivation, aeson, base, fay, happstack-fay-ajax
     , happstack-server, mtl
     }:
     mkDerivation {
       pname = "happstack-fay";
       version = "0.2.0";
       sha256 = "457b43d3ff5f15d7fc2a49c6731aef9f40a142305b23daaf1fdde832e23c9dd7";
       libraryHaskellDepends = [
         aeson base fay happstack-fay-ajax happstack-server mtl
       ];
       jailbreak = true;
       homepage = "http://www.happstack.com/";
       description = "Support for using Fay with Happstack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-fay-ajax" = callPackage
    ({ mkDerivation, fay-base, fay-jquery }:
     mkDerivation {
       pname = "happstack-fay-ajax";
       version = "0.2.0";
       sha256 = "92c8511adda63943e40e19c87ef5ceb7f6ff194ec2ed26cbc3db59eeebdeb37d";
       libraryHaskellDepends = [ fay-base fay-jquery ];
       jailbreak = true;
       homepage = "http://www.happstack.com/";
       description = "Support for using Fay with Happstack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happstack-foundation" = callPackage
    ({ mkDerivation, acid-state, base, happstack-hsp, happstack-server
     , hsp, lifted-base, monad-control, mtl, reform, reform-happstack
     , reform-hsp, safecopy, text, web-routes, web-routes-happstack
     , web-routes-hsp, web-routes-th
     }:
     mkDerivation {
       pname = "happstack-foundation";
       version = "0.5.9";
       sha256 = "b6f06231981f1bcb8357925cd5638c01e01a4fdd9b43c9b05b5bf262aa39c176";
       libraryHaskellDepends = [
         acid-state base happstack-hsp happstack-server hsp lifted-base
         monad-control mtl reform reform-happstack reform-hsp safecopy text
         web-routes web-routes-happstack web-routes-hsp web-routes-th
       ];
       homepage = "http://www.happstack.com/";
       description = "Glue code for using Happstack with acid-state, web-routes, reform, and HSP";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happstack-hamlet" = callPackage
    ({ mkDerivation, base, happstack-server, shakespeare, text }:
     mkDerivation {
       pname = "happstack-hamlet";
       version = "7.0.4";
       sha256 = "2a11133ff0e8ffecc5f3ae51dcfdef1210c37bca221933f54d8bae8fbd7f22d0";
       libraryHaskellDepends = [ base happstack-server shakespeare text ];
       jailbreak = true;
       homepage = "http://www.happstack.com/";
       description = "Support for Hamlet HTML templates in Happstack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happstack-heist" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, either, filepath
     , happstack-server, heist, mtl, text
     }:
     mkDerivation {
       pname = "happstack-heist";
       version = "7.2.4";
       sha256 = "a30946c3fba8e02a3bae88256b9ce8090ae873d026e3cf2a8d11a193b877a1ab";
       libraryHaskellDepends = [
         base blaze-builder bytestring either filepath happstack-server
         heist mtl text
       ];
       jailbreak = true;
       homepage = "http://www.happstack.com/";
       description = "Support for using Heist templates in Happstack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-helpers" = callPackage
    ({ mkDerivation, base, bytestring, containers, DebugTraceHelpers
     , directory, filepath, happstack-data, happstack-ixset
     , happstack-server, happstack-state, haskell98, hscolour, HSH
     , HStringTemplate, HStringTemplateHelpers, HTTP, MissingH, mtl
     , network, old-time, parsec, PBKDF2, pureMD5, random, safe, syb
     , text, utf8-string
     }:
     mkDerivation {
       pname = "happstack-helpers";
       version = "0.56";
       sha256 = "0288a6166bfe571d96f94182fd876d97fee57445de9dca77fc51c8fe58bb3a7b";
       libraryHaskellDepends = [
         base bytestring containers DebugTraceHelpers directory filepath
         happstack-data happstack-ixset happstack-server happstack-state
         haskell98 hscolour HSH HStringTemplate HStringTemplateHelpers HTTP
         MissingH mtl network old-time parsec PBKDF2 pureMD5 random safe syb
         text utf8-string
       ];
       jailbreak = true;
       homepage = "http://patch-tag.com/r/tphyahoo/HAppSHelpers/home";
       description = "Convenience functions for Happstack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-hsp" = callPackage
    ({ mkDerivation, base, bytestring, happstack-server, harp, hsp
     , hsx2hs, mtl, syb, text, utf8-string
     }:
     mkDerivation {
       pname = "happstack-hsp";
       version = "7.3.7";
       sha256 = "fe82bc53c2738a9f502f6c42500e690d04dbf3dd9811ba4140b3d8cdf6adb1f7";
       libraryHaskellDepends = [
         base bytestring happstack-server harp hsp hsx2hs mtl syb text
         utf8-string
       ];
       homepage = "http://www.happstack.com/";
       description = "Support for using HSP templates in Happstack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happstack-hstringtemplate" = callPackage
    ({ mkDerivation, base, bytestring, happstack-server, hslogger
     , HStringTemplate, mtl
     }:
     mkDerivation {
       pname = "happstack-hstringtemplate";
       version = "7.0.4";
       sha256 = "c46977de7d3406a0e79b927d4b9ea7bce522ad849d752f22ae6de5dfe33692dd";
       libraryHaskellDepends = [
         base bytestring happstack-server hslogger HStringTemplate mtl
       ];
       jailbreak = true;
       homepage = "http://www.happstack.com/";
       description = "Support for using HStringTemplate in Happstack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happstack-ixset" = callPackage
    ({ mkDerivation, base, containers, happstack-data, happstack-util
     , mtl, syb, syb-with-class, template-haskell
     }:
     mkDerivation {
       pname = "happstack-ixset";
       version = "6.0.1";
       sha256 = "d122eeff5fa0e0321a8a76d2b1ff39f9d99cc70df5dc13be9db970e723b0d0c2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers happstack-data happstack-util mtl syb
         syb-with-class template-haskell
       ];
       jailbreak = true;
       homepage = "http://happstack.com";
       description = "Efficient relational queries on Haskell sets";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-jmacro" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, cereal
     , digest, happstack-server, jmacro, text, utf8-string
     , wl-pprint-text
     }:
     mkDerivation {
       pname = "happstack-jmacro";
       version = "7.0.11";
       sha256 = "29c6b844d91fb7288c5264312c0cd203d964cfb0a13f98a5551699350fdbdf1c";
       libraryHaskellDepends = [
         base base64-bytestring bytestring cereal digest happstack-server
         jmacro text utf8-string wl-pprint-text
       ];
       homepage = "http://www.happstack.com/";
       description = "Support for using JMacro with Happstack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happstack-lite" = callPackage
    ({ mkDerivation, base, bytestring, happstack-server, mtl, text }:
     mkDerivation {
       pname = "happstack-lite";
       version = "7.3.6";
       sha256 = "e85659a3346f4aeb579dc2ef000e95c59ccc8c06afcea269daafb827ebba7fd7";
       libraryHaskellDepends = [
         base bytestring happstack-server mtl text
       ];
       homepage = "http://www.happstack.com/";
       description = "Happstack minus the useless stuff";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happstack-monad-peel" = callPackage
    ({ mkDerivation, base, happstack-server, monad-peel, mtl
     , transformers
     }:
     mkDerivation {
       pname = "happstack-monad-peel";
       version = "0.1";
       sha256 = "3e2ffcf489e3b2da331d177d5cd3ed4f73c11187d9c38b1ffcfb8a533cd4d46c";
       libraryHaskellDepends = [
         base happstack-server monad-peel mtl transformers
       ];
       description = "monad-peel instances for Happstack types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-plugins" = callPackage
    ({ mkDerivation, base, happstack-server, mtl, plugins-auto
     , template-haskell, th-lift
     }:
     mkDerivation {
       pname = "happstack-plugins";
       version = "7.0.2";
       sha256 = "2e2a6ad3d0fd2f661a20e643095fe95a0462daa14974f5a70a6de573e603f01f";
       libraryHaskellDepends = [
         base happstack-server mtl plugins-auto template-haskell th-lift
       ];
       jailbreak = true;
       homepage = "http://happstack.com";
       description = "The haskell application server stack + reload";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-server_7_3_9" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring
     , containers, directory, extensible-exceptions, filepath, hslogger
     , html, HUnit, monad-control, mtl, network, network-uri, old-locale
     , parsec, process, sendfile, syb, system-filepath, template-haskell
     , text, threads, time, time-compat, transformers, transformers-base
     , unix, utf8-string, xhtml, zlib
     }:
     mkDerivation {
       pname = "happstack-server";
       version = "7.3.9";
       sha256 = "9fb66700374db5455853db778c086549345150c7e7fb5e60f09e16deeb145a82";
       revision = "1";
       editedCabalFile = "4f2120821f3c61d3946d9e12b37f862d31acad7be0ce0fd014142f85caea7734";
       libraryHaskellDepends = [
         base base64-bytestring blaze-html bytestring containers directory
         extensible-exceptions filepath hslogger html monad-control mtl
         network network-uri old-locale parsec process sendfile syb
         system-filepath template-haskell text threads time time-compat
         transformers transformers-base unix utf8-string xhtml zlib
       ];
       testHaskellDepends = [
         base bytestring containers HUnit parsec zlib
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://happstack.com";
       description = "Web related tools and services";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-server_7_4_2" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring
     , containers, directory, exceptions, extensible-exceptions
     , filepath, hslogger, html, HUnit, monad-control, mtl, network
     , network-uri, old-locale, parsec, process, sendfile, 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.4.2";
       sha256 = "2fbb9b29ac6c3c70919aedd64982793c1d13e5dafbdfac155360c307e2609d3b";
       revision = "1";
       editedCabalFile = "3ee16f0ac8a9e0b2d641ecaee31310ebc1640d30db77fd85e4deccc22323bb2f";
       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
         sendfile syb system-filepath template-haskell text threads time
         time-compat transformers transformers-base transformers-compat unix
         utf8-string xhtml zlib
       ];
       testHaskellDepends = [
         base bytestring containers HUnit parsec zlib
       ];
       jailbreak = true;
       homepage = "http://happstack.com";
       description = "Web related tools and services";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-server_7_4_4" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring
     , containers, directory, exceptions, extensible-exceptions
     , filepath, hslogger, html, HUnit, monad-control, mtl, network
     , network-uri, old-locale, parsec, process, sendfile, 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.4.4";
       sha256 = "4e5a650554e6c04f2db7ffbed4e0c1af9163d14848bb80464d3d2db2b2d91ef2";
       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
         sendfile syb system-filepath template-haskell text threads time
         time-compat transformers transformers-base transformers-compat unix
         utf8-string xhtml zlib
       ];
       testHaskellDepends = [
         base bytestring containers HUnit parsec zlib
       ];
       jailbreak = true;
       homepage = "http://happstack.com";
       description = "Web related tools and services";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-server_7_4_5" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring
     , containers, directory, exceptions, extensible-exceptions
     , filepath, hslogger, html, HUnit, monad-control, mtl, network
     , network-uri, old-locale, parsec, process, sendfile, 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.4.5";
       sha256 = "704a11b50604e57bd960633a73baa77fe23993f41b35202a0e26f4af2f91dc96";
       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
         sendfile syb system-filepath template-haskell text threads time
         time-compat transformers transformers-base transformers-compat unix
         utf8-string xhtml zlib
       ];
       testHaskellDepends = [
         base bytestring containers HUnit parsec zlib
       ];
       jailbreak = true;
       homepage = "http://happstack.com";
       description = "Web related tools and services";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-server" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring
     , containers, directory, exceptions, extensible-exceptions
     , filepath, hslogger, html, HUnit, monad-control, mtl, network
     , network-uri, old-locale, parsec, process, sendfile, 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.4.6";
       sha256 = "8647b5f59de1b8c4d9788fff164ef6584e0f07b53bdcad06642e551eb357565c";
       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
         sendfile syb system-filepath template-haskell text threads time
         time-compat transformers transformers-base transformers-compat unix
         utf8-string xhtml zlib
       ];
       testHaskellDepends = [
         base bytestring containers HUnit parsec zlib
       ];
       homepage = "http://happstack.com";
       description = "Web related tools and services";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happstack-server-tls" = callPackage
    ({ mkDerivation, base, bytestring, extensible-exceptions
     , happstack-server, hslogger, HsOpenSSL, network, openssl, sendfile
     , time, unix
     }:
     mkDerivation {
       pname = "happstack-server-tls";
       version = "7.1.6.1";
       sha256 = "801fa353e8001bd105615713eae6068534d3e6789fac9dc762ed43e17f73a668";
       libraryHaskellDepends = [
         base bytestring extensible-exceptions happstack-server hslogger
         HsOpenSSL network sendfile time unix
       ];
       librarySystemDepends = [ openssl ];
       homepage = "http://www.happstack.com/";
       description = "extend happstack-server with https:// support (TLS/SSL)";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) openssl;};

  "happstack-server-tls-cryptonite" = callPackage
    ({ mkDerivation, base, bytestring, cryptonite, data-default-class
     , extensible-exceptions, happstack-server, hslogger, network
     , sendfile, time, tls, unix
     }:
     mkDerivation {
       pname = "happstack-server-tls-cryptonite";
       version = "0.1.1";
       sha256 = "5866fa63a5193a5ec2b9a10783c5a43069fde3a53f531ab1627872dd760385f8";
       libraryHaskellDepends = [
         base bytestring cryptonite data-default-class extensible-exceptions
         happstack-server hslogger network sendfile time tls unix
       ];
       description = "Extend happstack-server with native HTTPS support (TLS/SSL)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happstack-state" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , extensible-exceptions, filepath, happstack-data, happstack-util
     , hslogger, mtl, old-time, random, stm, syb, template-haskell, unix
     }:
     mkDerivation {
       pname = "happstack-state";
       version = "6.1.4";
       sha256 = "09f7d8eaa7eec13f99d59b7c5bf7e88b3d2889b6879f0f54731a9c6f4801d7f5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers directory extensible-exceptions
         filepath happstack-data happstack-util hslogger mtl old-time random
         stm syb template-haskell unix
       ];
       jailbreak = true;
       homepage = "http://happstack.com";
       description = "Event-based distributed state";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-static-routing" = callPackage
    ({ mkDerivation, base, containers, happstack-server, list-tries
     , transformers
     }:
     mkDerivation {
       pname = "happstack-static-routing";
       version = "0.4.2";
       sha256 = "0226f61e3ddd3dd832cdf93123812ab5b31418cdeeef9753d24f2ae82a490b3d";
       libraryHaskellDepends = [
         base containers happstack-server list-tries transformers
       ];
       homepage = "https://github.com/scrive/happstack-static-routing";
       description = "Support for static URL routing with overlap detection for Happstack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happstack-util" = callPackage
    ({ mkDerivation, array, base, bytestring, directory
     , extensible-exceptions, filepath, hslogger, mtl, network
     , old-locale, old-time, parsec, process, random, template-haskell
     , time, unix, unix-compat
     }:
     mkDerivation {
       pname = "happstack-util";
       version = "6.0.3";
       sha256 = "10de089778b70311d290420c7e6ad987da711b1c1961436ccf26c7cf4bd31a43";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring directory extensible-exceptions filepath
         hslogger mtl network old-locale old-time parsec process random
         template-haskell time unix unix-compat
       ];
       jailbreak = true;
       homepage = "http://happstack.com";
       description = "Web framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happstack-yui" = callPackage
    ({ mkDerivation, base, boomerang, bytestring, containers, directory
     , happstack-jmacro, happstack-server, hsp, interpolatedstring-perl6
     , jmacro, mtl, pretty, template-haskell, text, web-routes
     , web-routes-boomerang, web-routes-happstack, web-routes-th
     }:
     mkDerivation {
       pname = "happstack-yui";
       version = "7373.5.3";
       sha256 = "d17a3b8aed3e7d2bf33881964a24e260fed311578bdc74e903b7e5dab11c199d";
       libraryHaskellDepends = [
         base boomerang bytestring containers directory happstack-jmacro
         happstack-server hsp interpolatedstring-perl6 jmacro mtl pretty
         template-haskell text web-routes web-routes-boomerang
         web-routes-happstack web-routes-th
       ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/dag/yui/browse/happstack-yui";
       description = "Utilities for using YUI3 with Happstack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happy_1_19_4" = callPackage
    ({ mkDerivation, array, base, containers, mtl, process }:
     mkDerivation {
       pname = "happy";
       version = "1.19.4";
       sha256 = "6be499f66c61f8c48cbbbcb70515eb8e62c2bfa08adcc8c9474e7ae343a6936d";
       revision = "1";
       editedCabalFile = "394b39b57e8a8a8d2052bc5f42e53f4880904619ef17f5cc98601b0ae132a824";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base containers mtl ];
       testHaskellDepends = [ base process ];
       jailbreak = true;
       homepage = "http://www.haskell.org/happy/";
       description = "Happy is a parser generator for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happy" = callPackage
    ({ mkDerivation, array, base, containers, mtl, process }:
     mkDerivation {
       pname = "happy";
       version = "1.19.5";
       sha256 = "62f03ac11d7b4b9913f212f5aa2eee1087f3b46dc07d799d41e1854ff02843da";
       revision = "1";
       editedCabalFile = "d6a01f50aab2c480799b7d19643c5bb01891e01ac97aa892ffec3e6029a1446c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base containers mtl ];
       testHaskellDepends = [ base process ];
       doCheck = false;
       homepage = "http://www.haskell.org/happy/";
       description = "Happy is a parser generator for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happy-meta" = callPackage
    ({ mkDerivation, array, base, containers, happy, haskell-src-meta
     , mtl, template-haskell
     }:
     mkDerivation {
       pname = "happy-meta";
       version = "0.2.0.8";
       sha256 = "4fad1eabd825ffbd1aa858a3e056f991a1f53c403e15064ef51b5fbdd300d242";
       libraryHaskellDepends = [
         array base containers haskell-src-meta mtl template-haskell
       ];
       libraryToolDepends = [ happy ];
       description = "Quasi-quoter for Happy parsers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "happybara" = callPackage
    ({ mkDerivation, aeson, base, filepath, http-types, lifted-base
     , monad-control, mtl, text, time, transformers, transformers-base
     }:
     mkDerivation {
       pname = "happybara";
       version = "0.0.1";
       sha256 = "3b77027ac1c33b37fb0a401a7e6678a999eed2b626c77b9f09ed1c203757e2d2";
       libraryHaskellDepends = [
         aeson base filepath http-types lifted-base monad-control mtl text
         time transformers transformers-base
       ];
       jailbreak = true;
       homepage = "https://github.com/cstrahan/happybara";
       description = "Acceptance test framework for web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happybara-webkit" = callPackage
    ({ mkDerivation, aeson, base, bytestring, case-insensitive
     , data-default, directory, filepath, happybara, http-types
     , lifted-base, monad-control, mtl, network, process, text, time
     , transformers, transformers-base, vector, word8
     }:
     mkDerivation {
       pname = "happybara-webkit";
       version = "0.0.1";
       sha256 = "dc910e37f72fb26f49fd4c8f81bee669fd10c81652c36ab03d8d4bea2737849c";
       libraryHaskellDepends = [
         aeson base bytestring case-insensitive data-default directory
         filepath happybara http-types lifted-base monad-control mtl network
         process text time transformers transformers-base vector word8
       ];
       jailbreak = true;
       homepage = "https://github.com/cstrahan/happybara/happybara-webkit";
       description = "WebKit Happybara driver";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "happybara-webkit-server" = callPackage
    ({ mkDerivation, base, directory, filepath, process }:
     mkDerivation {
       pname = "happybara-webkit-server";
       version = "0.0.1";
       sha256 = "11ea82ca95bd880e62585a81107964a28e1523c7eb9da9fdc322bc5dd38b096e";
       libraryHaskellDepends = [ base directory filepath process ];
       jailbreak = true;
       homepage = "https://github.com/cstrahan/happybara/happybara-webkit-server";
       description = "WebKit Server binary for Happybara (taken from capybara-webkit)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "har" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, filepath, text
     }:
     mkDerivation {
       pname = "har";
       version = "0.1.1.0";
       sha256 = "e387def36cc56e1953fc0746a711d06fe8e641711b666b36be02bbe529d6a174";
       libraryHaskellDepends = [
         aeson base bytestring directory filepath text
       ];
       jailbreak = true;
       homepage = "https://github.com/freizl/har";
       description = "HAR spec in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "harchive" = callPackage
    ({ mkDerivation, base, binary, network, openssl, parsec, sqlite
     , unix, zlib
     }:
     mkDerivation {
       pname = "harchive";
       version = "0.2";
       sha256 = "35fd37eb05770a6d039ede545467bc132c780f29fa915006fe5a27db6c2c8880";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary network parsec unix zlib
       ];
       executableSystemDepends = [ openssl sqlite ];
       homepage = "http://www.davidb.org/darcs/harchive/";
       description = "Networked content addressed backup and restore software";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openssl; inherit (pkgs) sqlite;};

  "hardware-edsl" = callPackage
    ({ mkDerivation, array, base, bytestring, constraints, containers
     , language-vhdl, mtl, operational-alacarte, pretty, syntactic
     }:
     mkDerivation {
       pname = "hardware-edsl";
       version = "0.1.0.1";
       sha256 = "cb208be2c2db96264ff37bfcc81810e127d9e6faf15ab48cebe7251bd55fc38c";
       libraryHaskellDepends = [
         array base bytestring constraints containers language-vhdl mtl
         operational-alacarte pretty syntactic
       ];
       homepage = "https://github.com/markus-git/hardware-edsl";
       description = "Deep embedding of hardware descriptions with code generation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hark" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, haskell98
     , mtl, old-locale, old-time, regex-pcre
     }:
     mkDerivation {
       pname = "hark";
       version = "0.2";
       sha256 = "a4a39c2db70def71c6629658e202d6dcf707565593d114b20c6b7f4247efbcf3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory filepath haskell98 mtl old-locale
         old-time regex-pcre
       ];
       homepage = "http://code.google.com/p/hark/";
       description = "A Gentoo package query tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "harmony" = callPackage
    ({ mkDerivation, alex, array, base, BNFC, containers, derive
     , directory, happy, hastache, hlint, hslogger, hspec, HUnit, mtl
     , process, QuickCheck, text
     }:
     mkDerivation {
       pname = "harmony";
       version = "0.1.1.0";
       sha256 = "453e3a4db149729e19bcbd6970abf0ed9d3c25dfffeac2c3cb5be3dcfdddc5dd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base BNFC containers derive directory hastache hslogger mtl
         process QuickCheck text
       ];
       libraryToolDepends = [ alex happy ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base containers derive hlint hslogger hspec HUnit QuickCheck
       ];
       description = "A web service specification compiler that generates implementation and tests";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haroonga" = callPackage
    ({ mkDerivation, base, bindings-DSL, groonga, monad-control
     , resourcet, transformers
     }:
     mkDerivation {
       pname = "haroonga";
       version = "0.1.7.1";
       sha256 = "4fd4e816f713fc1ed3170f7c5ae75180071e6907bb004e16ff5fe1100c328648";
       libraryHaskellDepends = [
         base bindings-DSL monad-control resourcet transformers
       ];
       libraryPkgconfigDepends = [ groonga ];
       description = "Low level bindings for Groonga";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {groonga = null;};

  "haroonga-httpd" = callPackage
    ({ mkDerivation, base, directory, haroonga, http-types, old-locale
     , optparse-applicative, scotty, text, time, transformers, wai-extra
     }:
     mkDerivation {
       pname = "haroonga-httpd";
       version = "0.1.1.0";
       sha256 = "af689fe7e4af0a9be26166d5f0d616e62a1980b209fdc1933db6850fe759859c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory haroonga http-types old-locale optparse-applicative
         scotty text time transformers wai-extra
       ];
       jailbreak = true;
       description = "Yet another Groonga http server";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "harp" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "harp";
       version = "0.4.1";
       sha256 = "9fb2d788238be65627b881d5ac6d574e62e6270ba4ee5d9cf479629f781e3861";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/seereason/harp";
       description = "HaRP allows pattern-matching with regular expressions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "harpy" = callPackage
    ({ mkDerivation, array, base, containers, disassembler, mtl, parsec
     , pretty, template-haskell
     }:
     mkDerivation {
       pname = "harpy";
       version = "0.6.0.2";
       sha256 = "3e3b8654983d17d29544379d5579f240d7c2bd2dcd30194e1bd94987f9548be6";
       libraryHaskellDepends = [
         array base containers disassembler mtl parsec pretty
         template-haskell
       ];
       homepage = "https://github.com/mgrabmueller/harpy";
       description = "Runtime code generation for x86 machine code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "has" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "has";
       version = "0.5.0.1";
       sha256 = "5a5cdc8fafbb89a79e6831a707ce303c18edf54e0b389aab9dc6302532e4cd7f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base QuickCheck ];
       homepage = "http://github.com/nonowarn/has";
       description = "Entity based records";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "has-th" = callPackage
    ({ mkDerivation, base, has, template-haskell }:
     mkDerivation {
       pname = "has-th";
       version = "0.1";
       sha256 = "843d3c4a0e47fe4d3c20838649bf915f6026a43f3898c7f8739ef7575173d97b";
       libraryHaskellDepends = [ base has template-haskell ];
       homepage = "http://github.com/chrisdone/has-th";
       description = "Template Haskell function for Has records";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hascal" = callPackage
    ({ mkDerivation, base, HUnit, numbers }:
     mkDerivation {
       pname = "hascal";
       version = "2.0.0.1";
       sha256 = "344062494982b809fef504496c7bbacf0932fd7fd35c5b5716c832f1dc4003db";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base numbers ];
       testHaskellDepends = [ HUnit ];
       jailbreak = true;
       homepage = "http://darcsden.com/mekeor/hascal";
       description = "A minimalistic but extensible and precise calculator";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hascat" = callPackage
    ({ mkDerivation, base, bytestring, hascat-lib, hascat-setup
     , hascat-system, HaXml, haxr, html, HTTP, network, unix
     }:
     mkDerivation {
       pname = "hascat";
       version = "0.2";
       sha256 = "4745cc43b3795342d52adb1fe0eb5a9819f80f5c9d8d8662a4c77128e8c0e913";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring hascat-lib hascat-setup hascat-system HaXml haxr
         html HTTP network unix
       ];
       jailbreak = true;
       description = "Hascat Web Server";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hascat-lib" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, haskell98
     , HaXml, html, HTTP, mtl, network, old-locale, old-time, parsec
     , plugins, xhtml
     }:
     mkDerivation {
       pname = "hascat-lib";
       version = "0.2";
       sha256 = "12e7d9c7f0f188fedd7c8acfcb2b7ba7cfd879b039ffb9ef825d6c6f5f8f4c50";
       libraryHaskellDepends = [
         base bytestring containers directory haskell98 HaXml html HTTP mtl
         network old-locale old-time parsec plugins xhtml
       ];
       jailbreak = true;
       description = "Hascat Package";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hascat-setup" = callPackage
    ({ mkDerivation, base, directory, hascat-lib, hascat-system
     , haskell98, plugins
     }:
     mkDerivation {
       pname = "hascat-setup";
       version = "0.2";
       sha256 = "d16b5e3f9938b014f8efdeaa02db0182d3f722fcc4c465c108227b70b25f0a15";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory hascat-lib hascat-system haskell98 plugins
       ];
       executableHaskellDepends = [
         base directory hascat-lib hascat-system haskell98 plugins
       ];
       doHaddock = false;
       description = "Hascat Installation helper";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hascat-system" = callPackage
    ({ mkDerivation, base, bytestring, containers, hascat-lib, HaXml
     , HTTP, mtl, network, old-time, parsec, plugins, unix
     }:
     mkDerivation {
       pname = "hascat-system";
       version = "0.2";
       sha256 = "24351baec7d7fc3cb3815b0265695ff19f2dff9ef35f467bd19d664ac3b14bb9";
       libraryHaskellDepends = [
         base bytestring containers hascat-lib HaXml HTTP mtl network
         old-time parsec plugins unix
       ];
       jailbreak = true;
       description = "Hascat System Package";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hash" = callPackage
    ({ mkDerivation, base, bifunctors, bytestring, data-default
     , directory, doctest, filepath, generic-deriving, hashable, lens
     , transformers
     }:
     mkDerivation {
       pname = "hash";
       version = "0.2.0.1";
       sha256 = "3d8b7d07109319bc9149342758072764a4c87da7daee3e9e22fa993fef8f46cd";
       libraryHaskellDepends = [
         base bifunctors bytestring data-default generic-deriving hashable
         lens transformers
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/analytics/hash/";
       description = "Hashing tools";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hashable_1_2_3_0" = callPackage
    ({ mkDerivation, base, bytestring, ghc-prim, HUnit, integer-gmp
     , QuickCheck, random, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, unix
     }:
     mkDerivation {
       pname = "hashable";
       version = "1.2.3.0";
       sha256 = "1187b0bc519f45b0135e8ca3ca72f4b513fdb637b78761ad2c5cc82ff97d5309";
       revision = "1";
       editedCabalFile = "3183c85fe1c95e081310edc99c02fc80d98c9564e609d8f2a17d82d5fe26d8c4";
       libraryHaskellDepends = [
         base bytestring ghc-prim integer-gmp text
       ];
       testHaskellDepends = [
         base bytestring ghc-prim HUnit QuickCheck random test-framework
         test-framework-hunit test-framework-quickcheck2 text unix
       ];
       doHaddock = false;
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hashable_1_2_3_1" = callPackage
    ({ mkDerivation, base, bytestring, ghc-prim, HUnit, integer-gmp
     , QuickCheck, random, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, unix
     }:
     mkDerivation {
       pname = "hashable";
       version = "1.2.3.1";
       sha256 = "d5bf53df132e56671a3a4533c89324b327e1b47181b3961cffa87f5aea6f7af9";
       revision = "1";
       editedCabalFile = "1a0ab790d0a0f8ebcd927333d0924ff01e04f65b0ed6f37d186854e0d6dbb1ce";
       libraryHaskellDepends = [
         base bytestring ghc-prim integer-gmp text
       ];
       testHaskellDepends = [
         base bytestring ghc-prim HUnit QuickCheck random test-framework
         test-framework-hunit test-framework-quickcheck2 text unix
       ];
       doHaddock = false;
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hashable_1_2_3_2" = callPackage
    ({ mkDerivation, base, bytestring, ghc-prim, HUnit, integer-gmp
     , QuickCheck, random, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, unix
     }:
     mkDerivation {
       pname = "hashable";
       version = "1.2.3.2";
       sha256 = "8c66fc70f75c5e1eaa8278c2c624a8cf5a73d5127df1cb2956eb69b16f492241";
       libraryHaskellDepends = [
         base bytestring ghc-prim integer-gmp text
       ];
       testHaskellDepends = [
         base bytestring ghc-prim HUnit QuickCheck random test-framework
         test-framework-hunit test-framework-quickcheck2 text unix
       ];
       homepage = "http://github.com/tibbe/hashable";
       description = "A class for types that can be converted to a hash value";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hashable_1_2_3_3" = callPackage
    ({ mkDerivation, base, bytestring, ghc-prim, HUnit, integer-gmp
     , QuickCheck, random, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, unix
     }:
     mkDerivation {
       pname = "hashable";
       version = "1.2.3.3";
       sha256 = "fc923f7d1fdc0062416a61f6ab96b4e1958e1aee1ddf1c71fa2cc6d08154e44e";
       revision = "2";
       editedCabalFile = "abaa1b40915bdb6b825db78b8db5d375365c6dc0e0d94cc1e47a20d1aa7b8712";
       libraryHaskellDepends = [
         base bytestring ghc-prim integer-gmp text
       ];
       testHaskellDepends = [
         base bytestring ghc-prim HUnit QuickCheck random test-framework
         test-framework-hunit test-framework-quickcheck2 text unix
       ];
       homepage = "http://github.com/tibbe/hashable";
       description = "A class for types that can be converted to a hash value";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hashable" = callPackage
    ({ mkDerivation, base, bytestring, ghc-prim, HUnit, integer-gmp
     , QuickCheck, random, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, unix
     }:
     mkDerivation {
       pname = "hashable";
       version = "1.2.4.0";
       sha256 = "fb9671db0c39cd48d38e2e13e3352e2bf7dfa6341edfe68789a1753d21bb3cf3";
       libraryHaskellDepends = [
         base bytestring ghc-prim integer-gmp text
       ];
       testHaskellDepends = [
         base bytestring ghc-prim HUnit QuickCheck random test-framework
         test-framework-hunit test-framework-quickcheck2 text unix
       ];
       homepage = "http://github.com/tibbe/hashable";
       description = "A class for types that can be converted to a hash value";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hashable-extras_0_2_0_1" = callPackage
    ({ mkDerivation, base, bifunctors, bytestring, directory, doctest
     , filepath, generic-deriving, hashable, transformers
     }:
     mkDerivation {
       pname = "hashable-extras";
       version = "0.2.0.1";
       sha256 = "fa3cb5ececbf4b80d985da548a70587b69c76305795a9ceca1fad47839a8c227";
       revision = "1";
       editedCabalFile = "0797bee08c6190172fa48ce7f2821160efcd26f9fcf2afce08ea64737c1aef7d";
       libraryHaskellDepends = [
         base bifunctors bytestring generic-deriving hashable transformers
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/analytics/hashable-extras/";
       description = "Higher-rank Hashable";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hashable-extras_0_2_1" = callPackage
    ({ mkDerivation, base, bifunctors, bytestring, directory, doctest
     , filepath, generic-deriving, hashable, transformers
     }:
     mkDerivation {
       pname = "hashable-extras";
       version = "0.2.1";
       sha256 = "b4d66d07cc5c4459e131d1654ad17237c07c653c5d7dace04e2d026dbd731f0a";
       libraryHaskellDepends = [
         base bifunctors bytestring generic-deriving hashable transformers
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/analytics/hashable-extras/";
       description = "Higher-rank Hashable";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hashable-extras_0_2_2" = callPackage
    ({ mkDerivation, base, bifunctors, bytestring, directory, doctest
     , filepath, hashable, transformers
     }:
     mkDerivation {
       pname = "hashable-extras";
       version = "0.2.2";
       sha256 = "2bb0c9d1d75fd23cc75105d15fd3151404814d4a50100c9472417774ec101485";
       libraryHaskellDepends = [
         base bifunctors bytestring hashable transformers
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/analytics/hashable-extras/";
       description = "Higher-rank Hashable";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hashable-extras" = callPackage
    ({ mkDerivation, base, bifunctors, bytestring, directory, doctest
     , filepath, hashable, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "hashable-extras";
       version = "0.2.3";
       sha256 = "03e0303a50e265d8682402152c90e199d0f4685a1e553bf20a380652d6f06b6a";
       libraryHaskellDepends = [
         base bifunctors bytestring hashable transformers
         transformers-compat
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/analytics/hashable-extras/";
       description = "Higher-rank Hashable";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hashable-generics" = callPackage
    ({ mkDerivation, base, ghc-prim, hashable, QuickCheck
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "hashable-generics";
       version = "1.1.8";
       sha256 = "183a77fec48044d66fcd872383bc5c461fefd23d6eb954b7d4508caf1525b1d0";
       libraryHaskellDepends = [ base ghc-prim hashable ];
       testHaskellDepends = [
         base ghc-prim hashable QuickCheck test-framework
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/wowus/hashable-generics";
       description = "Automatically generates Hashable instances with GHC.Generics.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hashable-time" = callPackage
    ({ mkDerivation, base, hashable, time }:
     mkDerivation {
       pname = "hashable-time";
       version = "0.2";
       sha256 = "97b722ab467fae0d499de91bfaf3d6e346c7c1cac126796f0031aee5dbfe2b0a";
       revision = "1";
       editedCabalFile = "b925aba56f1b9a5a1952fae307eaf8ee653293b68651d3807c3852dc4c771d35";
       libraryHaskellDepends = [ base hashable time ];
       description = "Hashable instances for Data.Time";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hashabler" = callPackage
    ({ mkDerivation, array, base, bytestring, ghc-prim, integer-gmp
     , primitive, template-haskell, text
     }:
     mkDerivation {
       pname = "hashabler";
       version = "1.2.1";
       sha256 = "dbe4b8698748642afe6441b533fcde55d2c467557a86fe47700544841c4f13f5";
       libraryHaskellDepends = [
         array base bytestring ghc-prim integer-gmp primitive
         template-haskell text
       ];
       homepage = "https://github.com/jberryman/hashabler";
       description = "Principled, portable & extensible hashing of data and types, including an implementation of the FNV-1a and SipHash algorithms";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hashed-storage" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, dataenc
     , directory, extensible-exceptions, filepath, mmap, mtl, zlib
     }:
     mkDerivation {
       pname = "hashed-storage";
       version = "0.5.11";
       sha256 = "734b5e91081e355384f86fdd67f242e095e8c5196b182a62cc996fdabdb21569";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers dataenc directory
         extensible-exceptions filepath mmap mtl zlib
       ];
       description = "Hashed file storage support code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hashids" = callPackage
    ({ mkDerivation, base, bytestring, containers, split }:
     mkDerivation {
       pname = "hashids";
       version = "1.0.2.2";
       sha256 = "989d7d1f50738c664230629b3e43340c929d5995ab978837748a5cc22aaaf308";
       libraryHaskellDepends = [ base bytestring containers split ];
       testHaskellDepends = [ base bytestring containers split ];
       homepage = "http://hashids.org/";
       description = "Hashids generates short, unique, non-sequential ids from numbers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hashmap" = callPackage
    ({ mkDerivation, base, containers, deepseq, hashable }:
     mkDerivation {
       pname = "hashmap";
       version = "1.3.0.1";
       sha256 = "99cb18be6c5332d4641ea2a8c435d47f9e3f1f5c94c8fc5e45c101bc72a04c9b";
       libraryHaskellDepends = [ base containers deepseq hashable ];
       homepage = "http://git.auryn.cz/haskell/hashmap/";
       description = "Persistent containers Map and Set based on hashing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hashring" = callPackage
    ({ mkDerivation, base, containers, hashable, QuickCheck
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "hashring";
       version = "0.0.0";
       sha256 = "320595f4c3df4d855197fb23d3b27f6a92b3538aebcde8514f273f0fbc8a0917";
       libraryHaskellDepends = [ base containers hashable ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/mkscrg/hashring";
       description = "Efficient consistent hashing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hashtables_1_1_2_1" = callPackage
    ({ mkDerivation, base, ghc-prim, hashable, primitive, vector }:
     mkDerivation {
       pname = "hashtables";
       version = "1.1.2.1";
       sha256 = "c50d910fea2e81eca53d9a2dfbc925246be5b7cc2d0854c6d9e95eaab05ac684";
       libraryHaskellDepends = [
         base ghc-prim hashable primitive vector
       ];
       homepage = "http://github.com/gregorycollins/hashtables";
       description = "Mutable hash tables in the ST monad";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hashtables_1_2_0_1" = callPackage
    ({ mkDerivation, base, ghc-prim, hashable, primitive, vector }:
     mkDerivation {
       pname = "hashtables";
       version = "1.2.0.1";
       sha256 = "329d700e716b18a2cf1a75669104da3a773091a7e441c5470c202d4c439bf0fc";
       libraryHaskellDepends = [
         base ghc-prim hashable primitive vector
       ];
       homepage = "http://github.com/gregorycollins/hashtables";
       description = "Mutable hash tables in the ST monad";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hashtables_1_2_0_2" = callPackage
    ({ mkDerivation, base, ghc-prim, hashable, primitive, vector }:
     mkDerivation {
       pname = "hashtables";
       version = "1.2.0.2";
       sha256 = "012be9fa5e91118b9301ca58138fbf45222119a284d5561ca6f7e3f9b42e1837";
       libraryHaskellDepends = [
         base ghc-prim hashable primitive vector
       ];
       homepage = "http://github.com/gregorycollins/hashtables";
       description = "Mutable hash tables in the ST monad";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hashtables" = callPackage
    ({ mkDerivation, base, ghc-prim, hashable, primitive, vector }:
     mkDerivation {
       pname = "hashtables";
       version = "1.2.1.0";
       sha256 = "ef5122c8f3b72d1e817a4f2adb410ad88b30818934a276b7184790697f4fdcac";
       libraryHaskellDepends = [
         base ghc-prim hashable primitive vector
       ];
       homepage = "http://github.com/gregorycollins/hashtables";
       description = "Mutable hash tables in the ST monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hashtables-plus" = callPackage
    ({ mkDerivation, base, hashable, hashtables, loch-th, placeholders
     }:
     mkDerivation {
       pname = "hashtables-plus";
       version = "0.2.0";
       sha256 = "871e368990821dcddbd85f2247894ca0c0e5392647ea5a39f0d18c5702ab323d";
       libraryHaskellDepends = [
         base hashable hashtables loch-th placeholders
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/hashtables-plus";
       description = "Extensions for a \"hashtables\" library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hasim" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "hasim";
       version = "0.1.2";
       sha256 = "f6a074bbc8ed8483a5e859608b349e2f13fcaa581c4bf85c53076a900509960f";
       libraryHaskellDepends = [ base containers mtl ];
       homepage = "http://huygens.functor.nl/hasim/";
       description = "Process-Based Discrete Event Simulation library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hask" = callPackage
    ({ mkDerivation, base, constraints, ghc-prim, reflection, tagged
     , transformers, void
     }:
     mkDerivation {
       pname = "hask";
       version = "0";
       sha256 = "69ac3c6296c1a70e7f856e43a3415376631e4c5ec4c506e9f2d4deee549707b1";
       revision = "1";
       editedCabalFile = "04abcba45a7fbaa11d7f3bd9834f1e70a30f356ae871e59ab472f20d4cd60026";
       libraryHaskellDepends = [
         base constraints ghc-prim reflection tagged transformers void
       ];
       homepage = "http://github.com/ekmett/hask";
       description = "Categories";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hask-home" = callPackage
    ({ mkDerivation, base, Cabal, directory, hmarkup, hsemail, network
     , parsec, process, regex-compat, xhtml
     }:
     mkDerivation {
       pname = "hask-home";
       version = "2009.3.18";
       sha256 = "284c981fceb7bb04a9660e380fdf74d536097b155934c9b75d5b32ef439b1089";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal directory hmarkup hsemail network parsec process
         regex-compat xhtml
       ];
       homepage = "http://gregheartsfield.com/hask-home";
       description = "Generate homepages for cabal packages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskades" = callPackage
    ({ mkDerivation, base, bytestring, containers, errors, haskell-src
     , text, text-format
     }:
     mkDerivation {
       pname = "haskades";
       version = "0.2.1";
       sha256 = "e61a06335d1a8899656aefa24439b06715e20db30f997a322ee6adfedfa78fa5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers errors haskell-src text text-format
       ];
       homepage = "http://github.com/singpolyma/haskades";
       description = "Utility to generate bindings for BlackBerry Cascades";
       license = "unknown";
     }) {};

  "haskakafka" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, containers, either-unwrap
     , hspec, rdkafka, regex-posix, temporary, unix
     }:
     mkDerivation {
       pname = "haskakafka";
       version = "1.0.0";
       sha256 = "67426843d25b9f16d6cea9a62859b2052d3a965810c0c19b7f215d1a428c3b48";
       libraryHaskellDepends = [
         base bytestring containers temporary unix
       ];
       librarySystemDepends = [ rdkafka ];
       libraryToolDepends = [ c2hs ];
       testHaskellDepends = [
         base bytestring containers either-unwrap hspec regex-posix
       ];
       homepage = "http://github.com/cosbynator/haskakafka";
       description = "Kafka bindings for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) rdkafka;};

  "haskanoid" = callPackage
    ({ mkDerivation, base, freenect, hcwiid, IfElse, MissingH, mtl, SDL
     , SDL-image, SDL-mixer, SDL-ttf, transformers, vector, Yampa
     }:
     mkDerivation {
       pname = "haskanoid";
       version = "0.1.5";
       sha256 = "2a2270b3e941ec942c7d12f641bcf651895f42341514759b1edb77390d205ecc";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base freenect hcwiid IfElse MissingH mtl SDL SDL-image SDL-mixer
         SDL-ttf transformers vector Yampa
       ];
       homepage = "http://github.com/ivanperez-keera/haskanoid";
       description = "A breakout game written in Yampa using SDL";
       license = "unknown";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "haskarrow" = callPackage
    ({ mkDerivation, base, cmdargs, containers, cpphs, directory
     , her-lexer, split
     }:
     mkDerivation {
       pname = "haskarrow";
       version = "0.0";
       sha256 = "3eeee1ec757fe1249a4e0af0df3df199c44a93975b09603959543e1b2d068906";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs containers cpphs directory her-lexer split
       ];
       description = "A dialect of haskell with order of execution based on dependency resolution";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskbot-core" = callPackage
    ({ mkDerivation, aeson, base, bytestring, connection, containers
     , hspec, http-conduit, http-types, monads-tf, stm, text, wai, warp
     }:
     mkDerivation {
       pname = "haskbot-core";
       version = "0.1";
       sha256 = "e4fc1b4a03cad870dd42a564d3902cd6ceec0a8d8e2ca1413069ed27de93982a";
       libraryHaskellDepends = [
         aeson base bytestring connection containers http-conduit http-types
         monads-tf stm text wai warp
       ];
       testHaskellDepends = [
         aeson base bytestring connection containers hspec http-conduit
         http-types monads-tf stm text wai warp
       ];
       jailbreak = true;
       homepage = "https://github.com/jonplussed/haskbot-core";
       description = "Easily-extensible chatbot for Slack messaging service";
       license = stdenv.lib.licenses.mit;
     }) {};

  "haskdeep" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, bytestring
     , cereal, conduit, conduit-combinators, conduit-extra, containers
     , crypto-api, crypto-conduit, cryptohash, cryptohash-cryptoapi
     , directory, filepath, optparse-applicative, regex-tdfa
     , regex-tdfa-text, resourcet, text, time, transformers, unix-compat
     }:
     mkDerivation {
       pname = "haskdeep";
       version = "0.2.0.1";
       sha256 = "7d179798dc1da77a07b9969c9e11ceb5d4a93fe692f20f30c7d6379a3a4f9d59";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base16-bytestring bytestring cereal conduit
         conduit-combinators conduit-extra containers crypto-api
         crypto-conduit cryptohash cryptohash-cryptoapi directory filepath
         optparse-applicative regex-tdfa regex-tdfa-text resourcet text time
         transformers unix-compat
       ];
       jailbreak = true;
       homepage = "https://github.com/maurotrb/haskdeep";
       description = "Computes and audits file hashes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskdogs" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , optparse-applicative, process, text
     }:
     mkDerivation {
       pname = "haskdogs";
       version = "0.4.4";
       sha256 = "7bd450caafb4220aa6e0e86bd4a03815d8a903204f2bb79fb89a60e3a6902d5c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory filepath optparse-applicative
         process text
       ];
       homepage = "http://github.com/grwlf/haskdogs";
       description = "Generate tags file for Haskell project and its nearest deps";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskeem" = callPackage
    ({ mkDerivation, base, containers, directory, haskeline, haskell98
     , mtl, network, old-time, parsec, process, random, unix
     }:
     mkDerivation {
       pname = "haskeem";
       version = "0.7.16";
       sha256 = "d60c34634579508f8e875d3e4c1fd63eb07baf1b657a4f5c5ab72b81a3a2af3a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory haskeline haskell98 mtl network old-time
         parsec process random unix
       ];
       homepage = "http://www.korgwal.com/haskeem/";
       description = "A small scheme interpreter";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskeline_0_7_2_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , terminfo, transformers, unix
     }:
     mkDerivation {
       pname = "haskeline";
       version = "0.7.2.1";
       sha256 = "ae56a3c8ead8e33492e01921452db441568236c70df2a4f9086b08678ddf6427";
       configureFlags = [ "-fterminfo" ];
       libraryHaskellDepends = [
         base bytestring containers directory filepath terminfo transformers
         unix
       ];
       homepage = "http://trac.haskell.org/haskeline";
       description = "A command-line interface for user input, written in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskeline_0_7_2_2" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , terminfo, transformers, unix
     }:
     mkDerivation {
       pname = "haskeline";
       version = "0.7.2.2";
       sha256 = "7655f5850ad013b2e4eee637685029bcce79210180df3a61a88f8626ddde9281";
       configureFlags = [ "-fterminfo" ];
       libraryHaskellDepends = [
         base bytestring containers directory filepath terminfo transformers
         unix
       ];
       homepage = "http://trac.haskell.org/haskeline";
       description = "A command-line interface for user input, written in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskeline-class" = callPackage
    ({ mkDerivation, base, haskeline, mtl }:
     mkDerivation {
       pname = "haskeline-class";
       version = "0.6.2";
       sha256 = "d4d55f005b13e98a83273e8a7648a2a54e638b36c31639bff38c09febac0ed75";
       libraryHaskellDepends = [ base haskeline mtl ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~aslatter/code/haskeline-class";
       description = "Class interface for working with Haskeline";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-aliyun" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, basic-prelude
     , blaze-builder, bytestring, case-insensitive, conduit, Crypto
     , data-default, http-conduit, http-types, lifted-base
     , monad-control, old-locale, resourcet, safe, system-filepath, text
     , time, transformers, transformers-base, vector, xml2json
     }:
     mkDerivation {
       pname = "haskell-aliyun";
       version = "0.1.0.0";
       sha256 = "8a1cb84f31013ddda1ffcfa11dce3c45dbc8cb444537537d4dd80f97d5a1a1c5";
       libraryHaskellDepends = [
         aeson base base64-bytestring basic-prelude blaze-builder bytestring
         case-insensitive conduit Crypto data-default http-conduit
         http-types lifted-base monad-control old-locale resourcet safe
         system-filepath text time transformers transformers-base vector
         xml2json
       ];
       homepage = "https://github.com/yihuang/haskell-aliyun/";
       description = "haskell client of aliyun service";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-awk" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, doctest
     , easy-file, exceptions, filepath, haskell-src-exts, hint, hspec
     , HUnit, mtl, network, process, stringsearch, temporary
     , test-framework, test-framework-hunit, time, transformers
     }:
     mkDerivation {
       pname = "haskell-awk";
       version = "1.1.1";
       sha256 = "ed7d04bef1156ee5c76f91100579f95c1eb89979f7238ad2d59c0b88b5fbdb68";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers stringsearch
       ];
       executableHaskellDepends = [
         base bytestring containers directory easy-file exceptions filepath
         haskell-src-exts hint mtl network process stringsearch time
         transformers
       ];
       testHaskellDepends = [
         base bytestring containers directory doctest easy-file exceptions
         filepath haskell-src-exts hint hspec HUnit mtl network process
         stringsearch temporary test-framework test-framework-hunit time
         transformers
       ];
       description = "Transform text from the command-line using Haskell expressions";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-bcrypt" = callPackage
    ({ mkDerivation, base, bytestring, QuickCheck, random }:
     mkDerivation {
       pname = "haskell-bcrypt";
       version = "0.3.2";
       sha256 = "427c3f95a0b9e3bd53a8d4b17b5f44bf3656ae1d5cfa93e48f2be85e6ea48a5a";
       libraryHaskellDepends = [ base bytestring ];
       testHaskellDepends = [ base bytestring QuickCheck random ];
       homepage = "http://www.github.com/zbskii/haskell-bcrypt";
       description = "A bcrypt implementation for haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-brainfuck" = callPackage
    ({ mkDerivation, base, bytestring, mtl, parsec, QuickCheck, tasty
     , tasty-quickcheck, tasty-th
     }:
     mkDerivation {
       pname = "haskell-brainfuck";
       version = "0.1.0.1";
       sha256 = "284b4d5afd722e819eb1378b970be1dc6eae834309a811eb4d52021719b5d08b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring mtl parsec ];
       executableHaskellDepends = [ base bytestring ];
       testHaskellDepends = [
         base bytestring mtl QuickCheck tasty tasty-quickcheck tasty-th
       ];
       jailbreak = true;
       description = "BrainFuck interpreter";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-cnc" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , extensible-exceptions, ghc-prim, HSH, HUnit, MissingH, mtl
     , process, random, time, unix
     }:
     mkDerivation {
       pname = "haskell-cnc";
       version = "0.1.3.200";
       sha256 = "0d3627cb100946002de9af73310630f4f7782b6186bbc40bfa067bb57a933374";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers extensible-exceptions ghc-prim HSH
         HUnit MissingH mtl random time unix
       ];
       executableHaskellDepends = [ base directory process ];
       homepage = "http://software.intel.com/en-us/articles/intel-concurrent-collections-for-cc/";
       description = "Library for parallel programming in the Intel Concurrent Collections paradigm";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-coffee" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "haskell-coffee";
       version = "0.1.0.2";
       sha256 = "674eb2c80b5b88ca9f571b5d025620508b4d1f164878a512dac3f680fd24e9c7";
       libraryHaskellDepends = [ base process ];
       description = "Simple CoffeeScript API";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "haskell-compression" = callPackage
    ({ mkDerivation, base, bimap, boolean-list, bytestring, containers
     }:
     mkDerivation {
       pname = "haskell-compression";
       version = "0.1.1";
       sha256 = "3504d935a6ab3f881a888da0d71a8f139769411ade8e0134a0ba296ae8741934";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bimap boolean-list bytestring containers
       ];
       executableHaskellDepends = [
         base bimap boolean-list bytestring containers
       ];
       homepage = "codekinder.com";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskell-course-preludes" = callPackage
    ({ mkDerivation, base, deepseq }:
     mkDerivation {
       pname = "haskell-course-preludes";
       version = "0.0.0.4";
       sha256 = "567eaa088b72851edf306ade995cafade1ec6e47ff81c32d66f96bcdba821be4";
       libraryHaskellDepends = [ base deepseq ];
       jailbreak = true;
       description = "Small modules for a Haskell course in which Haskell is taught by implementing Prelude functionality";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-docs" = callPackage
    ({ mkDerivation, aeson, base, base16-bytestring, bytestring, Cabal
     , containers, cryptohash, directory, filepath, ghc, ghc-paths
     , haddock-api, haddock-library, monad-loops, process, text
     , unordered-containers
     }:
     mkDerivation {
       pname = "haskell-docs";
       version = "4.2.6";
       sha256 = "729293f120ddaacab6814f8c6735e3f9ca9fd88c2453e2b887f5a806cd4dbeba";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base16-bytestring bytestring Cabal containers cryptohash
         directory filepath ghc ghc-paths haddock-api haddock-library
         monad-loops process text unordered-containers
       ];
       executableHaskellDepends = [ base ghc text ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/chrisdone/haskell-docs";
       description = "A program to find and display the docs and type of a name";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskell-exp-parser" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "haskell-exp-parser";
       version = "0.1.1";
       sha256 = "a53cfae87b679f24b5c0a14a72be35760525bcad28b2fc0c870c19c09f2f975c";
       libraryHaskellDepends = [ base template-haskell ];
       testHaskellDepends = [ base template-haskell ];
       homepage = "https://github.com/emilaxelsson/haskell-exp-parser";
       description = "Simple parser parser from Haskell to TemplateHaskell expressions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskell-formatter" = callPackage
    ({ mkDerivation, base, containers, directory, directory-tree
     , doctest, filemanip, filepath, haskell-src-exts, hlint
     , optparse-applicative, scientific, tasty, tasty-hunit, text
     , unordered-containers, yaml
     }:
     mkDerivation {
       pname = "haskell-formatter";
       version = "1.0.0";
       sha256 = "eb9c24f60e59b87ac111ce0078a2fec5f53ee30d65aa577508d6def14e692c57";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers haskell-src-exts scientific text
         unordered-containers yaml
       ];
       executableHaskellDepends = [
         base directory filepath optparse-applicative
       ];
       testHaskellDepends = [
         base containers directory-tree doctest filemanip filepath hlint
         tasty tasty-hunit
       ];
       jailbreak = true;
       homepage = "https://github.com/evolutics/haskell-formatter";
       description = "Haskell source code formatter";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-ftp" = callPackage
    ({ mkDerivation, base, basic-prelude, bytestring, case-insensitive
     , conduit, directory, lifted-base, monad-control, network
     , network-conduit, process-conduit, system-filepath, text
     , transformers, transformers-base, unix
     }:
     mkDerivation {
       pname = "haskell-ftp";
       version = "0.1.0.1";
       sha256 = "372a4ccca765c0ce7ce3251233abe70c8d92743380973904de0f0f830b9c661c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base basic-prelude bytestring case-insensitive conduit directory
         lifted-base monad-control network network-conduit process-conduit
         system-filepath text transformers transformers-base unix
       ];
       executableHaskellDepends = [
         base basic-prelude bytestring case-insensitive conduit directory
         lifted-base monad-control network network-conduit process-conduit
         system-filepath text transformers transformers-base unix
       ];
       jailbreak = true;
       homepage = "https://github.com/yihuang/haskell-ftp";
       description = "A Haskell ftp server with configurable backend";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-generate" = callPackage
    ({ mkDerivation, base, containers, directory, doctest, filepath
     , haskell-src-exts, template-haskell, transformers
     }:
     mkDerivation {
       pname = "haskell-generate";
       version = "0.2.4";
       sha256 = "5ee6043024baf2cf79be13505e51f8ec3dab6aacb64df2ebb62f385ecf1b0c88";
       libraryHaskellDepends = [
         base containers haskell-src-exts template-haskell transformers
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/bennofs/haskell-generate/";
       description = "Typesafe generation of haskell source code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-gi" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory
     , file-embed, filepath, free, glib, gobjectIntrospection
     , haskell-gi-base, mtl, pretty-show, process, safe, text
     , transformers, xdg-basedir, xml-conduit
     }:
     mkDerivation {
       pname = "haskell-gi";
       version = "0.12";
       sha256 = "6d9f041a551dec6d557fa51a59fb7cbb01abbda82f5768146a9fd9b1b954b154";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory file-embed filepath free
         haskell-gi-base mtl pretty-show process safe text transformers
         xdg-basedir xml-conduit
       ];
       executablePkgconfigDepends = [ glib gobjectIntrospection ];
       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) gobjectIntrospection;};

  "haskell-gi-base" = callPackage
    ({ mkDerivation, base, bytestring, containers, glib, text
     , transformers
     }:
     mkDerivation {
       pname = "haskell-gi-base";
       version = "0.12";
       sha256 = "3f6fc64b2c878ebc1856f917fccb18dd6c990bd115019b851c96f121442ec8f7";
       libraryHaskellDepends = [
         base bytestring containers text transformers
       ];
       libraryPkgconfigDepends = [ glib ];
       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-import-graph" = callPackage
    ({ mkDerivation, base, classy-prelude, ghc, graphviz, process, text
     , transformers
     }:
     mkDerivation {
       pname = "haskell-import-graph";
       version = "1.0.0";
       sha256 = "af555336b7e734dae263e5f68b439d6c4234d7b2da493917fadfe132a7034dee";
       revision = "1";
       editedCabalFile = "4c2ba0b2c6d5649842b1f124e4183662cdc4db66810017775ce450cf84223d50";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base classy-prelude ghc graphviz process text transformers
       ];
       executableHaskellDepends = [ base ];
       description = "create haskell import graph for graphviz";
       license = stdenv.lib.licenses.mit;
     }) {};

  "haskell-in-space" = callPackage
    ({ mkDerivation, base, HGL, random }:
     mkDerivation {
       pname = "haskell-in-space";
       version = "0.1.1";
       sha256 = "e4887aa03e55a4fc4357b50a8fc24514ff750805a42ceca9f2c901d5872e9fe5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base HGL random ];
       homepage = "http://www.informatik.uni-bremen.de/~cxl/lehre/pi3.ws01/asteroids/";
       description = "'Asteroids' arcade games";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-lexer" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "haskell-lexer";
       version = "1.0";
       sha256 = "86d0c4071295c8613eb965768cb61a0c8422fc0c429a49c7a93e93a72b185b86";
       libraryHaskellDepends = [ base ];
       description = "A fully compliant Haskell 98 lexer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskell-modbus" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, hspec }:
     mkDerivation {
       pname = "haskell-modbus";
       version = "0.3.2";
       sha256 = "ce3f139ca327ebec546ceecd48995063d6902f79c2e29ea6ca091482dee16c21";
       libraryHaskellDepends = [ array base bytestring cereal ];
       testHaskellDepends = [ array base bytestring cereal hspec ];
       homepage = "http://www.github.com/jhickner/haskell-modbus";
       description = "A cereal-based parser for the Modbus protocol";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskell-mpfr" = callPackage
    ({ mkDerivation, base, ghc-prim, integer-gmp }:
     mkDerivation {
       pname = "haskell-mpfr";
       version = "0.1";
       sha256 = "9bd1ddbdff533479d69fb5a94a018aea93a5578c2be70446595f87f6b41172ad";
       libraryHaskellDepends = [ base ghc-prim integer-gmp ];
       jailbreak = true;
       homepage = "http://github.com/comius/haskell-mpfr";
       description = "Correctly-rounded arbitrary-precision floating-point arithmetic";
       license = "LGPL";
     }) {};

  "haskell-mpi" = callPackage
    ({ mkDerivation, array, base, bytestring, c2hs, cereal
     , extensible-exceptions, open-pal, open-rte, openmpi
     }:
     mkDerivation {
       pname = "haskell-mpi";
       version = "1.4.0";
       sha256 = "c0aa02ffe77d4a39d5b33e3f846e7615c78b2ddfb6b36c9cdec335edb79488ab";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cereal extensible-exceptions
       ];
       librarySystemDepends = [ open-pal open-rte openmpi ];
       libraryToolDepends = [ c2hs ];
       executableSystemDepends = [ open-pal open-rte openmpi ];
       executableToolDepends = [ c2hs ];
       homepage = "http://github.com/bjpop/haskell-mpi";
       description = "Distributed parallel programming in Haskell using MPI";
       license = stdenv.lib.licenses.bsd3;
     }) {open-pal = null; open-rte = null; inherit (pkgs) openmpi;};

  "haskell-names_0_4_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
     , data-lens-light, filemanip, filepath, haskell-packages
     , haskell-src-exts, hse-cpp, mtl, pretty-show, tagged, tasty
     , tasty-golden, transformers, traverse-with-class, type-eq
     , uniplate, utf8-string
     }:
     mkDerivation {
       pname = "haskell-names";
       version = "0.4.1";
       sha256 = "88ba49cdaf96d4e194e7ff816ffde28de3ba0883d07daccf7927d8a349c16efe";
       revision = "1";
       editedCabalFile = "d4674b37ad9690fec8dffd7311c6f27d6785a09914fbe1ceaa4103d05e73f741";
       libraryHaskellDepends = [
         aeson base bytestring Cabal containers data-lens-light filepath
         haskell-packages haskell-src-exts hse-cpp mtl tagged transformers
         traverse-with-class type-eq uniplate
       ];
       testHaskellDepends = [
         aeson base bytestring Cabal containers filemanip filepath
         haskell-packages haskell-src-exts hse-cpp mtl pretty-show tagged
         tasty tasty-golden traverse-with-class uniplate utf8-string
       ];
       jailbreak = true;
       homepage = "http://documentup.com/haskell-suite/haskell-names";
       description = "Name resolution library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-names_0_5_2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
     , data-lens-light, filemanip, filepath, haskell-packages
     , haskell-src-exts, hse-cpp, mtl, pretty-show, tagged, tasty
     , tasty-golden, transformers, traverse-with-class, type-eq
     , uniplate, utf8-string
     }:
     mkDerivation {
       pname = "haskell-names";
       version = "0.5.2";
       sha256 = "eea76fb3c979cf2f5afb87beb8a4b1df6d5536ef7da8d48df79d4ea6dc18bb37";
       revision = "1";
       editedCabalFile = "4f45a86d9e262be3e9d08172072d57ddbcd6d6512923d0dfab26091811737c01";
       libraryHaskellDepends = [
         aeson base bytestring Cabal containers data-lens-light filepath
         haskell-packages haskell-src-exts hse-cpp mtl tagged transformers
         traverse-with-class type-eq uniplate
       ];
       testHaskellDepends = [
         aeson base bytestring Cabal containers filemanip filepath
         haskell-packages haskell-src-exts hse-cpp mtl pretty-show tagged
         tasty tasty-golden traverse-with-class uniplate utf8-string
       ];
       jailbreak = true;
       homepage = "http://documentup.com/haskell-suite/haskell-names";
       description = "Name resolution library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-names_0_5_3" = callPackage
    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
     , data-lens-light, filemanip, filepath, haskell-packages
     , haskell-src-exts, hse-cpp, mtl, pretty-show, tagged, tasty
     , tasty-golden, transformers, traverse-with-class, type-eq
     , uniplate, utf8-string
     }:
     mkDerivation {
       pname = "haskell-names";
       version = "0.5.3";
       sha256 = "5517fc1e5d1c78a004b3b9d6f4ef8485c3f64b3227551bafb60836fa3081d518";
       revision = "1";
       editedCabalFile = "43a54712a54882de18c56c15e1a10a4d28ddf7d5269f194c214d322c976e4851";
       libraryHaskellDepends = [
         aeson base bytestring Cabal containers data-lens-light filepath
         haskell-packages haskell-src-exts hse-cpp mtl tagged transformers
         traverse-with-class type-eq uniplate
       ];
       testHaskellDepends = [
         aeson base bytestring Cabal containers filemanip filepath
         haskell-packages haskell-src-exts hse-cpp mtl pretty-show tagged
         tasty tasty-golden traverse-with-class uniplate utf8-string
       ];
       jailbreak = true;
       homepage = "http://documentup.com/haskell-suite/haskell-names";
       description = "Name resolution library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-names" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , data-lens-light, filemanip, filepath, haskell-src-exts, mtl
     , pretty-show, tasty, tasty-golden, transformers
     , traverse-with-class, uniplate
     }:
     mkDerivation {
       pname = "haskell-names";
       version = "0.6.0";
       sha256 = "8d45dabf15d4073a94f5d634538288dbac6ace1971b673cafc76ea92671bb26a";
       libraryHaskellDepends = [
         aeson base bytestring containers data-lens-light filepath
         haskell-src-exts mtl transformers traverse-with-class uniplate
       ];
       testHaskellDepends = [
         base containers filemanip filepath haskell-src-exts mtl pretty-show
         tasty tasty-golden traverse-with-class
       ];
       homepage = "http://documentup.com/haskell-suite/haskell-names";
       description = "Name resolution library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-neo4j-client_0_3_1_4" = callPackage
    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
     , data-default, hashable, HTTP, http-conduit, http-types, HUnit
     , lifted-base, mtl, network-uri, QuickCheck, resourcet, scientific
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , test-framework-th, text, transformers, transformers-base
     , transformers-compat, unordered-containers, vector
     }:
     mkDerivation {
       pname = "haskell-neo4j-client";
       version = "0.3.1.4";
       sha256 = "26c2521dcd91dfb2fc09f5e3881c7e3a2eb440c59c2870d3f1323ee8f6c82a9c";
       libraryHaskellDepends = [
         aeson base bytestring containers data-default hashable HTTP
         http-conduit http-types lifted-base mtl network-uri resourcet
         scientific text transformers transformers-base transformers-compat
         unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bytestring Cabal data-default hashable HTTP http-conduit
         http-types HUnit lifted-base mtl network-uri QuickCheck resourcet
         scientific test-framework test-framework-hunit
         test-framework-quickcheck2 test-framework-th text transformers
         transformers-base transformers-compat unordered-containers vector
       ];
       doCheck = false;
       homepage = "https://github.com/asilvestre/haskell-neo4j-rest-client";
       description = "A Haskell neo4j client";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-neo4j-client_0_3_2_0" = callPackage
    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
     , data-default, hashable, HTTP, http-client, http-conduit
     , http-types, HUnit, lifted-base, mtl, network-uri, QuickCheck
     , resourcet, scientific, test-framework, test-framework-hunit
     , test-framework-quickcheck2, test-framework-th, text, transformers
     , transformers-base, transformers-compat, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "haskell-neo4j-client";
       version = "0.3.2.0";
       sha256 = "f561c0b4c7278ef84c6cfd8fc062e3f2764dc59939bf64667e0a6f589dc2ac85";
       libraryHaskellDepends = [
         aeson base bytestring containers data-default hashable HTTP
         http-client http-conduit http-types lifted-base mtl network-uri
         resourcet scientific text transformers transformers-base
         transformers-compat unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bytestring Cabal data-default hashable HTTP http-client
         http-conduit http-types HUnit lifted-base mtl network-uri
         QuickCheck resourcet scientific test-framework test-framework-hunit
         test-framework-quickcheck2 test-framework-th text transformers
         transformers-base transformers-compat unordered-containers vector
       ];
       doCheck = false;
       homepage = "https://github.com/asilvestre/haskell-neo4j-rest-client";
       description = "A Haskell neo4j client";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-neo4j-client" = callPackage
    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
     , data-default, hashable, HTTP, http-client, http-conduit
     , http-types, HUnit, lifted-base, mtl, network-uri, QuickCheck
     , resourcet, scientific, test-framework, test-framework-hunit
     , test-framework-quickcheck2, test-framework-th, text, transformers
     , transformers-base, transformers-compat, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "haskell-neo4j-client";
       version = "0.3.2.1";
       sha256 = "9485f69dee0c77ca08d51108188440a2696ef2ba08e7b45237fb38c523623d73";
       libraryHaskellDepends = [
         aeson base bytestring containers data-default hashable HTTP
         http-client http-conduit http-types lifted-base mtl network-uri
         resourcet scientific text transformers transformers-base
         transformers-compat unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bytestring Cabal data-default hashable HTTP http-client
         http-conduit http-types HUnit lifted-base mtl network-uri
         QuickCheck resourcet scientific test-framework test-framework-hunit
         test-framework-quickcheck2 test-framework-th text transformers
         transformers-base transformers-compat unordered-containers vector
       ];
       doCheck = false;
       homepage = "https://github.com/asilvestre/haskell-neo4j-rest-client";
       description = "A Haskell neo4j client";
       license = stdenv.lib.licenses.mit;
     }) {};

  "haskell-openflow" = callPackage
    ({ mkDerivation, base, bytestring, cereal, network, network-info }:
     mkDerivation {
       pname = "haskell-openflow";
       version = "0.0.0.1";
       sha256 = "6d56fb780b4f653dae59427e945fd73445b183f4610ef3c8f94a9e48f89e3fff";
       libraryHaskellDepends = [
         base bytestring cereal network network-info
       ];
       testHaskellDepends = [ base ];
       homepage = "https://github.com/brooksbp/haskell-openflow";
       description = "OpenFlow protocol in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-packages_0_2_4_3" = callPackage
    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
     , deepseq, directory, filepath, haskell-src-exts, hse-cpp, mtl
     , optparse-applicative, tagged, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "haskell-packages";
       version = "0.2.4.3";
       sha256 = "b637e294e6c0287e21fa7be3f9969e0e41324ccc9f0547b395d58e42ff2f3f68";
       revision = "1";
       editedCabalFile = "cb42e7c13a67332bff8ddac491fd50c8ef7069f3be863ce886ee807354fd0b04";
       libraryHaskellDepends = [
         aeson base bytestring Cabal containers deepseq directory filepath
         haskell-src-exts hse-cpp mtl optparse-applicative tagged
         transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://documentup.com/haskell-suite/haskell-packages";
       description = "Haskell suite library for package management and integration with Cabal";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-packages_0_2_4_4" = callPackage
    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
     , deepseq, directory, filepath, haskell-src-exts, hse-cpp, mtl
     , optparse-applicative, tagged, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "haskell-packages";
       version = "0.2.4.4";
       sha256 = "ec7f7ca903129ad5cd6c55b56818039790a3b0676c8ef78145247f3d77a291d8";
       revision = "1";
       editedCabalFile = "0d8b5e0dd102cc4c6aac5bc12e523d5c2ad94d981f33792b459d9373bb25c399";
       libraryHaskellDepends = [
         aeson base bytestring Cabal containers deepseq directory filepath
         haskell-src-exts hse-cpp mtl optparse-applicative tagged
         transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://documentup.com/haskell-suite/haskell-packages";
       description = "Haskell suite library for package management and integration with Cabal";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-packages" = callPackage
    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
     , deepseq, directory, filepath, haskell-src-exts, hse-cpp, mtl
     , optparse-applicative, tagged, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "haskell-packages";
       version = "0.3";
       sha256 = "4073cb3fe0c51d52a2d4e18f33091c68f3094326a0c381748e564834d1cb3aa5";
       libraryHaskellDepends = [
         aeson base bytestring Cabal containers deepseq directory filepath
         haskell-src-exts hse-cpp mtl optparse-applicative tagged
         transformers transformers-compat
       ];
       homepage = "http://documentup.com/haskell-suite/haskell-packages";
       description = "Haskell suite library for package management and integration with Cabal";
       license = stdenv.lib.licenses.mit;
     }) {};

  "haskell-pdf-presenter" = callPackage
    ({ mkDerivation, base, bytestring, cairo, containers, directory
     , filepath, glib, gtk, old-locale, poppler, template-haskell, time
     , zlib
     }:
     mkDerivation {
       pname = "haskell-pdf-presenter";
       version = "0.2.5";
       sha256 = "4317f7c11ff0f4e67734a42e24ba207846f31cb253908505dea853dbe8b1c387";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cairo containers directory filepath glib gtk
         old-locale poppler template-haskell time zlib
       ];
       jailbreak = true;
       homepage = "http://michaeldadams.org/projects/haskell-pdf-presenter/";
       description = "Tool for presenting PDF-based presentations";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-platform-test" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, Cabal, cgi
     , containers, deepseq, directory, extensible-exceptions, fgl
     , filepath, ghc, ghc-prim, GLUT, happy, haskell-src, haskell98, hpc
     , html, HTTP, HUnit, mtl, network, old-locale, old-time, OpenGL
     , parallel, parsec, pretty, process, QuickCheck, random, regex-base
     , regex-compat, regex-posix, stm, syb, template-haskell, time, unix
     , xhtml, zlib
     }:
     mkDerivation {
       pname = "haskell-platform-test";
       version = "2010.2.0.0";
       sha256 = "93af73125b9b9feb76a11d0ff6e333a6cba56f25f9a95841a546a5d9efad264e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring Cabal cgi containers deepseq directory
         extensible-exceptions fgl filepath ghc ghc-prim GLUT haskell-src
         haskell98 hpc html HTTP HUnit mtl network old-locale old-time
         OpenGL parallel parsec pretty process QuickCheck random regex-base
         regex-compat regex-posix stm syb template-haskell time unix xhtml
         zlib
       ];
       executableToolDepends = [ alex happy ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~dons/code/haskell-platform-test";
       description = "A test system for the Haskell Platform environment";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-plot" = callPackage
    ({ mkDerivation, base, Chart, Chart-cairo, Chart-gtk, colour
     , data-default, lens, math-functions, vector
     }:
     mkDerivation {
       pname = "haskell-plot";
       version = "0.1.0.0";
       sha256 = "f16e55085e33d192f24e15e11c110338b508217157c33f5362d02e3dfe148a37";
       libraryHaskellDepends = [
         base Chart Chart-cairo Chart-gtk colour data-default lens
         math-functions vector
       ];
       homepage = "https://github.com/kaizhang/haskell-plot";
       description = "A library for generating 2D plots painlessly";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-qrencode" = callPackage
    ({ mkDerivation, base, bytestring, qrencode }:
     mkDerivation {
       pname = "haskell-qrencode";
       version = "1.0.4";
       sha256 = "12a2c616b61dfb8d19046d9ba30d7aeedb122ff8d876dbad9ba1eb4dfe7506b3";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ qrencode ];
       homepage = "https://github.com/jamessanders/haskell-qrencode";
       description = "Haskell bindings for libqrencode";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) qrencode;};

  "haskell-read-editor" = callPackage
    ({ mkDerivation, base, directory, hspec, process }:
     mkDerivation {
       pname = "haskell-read-editor";
       version = "0.1.0.0";
       sha256 = "ea4d6469f7f3b661ee08f74f53291f9361bd53bef5a6e645c5a96b8d3b345d23";
       libraryHaskellDepends = [ base directory process ];
       testHaskellDepends = [ base directory hspec process ];
       homepage = "https://github.com/yamadapc/haskell-read-editor";
       description = "Opens a temporary file on the system's EDITOR and returns the resulting edits";
       license = stdenv.lib.licenses.mit;
     }) {};

  "haskell-reflect" = callPackage
    ({ mkDerivation, base, containers, hint, MonadCatchIO-mtl, mtl
     , parsec, template-haskell, transformers
     }:
     mkDerivation {
       pname = "haskell-reflect";
       version = "0.9";
       sha256 = "d6ff34d5ad94815cec56e3a747817a2929cdadb2a354007b1efe02992ed2db84";
       libraryHaskellDepends = [
         base containers hint MonadCatchIO-mtl mtl parsec template-haskell
         transformers
       ];
       description = "Reflect Haskell types";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-rules" = callPackage
    ({ mkDerivation, base, syb }:
     mkDerivation {
       pname = "haskell-rules";
       version = "0.1.0.1";
       sha256 = "e6c357a23888313d9f2cfab4e72805a2d91507378063ec861b22b56e5f60a80d";
       libraryHaskellDepends = [ base syb ];
       description = "A DSL for expressing natural deduction rules in Haskell";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-spacegoo" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra
     , mtl, pretty, pretty-show, 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
       ];
       description = "Client API for Rocket Scissor Spacegoo";
       license = stdenv.lib.licenses.mit;
     }) {};

  "haskell-src_1_0_1_6" = callPackage
    ({ mkDerivation, array, base, pretty, syb }:
     mkDerivation {
       pname = "haskell-src";
       version = "1.0.1.6";
       sha256 = "c7c556366025d9895d1110ecfa30a29e29d7d0a8cb447716fe601e4ff5da4cef";
       revision = "1";
       editedCabalFile = "f623f3bdda8e83519df67531d2fe9a5751f2e8af64f9d8da1051a04911de1f85";
       libraryHaskellDepends = [ array base pretty syb ];
       jailbreak = true;
       description = "Support for manipulating Haskell source code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-src" = callPackage
    ({ mkDerivation, array, base, happy, pretty, syb }:
     mkDerivation {
       pname = "haskell-src";
       version = "1.0.2.0";
       sha256 = "2a25ee5729230edddb94af8d9881efbc1d8798bd316097f4646749cb2fa491a6";
       libraryHaskellDepends = [ array base pretty syb ];
       libraryToolDepends = [ happy ];
       description = "Support for manipulating Haskell source code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskell-src-exts_1_15_0_1" = callPackage
    ({ mkDerivation, array, base, containers, cpphs, directory
     , filemanip, filepath, ghc-prim, happy, mtl, pretty, smallcheck
     , syb, tasty, tasty-golden, tasty-smallcheck
     }:
     mkDerivation {
       pname = "haskell-src-exts";
       version = "1.15.0.1";
       sha256 = "85f475693a87fd26a3a8b32dea2660bfdca35c2b5d11506ab11b1dc20c88e576";
       libraryHaskellDepends = [ array base cpphs ghc-prim pretty ];
       libraryToolDepends = [ happy ];
       testHaskellDepends = [
         base containers directory filemanip filepath mtl smallcheck syb
         tasty tasty-golden tasty-smallcheck
       ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-src-exts_1_16_0_1" = callPackage
    ({ mkDerivation, array, base, containers, cpphs, directory
     , filepath, ghc-prim, happy, mtl, pretty, smallcheck, syb, tasty
     , tasty-golden, tasty-smallcheck
     }:
     mkDerivation {
       pname = "haskell-src-exts";
       version = "1.16.0.1";
       sha256 = "3f3bd41ad3a346a78e80195eca83de529d3ece63fa7edcd4df3b8bf40a970fc1";
       libraryHaskellDepends = [ array base cpphs ghc-prim pretty ];
       libraryToolDepends = [ happy ];
       testHaskellDepends = [
         base containers directory filepath mtl smallcheck syb tasty
         tasty-golden tasty-smallcheck
       ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-src-exts" = callPackage
    ({ mkDerivation, array, base, containers, cpphs, directory
     , filepath, ghc-prim, happy, mtl, pretty, pretty-show, smallcheck
     , syb, tasty, tasty-golden, tasty-smallcheck
     }:
     mkDerivation {
       pname = "haskell-src-exts";
       version = "1.17.1";
       sha256 = "ba5c547720514515ad0b94eb8a3d7e22a0e2ad2d85b5e1d178e62c61615528bd";
       revision = "1";
       editedCabalFile = "c07248f2a7b4bee1c7777dc6e441e8d1f32a02fb596ea49f47074c68b3c9ea0b";
       libraryHaskellDepends = [ array base cpphs ghc-prim pretty ];
       libraryToolDepends = [ happy ];
       testHaskellDepends = [
         base containers directory filepath mtl pretty-show smallcheck syb
         tasty tasty-golden tasty-smallcheck
       ];
       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-qq" = callPackage
    ({ mkDerivation, base, haskell-src-exts, haskell-src-meta, hspec
     , syb, template-haskell
     }:
     mkDerivation {
       pname = "haskell-src-exts-qq";
       version = "0.7";
       sha256 = "b61fd34e379b80c45013ba70441261ab41d49f60c12dab880b487edabc99a82f";
       libraryHaskellDepends = [
         base haskell-src-exts haskell-src-meta syb template-haskell
       ];
       testHaskellDepends = [ base haskell-src-exts hspec ];
       description = "A quasiquoter for haskell-src-exts";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskell-src-meta_0_6_0_8" = callPackage
    ({ mkDerivation, base, haskell-src-exts, pretty, syb
     , template-haskell, th-orphans
     }:
     mkDerivation {
       pname = "haskell-src-meta";
       version = "0.6.0.8";
       sha256 = "d3f69a05701d85880472c9d30efb3056fc8733f5f31e1795280aaf9f2c1262bb";
       revision = "1";
       editedCabalFile = "98609677e15a08af231b3bb957670cb1de50132625a36ef1fc83d530fb319f8a";
       libraryHaskellDepends = [
         base haskell-src-exts pretty syb template-haskell th-orphans
       ];
       jailbreak = true;
       description = "Parse source to template-haskell abstract syntax";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-src-meta_0_6_0_9" = callPackage
    ({ mkDerivation, base, haskell-src-exts, pretty, syb
     , template-haskell, th-orphans
     }:
     mkDerivation {
       pname = "haskell-src-meta";
       version = "0.6.0.9";
       sha256 = "aee7105b2e0571ef812f258b8fca4904acca66f02da9e75ea7a8c4a9957bb0a1";
       libraryHaskellDepends = [
         base haskell-src-exts pretty syb template-haskell th-orphans
       ];
       jailbreak = true;
       description = "Parse source to template-haskell abstract syntax";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-src-meta_0_6_0_10" = callPackage
    ({ mkDerivation, base, haskell-src-exts, pretty, syb
     , template-haskell, th-orphans
     }:
     mkDerivation {
       pname = "haskell-src-meta";
       version = "0.6.0.10";
       sha256 = "c15f7e3bd196d80e1458ee1925b5f194feaabfb050eb680ca68efc156bf48c3a";
       libraryHaskellDepends = [
         base haskell-src-exts pretty syb template-haskell th-orphans
       ];
       jailbreak = true;
       description = "Parse source to template-haskell abstract syntax";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-src-meta_0_6_0_11" = callPackage
    ({ mkDerivation, base, haskell-src-exts, pretty, syb
     , template-haskell, th-orphans
     }:
     mkDerivation {
       pname = "haskell-src-meta";
       version = "0.6.0.11";
       sha256 = "1752bf1a27681c71537baa412fc701fb6a49f489c7ef5e05d8c9cca47827c185";
       libraryHaskellDepends = [
         base haskell-src-exts pretty syb template-haskell th-orphans
       ];
       jailbreak = true;
       description = "Parse source to template-haskell abstract syntax";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-src-meta_0_6_0_12" = callPackage
    ({ mkDerivation, base, haskell-src-exts, pretty, syb
     , template-haskell, th-orphans
     }:
     mkDerivation {
       pname = "haskell-src-meta";
       version = "0.6.0.12";
       sha256 = "143742510abf5863de67e3d717721c80049f3f55a60e8e0c40f21aba5d76ebd7";
       libraryHaskellDepends = [
         base haskell-src-exts pretty syb template-haskell th-orphans
       ];
       jailbreak = true;
       description = "Parse source to template-haskell abstract syntax";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-src-meta" = callPackage
    ({ mkDerivation, base, haskell-src-exts, pretty, syb
     , template-haskell, th-orphans
     }:
     mkDerivation {
       pname = "haskell-src-meta";
       version = "0.6.0.13";
       sha256 = "3f33d39d5451f3a44d348981ae5923da65cb26356d962dc9f2cb0fc64670ceb6";
       libraryHaskellDepends = [
         base haskell-src-exts pretty syb template-haskell th-orphans
       ];
       description = "Parse source to template-haskell abstract syntax";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskell-src-meta-mwotton" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, haskell-src-exts
     , pretty, syb, template-haskell
     }:
     mkDerivation {
       pname = "haskell-src-meta-mwotton";
       version = "0.1.0";
       sha256 = "d622d4edeae11c2dd808828bdd968957e5d8486e30f6fd3c9e81efdae5b8c011";
       libraryHaskellDepends = [
         base containers ghc-prim haskell-src-exts pretty syb
         template-haskell
       ];
       jailbreak = true;
       description = "Parse source to template-haskell abstract syntax";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-token-utils" = callPackage
    ({ mkDerivation, base, containers, Diff, directory, dual-tree, ghc
     , ghc-mod, ghc-paths, ghc-prim, ghc-syb-utils, haskell-src-exts
     , hspec, HUnit, monoid-extras, mtl, pretty, QuickCheck, rosezipper
     , semigroups, syb, uniplate
     }:
     mkDerivation {
       pname = "haskell-token-utils";
       version = "0.0.0.6";
       sha256 = "39ddabf1f1efed180befd86b5bfcd4e2a230b296d558c55907e75abc13a7df92";
       libraryHaskellDepends = [
         base containers dual-tree ghc ghc-paths ghc-syb-utils
         haskell-src-exts monoid-extras mtl pretty rosezipper semigroups syb
       ];
       testHaskellDepends = [
         base containers Diff directory dual-tree ghc ghc-mod ghc-paths
         ghc-prim ghc-syb-utils haskell-src-exts hspec HUnit monoid-extras
         mtl pretty QuickCheck rosezipper semigroups syb uniplate
       ];
       jailbreak = true;
       homepage = "https://github.com/alanz/haskell-token-utils";
       description = "Utilities to tie up tokens to an AST";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-tor" = callPackage
    ({ mkDerivation, array, asn1-encoding, asn1-types, async
     , attoparsec, base, base64-bytestring, binary, bytestring, cereal
     , containers, cryptonite, fingertree, hans, hourglass, HUnit
     , memory, monadLib, network, pretty-hex, pure-zlib, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , time, tls, x509, x509-store
     }:
     mkDerivation {
       pname = "haskell-tor";
       version = "0.1.2";
       sha256 = "643fb2b1064482fbb636b1cac76721bec73e52257e3a88f98039d0d7d1d2d84b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array asn1-encoding asn1-types async attoparsec base
         base64-bytestring binary bytestring cereal containers cryptonite
         fingertree hans hourglass memory monadLib network pretty-hex
         pure-zlib time tls x509 x509-store
       ];
       executableHaskellDepends = [
         asn1-encoding asn1-types base base64-bytestring bytestring
         cryptonite hans hourglass memory network time tls x509
       ];
       testHaskellDepends = [
         asn1-types base binary bytestring cryptonite hourglass HUnit memory
         pretty-hex QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 time x509
       ];
       jailbreak = true;
       homepage = "http://github.com/GaloisInc/haskell-tor";
       description = "A Haskell Tor Node";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-type-exts" = callPackage
    ({ mkDerivation, base, containers, haskell-src-exts, pretty }:
     mkDerivation {
       pname = "haskell-type-exts";
       version = "0.1.0";
       sha256 = "28fd71761896d7569deaa69b6af55e1e36ae5a53ce5a3595c8f3b521d3d33414";
       libraryHaskellDepends = [
         base containers haskell-src-exts pretty
       ];
       homepage = "http://code.haskell.org/haskell-type-exts";
       description = "A type checker for Haskell/haskell-src-exts";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-typescript" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "haskell-typescript";
       version = "0.1.0.0";
       sha256 = "687028547acd68f1d6c2fe71b25883c3ecdb89dd3364e71e57b419a6ec18653b";
       libraryHaskellDepends = [ base process ];
       jailbreak = true;
       description = "Simple TypeScript API";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "haskell-tyrant" = callPackage
    ({ mkDerivation, base, binary, bytestring, network }:
     mkDerivation {
       pname = "haskell-tyrant";
       version = "0.4";
       sha256 = "27d1c018e2db191c27973cf06cf052f320a71d98af5081108e285e3ac10e10df";
       libraryHaskellDepends = [ base binary bytestring network ];
       homepage = "https://github.com/PeterScott/haskell-tyrant";
       description = "Haskell implementation of the Tokyo Tyrant binary protocol";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell-updater" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, directory
     , filepath, process
     }:
     mkDerivation {
       pname = "haskell-updater";
       version = "1.2.10";
       sha256 = "e9712ccaa38bb2ca4242272eee72c72e5b2d0943d7d35c846fccdd89a5428e7d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal containers directory filepath process
       ];
       homepage = "http://haskell.org/haskellwiki/Gentoo#haskell-updater";
       description = "Rebuild Haskell dependencies in Gentoo";
       license = "GPL";
     }) {};

  "haskell-xmpp" = callPackage
    ({ mkDerivation, array, base, HaXml, html, mtl, network, polyparse
     , pretty, random, regex-compat, stm, utf8-string
     }:
     mkDerivation {
       pname = "haskell-xmpp";
       version = "1.0.2";
       sha256 = "a9345eb03a7ea0dc4a50af3a916ad2c455fb2232c6d36830afc8e70d6c259dfc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base HaXml html mtl network polyparse pretty random
         regex-compat stm utf8-string
       ];
       homepage = "http://patch-tag.com/r/adept/haskell-xmpp/home";
       description = "Haskell XMPP (eXtensible Message Passing Protocol, a.k.a. Jabber) library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell2010" = callPackage
    ({ mkDerivation, array, base, ghc-prim }:
     mkDerivation {
       pname = "haskell2010";
       version = "1.1.2.0";
       sha256 = "957ccb3008bcfd099e72b0fee1649de9ab30eb40e74b41aa573c9685c0da0ae8";
       libraryHaskellDepends = [ array base ghc-prim ];
       jailbreak = true;
       homepage = "http://www.haskell.org/onlinereport/haskell2010/";
       description = "Compatibility with Haskell 2010";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell98" = callPackage
    ({ mkDerivation, array, base, directory, old-locale, old-time
     , process, time
     }:
     mkDerivation {
       pname = "haskell98";
       version = "2.0.0.3";
       sha256 = "bd5d4652f699caa1b1c654dc9ca94ecc2181b453c4f65999915abd63e75ba090";
       libraryHaskellDepends = [
         array base directory old-locale old-time process time
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/definition/";
       description = "Compatibility with Haskell 98";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskell98libraries" = callPackage
    ({ mkDerivation, array, base, directory, old-locale, old-time
     , process, time
     }:
     mkDerivation {
       pname = "haskell98libraries";
       version = "2.0.0.2";
       sha256 = "28a2acbdfd16833457350127c5964d277c36c5679d5db129d299eff7f6e492b5";
       libraryHaskellDepends = [
         array base directory old-locale old-time process time
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/definition/";
       description = "Compatibility with Haskell 98";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskelldb" = callPackage
    ({ mkDerivation, base, containers, directory, mtl, old-locale
     , old-time, pretty, time
     }:
     mkDerivation {
       pname = "haskelldb";
       version = "2.2.4";
       sha256 = "be90caa6cf54521704ba877645043a24f19166870ceccf8a61faf322fe4a0c39";
       libraryHaskellDepends = [
         base containers directory mtl old-locale old-time pretty time
       ];
       homepage = "https://github.com/m4dc4p/haskelldb";
       description = "A library of combinators for generating and executing SQL statements";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskelldb-connect-hdbc" = callPackage
    ({ mkDerivation, base, containers, haskelldb, HDBC }:
     mkDerivation {
       pname = "haskelldb-connect-hdbc";
       version = "0.1.0.0";
       sha256 = "740a1e94f7762d244393ccde1141166a9f6501f8df42e54c6e6ff5319c7331d1";
       libraryHaskellDepends = [ base containers haskelldb HDBC ];
       homepage = "http://twitter.com/khibino";
       description = "Bracketed HDBC session for HaskellDB";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskelldb-connect-hdbc-catchio-mtl" = callPackage
    ({ mkDerivation, base, haskelldb, haskelldb-connect-hdbc, HDBC
     , MonadCatchIO-mtl, mtl
     }:
     mkDerivation {
       pname = "haskelldb-connect-hdbc-catchio-mtl";
       version = "0.1.0.0";
       sha256 = "bc17845ea053740c2e29650ec083d5b3d4c168a9241156749c0a5e76b2494feb";
       libraryHaskellDepends = [
         base haskelldb haskelldb-connect-hdbc HDBC MonadCatchIO-mtl mtl
       ];
       homepage = "http://twitter.com/khibino";
       description = "Bracketed HaskellDB HDBC session using MonadCatchIO-mtl";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskelldb-connect-hdbc-catchio-tf" = callPackage
    ({ mkDerivation, base, haskelldb, haskelldb-connect-hdbc, HDBC
     , MonadCatchIO-transformers, transformers
     }:
     mkDerivation {
       pname = "haskelldb-connect-hdbc-catchio-tf";
       version = "0.1.0.0";
       sha256 = "84c3bbf9596da89459ea80f46f634b005e403f84d9256ee39229529f115a0a9b";
       libraryHaskellDepends = [
         base haskelldb haskelldb-connect-hdbc HDBC
         MonadCatchIO-transformers transformers
       ];
       homepage = "http://twitter.com/khibino";
       description = "Bracketed HaskellDB HDBC session using MonadCatchIO-transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskelldb-connect-hdbc-catchio-transformers" = callPackage
    ({ mkDerivation, base, haskelldb, haskelldb-connect-hdbc, HDBC
     , MonadCatchIO-transformers, transformers
     }:
     mkDerivation {
       pname = "haskelldb-connect-hdbc-catchio-transformers";
       version = "0.1.0.0";
       sha256 = "47961d8db314d85a779aae0c251f3f0be06ec629348dc88b33ff2bc2e8346b41";
       libraryHaskellDepends = [
         base haskelldb haskelldb-connect-hdbc HDBC
         MonadCatchIO-transformers transformers
       ];
       homepage = "http://twitter.com/khibino";
       description = "Bracketed HaskellDB HDBC session using MonadCatchIO-transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskelldb-connect-hdbc-lifted" = callPackage
    ({ mkDerivation, base, haskelldb, haskelldb-connect-hdbc, HDBC
     , lifted-base, monad-control, transformers-base
     }:
     mkDerivation {
       pname = "haskelldb-connect-hdbc-lifted";
       version = "0.1.0.0";
       sha256 = "8a0bb4fa66ce353825bc0cea5583bc449a6d4fc85c2f9b1953a3e5ba8e8256fb";
       libraryHaskellDepends = [
         base haskelldb haskelldb-connect-hdbc HDBC lifted-base
         monad-control transformers-base
       ];
       homepage = "http://twitter.com/khibino";
       description = "Bracketed HaskellDB HDBC session using lifted-base";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskelldb-dynamic" = callPackage
    ({ mkDerivation, base, haskell98, haskelldb, mtl, plugins }:
     mkDerivation {
       pname = "haskelldb-dynamic";
       version = "1.0.0";
       sha256 = "caa84303097f958a7b019a6c3458a85db20d747288941616774265253bf7b171";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base haskell98 haskelldb mtl plugins ];
       executableHaskellDepends = [ haskelldb ];
       jailbreak = true;
       homepage = "https://github.com/m4dc4p/haskelldb";
       description = "HaskellDB support for the dynamically loaded drivers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskelldb-flat" = callPackage
    ({ mkDerivation, base, containers, directory, haskelldb, mtl
     , old-time
     }:
     mkDerivation {
       pname = "haskelldb-flat";
       version = "1.0.1";
       sha256 = "a10f611e9b664cf273d83d70e8d7c1213ed72a96f685921eecebba7f4255e538";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory haskelldb mtl old-time
       ];
       jailbreak = true;
       homepage = "https://github.com/m4dc4p/haskelldb";
       description = "An experimental HaskellDB back-end in pure Haskell (no SQL)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskelldb-hdbc" = callPackage
    ({ mkDerivation, base, containers, convertible, haskelldb, HDBC
     , mtl, old-time
     }:
     mkDerivation {
       pname = "haskelldb-hdbc";
       version = "2.2.4";
       sha256 = "42270f14d5138b2e69ddd61684ce13080853519b29c2082698949ec12d4cc70b";
       libraryHaskellDepends = [
         base containers convertible haskelldb HDBC mtl old-time
       ];
       homepage = "https://github.com/m4dc4p/haskelldb";
       description = "HaskellDB support for HDBC";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskelldb-hdbc-mysql" = callPackage
    ({ mkDerivation, base, haskelldb, haskelldb-hdbc, HDBC, HDBC-mysql
     , mtl
     }:
     mkDerivation {
       pname = "haskelldb-hdbc-mysql";
       version = "0.1.1";
       sha256 = "222a20cf8b2e35db430f099f4151519d422d221ef0470034c75d98a8b394c85a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base haskelldb haskelldb-hdbc HDBC HDBC-mysql mtl
       ];
       jailbreak = true;
       description = "HaskellDB support for the HDBC MySQL driver";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskelldb-hdbc-odbc" = callPackage
    ({ mkDerivation, base, haskelldb, haskelldb-hdbc, HDBC, HDBC-odbc
     , mtl
     }:
     mkDerivation {
       pname = "haskelldb-hdbc-odbc";
       version = "2.1.2";
       sha256 = "d7e0d357c0661a870220b3428b15d23c3a5030737b8213ad663e4d43638c07f9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base haskelldb haskelldb-hdbc HDBC HDBC-odbc mtl
       ];
       homepage = "https://github.com/m4dc4p/haskelldb";
       description = "HaskellDB support for the HDBC ODBC driver";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskelldb-hdbc-postgresql" = callPackage
    ({ mkDerivation, base, haskelldb, haskelldb-hdbc, HDBC
     , HDBC-postgresql, mtl, postgresql
     }:
     mkDerivation {
       pname = "haskelldb-hdbc-postgresql";
       version = "2.1.2";
       sha256 = "ef40ab98dafa5b67d9b6da1afdbf2b6bdc3d54cdfb14cd82bbc0ed2f841f9b21";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base haskelldb haskelldb-hdbc HDBC HDBC-postgresql mtl
       ];
       executableSystemDepends = [ postgresql ];
       homepage = "https://github.com/m4dc4p/haskelldb";
       description = "HaskellDB support for the HDBC PostgreSQL driver";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) postgresql;};

  "haskelldb-hdbc-sqlite3" = callPackage
    ({ mkDerivation, base, haskelldb, haskelldb-hdbc, HDBC
     , HDBC-sqlite3, mtl
     }:
     mkDerivation {
       pname = "haskelldb-hdbc-sqlite3";
       version = "2.1.2";
       sha256 = "46ab9510762d9f558d878abe28bdcdfb293531af7bdf5b6f5adca3093f15b761";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base haskelldb haskelldb-hdbc HDBC HDBC-sqlite3 mtl
       ];
       homepage = "https://github.com/m4dc4p/haskelldb";
       description = "HaskellDB support for the HDBC SQLite driver";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskelldb-hsql" = callPackage
    ({ mkDerivation, base, haskelldb, hsql, mtl, old-time }:
     mkDerivation {
       pname = "haskelldb-hsql";
       version = "1.0.0";
       sha256 = "a0d365607c04a2310a14eb9367067ad0e418da3d09d1a90fd70cdf207ac42a48";
       libraryHaskellDepends = [ base haskelldb hsql mtl old-time ];
       jailbreak = true;
       homepage = "https://github.com/m4dc4p/haskelldb";
       description = "HaskellDB support for HSQL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskelldb-hsql-mysql" = callPackage
    ({ mkDerivation, base, haskelldb, haskelldb-hsql, hsql, hsql-mysql
     , mtl
     }:
     mkDerivation {
       pname = "haskelldb-hsql-mysql";
       version = "1.0.0";
       sha256 = "7576321aa9e470ec24995ce088cc650bacd1dd83d8d177bd3c1c8a25d3ce3427";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base haskelldb haskelldb-hsql hsql hsql-mysql mtl
       ];
       jailbreak = true;
       homepage = "https://github.com/m4dc4p/haskelldb";
       description = "HaskellDB support for the HSQL MySQL driver";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskelldb-hsql-odbc" = callPackage
    ({ mkDerivation, base, haskelldb, haskelldb-hsql, hsql, hsql-odbc
     , mtl
     }:
     mkDerivation {
       pname = "haskelldb-hsql-odbc";
       version = "1.0.0";
       sha256 = "cad837818ac99d032ee38e99c5283df87127f8836b3f326862499c413a5927a3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base haskelldb haskelldb-hsql hsql hsql-odbc mtl
       ];
       jailbreak = true;
       homepage = "https://github.com/m4dc4p/haskelldb";
       description = "HaskellDB support for the HSQL ODBC driver";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskelldb-hsql-oracle" = callPackage
    ({ mkDerivation, base, haskelldb, haskelldb-hsql, hsql, hsql-oracle
     , mtl
     }:
     mkDerivation {
       pname = "haskelldb-hsql-oracle";
       version = "1.0.0";
       sha256 = "a9dff51a3a8b05d56dffab14975701f49585aa707a6857a814d2aeb8527d4648";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base haskelldb haskelldb-hsql hsql hsql-oracle mtl
       ];
       jailbreak = true;
       homepage = "https://github.com/m4dc4p/haskelldb";
       description = "HaskellDB support for the HSQL Oracle driver";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {hsql-oracle = null;};

  "haskelldb-hsql-postgresql" = callPackage
    ({ mkDerivation, base, haskelldb, haskelldb-hsql, hsql
     , hsql-postgresql, mtl
     }:
     mkDerivation {
       pname = "haskelldb-hsql-postgresql";
       version = "1.0.0";
       sha256 = "5b6fa0800ebda784a4bbaeca76c9937d6ebb5b7dc282ed1e31089684137f3bb4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base haskelldb haskelldb-hsql hsql hsql-postgresql mtl
       ];
       jailbreak = true;
       homepage = "https://github.com/m4dc4p/haskelldb";
       description = "HaskellDB support for the HSQL PostgreSQL driver";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskelldb-hsql-sqlite" = callPackage
    ({ mkDerivation, base, haskelldb, haskelldb-hsql, hsql, hsql-sqlite
     , mtl
     }:
     mkDerivation {
       pname = "haskelldb-hsql-sqlite";
       version = "1.0.0";
       sha256 = "1cc2353c04fbe6efc8f220a5498bd0640f14d8f0763377a9b9447b166ff54843";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base haskelldb haskelldb-hsql hsql hsql-sqlite mtl
       ];
       jailbreak = true;
       homepage = "https://github.com/m4dc4p/haskelldb";
       description = "HaskellDB support for the HSQL SQLite driver";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {hsql-sqlite = null;};

  "haskelldb-hsql-sqlite3" = callPackage
    ({ mkDerivation, base, haskelldb, haskelldb-hsql, hsql
     , hsql-sqlite3, mtl
     }:
     mkDerivation {
       pname = "haskelldb-hsql-sqlite3";
       version = "1.0.0";
       sha256 = "85e58615bd36af8b5bcd2bb1af24de6ab2ef1f96de2473c2eb7c00719cc8b487";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base haskelldb haskelldb-hsql hsql hsql-sqlite3 mtl
       ];
       jailbreak = true;
       homepage = "https://github.com/m4dc4p/haskelldb";
       description = "HaskellDB support for the HSQL SQLite3 driver";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskelldb-th" = callPackage
    ({ mkDerivation, base, haskelldb, mtl, template-haskell }:
     mkDerivation {
       pname = "haskelldb-th";
       version = "2.1.0";
       sha256 = "cbabcf99fe125bf4064b5fc89d42f1dc860c69eab750975d9898268fc1df908b";
       libraryHaskellDepends = [ base haskelldb mtl template-haskell ];
       jailbreak = true;
       homepage = "http://trac.haskell.org/haskelldb-th";
       description = "Template Haskell utilities for HaskellDB";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskelldb-wx" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "haskelldb-wx";
       version = "1.0.0";
       sha256 = "1e8a89f51ca1cde14e41a085f69d7dee015b76bb146f6501200055bf4015c504";
       homepage = "https://github.com/m4dc4p/haskelldb";
       description = "HaskellDB support for WXHaskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskellscrabble" = callPackage
    ({ mkDerivation, array, arrows, base, containers, directory, errors
     , filepath, HUnit, listsafe, mtl, parsec, QuickCheck, random, safe
     , semigroups, split, test-framework, test-framework-hunit
     , test-framework-quickcheck2, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "haskellscrabble";
       version = "2.0.1";
       sha256 = "514e4af38a6e889532437fcfad09479c247e0097c01f5f01295b01beda4596e4";
       libraryHaskellDepends = [
         array arrows base containers errors listsafe mtl parsec QuickCheck
         random safe semigroups split transformers unordered-containers
       ];
       testHaskellDepends = [
         base containers directory filepath HUnit QuickCheck random
         semigroups test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://www.github.com/happy0/haskellscrabble";
       description = "A scrabble library capturing the core game logic of scrabble";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskellscript" = callPackage
    ({ mkDerivation, base, cryptohash, directory, either, filepath, mtl
     , process, text
     }:
     mkDerivation {
       pname = "haskellscript";
       version = "0.2.3";
       sha256 = "c3d189736e4128d93514397f9b3faf20fa20c3e3ac673b37cfb095d1efda3b4b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cryptohash directory either filepath mtl process text
       ];
       homepage = "http://github.com/seanparsons/haskellscript/";
       description = "Command line tool for running Haskell scripts with a hashbang";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskelm" = callPackage
    ({ mkDerivation, aeson, base, binary, containers, directory, Elm
     , haskell-src-exts, haskell-src-meta, mtl, parsec, pretty
     , shakespeare, split, template-haskell, temporary, text, th-desugar
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "haskelm";
       version = "0.1.12.0";
       sha256 = "1e4559e472d5a3641a54728fccdbcafb4f15c3c1845fbd2ff2fd19cc5c3af7af";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base binary containers directory haskell-src-exts
         haskell-src-meta mtl parsec pretty split template-haskell temporary
         text th-desugar unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson base binary containers directory haskell-src-exts
         haskell-src-meta mtl parsec pretty split template-haskell temporary
         text th-desugar unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base binary containers directory Elm haskell-src-exts
         haskell-src-meta mtl parsec pretty shakespeare split
         template-haskell temporary text th-desugar unordered-containers
         vector
       ];
       homepage = "http://github.com/JoeyEremondi/haskelm";
       description = "Elm to Haskell translation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskgame" = callPackage
    ({ mkDerivation, base, containers, haskell98, SDL, SDL-ttf }:
     mkDerivation {
       pname = "haskgame";
       version = "0.0.6";
       sha256 = "7fd312bb8773362525d23786a1915f14eb81063e071c9dc3b215b5d4ce842d18";
       libraryHaskellDepends = [ base containers haskell98 SDL SDL-ttf ];
       homepage = "http://haskell.org/haskellwiki/HaskGame";
       description = "Haskell game library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskheap" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-conduit, http-types
     , network, old-locale, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "haskheap";
       version = "0.1.2";
       sha256 = "194b8be2d0c9d741905ac2d10f4adc340612a9f1c813103bd8428f28307e4eb0";
       libraryHaskellDepends = [
         aeson base bytestring http-conduit http-types network old-locale
         text time unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/Raynes/haskheap";
       description = "Haskell bindings to refheap";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskhol-core" = callPackage
    ({ mkDerivation, acid-state, base, containers, deepseq, filepath
     , ghc-prim, hashable, mtl, parsec, pretty, safecopy, shelly
     , template-haskell, text, text-show, th-lift, unordered-containers
     }:
     mkDerivation {
       pname = "haskhol-core";
       version = "1.1.0";
       sha256 = "bddb4053c5a671935fd6c95378ae5e584c95c503d40723eddbef617ad7f29f6e";
       libraryHaskellDepends = [
         acid-state base containers deepseq filepath ghc-prim hashable mtl
         parsec pretty safecopy shelly template-haskell text text-show
         th-lift unordered-containers
       ];
       jailbreak = true;
       homepage = "http://haskhol.org";
       description = "The core logical system of HaskHOL, an EDSL for HOL theorem proving";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskintex_0_5_0_2" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , filepath, haskell-src-exts, HaTeX, hint, parsec, process, text
     , transformers
     }:
     mkDerivation {
       pname = "haskintex";
       version = "0.5.0.2";
       sha256 = "d6d55b06366e6e57612fd3e37cc5b11f61c0f663ba66e52a1e7af68b32d5d8e1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers directory filepath
         haskell-src-exts HaTeX hint parsec process text transformers
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://daniel-diaz.github.io/projects/haskintex";
       description = "Haskell Evaluation inside of LaTeX code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskintex_0_5_0_3" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , filepath, haskell-src-exts, HaTeX, hint, parsec, process, text
     , transformers
     }:
     mkDerivation {
       pname = "haskintex";
       version = "0.5.0.3";
       sha256 = "739cb703663ae622e5e3e333611cc393ec2b330d7af467e61b2b8b81d6c87a3d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers directory filepath
         haskell-src-exts HaTeX hint parsec process text transformers
       ];
       executableHaskellDepends = [ base ];
       homepage = "http://daniel-diaz.github.io/projects/haskintex";
       description = "Haskell Evaluation inside of LaTeX code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskintex_0_5_1_0" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , filepath, haskell-src-exts, HaTeX, hint, parsec, process, text
     , transformers
     }:
     mkDerivation {
       pname = "haskintex";
       version = "0.5.1.0";
       sha256 = "1c65a350e2cebce1117ce59fab5749ab7796cf36476e03c882f91cf7a46cb0df";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers directory filepath
         haskell-src-exts HaTeX hint parsec process text transformers
       ];
       executableHaskellDepends = [ base ];
       homepage = "http://daniel-diaz.github.io/projects/haskintex";
       description = "Haskell Evaluation inside of LaTeX code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskintex" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , filepath, haskell-src-exts, HaTeX, hint, parsec, process, text
     , transformers
     }:
     mkDerivation {
       pname = "haskintex";
       version = "0.6.0.0";
       sha256 = "229a817b9a688f23d2e394a7e76aff80973707df86fe628214577e863072914f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers directory filepath
         haskell-src-exts HaTeX hint parsec process text transformers
       ];
       executableHaskellDepends = [ base ];
       homepage = "http://daniel-diaz.github.io/projects/haskintex";
       description = "Haskell Evaluation inside of LaTeX code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haskmon" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, http-streams
     , io-streams, time, vector
     }:
     mkDerivation {
       pname = "haskmon";
       version = "0.2.1.0";
       sha256 = "69ac7e21a62f20c2fce94db01c373dbd66876a0cb016ab25a99a9dedc4f62677";
       libraryHaskellDepends = [
         aeson base bytestring containers http-streams io-streams time
         vector
       ];
       jailbreak = true;
       description = "A haskell wrapper for PokeAPI.co (www.pokeapi.co)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "haskoin" = callPackage
    ({ mkDerivation, aeson, async, base, binary, byteable, bytestring
     , containers, cryptohash, deepseq, either, HUnit, json-rpc, mtl
     , pbkdf, QuickCheck, split, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "haskoin";
       version = "0.1.0.2";
       sha256 = "0c3de9ef72c73a96f3b7e8e605e43a0b16d2b2f47855251d6b609a1237177050";
       libraryHaskellDepends = [
         aeson base binary byteable bytestring containers cryptohash deepseq
         either json-rpc mtl pbkdf split text
       ];
       testHaskellDepends = [
         aeson async base binary byteable bytestring containers cryptohash
         deepseq either HUnit json-rpc mtl pbkdf QuickCheck split
         test-framework test-framework-hunit test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "http://github.com/haskoin/haskoin";
       description = "Implementation of the Bitcoin protocol";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskoin-core" = callPackage
    ({ mkDerivation, aeson, base, base16-bytestring, binary, byteable
     , bytestring, conduit, containers, cryptohash, deepseq, either
     , entropy, HUnit, largeword, mtl, murmur3, network, pbkdf
     , QuickCheck, secp256k1, split, string-conversions, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , vector
     }:
     mkDerivation {
       pname = "haskoin-core";
       version = "0.2.0";
       sha256 = "d714fc5b3b282e5d3d0237c6223933724324e21be1baef11fe7fb28dcb7affb8";
       libraryHaskellDepends = [
         aeson base base16-bytestring binary byteable bytestring conduit
         containers cryptohash deepseq either entropy largeword mtl murmur3
         network pbkdf QuickCheck secp256k1 split string-conversions text
         time vector
       ];
       testHaskellDepends = [
         aeson base binary bytestring containers HUnit largeword mtl
         QuickCheck secp256k1 split string-conversions test-framework
         test-framework-hunit test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "http://github.com/haskoin/haskoin";
       description = "Implementation of the core Bitcoin protocol features";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskoin-crypto" = callPackage
    ({ mkDerivation, base, binary, byteable, bytestring, containers
     , cryptohash, haskoin-util, HUnit, mtl, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "haskoin-crypto";
       version = "0.0.1.1";
       sha256 = "e934183202a51465b77fde444ad2c84f2e15a2ee86b4d55943524d3ce47d5901";
       libraryHaskellDepends = [
         base binary byteable bytestring containers cryptohash haskoin-util
         mtl QuickCheck
       ];
       testHaskellDepends = [
         base binary byteable bytestring containers cryptohash haskoin-util
         HUnit mtl QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/plaprade/haskoin-crypto";
       description = "Implementation of Bitcoin cryptographic primitives";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskoin-node" = callPackage
    ({ mkDerivation, aeson, async, base, binary, bytestring
     , concurrent-extra, conduit, conduit-extra, containers
     , data-default, deepseq, either, exceptions, haskoin-core, HUnit
     , leveldb-haskell, lifted-async, lifted-base, monad-control
     , monad-logger, mtl, network, QuickCheck, random, stm, stm-chans
     , stm-conduit, string-conversions, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     }:
     mkDerivation {
       pname = "haskoin-node";
       version = "0.2.0";
       sha256 = "2fd8db2a4571d6fab610d3902dee91e7bae15085e49e4167f0ad4bd823ddb0d2";
       libraryHaskellDepends = [
         aeson async base binary bytestring concurrent-extra conduit
         conduit-extra containers data-default deepseq either exceptions
         haskoin-core leveldb-haskell lifted-async lifted-base monad-control
         monad-logger mtl network random stm stm-chans stm-conduit
         string-conversions text time
       ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/haskoin/haskoin";
       description = "Implementation of a Bitoin node";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskoin-protocol" = callPackage
    ({ mkDerivation, base, binary, bytestring, haskoin-crypto
     , haskoin-util, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "haskoin-protocol";
       version = "0.0.1.1";
       sha256 = "5bbc6c71231b4e4bb7a66aa0142f3d1c65b3272ff46af04b6abb3ceabd662564";
       libraryHaskellDepends = [
         base binary bytestring haskoin-crypto haskoin-util QuickCheck
       ];
       testHaskellDepends = [
         base binary bytestring haskoin-crypto haskoin-util HUnit QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/plaprade/haskoin-protocol";
       description = "Implementation of the Bitcoin network protocol messages";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskoin-script" = callPackage
    ({ mkDerivation, base, binary, bytestring, haskoin-crypto
     , haskoin-protocol, haskoin-util, HUnit, mtl, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "haskoin-script";
       version = "0.0.1";
       sha256 = "21d027aa089809e7412574c3494483001e18252c439119386491c8cd3b2c9ca2";
       libraryHaskellDepends = [
         base binary bytestring haskoin-crypto haskoin-protocol haskoin-util
         mtl QuickCheck
       ];
       testHaskellDepends = [
         base binary bytestring haskoin-crypto haskoin-protocol haskoin-util
         HUnit mtl QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/plaprade/haskoin-script";
       description = "Implementation of Bitcoin script parsing and evaluation";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskoin-util" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, either
     , HUnit, mtl, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "haskoin-util";
       version = "0.0.1.1";
       sha256 = "dc3d4700ee9a4afcb1ee00e52f4af781313c83bf69674bb853175d8db7da0342";
       libraryHaskellDepends = [
         base binary bytestring either mtl QuickCheck
       ];
       testHaskellDepends = [
         base binary bytestring containers either HUnit mtl QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/plaprade/haskoin-util";
       description = "Utility functions for the Network.Haskoin project";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskoin-wallet" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, conduit
     , containers, daemons, data-default, deepseq, directory, esqueleto
     , exceptions, file-embed, filepath, haskoin-core, haskoin-node
     , HUnit, leveldb-haskell, lifted-async, lifted-base, monad-control
     , monad-logger, mtl, persistent, persistent-sqlite
     , persistent-template, QuickCheck, resourcet, SafeSemaphore, split
     , stm, stm-chans, stm-conduit, string-conversions, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , transformers-base, unix, unordered-containers, yaml
     , zeromq4-haskell
     }:
     mkDerivation {
       pname = "haskoin-wallet";
       version = "0.2.0";
       sha256 = "96cf7a0e3310cf1403417287ef4a101f2cb4dbf284b546ebf5b9d3dc426019b9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty base bytestring conduit containers daemons
         data-default deepseq directory esqueleto exceptions file-embed
         filepath haskoin-core haskoin-node leveldb-haskell lifted-async
         lifted-base monad-control monad-logger mtl persistent
         persistent-sqlite persistent-template resourcet SafeSemaphore split
         stm stm-chans stm-conduit string-conversions text time
         transformers-base unix unordered-containers yaml zeromq4-haskell
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         aeson base bytestring containers directory haskoin-core
         haskoin-node HUnit monad-logger mtl persistent persistent-sqlite
         QuickCheck resourcet test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "http://github.com/haskoin/haskoin";
       description = "Implementation of a Bitcoin SPV Wallet with BIP32 and multisig support";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskoon" = callPackage
    ({ mkDerivation, base, bytestring, cgi, directory, fastcgi
     , filepath, hslogger, hsp, hsx, MaybeT, MissingH, mtl, network
     , regex-posix, safe, utf8-string
     }:
     mkDerivation {
       pname = "haskoon";
       version = "0.3.1.1";
       sha256 = "34d125ead181f92c20f9c68e19ea2b6cc0df99d006c202438d38eabb6be0c5e5";
       libraryHaskellDepends = [
         base bytestring cgi directory fastcgi filepath hslogger hsp hsx
         MaybeT MissingH mtl network regex-posix safe utf8-string
       ];
       description = "Web Application Abstraction";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskoon-httpspec" = callPackage
    ({ mkDerivation, base, bidispec, bytestring, haskoon, hslogger
     , HTTP, httpspec, mtl, network
     }:
     mkDerivation {
       pname = "haskoon-httpspec";
       version = "0.5.0.1";
       sha256 = "df747afa2fa84ddd32ebad0dbfe3fbab94fde5b6fbafdb842c41b9a222f73015";
       libraryHaskellDepends = [
         base bidispec bytestring haskoon hslogger HTTP httpspec mtl network
       ];
       description = "Integrating HttpSpec with Haskoon";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskoon-salvia" = callPackage
    ({ mkDerivation, base, bytestring, cgi, fclabels, haskoon, hslogger
     , HTTP, monads-fd, mtl, network, salvia, salvia-protocol
     , transformers
     }:
     mkDerivation {
       pname = "haskoon-salvia";
       version = "0.4.0.2";
       sha256 = "139a2650c76e3d679a859f053495b732df030a3f5498e9b55e7de497da071a34";
       libraryHaskellDepends = [
         base bytestring cgi fclabels haskoon hslogger HTTP monads-fd mtl
         network salvia salvia-protocol transformers
       ];
       description = "Integrating HttpSpec with Haskoon";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskore" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, data-accessor
     , event-list, haskell-src, HUnit, markov-chain, midi, non-negative
     , parsec, process, QuickCheck, random, transformers, utility-ht
     }:
     mkDerivation {
       pname = "haskore";
       version = "0.2.0.8";
       sha256 = "b4ac45e260e8ae417347985cc84062b684e59cc3519d18e765fa2d35f7c3d429";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers data-accessor event-list
         haskell-src markov-chain midi non-negative parsec process random
         transformers utility-ht
       ];
       testHaskellDepends = [
         base bytestring data-accessor event-list HUnit midi non-negative
         process QuickCheck random transformers utility-ht
       ];
       homepage = "http://www.haskell.org/haskellwiki/Haskore";
       description = "The Haskore Computer Music System";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskore-realtime" = callPackage
    ({ mkDerivation, base, bytestring, data-accessor, directory
     , event-list, haskore, midi, non-negative, old-time, process
     , transformers, unix, utility-ht
     }:
     mkDerivation {
       pname = "haskore-realtime";
       version = "0.2";
       sha256 = "aec4fb20124137eabddaa6849bce03714fc9c01937632adf48fe12727774143a";
       libraryHaskellDepends = [
         base bytestring data-accessor directory event-list haskore midi
         non-negative old-time process transformers unix utility-ht
       ];
       homepage = "http://www.haskell.org/haskellwiki/Haskore/";
       description = "Routines for realtime playback of Haskore songs";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskore-supercollider" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, data-accessor
     , event-list, haskore, haskore-realtime, hosc, hsc3, non-negative
     , opensoundcontrol-ht, process, random, supercollider-ht
     , transformers, unix, utility-ht
     }:
     mkDerivation {
       pname = "haskore-supercollider";
       version = "0.3";
       sha256 = "be63b076574e91734cbc7833739195a574acc6ee21a2766d32c52bb4c35c3f13";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers data-accessor event-list haskore
         haskore-realtime hosc hsc3 non-negative opensoundcontrol-ht process
         random supercollider-ht transformers unix utility-ht
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/SuperCollider";
       description = "Haskore back-end for SuperCollider";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskore-synthesizer" = callPackage
    ({ mkDerivation, base, data-accessor, event-list, haskore
     , non-negative, numeric-prelude, random, synthesizer-core
     , synthesizer-filter, utility-ht
     }:
     mkDerivation {
       pname = "haskore-synthesizer";
       version = "0.0.3.2";
       sha256 = "071de904ab39fd812a25395b51fbb6991dc5e22a3b9d2213067a884c0e08f705";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base data-accessor event-list haskore non-negative numeric-prelude
         random synthesizer-core synthesizer-filter utility-ht
       ];
       executableHaskellDepends = [ base synthesizer-core utility-ht ];
       homepage = "http://www.haskell.org/haskellwiki/Synthesizer";
       description = "Music rendering coded in Haskell";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haskore-vintage" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "haskore-vintage";
       version = "0.3";
       sha256 = "0bd49a041c73292d195897a1e8a73713669b09b1a73f3e29251f72223da708ab";
       libraryHaskellDepends = [ base ];
       homepage = "http://haskell.org/haskore/";
       description = "The February 2000 version of Haskore";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hasktags" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, json, unix
     , utf8-string
     }:
     mkDerivation {
       pname = "hasktags";
       version = "0.69.1";
       sha256 = "243f802c581ea7c0327065d2c71f21019dc6d7dc7dfadad9d17fffd8b34df1e6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring directory filepath json unix utf8-string
       ];
       executableHaskellDepends = [ base directory filepath unix ];
       homepage = "http://github.com/MarcWeber/hasktags";
       description = "Produces ctags \"tags\" and etags \"TAGS\" files for Haskell programs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haslo" = callPackage
    ({ mkDerivation, base, mtl, old-time, QuickCheck, time, wtk }:
     mkDerivation {
       pname = "haslo";
       version = "0.1.3";
       sha256 = "748ea9490a714ce5277225dcecc0b0b61ac594a8bca7f7639b69128e526c3f46";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl old-time wtk ];
       executableHaskellDepends = [ mtl old-time QuickCheck time wtk ];
       description = "Loan calculator engine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasloGUI" = callPackage
    ({ mkDerivation, base, convertible, gtk, haslo, lenses, mtl
     , old-time, QuickCheck, time, wtk, wtk-gtk
     }:
     mkDerivation {
       pname = "hasloGUI";
       version = "0.1";
       sha256 = "9d92327775c126dead6798103b5ed638cf2167d707cccf036be1a9637dba5b0d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base convertible gtk haslo lenses mtl old-time QuickCheck time wtk
         wtk-gtk
       ];
       description = "Loan calculator Gtk GUI. Based on haslo (Haskell Loan) library.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasparql-client" = callPackage
    ({ mkDerivation, base, HTTP, monads-fd, network, xml }:
     mkDerivation {
       pname = "hasparql-client";
       version = "0.1";
       sha256 = "f526cdfdf54014ec4cf35de93a9e7360b4bb92ac80caccac46d478406a9bc0d2";
       libraryHaskellDepends = [ base HTTP monads-fd network xml ];
       homepage = "https://github.com/lhpaladin/HaSparql-Client";
       description = "This package enables to write SPARQL queries to remote endpoints";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haspell" = callPackage
    ({ mkDerivation, aspell, base, bytestring }:
     mkDerivation {
       pname = "haspell";
       version = "1.1.0";
       sha256 = "417842bc66321e4e214b1ed6c14d1e837a1a64f5bc0bc37b7f15e52d9f6c3022";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ aspell ];
       homepage = "https://github.com/otters/haspell";
       description = "Haskell bindings to aspell";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) aspell;};

  "hasql_0_4_0" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, bytestring
     , ex-pool, hasql-backend, hasql-postgres, HTF, list-t, loch-th
     , mmorph, monad-control, mtl-prelude, placeholders, safe
     , template-haskell, text, time, transformers, transformers-base
     , vector
     }:
     mkDerivation {
       pname = "hasql";
       version = "0.4.0";
       sha256 = "675c28d5ae59c1ab60f75f0c1a7d4307c91fdf00f790cb67936f4da42ed08ef8";
       libraryHaskellDepends = [
         attoparsec base base-prelude bytestring ex-pool hasql-backend
         list-t loch-th mmorph monad-control placeholders safe
         template-haskell text time transformers transformers-base vector
       ];
       testHaskellDepends = [
         base base-prelude hasql-backend hasql-postgres HTF mtl-prelude
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql";
       description = "A minimalistic general high level API for relational databases";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql_0_4_1" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, bytestring
     , ex-pool, hasql-backend, hasql-postgres, hspec, list-t, loch-th
     , mmorph, monad-control, mtl-prelude, placeholders, safe
     , slave-thread, template-haskell, text, time, transformers
     , transformers-base, vector
     }:
     mkDerivation {
       pname = "hasql";
       version = "0.4.1";
       sha256 = "3a397ea7618407679b7f330b075eefba9569bc8e1313877943d90958d36dfd2f";
       libraryHaskellDepends = [
         attoparsec base base-prelude bytestring ex-pool hasql-backend
         list-t loch-th mmorph monad-control placeholders safe
         template-haskell text time transformers transformers-base vector
       ];
       testHaskellDepends = [
         base base-prelude hasql-backend hasql-postgres hspec mtl-prelude
         slave-thread text
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql";
       description = "A minimalistic general high level API for relational databases";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql_0_7_1" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, either
     , hasql-backend, hasql-postgres, hspec, list-t, mmorph
     , monad-control, mtl, mtl-prelude, resource-pool, slave-thread
     , template-haskell, text, transformers, transformers-base, vector
     }:
     mkDerivation {
       pname = "hasql";
       version = "0.7.1";
       sha256 = "42b7ad242bdafe0c6c342b44b000be969f39ef0fa413f1c6e08c7af154bb6445";
       libraryHaskellDepends = [
         attoparsec base base-prelude either hasql-backend list-t mmorph
         monad-control mtl resource-pool template-haskell text transformers
         transformers-base vector
       ];
       testHaskellDepends = [
         base base-prelude either hasql-backend hasql-postgres hspec
         monad-control mtl-prelude slave-thread text vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql";
       description = "A minimalistic general high level API for relational databases";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql_0_7_2" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, either
     , hasql-backend, hasql-postgres, hspec, list-t, mmorph
     , monad-control, mtl, mtl-prelude, resource-pool, slave-thread
     , template-haskell, text, transformers, transformers-base, vector
     }:
     mkDerivation {
       pname = "hasql";
       version = "0.7.2";
       sha256 = "af35bc0db5b81aacf7b5380890727dba0421be1fbe1267cdbd73d8aceb7fb1bf";
       libraryHaskellDepends = [
         attoparsec base base-prelude either hasql-backend list-t mmorph
         monad-control mtl resource-pool template-haskell text transformers
         transformers-base vector
       ];
       testHaskellDepends = [
         base base-prelude either hasql-backend hasql-postgres hspec
         monad-control mtl-prelude slave-thread text vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql";
       description = "A minimalistic general high level API for relational databases";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql_0_7_3" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, either
     , hasql-backend, hasql-postgres, hspec, list-t, mmorph
     , monad-control, mtl, mtl-prelude, resource-pool, slave-thread
     , template-haskell, text, transformers, transformers-base, vector
     }:
     mkDerivation {
       pname = "hasql";
       version = "0.7.3";
       sha256 = "68e561475c1a5d36ef723201d1013621a4d8d3cb2635c584a4618a8f99651c29";
       libraryHaskellDepends = [
         attoparsec base base-prelude either hasql-backend list-t mmorph
         monad-control mtl resource-pool template-haskell text transformers
         transformers-base vector
       ];
       testHaskellDepends = [
         base-prelude either hasql-backend hasql-postgres hspec
         monad-control mtl-prelude slave-thread text vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql";
       description = "A minimalistic general high level API for relational databases";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql_0_7_3_1" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, either
     , hasql-backend, hasql-postgres, hspec, list-t, mmorph
     , monad-control, mtl, mtl-prelude, resource-pool, slave-thread
     , template-haskell, text, transformers, transformers-base, vector
     }:
     mkDerivation {
       pname = "hasql";
       version = "0.7.3.1";
       sha256 = "84a1b2c64568cc6386c57ce0c7446db5bab25341f421707d352f47b1cd1c2daf";
       libraryHaskellDepends = [
         attoparsec base base-prelude either hasql-backend list-t mmorph
         monad-control mtl resource-pool template-haskell text transformers
         transformers-base vector
       ];
       testHaskellDepends = [
         base-prelude either hasql-backend hasql-postgres hspec
         monad-control mtl-prelude slave-thread text vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql";
       description = "A minimalistic general high level API for relational databases";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql_0_7_3_2" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, either
     , hasql-backend, hasql-postgres, hspec, list-t, mmorph
     , monad-control, mtl, mtl-prelude, resource-pool, slave-thread
     , template-haskell, text, transformers, transformers-base, vector
     }:
     mkDerivation {
       pname = "hasql";
       version = "0.7.3.2";
       sha256 = "95cdeb9487335d1087d51c1d513dd71ab45a0f359586adc218e321cc14d118c2";
       libraryHaskellDepends = [
         attoparsec base base-prelude either hasql-backend list-t mmorph
         monad-control mtl resource-pool template-haskell text transformers
         transformers-base vector
       ];
       testHaskellDepends = [
         base-prelude either hasql-backend hasql-postgres hspec
         monad-control mtl-prelude slave-thread text vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql";
       description = "A minimalistic general high level API for relational databases";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql_0_7_4" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, either
     , hasql-backend, hasql-postgres, hspec, list-t, mmorph
     , monad-control, mtl, mtl-prelude, resource-pool, slave-thread
     , template-haskell, text, transformers, transformers-base, vector
     }:
     mkDerivation {
       pname = "hasql";
       version = "0.7.4";
       sha256 = "c7172de28bf9fdecaff4f2f04b16bfc70994555ebe339c9b96995e224e9d694f";
       libraryHaskellDepends = [
         attoparsec base base-prelude either hasql-backend list-t mmorph
         monad-control mtl resource-pool template-haskell text transformers
         transformers-base vector
       ];
       testHaskellDepends = [
         base-prelude either hasql-backend hasql-postgres hspec
         monad-control mtl-prelude slave-thread text vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql";
       description = "A minimalistic general high level API for relational databases";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql_0_15_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base-prelude, bytestring
     , contravariant, contravariant-extras, data-default-class, dlist
     , either, hashable, hashtables, loch-th, placeholders
     , postgresql-binary, postgresql-libpq, profunctors, QuickCheck
     , quickcheck-instances, scientific, tasty, tasty-hunit
     , tasty-quickcheck, tasty-smallcheck, text, time, transformers
     , uuid, vector
     }:
     mkDerivation {
       pname = "hasql";
       version = "0.15.1";
       sha256 = "8eefdfca21975e215708126b805ee8ba1803e3e3ce32e5c29a1b3e5912ededf8";
       libraryHaskellDepends = [
         aeson attoparsec base base-prelude bytestring contravariant
         contravariant-extras data-default-class dlist either hashable
         hashtables loch-th placeholders postgresql-binary postgresql-libpq
         profunctors scientific text time transformers uuid vector
       ];
       testHaskellDepends = [
         base base-prelude bytestring contravariant contravariant-extras
         data-default-class dlist either hashable profunctors QuickCheck
         quickcheck-instances scientific tasty tasty-hunit tasty-quickcheck
         tasty-smallcheck text time transformers uuid vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql";
       description = "A very efficient PostgreSQL driver and a flexible mapping API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql_0_15_1_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base-prelude, bytestring
     , contravariant, contravariant-extras, data-default-class, dlist
     , either, hashable, hashtables, loch-th, placeholders
     , postgresql-binary, postgresql-libpq, profunctors, QuickCheck
     , quickcheck-instances, scientific, tasty, tasty-hunit
     , tasty-quickcheck, tasty-smallcheck, text, time, transformers
     , uuid, vector
     }:
     mkDerivation {
       pname = "hasql";
       version = "0.15.1.1";
       sha256 = "79a3019362f0973daa719eb8b52d31524c7453833c19044e1c1d9a67b650ce57";
       libraryHaskellDepends = [
         aeson attoparsec base base-prelude bytestring contravariant
         contravariant-extras data-default-class dlist either hashable
         hashtables loch-th placeholders postgresql-binary postgresql-libpq
         profunctors scientific text time transformers uuid vector
       ];
       testHaskellDepends = [
         base base-prelude bytestring contravariant contravariant-extras
         data-default-class dlist either hashable profunctors QuickCheck
         quickcheck-instances scientific tasty tasty-hunit tasty-quickcheck
         tasty-smallcheck text time transformers uuid vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql";
       description = "A very efficient PostgreSQL driver and a flexible mapping API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql_0_19_3_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base-prelude, bytestring
     , contravariant, contravariant-extras, data-default-class, dlist
     , either, hashable, hashtables, loch-th, mtl, placeholders
     , postgresql-binary, postgresql-libpq, profunctors, QuickCheck
     , quickcheck-instances, scientific, tasty, tasty-hunit
     , tasty-quickcheck, tasty-smallcheck, text, time, transformers
     , uuid, vector
     }:
     mkDerivation {
       pname = "hasql";
       version = "0.19.3.3";
       sha256 = "cfface6cef70a7841c233d445610f1bb175de55ea63c25dee7de2942417cd87e";
       libraryHaskellDepends = [
         aeson attoparsec base base-prelude bytestring contravariant
         contravariant-extras data-default-class dlist either hashable
         hashtables loch-th mtl placeholders postgresql-binary
         postgresql-libpq profunctors scientific text time transformers uuid
         vector
       ];
       testHaskellDepends = [
         base base-prelude bytestring contravariant contravariant-extras
         data-default-class dlist either hashable profunctors QuickCheck
         quickcheck-instances scientific tasty tasty-hunit tasty-quickcheck
         tasty-smallcheck text time transformers uuid vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql";
       description = "A very efficient PostgreSQL driver and a flexible mapping API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql_0_19_6" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base-prelude, bytestring
     , contravariant, contravariant-extras, data-default-class, dlist
     , either, hashable, hashtables, loch-th, mtl, placeholders
     , postgresql-binary, postgresql-libpq, profunctors, QuickCheck
     , quickcheck-instances, scientific, tasty, tasty-hunit
     , tasty-quickcheck, tasty-smallcheck, text, time, transformers
     , uuid, vector
     }:
     mkDerivation {
       pname = "hasql";
       version = "0.19.6";
       sha256 = "88f1fe05e48640d133317513c270667c9e745eb9d71d94a9db582ee71b59934c";
       libraryHaskellDepends = [
         aeson attoparsec base base-prelude bytestring contravariant
         contravariant-extras data-default-class dlist either hashable
         hashtables loch-th mtl placeholders postgresql-binary
         postgresql-libpq profunctors scientific text time transformers uuid
         vector
       ];
       testHaskellDepends = [
         base base-prelude bytestring contravariant contravariant-extras
         data-default-class dlist either hashable profunctors QuickCheck
         quickcheck-instances scientific tasty tasty-hunit tasty-quickcheck
         tasty-smallcheck text time transformers uuid vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql";
       description = "A very efficient PostgreSQL driver and a flexible mapping API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base-prelude, bytestring
     , contravariant, contravariant-extras, data-default-class, dlist
     , either, hashable, hashtables, loch-th, mtl, placeholders
     , postgresql-binary, postgresql-libpq, profunctors, QuickCheck
     , quickcheck-instances, scientific, tasty, tasty-hunit
     , tasty-quickcheck, tasty-smallcheck, text, time, transformers
     , uuid, vector
     }:
     mkDerivation {
       pname = "hasql";
       version = "0.19.8";
       sha256 = "34eaaa18216ba49621f7cf4ae5202299c8e2b57b460ac45a8dc161a159a564d1";
       libraryHaskellDepends = [
         aeson attoparsec base base-prelude bytestring contravariant
         contravariant-extras data-default-class dlist either hashable
         hashtables loch-th mtl placeholders postgresql-binary
         postgresql-libpq profunctors scientific text time transformers uuid
         vector
       ];
       testHaskellDepends = [
         base base-prelude bytestring contravariant contravariant-extras
         data-default-class dlist either hashable profunctors QuickCheck
         quickcheck-instances scientific tasty tasty-hunit tasty-quickcheck
         tasty-smallcheck text time transformers uuid vector
       ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql";
       description = "A very efficient PostgreSQL driver and a flexible mapping API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hasql-backend_0_2_1" = callPackage
    ({ mkDerivation, base, base-prelude, bytestring, list-t, text
     , vector
     }:
     mkDerivation {
       pname = "hasql-backend";
       version = "0.2.1";
       sha256 = "8cb9c5563cbe050f586b65267efcbf21a0288a9e06225e43d7ac665c21d53c55";
       libraryHaskellDepends = [
         base base-prelude bytestring list-t text vector
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-backend";
       description = "API for backends of \"hasql\"";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-backend_0_2_2" = callPackage
    ({ mkDerivation, base, base-prelude, bytestring, list-t, text
     , vector
     }:
     mkDerivation {
       pname = "hasql-backend";
       version = "0.2.2";
       sha256 = "a0af8fca6f61dfecccda37fdfd8cdea384c32504e28aa5bd11ae265e6e63df7f";
       libraryHaskellDepends = [
         base base-prelude bytestring list-t text vector
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-backend";
       description = "API for backends of \"hasql\"";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-backend_0_4_0" = callPackage
    ({ mkDerivation, base, base-prelude, bytestring, either, free
     , list-t, text, transformers, vector
     }:
     mkDerivation {
       pname = "hasql-backend";
       version = "0.4.0";
       sha256 = "da5b2a0607976ea4729e6028dbeda92caeefdc613e80058e379ac04a03f85f96";
       libraryHaskellDepends = [
         base base-prelude bytestring either free list-t text transformers
         vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-backend";
       description = "API for backends of \"hasql\"";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-backend_0_4_1" = callPackage
    ({ mkDerivation, base-prelude, bytestring, either, free, list-t
     , text, transformers, vector
     }:
     mkDerivation {
       pname = "hasql-backend";
       version = "0.4.1";
       sha256 = "d56a341835ef2f452df09b2be77d24057e0518e5d9697742d4fc0954145df10c";
       libraryHaskellDepends = [
         base-prelude bytestring either free list-t text transformers vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-backend";
       description = "API for backends of \"hasql\"";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-backend_0_4_1_1" = callPackage
    ({ mkDerivation, base-prelude, bytestring, either, free, list-t
     , text, transformers, vector
     }:
     mkDerivation {
       pname = "hasql-backend";
       version = "0.4.1.1";
       sha256 = "a5b69eb82c1e616c97f0c83f53373d0f415147a5d4e30add3453c879efbe948e";
       libraryHaskellDepends = [
         base-prelude bytestring either free list-t text transformers vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-backend";
       description = "API for backends of \"hasql\"";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-backend" = callPackage
    ({ mkDerivation, base-prelude, bytestring, either, free, list-t
     , text, transformers, vector
     }:
     mkDerivation {
       pname = "hasql-backend";
       version = "0.4.2";
       sha256 = "541a37b288ec5300e9830416a764ef54cce82415b3678c08af526f569e88c20a";
       libraryHaskellDepends = [
         base-prelude bytestring either free list-t text transformers vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-backend";
       description = "API for backends of \"hasql\"";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hasql-optparse-applicative" = callPackage
    ({ mkDerivation, base-prelude, hasql, hasql-pool
     , optparse-applicative
     }:
     mkDerivation {
       pname = "hasql-optparse-applicative";
       version = "0.1";
       sha256 = "42f0b2acdfd1e213f8c30f65abeb063cb62534cb8d8a2f7950201409b00b7ac5";
       libraryHaskellDepends = [
         base-prelude hasql hasql-pool optparse-applicative
       ];
       jailbreak = true;
       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, time }:
     mkDerivation {
       pname = "hasql-pool";
       version = "0.4";
       sha256 = "6bb18b7f41a471e0260a60ecd0a4495ccef111e3151d0b3e55ae5e3865c3850e";
       libraryHaskellDepends = [ base-prelude hasql resource-pool time ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/hasql-pool";
       description = "A pool of connections for Hasql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-postgres_0_7_3" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, bytestring, either
     , hashable, hashtables, hasql, hasql-backend, HTF, list-t, loch-th
     , mmorph, mtl-prelude, old-locale, placeholders, postgresql-binary
     , postgresql-libpq, QuickCheck, quickcheck-instances, SafeSemaphore
     , scientific, slave-thread, template-haskell, text, time
     , transformers, uuid, vector
     }:
     mkDerivation {
       pname = "hasql-postgres";
       version = "0.7.3";
       sha256 = "b9335420ca8efa44e2f14a2f39683ce72537e8d1472c2f5f30acaad1645a301f";
       libraryHaskellDepends = [
         attoparsec base base-prelude bytestring either hashable hashtables
         hasql-backend list-t loch-th mmorph placeholders postgresql-binary
         postgresql-libpq scientific template-haskell text time transformers
         uuid vector
       ];
       testHaskellDepends = [
         attoparsec base base-prelude bytestring either hashable hashtables
         hasql hasql-backend HTF list-t loch-th mmorph mtl-prelude
         old-locale placeholders postgresql-binary postgresql-libpq
         QuickCheck quickcheck-instances SafeSemaphore scientific
         slave-thread template-haskell text time transformers uuid vector
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-postgres";
       description = "A \"PostgreSQL\" backend for the \"hasql\" library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-postgres_0_10_1" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, bytestring
     , directory, doctest, either, filepath, free, hashable, hashtables
     , hasql, hasql-backend, hspec, list-t, loch-th, mmorph, mtl-prelude
     , old-locale, placeholders, postgresql-binary, postgresql-libpq
     , QuickCheck, quickcheck-instances, scientific, template-haskell
     , text, time, transformers, uuid, vector
     }:
     mkDerivation {
       pname = "hasql-postgres";
       version = "0.10.1";
       sha256 = "500591d0aa6fc7779fa7d23b74a946a1d7212e921336caad1cfc860676636fd8";
       libraryHaskellDepends = [
         attoparsec base base-prelude bytestring either free hashable
         hashtables hasql-backend list-t loch-th mmorph placeholders
         postgresql-binary postgresql-libpq scientific template-haskell text
         time transformers uuid vector
       ];
       testHaskellDepends = [
         base base-prelude bytestring directory doctest either filepath
         hashable hasql hasql-backend hspec list-t mtl-prelude old-locale
         postgresql-binary QuickCheck quickcheck-instances scientific text
         time vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-postgres";
       description = "A \"PostgreSQL\" backend for the \"hasql\" library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-postgres_0_10_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base-prelude, bytestring
     , directory, doctest, either, filepath, free, hashable, hashtables
     , hasql, hasql-backend, hspec, list-t, loch-th, mmorph, mtl-prelude
     , old-locale, placeholders, postgresql-binary, postgresql-libpq
     , QuickCheck, quickcheck-instances, scientific, template-haskell
     , text, time, transformers, uuid, vector
     }:
     mkDerivation {
       pname = "hasql-postgres";
       version = "0.10.2";
       sha256 = "05ef12fad5f49f2e530e8bf3c5a15b67be6d07420d758701a90c36c713ee815b";
       libraryHaskellDepends = [
         aeson attoparsec base base-prelude bytestring either free hashable
         hashtables hasql-backend list-t loch-th mmorph placeholders
         postgresql-binary postgresql-libpq scientific template-haskell text
         time transformers uuid vector
       ];
       testHaskellDepends = [
         aeson base base-prelude bytestring directory doctest either
         filepath hashable hasql hasql-backend hspec list-t mtl-prelude
         old-locale postgresql-binary QuickCheck quickcheck-instances
         scientific text time vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-postgres";
       description = "A \"PostgreSQL\" backend for the \"hasql\" library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-postgres_0_10_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base-prelude, bytestring
     , directory, doctest, either, filepath, free, hashable, hashtables
     , hasql, hasql-backend, hspec, list-t, loch-th, mmorph, mtl-prelude
     , old-locale, placeholders, postgresql-binary, postgresql-libpq
     , QuickCheck, quickcheck-instances, scientific, template-haskell
     , text, time, transformers, uuid, vector
     }:
     mkDerivation {
       pname = "hasql-postgres";
       version = "0.10.3";
       sha256 = "9c646df5979d079d64cbe315130ce87b244c42169d6415f807638d48c9178588";
       libraryHaskellDepends = [
         aeson attoparsec base-prelude bytestring either free hashable
         hashtables hasql-backend list-t loch-th mmorph placeholders
         postgresql-binary postgresql-libpq scientific template-haskell text
         time transformers uuid vector
       ];
       testHaskellDepends = [
         aeson base base-prelude bytestring directory doctest either
         filepath hashable hasql hasql-backend hspec list-t mtl-prelude
         old-locale postgresql-binary QuickCheck quickcheck-instances
         scientific text time vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-postgres";
       description = "A \"PostgreSQL\" backend for the \"hasql\" library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-postgres_0_10_3_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base-prelude, bytestring
     , directory, doctest, either, filepath, free, hashable, hashtables
     , hasql, hasql-backend, hspec, list-t, loch-th, mmorph, mtl-prelude
     , old-locale, placeholders, postgresql-binary, postgresql-libpq
     , QuickCheck, quickcheck-instances, scientific, template-haskell
     , text, time, transformers, uuid, vector
     }:
     mkDerivation {
       pname = "hasql-postgres";
       version = "0.10.3.1";
       sha256 = "2ce013174d766c728a049cff1dd917395f9019734faa728503a3f0f48fadb86d";
       libraryHaskellDepends = [
         aeson attoparsec base-prelude bytestring either free hashable
         hashtables hasql-backend list-t loch-th mmorph placeholders
         postgresql-binary postgresql-libpq scientific template-haskell text
         time transformers uuid vector
       ];
       testHaskellDepends = [
         aeson base base-prelude bytestring directory doctest either
         filepath hashable hasql hasql-backend hspec list-t mtl-prelude
         old-locale postgresql-binary QuickCheck quickcheck-instances
         scientific text time vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-postgres";
       description = "A \"PostgreSQL\" backend for the \"hasql\" library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-postgres_0_10_3_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base-prelude, bytestring
     , directory, doctest, either, filepath, free, hashable, hashtables
     , hasql, hasql-backend, hspec, list-t, loch-th, mmorph, mtl-prelude
     , old-locale, placeholders, postgresql-binary, postgresql-libpq
     , QuickCheck, quickcheck-instances, scientific, template-haskell
     , text, time, transformers, uuid, vector
     }:
     mkDerivation {
       pname = "hasql-postgres";
       version = "0.10.3.2";
       sha256 = "e33601742468c8b3671a4ae098c5d414db87f6e075ce0bc4ac014ea3a321b9d8";
       libraryHaskellDepends = [
         aeson attoparsec base-prelude bytestring either free hashable
         hashtables hasql-backend list-t loch-th mmorph placeholders
         postgresql-binary postgresql-libpq scientific template-haskell text
         time transformers uuid vector
       ];
       testHaskellDepends = [
         aeson base base-prelude bytestring directory doctest either
         filepath hashable hasql hasql-backend hspec list-t mtl-prelude
         old-locale postgresql-binary QuickCheck quickcheck-instances
         scientific text time vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-postgres";
       description = "A \"PostgreSQL\" backend for the \"hasql\" library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-postgres_0_10_3_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base-prelude, bytestring
     , directory, doctest, either, filepath, free, hashable, hashtables
     , hasql, hasql-backend, hspec, list-t, loch-th, mmorph, mtl-prelude
     , old-locale, placeholders, postgresql-binary, postgresql-libpq
     , QuickCheck, quickcheck-instances, scientific, template-haskell
     , text, time, transformers, uuid, vector
     }:
     mkDerivation {
       pname = "hasql-postgres";
       version = "0.10.3.3";
       sha256 = "301f4537e86e6ac20b3b2e1a5a16fcdfcec2e0844787e082d54ce7284f0e8c77";
       libraryHaskellDepends = [
         aeson attoparsec base-prelude bytestring either free hashable
         hashtables hasql-backend list-t loch-th mmorph placeholders
         postgresql-binary postgresql-libpq scientific template-haskell text
         time transformers uuid vector
       ];
       testHaskellDepends = [
         aeson base base-prelude bytestring directory doctest either
         filepath hashable hasql hasql-backend hspec list-t mtl-prelude
         old-locale postgresql-binary QuickCheck quickcheck-instances
         scientific text time vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-postgres";
       description = "A \"PostgreSQL\" backend for the \"hasql\" library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-postgres_0_10_4_0" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base-prelude, bytestring
     , directory, doctest, either, filepath, free, hashable, hashtables
     , hasql, hasql-backend, hspec, list-t, loch-th, mmorph, mtl-prelude
     , old-locale, placeholders, postgresql-binary, postgresql-libpq
     , QuickCheck, quickcheck-instances, scientific, template-haskell
     , text, time, transformers, uuid, vector
     }:
     mkDerivation {
       pname = "hasql-postgres";
       version = "0.10.4.0";
       sha256 = "ee6b4fb82fff6003bdfc74be30447508d29e9a83f5d351f9d054d553097a5668";
       libraryHaskellDepends = [
         aeson attoparsec base-prelude bytestring either free hashable
         hashtables hasql-backend list-t loch-th mmorph placeholders
         postgresql-binary postgresql-libpq scientific template-haskell text
         time transformers uuid vector
       ];
       testHaskellDepends = [
         aeson base base-prelude bytestring directory doctest either
         filepath hashable hasql hasql-backend hspec list-t mtl-prelude
         old-locale postgresql-binary QuickCheck quickcheck-instances
         scientific text time vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-postgres";
       description = "A \"PostgreSQL\" backend for the \"hasql\" library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-postgres_0_10_5" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base-prelude, bytestring
     , directory, doctest, either, filepath, free, hashable, hashtables
     , hasql, hasql-backend, hspec, list-t, loch-th, mmorph, mtl-prelude
     , old-locale, placeholders, postgresql-binary, postgresql-libpq
     , QuickCheck, quickcheck-instances, scientific, template-haskell
     , text, time, transformers, uuid, vector
     }:
     mkDerivation {
       pname = "hasql-postgres";
       version = "0.10.5";
       sha256 = "114b137e00975e729a19f5d2195da2db7c9c5080fc8a76821c712a9304a6d29a";
       libraryHaskellDepends = [
         aeson attoparsec base-prelude bytestring either free hashable
         hashtables hasql-backend list-t loch-th mmorph placeholders
         postgresql-binary postgresql-libpq scientific template-haskell text
         time transformers uuid vector
       ];
       testHaskellDepends = [
         aeson base base-prelude bytestring directory doctest either
         filepath hashable hasql hasql-backend hspec list-t mtl-prelude
         old-locale postgresql-binary QuickCheck quickcheck-instances
         scientific text time vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-postgres";
       description = "A \"PostgreSQL\" backend for the \"hasql\" library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-postgres" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base-prelude, bytestring
     , directory, doctest, either, filepath, free, hashable, hashtables
     , hasql, hasql-backend, hspec, list-t, loch-th, mmorph, mtl-prelude
     , old-locale, placeholders, postgresql-binary, postgresql-libpq
     , QuickCheck, quickcheck-instances, scientific, template-haskell
     , text, time, transformers, uuid, vector
     }:
     mkDerivation {
       pname = "hasql-postgres";
       version = "0.10.6";
       sha256 = "068c8de6696ae07a490e14fe83367fc383f2a6a41b9e64c688938f64bc04ec48";
       libraryHaskellDepends = [
         aeson attoparsec base-prelude bytestring either free hashable
         hashtables hasql-backend list-t loch-th mmorph placeholders
         postgresql-binary postgresql-libpq scientific template-haskell text
         time transformers uuid vector
       ];
       testHaskellDepends = [
         aeson base base-prelude bytestring directory doctest either
         filepath hashable hasql hasql-backend hspec list-t mtl-prelude
         old-locale postgresql-binary QuickCheck quickcheck-instances
         scientific text time vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/hasql-postgres";
       description = "A \"PostgreSQL\" backend for the \"hasql\" library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-postgres-options" = callPackage
    ({ mkDerivation, base-prelude, hasql-postgres, optparse-applicative
     }:
     mkDerivation {
       pname = "hasql-postgres-options";
       version = "0.1.5";
       sha256 = "a2204c448f7a494d16f37ae36624914f73fc12bd7f25154d19706ea7302a5a90";
       libraryHaskellDepends = [
         base-prelude hasql-postgres optparse-applicative
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/hasql-postgres-options";
       description = "An \"optparse-applicative\" parser for \"hasql-postgres\"";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-th" = callPackage
    ({ mkDerivation, base-prelude, bytestring, template-haskell, text
     }:
     mkDerivation {
       pname = "hasql-th";
       version = "0.2";
       sha256 = "c08dab84a62bb5adff1e8f0aa2e0a626d1a8347597ca287deebb12b46602a4e4";
       libraryHaskellDepends = [
         base-prelude bytestring template-haskell text
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/hasql-th";
       description = "Template Haskell utilities for Hasql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hasql-transaction" = callPackage
    ({ mkDerivation, base-prelude, bytestring, bytestring-tree-builder
     , contravariant, contravariant-extras, either, hasql, mtl
     , postgresql-error-codes, transformers
     }:
     mkDerivation {
       pname = "hasql-transaction";
       version = "0.4.2";
       sha256 = "b8e6e62cae96802c7f74620106d0e7b17b3fdd8ad0b30f58c81f8c8550ddea49";
       libraryHaskellDepends = [
         base-prelude bytestring bytestring-tree-builder contravariant
         contravariant-extras either hasql mtl postgresql-error-codes
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/hasql-transaction";
       description = "A composable abstraction over the retryable transactions for Hasql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hastache_0_6_0" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers
     , directory, filepath, HUnit, ieee754, mtl, syb, text, transformers
     , utf8-string
     }:
     mkDerivation {
       pname = "hastache";
       version = "0.6.0";
       sha256 = "b033a0dd3a38e0ef0772562bb1d5ed8f535c2fa6955633875ae520a6614dc0fc";
       revision = "3";
       editedCabalFile = "ef93124dacac0dcfb2b13d6cc6e5628682284641897065e145adc062c17e7e6e";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers directory filepath ieee754
         mtl syb text transformers utf8-string
       ];
       testHaskellDepends = [
         base bytestring directory HUnit mtl syb text
       ];
       jailbreak = true;
       homepage = "http://github.com/lymar/hastache";
       description = "Haskell implementation of Mustache templates";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hastache" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers
     , directory, filepath, HUnit, ieee754, mtl, process, syb, text
     , transformers
     }:
     mkDerivation {
       pname = "hastache";
       version = "0.6.1";
       sha256 = "8c8f89669d6125201d7163385ea9055ab8027a69d1513259f8fbdd53c244b464";
       revision = "4";
       editedCabalFile = "10661eb3aea897aae7d81242de0dbba4eb412ee282d3a7343ed88ce626fd6bd8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring containers directory filepath ieee754
         mtl syb text transformers
       ];
       executableHaskellDepends = [
         base blaze-builder bytestring containers directory filepath ieee754
         mtl process syb text transformers
       ];
       testHaskellDepends = [
         base bytestring directory HUnit mtl syb text
       ];
       doCheck = false;
       homepage = "http://github.com/lymar/hastache";
       description = "Haskell implementation of Mustache templates";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hastache-aeson" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, hastache
     , scientific, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "hastache-aeson";
       version = "0.1.1.0";
       sha256 = "361a6102a9cf43facbd75e7d339efed28511ea78f0b667090b75a92c6f3c7371";
       libraryHaskellDepends = [
         aeson base bytestring containers hastache scientific text
         unordered-containers vector
       ];
       homepage = "https://github.com/proger/hastache-aeson";
       description = "render hastache templates using aeson values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haste" = callPackage
    ({ mkDerivation, base, curl, filepath, mtl }:
     mkDerivation {
       pname = "haste";
       version = "0.1.1";
       sha256 = "d22e0568df4f3cc6182aaec8f1e3150ae73bd11e32076bc9a8d6064a4e34e3ef";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base curl filepath mtl ];
       jailbreak = true;
       description = "A universal pastebin tool, written in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haste-compiler" = callPackage
    ({ mkDerivation, array, base, bin-package-db, binary, blaze-builder
     , bytestring, bzlib, Cabal, containers, data-binary-ieee754
     , directory, either, filepath, ghc, ghc-paths, ghc-prim, ghc-simple
     , HTTP, monads-tf, mtl, network, network-uri, process, random
     , shellmate, system-fileio, tar, terminfo, transformers, unix
     , utf8-string, websockets
     }:
     mkDerivation {
       pname = "haste-compiler";
       version = "0.5.4";
       sha256 = "4018bf4abf3ece8ee577ae5983cac0b016ae96098c704aeecd9698365c3a021e";
       configureFlags = [ "-fportable" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers data-binary-ieee754 directory
         filepath ghc ghc-paths ghc-prim monads-tf network network-uri
         process random shellmate transformers utf8-string websockets
       ];
       executableHaskellDepends = [
         array base bin-package-db binary blaze-builder bytestring bzlib
         Cabal containers directory either filepath ghc ghc-paths ghc-prim
         ghc-simple HTTP mtl network network-uri process random shellmate
         system-fileio tar terminfo transformers unix utf8-string
       ];
       homepage = "http://haste-lang.org/";
       description = "Haskell To ECMAScript compiler";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haste-markup" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, haste-lib
     }:
     mkDerivation {
       pname = "haste-markup";
       version = "0.0.1.0";
       sha256 = "c142e266bf76804ed2dffc9e76b4e0e32c59c55aa1e125846182732531a9380b";
       libraryHaskellDepends = [
         base containers directory filepath haste-lib
       ];
       jailbreak = true;
       homepage = "http://github.com/ajnsit/haste-markup";
       description = "A port of blaze-markup and blaze-html to Haste";
       license = stdenv.lib.licenses.mit;
       broken = true;
     }) {haste-lib = null;};

  "haste-perch" = callPackage
    ({ mkDerivation, base, haste-compiler, transformers }:
     mkDerivation {
       pname = "haste-perch";
       version = "0.1.0.9";
       sha256 = "88c57103d12d7f0976fd6ff0adc64ac5fb826f67e25219e46b206b782b5422a9";
       libraryHaskellDepends = [ base haste-compiler transformers ];
       homepage = "https://github.com/agocorona/haste-perch";
       description = "Create, navigate and modify the DOM tree with composable syntax, with the haste compiler";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hastily" = callPackage
    ({ mkDerivation, aeson, base, bytestring, concurrent-extra
     , containers, directory, directory-tree, exceptions, filepath
     , http-client, http-types, hxt, parsec, string-conversions, text
     , unbounded-delays, zip-archive
     }:
     mkDerivation {
       pname = "hastily";
       version = "0.1.0.6";
       sha256 = "d001119682dc0389bbac946793401209c7286a01d9b157fab638ac8fda78a72e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring concurrent-extra containers directory
         directory-tree exceptions filepath http-client http-types hxt
         parsec string-conversions text unbounded-delays zip-archive
       ];
       executableHaskellDepends = [
         base directory string-conversions text
       ];
       testHaskellDepends = [ base ];
       homepage = "http://bitbucket.org/sras/hastily";
       description = "A program to download subtitle files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hasty-hamiltonian" = callPackage
    ({ mkDerivation, ad, base, lens, mcmc-types, mwc-probability, pipes
     , primitive, transformers
     }:
     mkDerivation {
       pname = "hasty-hamiltonian";
       version = "1.1.2";
       sha256 = "479b6a4bf1d9a7af857b584178f75df5460c714f40a2777ebda6079a6c11a93d";
       libraryHaskellDepends = [
         base lens mcmc-types mwc-probability pipes primitive transformers
       ];
       testHaskellDepends = [ ad base mwc-probability ];
       homepage = "http://jtobin.github.com/hasty-hamiltonian";
       description = "Speedy traversal through parameter space";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hat" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , haskeline, haskell-src-exts, old-locale, old-time, polyparse
     , process, random
     }:
     mkDerivation {
       pname = "hat";
       version = "2.9.0.0";
       sha256 = "2e557847aca6531307d0fd9d5f453ea6663a0f7fd41d89896d50455a037e4b17";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory old-locale old-time process random
       ];
       executableHaskellDepends = [
         base bytestring containers directory filepath haskeline
         haskell-src-exts polyparse process
       ];
       homepage = "http://projects.haskell.org/hat/";
       description = "The Haskell tracer, generating and viewing Haskell execution traces";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hatex-guide" = callPackage
    ({ mkDerivation, base, blaze-html, directory, filepath, HaTeX
     , parsec, text, time, transformers
     }:
     mkDerivation {
       pname = "hatex-guide";
       version = "1.3.1.1";
       sha256 = "19bdc6cd223514e0066fa3d74f8a86817f756245838437e9ba4e50faedb21acd";
       libraryHaskellDepends = [
         base blaze-html directory filepath HaTeX parsec text time
         transformers
       ];
       description = "HaTeX User's Guide";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hath" = callPackage
    ({ mkDerivation, base, cmdargs, MissingH, process, split, tasty
     , tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "hath";
       version = "0.3.0";
       sha256 = "a1d7e9643a4f09395f1af453beffca2b371c4bac6003ba16fc5aa1b41c6177fe";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs MissingH split tasty tasty-hunit tasty-quickcheck
       ];
       testHaskellDepends = [
         base cmdargs MissingH process split tasty tasty-hunit
         tasty-quickcheck
       ];
       homepage = "http://michael.orlitzky.com/code/hath.php";
       description = "Hath manipulates network blocks in CIDR notation";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "hatt" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, cmdargs, containers
     , haskeline, parsec, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "hatt";
       version = "1.5.0.3";
       sha256 = "e403602f924c0a1859dbe7f9446138300f024223e8c12126e509917d808af235";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-wl-pprint base containers parsec QuickCheck
       ];
       executableHaskellDepends = [ base cmdargs haskeline ];
       testHaskellDepends = [
         base test-framework test-framework-quickcheck2
       ];
       homepage = "http://extralogical.net/projects/hatt";
       description = "A truth table generator for classical propositional logic";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haverer" = callPackage
    ({ mkDerivation, base, basic-prelude, containers, errors, lens
     , MonadRandom, mtl, random-shuffle, tasty, tasty-hunit
     , tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "haverer";
       version = "0.3.0.0";
       sha256 = "17f8f2c5ca254c4e4cb0f1e0f867ad3fbb5554b9b2a002c2fb029ea524a794dc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base basic-prelude containers errors lens MonadRandom mtl
         random-shuffle tasty tasty-quickcheck text
       ];
       executableHaskellDepends = [ base basic-prelude text ];
       testHaskellDepends = [
         base basic-prelude containers errors mtl random-shuffle tasty
         tasty-hunit tasty-quickcheck text
       ];
       jailbreak = true;
       description = "Implementation of the rules of Love Letter";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hawitter" = callPackage
    ({ mkDerivation, base, base64-string, bytestring, clock, containers
     , gconf, glade, gtk, hoauth, HTTP, json, mtl, network, old-locale
     , parsec, regex-base, regex-tdfa, SHA, time, utf8-string
     }:
     mkDerivation {
       pname = "hawitter";
       version = "0.4";
       sha256 = "acb7a4c3c10cdf5f867c91b325d7e9885c681e23e61d62f14ff4043831110f83";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base base64-string bytestring clock containers gconf glade gtk
         hoauth HTTP json mtl network old-locale parsec regex-base
         regex-tdfa SHA time utf8-string
       ];
       homepage = "http://d.hatena.ne.jp/xanxys/20100321/1269137834";
       description = "A twitter client for GTK+. Beta version.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haxl" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, deepseq
     , directory, exceptions, filepath, hashable, HUnit, pretty, text
     , time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "haxl";
       version = "0.3.1.0";
       sha256 = "fba961b0f3a9a9b6f7cf6ac24689d48fb8404d79ec86a36c2784f3f45d06669a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers deepseq directory exceptions
         filepath hashable HUnit pretty text time unordered-containers
         vector
       ];
       executableHaskellDepends = [ base hashable time ];
       testHaskellDepends = [
         aeson base bytestring containers hashable HUnit text
         unordered-containers
       ];
       homepage = "https://github.com/facebook/Haxl";
       description = "A Haskell library for efficient, concurrent, and concise data access";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haxl-amazonka" = callPackage
    ({ mkDerivation, amazonka, amazonka-core, async, base, conduit
     , hashable, haxl, transformers
     }:
     mkDerivation {
       pname = "haxl-amazonka";
       version = "0.1.0.0";
       sha256 = "7ca933cec8cf15d41384a8f5135713e69da7cd41c9421638afa0980b1c2768ec";
       revision = "1";
       editedCabalFile = "360466927f82110c63cbd3f98da74cfb2e7222ba2828040e4daabcdc8ffee7df";
       libraryHaskellDepends = [
         amazonka amazonka-core async base conduit hashable haxl
         transformers
       ];
       homepage = "http://github.com/tvh/haxl-amazonka#readme";
       description = "Haxl data source for accessing AWS services through amazonka";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haxl-facebook" = callPackage
    ({ mkDerivation, aeson, async, base, conduit, data-default, fb
     , hashable, haxl, http-client-tls, http-conduit, resourcet, text
     , time, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "haxl-facebook";
       version = "0.1.0.0";
       sha256 = "5809694e88020c2378da747a60980599a81a5ff34a4b5561cf4e870235f30d55";
       libraryHaskellDepends = [
         aeson async base conduit data-default fb hashable haxl
         http-client-tls http-conduit resourcet text time transformers
       ];
       testHaskellDepends = [
         aeson async base conduit data-default fb hashable haxl
         http-client-tls http-conduit resourcet text time transformers
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/facebook/Haxl";
       description = "An example Haxl data source for accessing the Facebook Graph API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haxparse" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , data-binary-ieee754, data-default, mtl, optparse-applicative
     , parsec, split, template-haskell, transformers, utf8-string, zlib
     }:
     mkDerivation {
       pname = "haxparse";
       version = "0.3.1.0";
       sha256 = "d2f833c2f78d471817c4a9cddd566cc82f8247a938eb04ed47dafa302bac7a8a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers data-binary-ieee754 data-default
         mtl parsec split template-haskell transformers utf8-string zlib
       ];
       executableHaskellDepends = [
         base binary bytestring containers data-binary-ieee754 data-default
         mtl optparse-applicative parsec split template-haskell transformers
         utf8-string zlib
       ];
       jailbreak = true;
       homepage = "https://github.com/joelteon/haxparse";
       description = "Readable HaxBall replays";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haxr_3000_10_3_1" = callPackage
    ({ mkDerivation, array, base, base64-bytestring, blaze-builder
     , bytestring, HaXml, HTTP, mtl, network, network-uri, old-locale
     , old-time, template-haskell, time, utf8-string
     }:
     mkDerivation {
       pname = "haxr";
       version = "3000.10.3.1";
       sha256 = "f59dde2b28dbfd289622e3245a06ea9adcc9e4535027e5603a34b882a6ce9b2a";
       revision = "1";
       editedCabalFile = "911a81d122ae60328ff513ed2de6e055c051b03a5f88280f602da23e36111918";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring HaXml HTTP
         mtl network network-uri old-locale old-time template-haskell time
         utf8-string
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/HaXR";
       description = "XML-RPC client and server library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haxr_3000_10_4_2" = callPackage
    ({ mkDerivation, array, base, base64-bytestring, blaze-builder
     , bytestring, HaXml, HTTP, mtl, mtl-compat, network, network-uri
     , old-locale, old-time, template-haskell, time, utf8-string
     }:
     mkDerivation {
       pname = "haxr";
       version = "3000.10.4.2";
       sha256 = "3e03494a5d4738751a72b350cc648a149b4d5096371427b5f555594ec7e93aed";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring HaXml HTTP
         mtl mtl-compat network network-uri old-locale old-time
         template-haskell time utf8-string
       ];
       homepage = "http://www.haskell.org/haskellwiki/HaXR";
       description = "XML-RPC client and server library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haxr_3000_11_1_1" = callPackage
    ({ mkDerivation, array, base, base-compat, base64-bytestring
     , blaze-builder, bytestring, HaXml, HsOpenSSL, http-streams
     , http-types, io-streams, mtl, mtl-compat, network, network-uri
     , old-locale, old-time, template-haskell, time, utf8-string
     }:
     mkDerivation {
       pname = "haxr";
       version = "3000.11.1.1";
       sha256 = "d0b9ea22c145ad0fdc8e6a6f464c00046098a7b940eb147ad8d2a84220688a28";
       libraryHaskellDepends = [
         array base base-compat base64-bytestring blaze-builder bytestring
         HaXml HsOpenSSL http-streams http-types io-streams mtl mtl-compat
         network network-uri old-locale old-time template-haskell time
         utf8-string
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/HaXR";
       description = "XML-RPC client and server library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haxr_3000_11_1_2" = callPackage
    ({ mkDerivation, array, base, base-compat, base64-bytestring
     , blaze-builder, bytestring, HaXml, HsOpenSSL, http-streams
     , http-types, io-streams, mtl, mtl-compat, network, network-uri
     , old-locale, old-time, template-haskell, time, utf8-string
     }:
     mkDerivation {
       pname = "haxr";
       version = "3000.11.1.2";
       sha256 = "a8a63a7d7df20472fa8fd2cdc089155292c16e4da34616180dbb33ba3ca0e436";
       libraryHaskellDepends = [
         array base base-compat base64-bytestring blaze-builder bytestring
         HaXml HsOpenSSL http-streams http-types io-streams mtl mtl-compat
         network network-uri old-locale old-time template-haskell time
         utf8-string
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/HaXR";
       description = "XML-RPC client and server library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "haxr" = callPackage
    ({ mkDerivation, array, base, base-compat, base64-bytestring
     , blaze-builder, bytestring, HaXml, HsOpenSSL, http-streams
     , http-types, io-streams, mtl, mtl-compat, network, network-uri
     , old-locale, old-time, template-haskell, time, utf8-string
     }:
     mkDerivation {
       pname = "haxr";
       version = "3000.11.1.3";
       sha256 = "99aafefc48dfd49c4d638dd9b049c602aa69cf22eafa8dcbd5c6b1a3a379ad53";
       libraryHaskellDepends = [
         array base base-compat base64-bytestring blaze-builder bytestring
         HaXml HsOpenSSL http-streams http-types io-streams mtl mtl-compat
         network network-uri old-locale old-time template-haskell time
         utf8-string
       ];
       homepage = "http://www.haskell.org/haskellwiki/HaXR";
       description = "XML-RPC client and server library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haxr-th" = callPackage
    ({ mkDerivation, base, haxr, template-haskell }:
     mkDerivation {
       pname = "haxr-th";
       version = "3000.5";
       sha256 = "2e6aef7e357aefaf3cb559c12ebb0196692d5c1095dc98889279ccc24e262fc0";
       libraryHaskellDepends = [ base haxr template-haskell ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haxr/";
       description = "Automatic deriving of XML-RPC structs for Haskell records";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "haxy" = callPackage
    ({ mkDerivation, base, bytestring, data-default-class, hostname
     , HTTP, http-server, mtl, url
     }:
     mkDerivation {
       pname = "haxy";
       version = "1.0.1";
       sha256 = "6db58fd3433a7c92d660f1c21b11edb739f5cdbe21b47d99336fab2928cd8f4c";
       libraryHaskellDepends = [
         base bytestring data-default-class hostname HTTP http-server mtl
         url
       ];
       homepage = "http://github.com/achudnov/haxy";
       description = "A simple HTTP proxy server library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hayland" = callPackage
    ({ mkDerivation, base, data-flags, mesa, process, template-haskell
     , time, wayland, xml
     }:
     mkDerivation {
       pname = "hayland";
       version = "0.1.0.1";
       sha256 = "c0b7497cb3117593495e5c69a831625289f86f7585c3e82ea7c82bedf0d2f136";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base data-flags process template-haskell time xml
       ];
       librarySystemDepends = [ mesa wayland ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base process xml ];
       jailbreak = true;
       description = "Haskell bindings for the C Wayland library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mesa; inherit (pkgs) wayland;};

  "hayoo-cli" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-conduit, http-types
     , optparse-applicative, pandoc, url
     }:
     mkDerivation {
       pname = "hayoo-cli";
       version = "0.1.0.4";
       sha256 = "405361c83e2b06a82fc60128ed82781c779501feaff1a1a8f543d57ee7ed8e17";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring http-conduit http-types optparse-applicative
         pandoc url
       ];
       jailbreak = true;
       homepage = "https://github.com/Gonzih/hayoo-cli";
       description = "Hayoo CLI";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hback" = callPackage
    ({ mkDerivation, base, cairo, filepath, glade, gtk, haskell98
     , process, svgcairo, time, unix
     }:
     mkDerivation {
       pname = "hback";
       version = "0.0.3";
       sha256 = "b2d4f95942a8dc84d893d99c2f4673f83a0a2494cd6f9800069431a069239d07";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cairo filepath glade gtk haskell98 process svgcairo time unix
       ];
       homepage = "http://hback.googlecode.com/";
       description = "N-back memory game";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hbayes" = callPackage
    ({ mkDerivation, array, base, binary, boxes, containers, directory
     , filepath, gamma, HUnit, mtl, mwc-random, parsec, pretty
     , QuickCheck, random, split, statistics, test-framework
     , test-framework-hunit, test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "hbayes";
       version = "0.5";
       sha256 = "6980ffee8b65dd1710759268ef1d869c50916ebe735c8d28e5cecb52158412fe";
       libraryHaskellDepends = [
         array base binary boxes containers directory filepath gamma HUnit
         mtl mwc-random parsec pretty QuickCheck random split statistics
         test-framework test-framework-hunit test-framework-quickcheck2
         vector
       ];
       homepage = "http://www.alpheccar.org";
       description = "Bayesian Networks";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hbb" = callPackage
    ({ mkDerivation, base, directory, ghc, ghc-mod, ghc-paths, libhbb
     }:
     mkDerivation {
       pname = "hbb";
       version = "0.4.0.2";
       sha256 = "96a7b9e844293b91c0aa4044d2d17cfe6070c4fe7d28c3dac8302d02f6d216f2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory ghc ghc-mod ghc-paths libhbb
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/bhris/hbb";
       description = "Haskell Busy Bee, a backend for text editors";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hbcd" = callPackage
    ({ mkDerivation, base, bytestring, Decimal, digits, split }:
     mkDerivation {
       pname = "hbcd";
       version = "1.0";
       sha256 = "b8915c3a40aa07b507e9cc8b3024906808af63c1890f030b741e4153096994be";
       libraryHaskellDepends = [ base bytestring Decimal digits split ];
       description = "Packed binary-coded decimal (BCD) serialization";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hbeanstalk" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , containers, network
     }:
     mkDerivation {
       pname = "hbeanstalk";
       version = "0.2.4";
       sha256 = "feaf97fd18fedb3e5abf337e61c98a03108d917d9f87f885c8d02b6b838aac8f";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring containers network
       ];
       homepage = "http://github.com/scsibug/hbeanstalk/";
       description = "Client for the beanstalkd workqueue service";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hbeat" = callPackage
    ({ mkDerivation, base, containers, mtl, old-time, OpenGL, SDL
     , SDL-mixer, SDL_mixer
     }:
     mkDerivation {
       pname = "hbeat";
       version = "0.1.2";
       sha256 = "5776e815f293c6baa8a859141dcbb49a418880b39b8af7fe676fd7783997fad1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers mtl old-time OpenGL SDL SDL-mixer
       ];
       executableSystemDepends = [ SDL_mixer ];
       homepage = "http://www.dockerz.net/software/hbeat.html";
       description = "A simple step sequencer GUI";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) SDL_mixer;};

  "hblas" = callPackage
    ({ mkDerivation, base, blas, HUnit, liblapack, primitive
     , storable-complex, tasty, tasty-hunit, vector
     }:
     mkDerivation {
       pname = "hblas";
       version = "0.3.2.1";
       sha256 = "3e159cc8c98735861edad47cd4da11bd5862bb629601a9bc441960c921ae8215";
       revision = "1";
       editedCabalFile = "cf7946aba77f6f23a665fe06859a6ba306b513f5849f9828ed171e84bad4a43e";
       libraryHaskellDepends = [ base primitive storable-complex vector ];
       librarySystemDepends = [ blas liblapack ];
       testHaskellDepends = [ base HUnit tasty tasty-hunit vector ];
       jailbreak = true;
       homepage = "http://github.com/wellposed/hblas/";
       description = "Human friendly BLAS and Lapack bindings for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};

  "hblock" = callPackage
    ({ mkDerivation, aeson, base, blaze-markup, bytestring, cereal
     , containers, deepseq, hashable, path-pieces, safecopy, text
     , unordered-containers, uuid, vector
     }:
     mkDerivation {
       pname = "hblock";
       version = "0.1.0.2";
       sha256 = "7bf0dc5ef70b033464462e741d5cb8c5b1f6c91436dee178bd4c8e1c0591103d";
       revision = "1";
       editedCabalFile = "0182ceac5536afe15ee507e30953ff97f890facf3f15f2766f74f6312036eca6";
       libraryHaskellDepends = [
         aeson base blaze-markup bytestring cereal containers deepseq
         hashable path-pieces safecopy text unordered-containers uuid vector
       ];
       jailbreak = true;
       description = "A mutable vector that provides indexation on the datatype fields it stores";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hbro" = callPackage
    ({ mkDerivation, base, bytestring, classy-prelude, cond, containers
     , data-default-class, directory, dyre, errors, exceptions
     , fast-logger, filepath, glib, gtk3, lens, lifted-async
     , lifted-base, monad-control, monad-logger, mtl, network-uri
     , optparse-applicative, pango, parsec, process, random, resourcet
     , safe, semigroups, stm-chans, text, time, transformers
     , transformers-base, unix, uuid, webkitgtk3, zeromq4-haskell
     }:
     mkDerivation {
       pname = "hbro";
       version = "1.5.0.0";
       sha256 = "8f66263f288dba0e90cce6d6b9d2682b71acc46c2790128cba78b984c7990d6f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring classy-prelude cond containers data-default-class
         directory dyre errors exceptions fast-logger filepath glib gtk3
         lens lifted-async lifted-base monad-control monad-logger mtl
         network-uri optparse-applicative pango parsec process random
         resourcet safe semigroups stm-chans text time transformers
         transformers-base unix uuid webkitgtk3 zeromq4-haskell
       ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/k0ral/hbro";
       description = "Minimal extensible web-browser";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hbro-contrib" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring
     , classy-prelude, containers, directory, glib, gtk3, hbro, lens
     , monad-control, mtl, network-uri, pango, parsec, process
     , resourcet, safe, text, time, transformers-base, unix, webkitgtk3
     }:
     mkDerivation {
       pname = "hbro-contrib";
       version = "1.5.0.0";
       sha256 = "0331c2024f52cfbefba781095e8309fd20cd32082a9a8887c3fcb4f52fc76fbc";
       libraryHaskellDepends = [
         aeson aeson-pretty base bytestring classy-prelude containers
         directory glib gtk3 hbro lens monad-control mtl network-uri pango
         parsec process resourcet safe text time transformers-base unix
         webkitgtk3
       ];
       homepage = "https://github.com/k0ral/hbro-contrib";
       description = "Third-party extensions to hbro";
       license = "unknown";
     }) {};

  "hburg" = callPackage
    ({ mkDerivation, array, base, containers, filepath, haskell98, mtl
     }:
     mkDerivation {
       pname = "hburg";
       version = "1.1.2";
       sha256 = "db311af08ba1a90fdb5b8bd66d02ac073e004f19631419da9615165d1f04ed0d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers filepath haskell98 mtl
       ];
       homepage = "http://www.bytelabs.org/hburg.html";
       description = "Haskell Bottom Up Rewrite Generator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hcc" = callPackage
    ({ mkDerivation, base, bytestring, language-c }:
     mkDerivation {
       pname = "hcc";
       version = "0.0.0";
       sha256 = "97409bf32c59323ad64bcfe10eff7fc17c35089052c0f76611eb055813fd4c11";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bytestring language-c ];
       jailbreak = true;
       homepage = "http://tomahawkins.org";
       description = "A toy C compiler";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hcg-minus" = callPackage
    ({ mkDerivation, base, colour }:
     mkDerivation {
       pname = "hcg-minus";
       version = "0.15";
       sha256 = "b9b422e807f030b35c2d01971dfff9806a11fdb20f506ffde004a4933571e011";
       libraryHaskellDepends = [ base colour ];
       homepage = "http://rd.slavepianos.org/t/hcg-minus";
       description = "haskell cg (minus)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hcg-minus-cairo" = callPackage
    ({ mkDerivation, base, cairo, colour, filepath, hcg-minus
     , utf8-string
     }:
     mkDerivation {
       pname = "hcg-minus-cairo";
       version = "0.15";
       sha256 = "090b4ad88bb25bdb4290d2cc357f920b478cfebf96ad89ad930c7edc14824f00";
       libraryHaskellDepends = [
         base cairo colour filepath hcg-minus utf8-string
       ];
       homepage = "http://rd.slavepianos.org/t/hcg-minus-cairo";
       description = "haskell cg (minus) (cairo rendering)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hcheat" = callPackage
    ({ mkDerivation, base, mps }:
     mkDerivation {
       pname = "hcheat";
       version = "2010.1.16";
       sha256 = "42f96b9075a7ac6a068945edc5490a0f4a0955b1a83d15cfc249c159c2b58fbb";
       libraryHaskellDepends = [ base mps ];
       homepage = "http://github.com/nfjinjing/hcheat/";
       description = "A collection of code cheatsheet";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hchesslib" = callPackage
    ({ mkDerivation, array, attoparsec, base, containers, hlint, hspec
     , QuickCheck, text
     }:
     mkDerivation {
       pname = "hchesslib";
       version = "0.1.0.0";
       sha256 = "3bcb0946c2caf1bc91634ddf51d6e80110c9b6e529e49d83a5ad1d64532be880";
       libraryHaskellDepends = [ array attoparsec base containers text ];
       testHaskellDepends = [
         array attoparsec base containers hlint hspec QuickCheck text
       ];
       homepage = "https://github.com/nablaa/hchesslib";
       description = "Chess library";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hcltest" = callPackage
    ({ mkDerivation, base, bytestring, directory, dlist, doctest
     , either, filepath, free, lens, mmorph, monad-control, mtl
     , optparse-applicative, process, random-shuffle, split, stm, tagged
     , tasty, temporary, text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "hcltest";
       version = "0.3.7";
       sha256 = "ed3530f93c1af0a1fc1fec67d3ee32f5b4a6fcf200c3803124f8fabee0041dc3";
       libraryHaskellDepends = [
         base bytestring directory dlist either filepath free lens mmorph
         monad-control mtl optparse-applicative process random-shuffle split
         stm tagged tasty temporary text transformers transformers-base
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/bennofs/hcltest/";
       description = "A testing library for command line applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hcoap" = callPackage
    ({ mkDerivation, async, base, binary, bytestring, dns, HUnit
     , iproute, mtl, network, network-uri, QuickCheck, random, stm, time
     }:
     mkDerivation {
       pname = "hcoap";
       version = "0.1.2.1";
       sha256 = "eb7c7d22922b758708c4789d53f237b251718a64d163e13807787ad8213782d6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base binary bytestring dns iproute mtl network network-uri
         random stm time
       ];
       executableHaskellDepends = [ base bytestring network network-uri ];
       testHaskellDepends = [
         async base bytestring HUnit network QuickCheck random
       ];
       homepage = "https://github.com/lulf/hcoap";
       description = "CoAP implementation for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hcron" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, mtl
     , old-locale, pretty, process, random, stm, time
     }:
     mkDerivation {
       pname = "hcron";
       version = "0.0.0.3";
       sha256 = "075b1f2a403ff42e60389b2a0bb583f02b496ef35a1beff97ded3923154a7832";
       libraryHaskellDepends = [
         base bytestring containers directory mtl old-locale pretty process
         random stm time
       ];
       jailbreak = true;
       homepage = "http://github.com/tbh/hcron";
       description = "A simple job scheduler, which just runs some IO action at a given time";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hcube" = callPackage
    ({ mkDerivation, base, directory, HaskellForMaths, QuickCheck, text
     }:
     mkDerivation {
       pname = "hcube";
       version = "0.1.1";
       sha256 = "d99d5d18aba9cc3806ad0883128076273f0f3bf7bc925a8bc1625a8e54012fc0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory HaskellForMaths QuickCheck text
       ];
       executableHaskellDepends = [
         base directory HaskellForMaths QuickCheck text
       ];
       description = "Virtual Rubik's cube of arbitrary size";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hcwiid" = callPackage
    ({ mkDerivation, base, bluetooth, cwiid, unix }:
     mkDerivation {
       pname = "hcwiid";
       version = "0.0.5";
       sha256 = "9d249bc8263cb0ad576c64a71bbdd42fb423d2bfb5a2e9cdf449b5d0e64cc136";
       libraryHaskellDepends = [ base unix ];
       librarySystemDepends = [ bluetooth cwiid ];
       homepage = "https://github.com/ivanperez-keera/hcwiid";
       description = "Library to interface with the wiimote";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {bluetooth = null; inherit (pkgs) cwiid;};

  "hdaemonize_0_5_0_0" = callPackage
    ({ mkDerivation, base, extensible-exceptions, filepath, hsyslog
     , mtl, unix
     }:
     mkDerivation {
       pname = "hdaemonize";
       version = "0.5.0.0";
       sha256 = "fb49f9a54a862a3e119de5f1fae9cec9bb09520caffbf4f4b852d7959352be95";
       libraryHaskellDepends = [
         base extensible-exceptions filepath hsyslog mtl unix
       ];
       homepage = "http://github.com/madhadron/hdaemonize";
       description = "Library to handle the details of writing daemons for UNIX";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdaemonize" = callPackage
    ({ mkDerivation, base, extensible-exceptions, filepath, hsyslog
     , mtl, unix
     }:
     mkDerivation {
       pname = "hdaemonize";
       version = "0.5.0.1";
       sha256 = "baa2161085531c54faf4b01a5b54d8ce6c4f4936798b59e0000574b43072aa0d";
       libraryHaskellDepends = [
         base extensible-exceptions filepath hsyslog mtl unix
       ];
       homepage = "http://github.com/greydot/hdaemonize";
       description = "Library to handle the details of writing daemons for UNIX";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hdaemonize-buildfix" = callPackage
    ({ mkDerivation, base, extensible-exceptions, filepath, hsyslog
     , mtl, unix
     }:
     mkDerivation {
       pname = "hdaemonize-buildfix";
       version = "0.4.5";
       sha256 = "c619d495a01b6958d81e93966ed38e47827e716d9852d2a30cbe28c5cef96496";
       libraryHaskellDepends = [
         base extensible-exceptions filepath hsyslog mtl unix
       ];
       homepage = "http://github.com/madhadron/hdaemonize";
       description = "Library to handle the details of writing daemons for UNIX";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdbc-aeson" = callPackage
    ({ mkDerivation, aeson, base, convertible, HDBC, scientific, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "hdbc-aeson";
       version = "0.1.3.2";
       sha256 = "a599a965f9724dfa7f8e25b0b3967a2033a2c33b7fbd40c4fc8aaac2fb0f7711";
       libraryHaskellDepends = [
         aeson base convertible HDBC scientific text unordered-containers
         vector
       ];
       jailbreak = true;
       homepage = "https://github.com/danchoi/hdbc-aeson";
       description = "Deserialize from HDBC rows to FromJSON instances";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hdbc-postgresql-hstore" = callPackage
    ({ mkDerivation, attoparsec, base, containers, HDBC, text }:
     mkDerivation {
       pname = "hdbc-postgresql-hstore";
       version = "0.0.1.1";
       sha256 = "92ab052490fd6f205c65aa9601cf0a6d61ef5450441a978cb6046ef570d59f0c";
       libraryHaskellDepends = [ attoparsec base containers HDBC text ];
       jailbreak = true;
       homepage = "http://bitbucket.com/dpwiz/hdbc-postgresql-hstore";
       description = "Manipulate data in PostgreSQL \"hstore\" columns";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hdbc-tuple" = callPackage
    ({ mkDerivation, base, convertible, HDBC, typical }:
     mkDerivation {
       pname = "hdbc-tuple";
       version = "0.0.1";
       sha256 = "ad71396fe0f8c834f24e3d263496c3966c232fbfa81f38e51b2bb0816856ad94";
       libraryHaskellDepends = [ base convertible HDBC typical ];
       description = "Type save tuples for HDBC";
       license = "GPL";
     }) {};

  "hdbi" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , containers, Decimal, deepseq, derive, hspec-expectations, HUnit
     , old-locale, QuickCheck, quickcheck-assertions
     , quickcheck-instances, stm, template-haskell, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , uuid
     }:
     mkDerivation {
       pname = "hdbi";
       version = "1.3.0";
       sha256 = "82355e0e767a0a449454ecb493cb535225d1642bcc9a2897c878d27434de117d";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring containers Decimal deepseq
         old-locale stm template-haskell text time uuid
       ];
       testHaskellDepends = [
         attoparsec base blaze-builder bytestring containers Decimal deepseq
         derive hspec-expectations HUnit old-locale QuickCheck
         quickcheck-assertions quickcheck-instances stm template-haskell
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time uuid
       ];
       jailbreak = true;
       homepage = "https://github.com/s9gf4ult/hdbi";
       description = "Haskell Database Independent interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdbi-conduit" = callPackage
    ({ mkDerivation, base, conduit, hdbi, hdbi-sqlite, QuickCheck
     , quickcheck-assertions, resourcet, test-framework
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "hdbi-conduit";
       version = "1.3.0";
       sha256 = "f235073547bc19a08d29ecc3d2e56a05a1d4910897b46a37d53b14822a1a2cf3";
       libraryHaskellDepends = [
         base conduit hdbi resourcet transformers
       ];
       testHaskellDepends = [
         base conduit hdbi hdbi-sqlite QuickCheck quickcheck-assertions
         resourcet test-framework test-framework-quickcheck2 transformers
       ];
       homepage = "https://github.com/s9gf4ult/hdbi-conduit";
       description = "Conduit glue for HDBI";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdbi-postgresql" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , containers, Decimal, derive, hdbi, hdbi-tests, HUnit, ieee754
     , mtl, old-locale, postgresql-libpq, postgresql-simple, QuickCheck
     , quickcheck-assertions, quickcheck-instances, safe, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , uuid
     }:
     mkDerivation {
       pname = "hdbi-postgresql";
       version = "1.3.0";
       sha256 = "3dbc951d54013afe2daf574bae3535d0f4deb6743151241faa8b14d6e8b84cba";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring hdbi mtl old-locale
         postgresql-libpq postgresql-simple safe text time uuid
       ];
       testHaskellDepends = [
         attoparsec base blaze-builder bytestring containers Decimal derive
         hdbi hdbi-tests HUnit ieee754 mtl old-locale postgresql-libpq
         postgresql-simple QuickCheck quickcheck-assertions
         quickcheck-instances safe test-framework test-framework-hunit
         test-framework-quickcheck2 text time uuid
       ];
       jailbreak = true;
       homepage = "https://github.com/s9gf4ult/hdbi-postgresql";
       description = "PostgreSQL driver for hdbi";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdbi-sqlite" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, direct-sqlite
     , hdbi, hdbi-tests, test-framework, text
     }:
     mkDerivation {
       pname = "hdbi-sqlite";
       version = "1.3.0";
       sha256 = "04bc007103828e002cd8c02c16d07db9e8218f3a29eda838cf664112762f6e0f";
       libraryHaskellDepends = [
         base blaze-builder bytestring direct-sqlite hdbi text
       ];
       testHaskellDepends = [
         base blaze-builder bytestring direct-sqlite hdbi hdbi-tests
         test-framework text
       ];
       homepage = "https://github.com/s9gf4ult/hdbi-sqlite";
       description = "SQlite driver for HDBI";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdbi-tests" = callPackage
    ({ mkDerivation, base, bytestring, containers, Decimal, hdbi, HUnit
     , ieee754, QuickCheck, quickcheck-assertions, quickcheck-instances
     , stm, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time, uuid
     }:
     mkDerivation {
       pname = "hdbi-tests";
       version = "1.3.0";
       sha256 = "e5491fa9113eee7e5e9b89042bfae811bc3d117c77998d70d5d4818436937967";
       libraryHaskellDepends = [
         base bytestring containers Decimal hdbi HUnit ieee754 QuickCheck
         quickcheck-assertions quickcheck-instances stm test-framework
         test-framework-hunit test-framework-quickcheck2 text time uuid
       ];
       jailbreak = true;
       homepage = "https://github.com/s9gf4ult/hdbi-tests";
       description = "test suite for testing HDBI";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdevtools_0_1_0_6" = callPackage
    ({ mkDerivation, base, Cabal, cmdargs, directory, filepath, ghc
     , ghc-paths, network, syb, time, unix
     }:
     mkDerivation {
       pname = "hdevtools";
       version = "0.1.0.6";
       sha256 = "5309d33a382ec5d6f8b0fe4f8cb3076aabc69951c33677fc1f89882d619b97de";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal cmdargs directory filepath ghc ghc-paths network syb
         time unix
       ];
       homepage = "https://github.com/bitc/hdevtools/";
       description = "Persistent GHC powered background server for FAST haskell development tools";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdevtools_0_1_0_8" = callPackage
    ({ mkDerivation, base, Cabal, cmdargs, directory, filepath, ghc
     , ghc-paths, network, syb, time, unix
     }:
     mkDerivation {
       pname = "hdevtools";
       version = "0.1.0.8";
       sha256 = "27088456a87d1fdbeb472caaec2193d51f34ab782905105cb867801b918d04a9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal cmdargs directory filepath ghc ghc-paths network syb
         time unix
       ];
       homepage = "https://github.com/schell/hdevtools/";
       description = "Persistent GHC powered background server for FAST haskell development tools";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdevtools_0_1_0_9" = callPackage
    ({ mkDerivation, base, Cabal, cmdargs, directory, filepath, ghc
     , ghc-paths, network, syb, time, unix
     }:
     mkDerivation {
       pname = "hdevtools";
       version = "0.1.0.9";
       sha256 = "c6405abfdcba17012d9e4a728f34a652c6ac41fe9c5eac972fd284e800d49c73";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal cmdargs directory filepath ghc ghc-paths network syb
         time unix
       ];
       homepage = "https://github.com/schell/hdevtools/";
       description = "Persistent GHC powered background server for FAST haskell development tools";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdevtools_0_1_1_9" = callPackage
    ({ mkDerivation, base, Cabal, cmdargs, directory, filepath, ghc
     , ghc-paths, network, process, syb, time, unix
     }:
     mkDerivation {
       pname = "hdevtools";
       version = "0.1.1.9";
       sha256 = "4c75a9399e07ba3ea94bab454663b2ef7072f2db6f4b316fce3912cd3da98f33";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal cmdargs directory filepath ghc ghc-paths network process
         syb time unix
       ];
       homepage = "https://github.com/schell/hdevtools/";
       description = "Persistent GHC powered background server for FAST haskell development tools";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdevtools_0_1_2_1" = callPackage
    ({ mkDerivation, base, bin-package-db, Cabal, cmdargs, directory
     , filepath, ghc, ghc-paths, network, process, syb, time, unix
     }:
     mkDerivation {
       pname = "hdevtools";
       version = "0.1.2.1";
       sha256 = "88ec6f28c11a6f04e3db4ab3cb1b17d6c30c10023fd81996b1b66a251d8e65a7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bin-package-db Cabal cmdargs directory filepath ghc ghc-paths
         network process syb time unix
       ];
       homepage = "https://github.com/schell/hdevtools/";
       description = "Persistent GHC powered background server for FAST haskell development tools";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdevtools" = callPackage
    ({ mkDerivation, base, bin-package-db, Cabal, cmdargs, directory
     , filepath, ghc, ghc-paths, network, process, syb, time
     , transformers, unix
     }:
     mkDerivation {
       pname = "hdevtools";
       version = "0.1.2.2";
       sha256 = "e1bb2a45e4911b9b8811e0c43aab3a819fa150829c26489a85ee0f395e2633aa";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bin-package-db Cabal cmdargs directory filepath ghc ghc-paths
         network process syb time transformers unix
       ];
       homepage = "https://github.com/hdevtools/hdevtools/";
       description = "Persistent GHC powered background server for FAST haskell development tools";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hdf" = callPackage
    ({ mkDerivation, base, directory, fgl, fgl-visualize, filepath
     , hosc, hsc3, murmur-hash, process, split, transformers
     }:
     mkDerivation {
       pname = "hdf";
       version = "0.15";
       sha256 = "732e5765796abb6e2b6b0e8ebe572511d8c6006d2f41b8806b1eb6ea294fce86";
       libraryHaskellDepends = [
         base directory fgl fgl-visualize filepath hosc hsc3 murmur-hash
         process split transformers
       ];
       homepage = "http://rd.slavepianos.org/t/hdf";
       description = "HDF: Uniform Rate Audio Signal Processing in Haskell";
       license = "GPL";
     }) {};

  "hdigest" = callPackage
    ({ mkDerivation, base, cgi, Crypto, network, parsec, random, time
     }:
     mkDerivation {
       pname = "hdigest";
       version = "1.0";
       sha256 = "6e103070d2851e203242e974b670366cfa9fab9ff593df987e6039c92c92a9f2";
       libraryHaskellDepends = [
         base cgi Crypto network parsec random time
       ];
       description = "Server-side HTTP Digest (RFC2617) in the CGI monad";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdirect" = callPackage
    ({ mkDerivation, array, base, happy, haskell98, pretty }:
     mkDerivation {
       pname = "hdirect";
       version = "0.21.0";
       sha256 = "c2db117dcc9e9a293dc409ecc7813aaab52d891e0e26328f2866c50966eafeec";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base haskell98 pretty ];
       libraryToolDepends = [ happy ];
       executableHaskellDepends = [ array base haskell98 pretty ];
       executableToolDepends = [ happy ];
       homepage = "http://www.haskell.org/hdirect/";
       description = "An IDL compiler for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdis86" = callPackage
    ({ mkDerivation, base, bytestring, containers, QuickCheck }:
     mkDerivation {
       pname = "hdis86";
       version = "0.2";
       sha256 = "7ab68d30a31e621962eedc72e427f17e6e38536e9c475023d9cccebd30692863";
       libraryHaskellDepends = [ base bytestring containers QuickCheck ];
       homepage = "https://github.com/kmcallister/hdis86";
       description = "Interface to the udis86 disassembler for x86 and x86-64 / AMD64";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdiscount" = callPackage
    ({ mkDerivation, base, bytestring, markdown }:
     mkDerivation {
       pname = "hdiscount";
       version = "0.1.0.0";
       sha256 = "c0dfe335a447ecb0d611a8f7bcaa11cf7b9b639cd1eca2f7e558be53a6bed37c";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ markdown ];
       jailbreak = true;
       homepage = "https://github.com/jamwt/hdiscount";
       description = "Haskell bindings to the Discount markdown library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {markdown = null;};

  "hdm" = callPackage
    ({ mkDerivation, base, directory, process, unix, vty }:
     mkDerivation {
       pname = "hdm";
       version = "0.0.1";
       sha256 = "f06d97c5445a1856bfdd35f321b35c6300a83af417b8416409e34681f922f8e1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory process unix vty ];
       description = "a small display manager";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdocs_0_4_1_3" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
     , filepath, ghc, ghc-paths, haddock-api, MonadCatchIO-transformers
     , mtl, network, process, text, transformers
     }:
     mkDerivation {
       pname = "hdocs";
       version = "0.4.1.3";
       sha256 = "b183e62f2ab16dfaf8161c68a119f49cdb695d6229befa37ef43f4e219214cfd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers filepath ghc ghc-paths haddock-api
         MonadCatchIO-transformers mtl network process text transformers
       ];
       executableHaskellDepends = [
         aeson aeson-pretty base bytestring containers filepath mtl network
         text
       ];
       testHaskellDepends = [ base containers mtl ];
       jailbreak = true;
       homepage = "https://github.com/mvoidex/hdocs";
       description = "Haskell docs tool";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdocs" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, Cabal
     , containers, filepath, ghc, ghc-paths, haddock-api
     , haddock-library, MonadCatchIO-transformers, mtl, network, process
     , text, transformers
     }:
     mkDerivation {
       pname = "hdocs";
       version = "0.4.4.0";
       sha256 = "2805aa45cf53828670d2dcd7b23e5a1720b8062c23f4eea43612a4e142e37994";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring Cabal containers filepath ghc ghc-paths
         haddock-api haddock-library MonadCatchIO-transformers mtl network
         process text transformers
       ];
       executableHaskellDepends = [
         aeson aeson-pretty base bytestring containers filepath mtl network
         text
       ];
       testHaskellDepends = [ base containers mtl ];
       homepage = "https://github.com/mvoidex/hdocs";
       description = "Haskell docs tool";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hdph" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, deepseq
     , hdph-closure, mtl, network, network-info, network-multicast
     , network-transport, network-transport-tcp, random
     , template-haskell, time
     }:
     mkDerivation {
       pname = "hdph";
       version = "0.0.1";
       sha256 = "ca24e2151ddc8e632acb676eb282d1e8ee7419cd375a75de0b8c5d90594ac484";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal containers deepseq hdph-closure mtl network
         network-info network-multicast network-transport
         network-transport-tcp random template-haskell time
       ];
       executableHaskellDepends = [
         base bytestring cereal containers deepseq hdph-closure mtl network
         network-info network-multicast network-transport
         network-transport-tcp random template-haskell time
       ];
       jailbreak = true;
       homepage = "https://github.com/PatrickMaier/HdpH";
       description = "Haskell distributed parallel Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdph-closure" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, containers
     , deepseq, template-haskell
     }:
     mkDerivation {
       pname = "hdph-closure";
       version = "0.0.1";
       sha256 = "a81923db3300cdde075e66b5da3b4b474bbf5aa4bc506cd183ef6e7962b99565";
       libraryHaskellDepends = [
         array base bytestring cereal containers deepseq template-haskell
       ];
       jailbreak = true;
       homepage = "https://github.com/PatrickMaier/HdpH";
       description = "Explicit closures in Haskell distributed parallel Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hdr-histogram" = callPackage
    ({ mkDerivation, base, deepseq, hspec, primitive, QuickCheck
     , random, tagged, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "hdr-histogram";
       version = "0.1.0.0";
       sha256 = "f8780c975a6d918c04eaef674a90a13b84f1d671079ebd6ffd7447378511762c";
       libraryHaskellDepends = [
         base deepseq primitive QuickCheck tagged vector
       ];
       testHaskellDepends = [
         base hspec QuickCheck random tagged vector vector-algorithms
       ];
       homepage = "http://github.com/joshbohde/hdr-histogram#readme";
       description = "Haskell implementation of High Dynamic Range (HDR) Histograms";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "headergen" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, directory
     , filepath, haskeline, time
     }:
     mkDerivation {
       pname = "headergen";
       version = "0.2.0.0";
       sha256 = "ea76d9d8398ebae12ca608d4818e53ecb4685eff2ac6701499a2902457bd81c1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson aeson-pretty base bytestring directory filepath haskeline
         time
       ];
       homepage = "https://github.com/aka-bash0r/headergen";
       description = "Creates a header for a haskell source file";
       license = stdenv.lib.licenses.mit;
     }) {};

  "heap" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "heap";
       version = "1.0.2";
       sha256 = "5a71b435989a320fe693f0f63042c534e8a4e49a535b5c7117159552496f8ff7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base QuickCheck ];
       description = "Heaps in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "heaps_0_3_1" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath }:
     mkDerivation {
       pname = "heaps";
       version = "0.3.1";
       sha256 = "924ba576faaf415bad11a991030a622c5e79b6d29a78d8a08d9207f64f0217c0";
       revision = "1";
       editedCabalFile = "8e3b4bef28315c04ce0b34d8f8b4f38527765569d19c4a1802fe77186b26b55c";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/heaps/";
       description = "Asymptotically optimal Brodal/Okasaki heaps";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "heaps_0_3_2" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath }:
     mkDerivation {
       pname = "heaps";
       version = "0.3.2";
       sha256 = "8678758c23fb73aecae8924cab78f909696c8480a984846697affa9326156bf6";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/heaps/";
       description = "Asymptotically optimal Brodal/Okasaki heaps";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "heaps_0_3_2_1" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath }:
     mkDerivation {
       pname = "heaps";
       version = "0.3.2.1";
       sha256 = "cbc8b15248aaf19b8c8cccdef039c93ae755260638467f79f55e3a1ccc7096bc";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/ekmett/heaps/";
       description = "Asymptotically optimal Brodal/Okasaki heaps";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "heaps" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath }:
     mkDerivation {
       pname = "heaps";
       version = "0.3.3";
       sha256 = "04e358d3e6d8ca7786749b6d3945e18159506f8b21ca48b1913c771dcaae1537";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/ekmett/heaps/";
       description = "Asymptotically optimal Brodal/Okasaki heaps";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "heapsort" = callPackage
    ({ mkDerivation, array, base, QuickCheck }:
     mkDerivation {
       pname = "heapsort";
       version = "0.1.0";
       sha256 = "0aa7894611c78f93db49ece38d3731c20469d091db1ec9977e5e63285dd2fc3b";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [ array base QuickCheck ];
       homepage = "http://wiki.cs.pdx.edu/bartforge/heapsort";
       description = "Heapsort of MArrays as a demo of imperative programming";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hebrew-time" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time
     }:
     mkDerivation {
       pname = "hebrew-time";
       version = "0.1.1";
       sha256 = "c7997ee86df43d5d734df63c5e091543bb7fd75a93d530c1857067e27a8b7932";
       libraryHaskellDepends = [ base time ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 time
       ];
       homepage = "https://github.com/snoyberg/hebrew-time";
       description = "Hebrew dates and prayer times";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hecc" = callPackage
    ({ mkDerivation, base, cereal, crypto-api, hF2 }:
     mkDerivation {
       pname = "hecc";
       version = "0.4.1.1";
       sha256 = "dd6b48dc6b60bf4323f52f1232f9cf47e4d74026246168a3e020a2ab684df0dc";
       libraryHaskellDepends = [ base cereal crypto-api hF2 ];
       description = "Elliptic Curve Cryptography for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hedis_0_6_9" = callPackage
    ({ mkDerivation, attoparsec, base, BoundedChan, bytestring
     , bytestring-lexing, HUnit, mtl, network, resource-pool
     , test-framework, test-framework-hunit, time, vector
     }:
     mkDerivation {
       pname = "hedis";
       version = "0.6.9";
       sha256 = "ead8c36dcb7093be9e414da900e2b6fa2f4bc8723a3a5346020d316c75e79179";
       libraryHaskellDepends = [
         attoparsec base BoundedChan bytestring bytestring-lexing mtl
         network resource-pool time vector
       ];
       testHaskellDepends = [
         base bytestring HUnit mtl test-framework test-framework-hunit time
       ];
       doHaddock = false;
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hedis" = callPackage
    ({ mkDerivation, attoparsec, base, BoundedChan, bytestring
     , bytestring-lexing, HUnit, mtl, network, resource-pool
     , test-framework, test-framework-hunit, time, vector
     }:
     mkDerivation {
       pname = "hedis";
       version = "0.6.10";
       sha256 = "31974bfd8e891a4b54a444dcc86dfdac83875e0c3c5933648884230db72a895d";
       libraryHaskellDepends = [
         attoparsec base BoundedChan bytestring bytestring-lexing mtl
         network resource-pool time vector
       ];
       testHaskellDepends = [
         base bytestring HUnit mtl test-framework test-framework-hunit time
       ];
       doHaddock = false;
       jailbreak = true;
       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;
     }) {};

  "hedis-config" = callPackage
    ({ mkDerivation, aeson, base, hedis, scientific, text, time }:
     mkDerivation {
       pname = "hedis-config";
       version = "0.0.2";
       sha256 = "62be34f977587d64588cf78e52390a6960a93655331a16d7f5bab1d71a1055c7";
       libraryHaskellDepends = [ aeson base hedis scientific text time ];
       homepage = "https://bitbucket.org/s9gf4ult/hedis-config";
       description = "Easy trivial configuration for Redis";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hedis-monadic" = callPackage
    ({ mkDerivation, base, hedis, monad-control, mtl, transformers
     , transformers-base, transformers-compat
     }:
     mkDerivation {
       pname = "hedis-monadic";
       version = "0.0.4";
       sha256 = "1c6113dd9fe35d4c3ea7249f8eb19a6db8dff2e99d1f7b129bc217a332618094";
       libraryHaskellDepends = [
         base hedis monad-control mtl transformers transformers-base
         transformers-compat
       ];
       homepage = "https://bitbucket.org/s9gf4ult/redis-monadic";
       description = "A la MonadReader for Redis connection";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hedis-pile" = callPackage
    ({ mkDerivation, base, binary, bytestring, hedis, hedis-tags, HUnit
     , lifted-base, string-conversions, test-framework
     , test-framework-hunit, transformers
     }:
     mkDerivation {
       pname = "hedis-pile";
       version = "0.6.3";
       sha256 = "1611814eb26fd85527d82a03f18376517e1d8a92e421e3f19cd3d50d897a9c2b";
       libraryHaskellDepends = [
         base binary bytestring hedis hedis-tags string-conversions
         transformers
       ];
       testHaskellDepends = [
         base binary bytestring hedis HUnit lifted-base string-conversions
         test-framework test-framework-hunit transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/akaspin/hedis-pile";
       description = "Caching mandatory data with Redis";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hedis-simple" = callPackage
    ({ mkDerivation, base, bytestring, either, hedis, mtl }:
     mkDerivation {
       pname = "hedis-simple";
       version = "0.1.0.0";
       sha256 = "5b9dbfa52f334c5a8b9a6a42251d3bb8a6d21e6e5660628cc48a95f1f0cd07b7";
       libraryHaskellDepends = [ base bytestring either hedis mtl ];
       jailbreak = true;
       homepage = "http://github.com/sanetracker/hedis-simple";
       description = "A simplified API for hedis";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hedis-tags" = callPackage
    ({ mkDerivation, base, bytestring, hedis, HUnit, lifted-base
     , test-framework, test-framework-hunit, transformers
     }:
     mkDerivation {
       pname = "hedis-tags";
       version = "0.2.3";
       sha256 = "3a3490dbd352d1c16fe2fcc7c26f0fa11192f43243d5341893b21b338cc83235";
       libraryHaskellDepends = [ base bytestring hedis ];
       testHaskellDepends = [
         base bytestring hedis HUnit lifted-base test-framework
         test-framework-hunit transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/akaspin/hedis-tags";
       description = "Tags for hedis";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hedn" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, deepseq
     , hspec, HUnit, mtl, old-locale, QuickCheck, stringsearch
     , template-haskell, text, time, utf8-string, vector
     }:
     mkDerivation {
       pname = "hedn";
       version = "0.1.8.1";
       sha256 = "21a73512dae8076ef6fbd6427cf07d55dc29895307c70f6dbb09a78265b3278b";
       libraryHaskellDepends = [
         attoparsec base bytestring containers deepseq mtl old-locale
         stringsearch text time utf8-string vector
       ];
       testHaskellDepends = [
         base bytestring containers hspec HUnit QuickCheck template-haskell
         text time vector
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/dpwiz/hedn";
       description = "EDN parsing and encoding";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hein" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath
     , http-conduit, process, transformers
     }:
     mkDerivation {
       pname = "hein";
       version = "0.1.0.5";
       sha256 = "c0801015827966d4d59579fec24b3cf413bdffe6ca4ffe7ffca93b0bf74d6c7c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory filepath http-conduit process
         transformers
       ];
       homepage = "https://github.com/khanage/heineken";
       description = "An extensible build helper for haskell, in the vein of leiningen";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "heist_0_14_0_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html
     , bytestring, containers, directory, directory-tree, dlist, errors
     , filepath, hashable, map-syntax, MonadCatchIO-transformers, mtl
     , process, random, text, time, transformers, unordered-containers
     , vector, xmlhtml
     }:
     mkDerivation {
       pname = "heist";
       version = "0.14.0.1";
       sha256 = "7ca43497a5d905152aa39b07b99d9c9b50d91538f5cd416bf565ec926cd313da";
       revision = "1";
       editedCabalFile = "6cc46649ab05899f5c784e81e2dcbda7b9c2f1da43cdefa7dc3462ae59c71eae";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder blaze-html bytestring
         containers directory directory-tree dlist errors filepath hashable
         map-syntax MonadCatchIO-transformers mtl process random text time
         transformers unordered-containers vector xmlhtml
       ];
       jailbreak = true;
       homepage = "http://snapframework.com/";
       description = "An Haskell template system supporting both HTML5 and XML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "heist_0_14_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html
     , bytestring, containers, directory, directory-tree, dlist, errors
     , filepath, hashable, map-syntax, MonadCatchIO-transformers, mtl
     , process, random, text, time, transformers, unordered-containers
     , vector, xmlhtml
     }:
     mkDerivation {
       pname = "heist";
       version = "0.14.1";
       sha256 = "fe298a9da8cdeda369f301c2186b50b19007258643d6f333bf3ed99e5eb6e685";
       revision = "4";
       editedCabalFile = "d61d5b4f4b360c12b46179000fe761037a23182489362188c929476a42248876";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder blaze-html bytestring
         containers directory directory-tree dlist errors filepath hashable
         map-syntax MonadCatchIO-transformers mtl process random text time
         transformers unordered-containers vector xmlhtml
       ];
       jailbreak = true;
       homepage = "http://snapframework.com/";
       description = "An Haskell template system supporting both HTML5 and XML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "heist" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html
     , bytestring, containers, directory, directory-tree, dlist, either
     , filepath, hashable, map-syntax, MonadCatchIO-transformers, mtl
     , process, random, text, time, transformers, unordered-containers
     , vector, xmlhtml
     }:
     mkDerivation {
       pname = "heist";
       version = "0.14.1.1";
       sha256 = "2934ece5e58b4a180a6975c0404a2a48e46b85693822aa6ab18f700a44438e43";
       revision = "2";
       editedCabalFile = "d7030f50fb41e4a8c32cd06493df540268d2c53d6f26f3151b3acd0a7839a85f";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder blaze-html bytestring
         containers directory directory-tree dlist either filepath hashable
         map-syntax MonadCatchIO-transformers mtl process random text time
         transformers unordered-containers vector xmlhtml
       ];
       homepage = "http://snapframework.com/";
       description = "An Haskell template system supporting both HTML5 and XML";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "heist-aeson" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, containers
     , heist, monads-fd, text, vector, xmlhtml
     }:
     mkDerivation {
       pname = "heist-aeson";
       version = "0.5";
       sha256 = "aca56019ef0582098bb775ca4aaacace38098263870358ae954aff0756e619d4";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring containers heist monads-fd text
         vector xmlhtml
       ];
       description = "Use JSON directly from Heist templates";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "heist-async" = callPackage
    ({ mkDerivation, base, heist, template-haskell, text, xmlhtml }:
     mkDerivation {
       pname = "heist-async";
       version = "0.6.0.0";
       sha256 = "94a272d73c0aa83de6f2bc525e42b0aae0d6bce8f57ae3b436463aa31d1b4b99";
       libraryHaskellDepends = [
         base heist template-haskell text xmlhtml
       ];
       homepage = "http://github.com/dbp/heist-async";
       description = "Adding support for asynchronous updates (\"AJAX\") with heist";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "helics" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-show
     , data-default-class, newrelic-collector-client, newrelic-common
     , newrelic-transaction, time, unix
     }:
     mkDerivation {
       pname = "helics";
       version = "0.5.1";
       sha256 = "4cbc6fe323dd997d17b7c3724ec229d78209796133611af3379c7e5ab320721a";
       revision = "1";
       editedCabalFile = "698732187d22f634ca220584e3b4056415c873360a85bc0a4ab7c1e2c86fca3d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring bytestring-show data-default-class time unix
       ];
       librarySystemDepends = [
         newrelic-collector-client newrelic-common newrelic-transaction
       ];
       homepage = "https://github.com/philopon/helics";
       description = "New Relic® agent SDK wrapper for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {newrelic-collector-client = null; newrelic-common = null; 
         newrelic-transaction = null;};

  "helics-wai" = callPackage
    ({ mkDerivation, base, bytestring, data-default-class, helics
     , vault, wai
     }:
     mkDerivation {
       pname = "helics-wai";
       version = "0.5.1";
       sha256 = "61ac00d92870d2c5cb86fb15bcea21a0522bf12665f35b5c2a300ca7094d2b83";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring data-default-class helics vault wai
       ];
       jailbreak = true;
       homepage = "https://github.com/philopon/helics";
       description = "New Relic® agent SDK wrapper for wai";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "helisp" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec, process }:
     mkDerivation {
       pname = "helisp";
       version = "0.1";
       sha256 = "017d79b3e896d5516e3a60da0cc3d5bff9b15496c6d2b815196d1036872c89c8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers mtl parsec process ];
       homepage = "http://www.codersbase.com/index.php/Helisp";
       description = "An incomplete Elisp compiler";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "helium" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, lvmlib, mtl
     , network, parsec, process, Top, transformers, wl-pprint
     }:
     mkDerivation {
       pname = "helium";
       version = "1.8.1";
       sha256 = "b2c0c29c31f495c4d4ab55bec3cfa84dba19efc3cdf2e699bcc350ee0a44936f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory filepath lvmlib mtl network parsec
         process Top transformers wl-pprint
       ];
       executableHaskellDepends = [
         base containers directory filepath lvmlib mtl network parsec
         process Top transformers wl-pprint
       ];
       homepage = "http://www.cs.uu.nl/wiki/bin/view/Helium/WebHome";
       description = "The Helium Compiler";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "helix" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring
     , case-insensitive, containers, cookie, data-default-class
     , filepath, hspec, hspec-wai, hspec-wai-json, http-types
     , mime-types, monad-loops, mtl, path-pieces, random
     , template-haskell, text, vault, wai, wai-app-static, wai-extra
     }:
     mkDerivation {
       pname = "helix";
       version = "0.9.5";
       sha256 = "20e24be12f0db6cf15ec66d28e20e0a14f1fcba79a728aad3843d48f4f581fab";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring case-insensitive containers
         cookie data-default-class filepath http-types mime-types
         monad-loops mtl path-pieces random template-haskell text vault wai
         wai-app-static wai-extra
       ];
       testHaskellDepends = [
         aeson base hspec hspec-wai hspec-wai-json text wai
       ];
       homepage = "https://ajnsit.github.io/helix/";
       description = "Web development micro framework for haskell with typesafe URLs";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hell" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , data-default, directory, filepath, ghc, ghc-paths, haskeline
     , monad-extras, mtl, pdfinfo, process, process-extras, resourcet
     , shell-conduit, split, template-haskell, text, time, transformers
     , unix, utf8-string
     }:
     mkDerivation {
       pname = "hell";
       version = "2.1";
       sha256 = "d452d5dfbd2afde437b5247009ecb42a07cbd3059a7536055d683c92d29cbdcd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra data-default directory
         filepath ghc ghc-paths haskeline monad-extras mtl pdfinfo process
         process-extras resourcet shell-conduit split template-haskell text
         time transformers unix
       ];
       executableHaskellDepends = [ base transformers utf8-string ];
       description = "A Haskell shell based on shell-conduit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hellage" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, hellnet
     , hjpath, hjson, HTTP, Lucu, mtl, network, regex-pcre, safe, stm
     , tar, utf8-string, zlib
     }:
     mkDerivation {
       pname = "hellage";
       version = "0.1.1";
       sha256 = "e5445656b4a38e6863e67e692b44e3285602c2724655ef8c9a90338f05011fbf";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory hellnet hjpath hjson HTTP Lucu
         mtl network regex-pcre safe stm tar utf8-string zlib
       ];
       homepage = "http://bitcheese.net/wiki/hellnet/hellage";
       description = "Distributed hackage mirror";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hellnet" = callPackage
    ({ mkDerivation, base, bytestring, containers, Crypto, directory
     , filepath, haskell98, hjpath, hjson, HTTP, Lucu, mtl, network
     , old-locale, parsec, pretty, process, random, regex-posix, RSA
     , safe, time, unix, uri, utf8-string
     }:
     mkDerivation {
       pname = "hellnet";
       version = "0.1.1";
       sha256 = "a69a9bb754224082b110d4011b33ce64b39162e9f37dd64fc681a6b16cca6439";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring Crypto directory filepath haskell98 hjpath hjson
         HTTP old-locale parsec pretty process random RSA safe time unix uri
         utf8-string
       ];
       executableHaskellDepends = [
         base containers Lucu mtl network regex-posix
       ];
       homepage = "http://bitcheese.net/wiki/hellnet/hspawn";
       description = "Simple, distributed, anonymous data sharing network";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hello" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hello";
       version = "1.0.0.2";
       sha256 = "a7c0b5a2a9e29b07f36904944e47ad6796db6af3b9431cba6b92b0bcb23bd8f4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       homepage = "http://www.haskell.org/hello/";
       description = "Hello World, an example package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "helm" = callPackage
    ({ mkDerivation, base, cairo, containers, cpu, elerea, filepath
     , HUnit, mtl, pango, random, sdl2, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , transformers
     }:
     mkDerivation {
       pname = "helm";
       version = "0.7.1";
       sha256 = "eff90ae15a7af236bc0f431686409869c6a5881e6978bee523f29329b0e95513";
       libraryHaskellDepends = [
         base cairo containers cpu elerea filepath mtl pango random sdl2
         text time transformers
       ];
       testHaskellDepends = [
         base cairo containers elerea HUnit sdl2 test-framework
         test-framework-hunit test-framework-quickcheck2 time
       ];
       jailbreak = true;
       homepage = "http://github.com/switchface/helm";
       description = "A functionally reactive game engine";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "help-esb" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, MissingH
     , network, network-uri, text, uuid
     }:
     mkDerivation {
       pname = "help-esb";
       version = "0.1.6";
       sha256 = "268040d97cbfd240f5c145837ec50559c9a98a98f7be73635bb3c1d19f6fc03b";
       libraryHaskellDepends = [
         aeson base bytestring containers MissingH network network-uri text
         uuid
       ];
       homepage = "https://github.com/helpdotcom/help-esb.hs";
       description = "A Haskell client for the Help.com team's ESB.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hemkay" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, hemkay-core
     , portaudio
     }:
     mkDerivation {
       pname = "hemkay";
       version = "0.2.0";
       sha256 = "34b0caaaf402359b7b1c9474818509245a0f6b422be81cd477470211efb7c199";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base binary bytestring hemkay-core portaudio
       ];
       description = "A module music mixer and player";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hemkay-core" = callPackage
    ({ mkDerivation, array, base, binary, bytestring }:
     mkDerivation {
       pname = "hemkay-core";
       version = "0.1.4";
       sha256 = "09fdc4c089abc6bf1089283e53a37fbffe52ea018b42b17e1bdc7a990e0a242f";
       libraryHaskellDepends = [ array base binary bytestring ];
       description = "A device independent module music mixer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hemokit" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring, cairo
     , cipher-aes, conduit, deepseq, deepseq-generics, gtk, hidapi
     , hspec, HUnit, mtl, network-simple, optparse-applicative
     , pretty-show, robot, split, svgcairo, text, time, transformers
     , vector, vector-fftw, websockets
     }:
     mkDerivation {
       pname = "hemokit";
       version = "0.6.6";
       sha256 = "83ee3c5ace9f86602249ed3d66f0b4d81dfea97b477685ef43a097417713df55";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring cipher-aes conduit deepseq
         deepseq-generics hidapi mtl network-simple optparse-applicative
         text vector websockets
       ];
       executableHaskellDepends = [
         aeson base bytestring cairo conduit gtk mtl network-simple
         optparse-applicative pretty-show robot split svgcairo time
         transformers vector vector-fftw websockets
       ];
       testHaskellDepends = [ base bytestring hspec HUnit vector ];
       homepage = "https://github.com/nh2/hemokit";
       description = "Haskell port of the Emokit EEG project";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hen" = callPackage
    ({ mkDerivation, base, bitset, exceptions, mtl, QuickCheck, tasty
     , tasty-quickcheck, transformers, uuid, xenctrl
     }:
     mkDerivation {
       pname = "hen";
       version = "0.1.3";
       sha256 = "9446fd9879835fd107f71e1e127c9f1f59771f3de4a62cba4ca00a567b5e26e6";
       libraryHaskellDepends = [
         base bitset exceptions mtl transformers uuid
       ];
       librarySystemDepends = [ xenctrl ];
       testHaskellDepends = [
         base bitset exceptions mtl QuickCheck tasty tasty-quickcheck
         transformers uuid
       ];
       jailbreak = true;
       homepage = "https://github.com/selectel/hen";
       description = "Haskell bindings to Xen hypervisor interface";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {xenctrl = null;};

  "henet" = callPackage
    ({ mkDerivation, base, bitset, bytestring, network, typesafe-endian
     }:
     mkDerivation {
       pname = "henet";
       version = "1.3.9.3";
       sha256 = "58957f9aa80bec0dcab3b3d656019bd9f114675d881140583cc4b07caca5a55e";
       libraryHaskellDepends = [
         base bitset bytestring network typesafe-endian
       ];
       description = "Bindings and high level interface for to ENet v1.3.9";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hepevt" = callPackage
    ({ mkDerivation, bytestring, haskell2010, lha }:
     mkDerivation {
       pname = "hepevt";
       version = "0.5";
       sha256 = "7f883a4f0461856aed1ae688879346406b43ee42934488d292f6b3f5ddf7fa2c";
       libraryHaskellDepends = [ bytestring haskell2010 lha ];
       description = "HEPEVT parser";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "her-lexer" = callPackage
    ({ mkDerivation, base, mtl, split }:
     mkDerivation {
       pname = "her-lexer";
       version = "0.1.1";
       sha256 = "be8add2ffa92ccd7fa3a8a9dab57bc4856559fba63012771c9beb68f32227dc1";
       libraryHaskellDepends = [ base mtl split ];
       homepage = "http://personal.cis.strath.ac.uk/~conor/pub/she";
       description = "A lexer for Haskell source code";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "her-lexer-parsec" = callPackage
    ({ mkDerivation, base, her-lexer, parsec, transformers }:
     mkDerivation {
       pname = "her-lexer-parsec";
       version = "0.0.0";
       sha256 = "f6d1f3fbfccaeb97f0efc90e83156dc18a33545a082b8860cf517635636a6cbe";
       libraryHaskellDepends = [ base her-lexer parsec transformers ];
       description = "Parsec frontend to \"her-lexer\" for Haskell source code";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "herbalizer" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, indents, mtl, parsec
     , regex-posix
     }:
     mkDerivation {
       pname = "herbalizer";
       version = "0.4.9";
       sha256 = "46772794de683dd90b3c09dd5fb57e01af6aec0fb2aea6ba26e3c47083f2a1be";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers ghc-prim indents mtl parsec regex-posix
       ];
       homepage = "https://github.com/danchoi/herbalizer";
       description = "HAML to ERB translator";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "here_1_2_6" = callPackage
    ({ mkDerivation, base, haskell-src-meta, mtl, parsec
     , template-haskell
     }:
     mkDerivation {
       pname = "here";
       version = "1.2.6";
       sha256 = "2ef2c5d4a97a76ade2de80c8b06d706310a9ad2c630ab69b45710aa28a02ebb0";
       libraryHaskellDepends = [
         base haskell-src-meta mtl parsec template-haskell
       ];
       jailbreak = true;
       homepage = "https://github.com/tmhedberg/here";
       description = "Here docs & interpolated strings via quasiquotation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "here" = callPackage
    ({ mkDerivation, base, haskell-src-meta, mtl, parsec
     , template-haskell
     }:
     mkDerivation {
       pname = "here";
       version = "1.2.7";
       sha256 = "263f525f207d662874874c20c7caec342de9acdeea96c3e2312ebaf1dcc712bb";
       libraryHaskellDepends = [
         base haskell-src-meta mtl parsec template-haskell
       ];
       homepage = "https://github.com/tmhedberg/here";
       description = "Here docs & interpolated strings via quasiquotation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "heredoc" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "heredoc";
       version = "0.2.0.0";
       sha256 = "c90d9fc61cb8cd812be510845493b6a6eddcc4b772581fd40a9433ed8f130f40";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://hackage.haskell.org/package/heredoc";
       description = "multi-line string / here document using QuasiQuotes";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "herf-time" = callPackage
    ({ mkDerivation, base, doctest, time }:
     mkDerivation {
       pname = "herf-time";
       version = "0.2.2";
       sha256 = "9554f70b4399e11d8ea1a49c03ec80d27e471e1a94bbb1542ea5b85aa821d68e";
       libraryHaskellDepends = [ base time ];
       testHaskellDepends = [ base doctest ];
       description = "haskell time manipulation in a 'kerf like' style";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hermit" = callPackage
    ({ mkDerivation, alex, ansi-terminal, array, base, base-compat
     , containers, data-default-class, directory, ghc, happy, haskeline
     , kure, marked-pretty, mtl, process, stm, temporary, terminfo
     , transformers, transformers-compat
     }:
     mkDerivation {
       pname = "hermit";
       version = "1.0.0.0";
       sha256 = "7b66b8d8c9d1f6eb2c7e37dfc932884f299e26e80b6dad163174f428c47d6dd4";
       revision = "1";
       editedCabalFile = "e16afd9af9b41f5d2f1e30625045865bb315f0c8daf469a0f5b491064323060d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal array base base-compat containers data-default-class
         directory ghc haskeline kure marked-pretty mtl process stm
         temporary terminfo transformers transformers-compat
       ];
       libraryToolDepends = [ alex happy ];
       executableHaskellDepends = [ base ];
       description = "Haskell Equational Reasoning Model-to-Implementation Tunnel";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hermit-syb" = callPackage
    ({ mkDerivation, base, containers, ghc, ghc-prim, hermit, syb
     , template-haskell
     }:
     mkDerivation {
       pname = "hermit-syb";
       version = "0.1.0.0";
       sha256 = "3d181379d568479c4d2935e6dd6e6a00eb6b5ac8081e28ae6de66084f0b1e0a4";
       libraryHaskellDepends = [
         base containers ghc ghc-prim hermit syb template-haskell
       ];
       description = "HERMIT plugin for optimizing Scrap-Your-Boilerplate traversals";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hero-club-five-tenets" = callPackage
    ({ mkDerivation, base, random, text }:
     mkDerivation {
       pname = "hero-club-five-tenets";
       version = "0.3.0.3";
       sha256 = "b706afb5213aa5be028e27193e2df10e8f5de7ad1952f41bb16796949fbada3b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base random text ];
       executableHaskellDepends = [ base random text ];
       homepage = "https://github.com/i-amd3/hero-club-five-tenets";
       description = "Think back of the five tenets of hero club";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "heroku" = callPackage
    ({ mkDerivation, base, hspec, network-uri, text }:
     mkDerivation {
       pname = "heroku";
       version = "0.1.2.3";
       sha256 = "53748229bd82fc9b24c682b278c4f58256086bc3dcc9ed6b96f4c86a6fd38dbe";
       libraryHaskellDepends = [ base network-uri text ];
       testHaskellDepends = [ base hspec network-uri text ];
       homepage = "https://github.com/gregwebs/haskell-heroku";
       description = "helpers for deploying to Heroku";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "heroku-persistent" = callPackage
    ({ mkDerivation, base, bytestring, heroku, hspec
     , persistent-postgresql, text
     }:
     mkDerivation {
       pname = "heroku-persistent";
       version = "0.1.0";
       sha256 = "6ef14323b7f054fd140aa3300199f0a7ea5326e68ed7f4bda04891d9cc0144f3";
       libraryHaskellDepends = [
         base bytestring heroku persistent-postgresql text
       ];
       testHaskellDepends = [ base hspec persistent-postgresql ];
       description = "Parse DATABASE_URL into configuration types for Persistent";
       license = stdenv.lib.licenses.mit;
     }) {};

  "herringbone" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory
     , http-types, mtl, old-locale, process, process-listlike
     , system-fileio, system-filepath, text, time, transformers
     , unix-compat
     }:
     mkDerivation {
       pname = "herringbone";
       version = "0.1.1";
       sha256 = "b37248062624c51e3b7a5a6d99744d26089902cf2e94fec837a5dad888f8edf6";
       libraryHaskellDepends = [
         base bytestring containers directory http-types mtl old-locale
         process process-listlike system-fileio system-filepath text time
         transformers unix-compat
       ];
       description = "A library for compiling and serving static web assets";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "herringbone-embed" = callPackage
    ({ mkDerivation, base, bytestring, file-embed, herringbone
     , system-fileio, system-filepath, template-haskell, text
     }:
     mkDerivation {
       pname = "herringbone-embed";
       version = "0.1.1";
       sha256 = "0686594f29deaee24a9b8c1eefc4cc608365b35d862b0fba22cb82e79298200a";
       libraryHaskellDepends = [
         base bytestring file-embed herringbone system-fileio
         system-filepath template-haskell text
       ];
       description = "Embed preprocessed web assets in your executable with Template Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "herringbone-wai" = callPackage
    ({ mkDerivation, base, bytestring, herringbone, http-types
     , system-fileio, system-filepath, text, time, wai, wai-app-static
     }:
     mkDerivation {
       pname = "herringbone-wai";
       version = "0.1.1";
       sha256 = "0ea034a1efa9a58feaca4f208ddc0ddc564da651b784c1d355fe2b8c13b280cf";
       libraryHaskellDepends = [
         base bytestring herringbone http-types system-fileio
         system-filepath text time wai wai-app-static
       ];
       description = "Wai adapter for the Herringbone web asset preprocessor";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hesql" = callPackage
    ({ mkDerivation, base, filepath, haskell-src, HDBC, HDBC-postgresql
     , hssqlppp, parsec
     }:
     mkDerivation {
       pname = "hesql";
       version = "0.8";
       sha256 = "8a57e56ac331fc63517a00ce7ab0069ee3f30ab8f0b84a112992233b56a9b5f7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base filepath haskell-src HDBC HDBC-postgresql hssqlppp parsec
       ];
       jailbreak = true;
       description = "Haskell's embedded SQL";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hetero-map" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hetero-map";
       version = "0.21";
       sha256 = "677e2bbc0774b93e7b2e9d887535b0a07895c001d88f0a99c4af283fcf90dfba";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/luqui/hetero-map";
       description = "Pure heterogeneous maps";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hetris" = callPackage
    ({ mkDerivation, array, base, hscurses, ncurses, old-time, random
     }:
     mkDerivation {
       pname = "hetris";
       version = "0.2";
       sha256 = "dd2399c0ab8d0bdc03c2cc41ed814b99c1ef083b425af0e3c1fdac3f7d7e406a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base hscurses old-time random ];
       executableSystemDepends = [ ncurses ];
       homepage = "http://web.comlab.ox.ac.uk/oucl/work/ian.lynagh/Hetris/";
       description = "Text Tetris";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) ncurses;};

  "heukarya" = callPackage
    ({ mkDerivation, base, containers, deepseq, parallel, random, text
     }:
     mkDerivation {
       pname = "heukarya";
       version = "0.2.0.2";
       sha256 = "afb321566f3276d7f5c6ad9241b7a8db14f3aea3e7547e006448b6cc92f08ef9";
       libraryHaskellDepends = [
         base containers deepseq parallel random text
       ];
       homepage = "https://github.com/t3476/heukarya";
       description = "A genetic programming based on tree structure";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hevolisa" = callPackage
    ({ mkDerivation, base, bytestring, cairo, filepath, haskell98 }:
     mkDerivation {
       pname = "hevolisa";
       version = "0.0.1";
       sha256 = "5a28d8c5ba95676ca664982ea66bbbe3c8eee04f04d6b7c537966f9b1bee47fb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cairo filepath haskell98
       ];
       description = "Genetic Mona Lisa problem in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hevolisa-dph" = callPackage
    ({ mkDerivation, base, bytestring, cairo, dph-seq, filepath
     , haskell98
     }:
     mkDerivation {
       pname = "hevolisa-dph";
       version = "0.0.1";
       sha256 = "6b8e2b6a8996a47b8e72ea68e9b1c18cd4d738f90408bb8b2eede4315ab75e4b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cairo dph-seq filepath haskell98
       ];
       description = "Genetic Mona Lisa problem in Haskell - using Data Parallel Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hex" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "hex";
       version = "0.1.2";
       sha256 = "12ee1243edd80570a486521565fb0c9b5e39374f21a12f050636e71d55ec61ec";
       libraryHaskellDepends = [ base bytestring ];
       description = "Convert strings into hexadecimal and back";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hexdump" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hexdump";
       version = "0.1";
       sha256 = "0c5a26f9e093392fc39abdd6b8d788e4abbd8f4ecdaf362c1c99439cac9d5004";
       libraryHaskellDepends = [ base ];
       description = "A library for forming hexdumps";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "hexif" = callPackage
    ({ mkDerivation, base, binary, bytestring, filepath }:
     mkDerivation {
       pname = "hexif";
       version = "0.2.0.0";
       sha256 = "14d344b138c1858d314df98f3b6676e75f7af523aad4ed9c8bac9264f42e5bab";
       libraryHaskellDepends = [ base binary bytestring filepath ];
       jailbreak = true;
       homepage = "http://www.github.com/hansroland/hexif";
       description = "Reading Exif data form a JPEG file with Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hexpat" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, List, text
     , transformers, utf8-string
     }:
     mkDerivation {
       pname = "hexpat";
       version = "0.20.9";
       sha256 = "5d1c075f1ae00be2e80c0018b522a351b2f4ef73b9baca1113ee80e554449d9d";
       libraryHaskellDepends = [
         base bytestring containers deepseq List text transformers
         utf8-string
       ];
       homepage = "http://haskell.org/haskellwiki/Hexpat/";
       description = "XML parser/formatter based on expat";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hexpat-iteratee" = callPackage
    ({ mkDerivation, base, bytestring, containers
     , extensible-exceptions, hexpat, iteratee, List, parallel
     , transformers
     }:
     mkDerivation {
       pname = "hexpat-iteratee";
       version = "0.6";
       sha256 = "165b8087dad4b9876155a24e15f9971ab0e710c1cfcc9a32a4289487737e9881";
       libraryHaskellDepends = [
         base bytestring containers extensible-exceptions hexpat iteratee
         List parallel transformers
       ];
       jailbreak = true;
       homepage = "http://haskell.org/haskellwiki/Hexpat/";
       description = "Chunked XML parsing using iteratees";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hexpat-lens" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, hexpat, hexpat-tagsoup
     , lens
     }:
     mkDerivation {
       pname = "hexpat-lens";
       version = "0.1.4";
       sha256 = "35783e1bb8654ac74866b7910f7f58385a78d0005d05c26bc7efd36ca9827978";
       libraryHaskellDepends = [
         base bytestring deepseq hexpat hexpat-tagsoup lens
       ];
       homepage = "https://github.com/tel/hexpat-lens";
       description = "Lenses for Hexpat";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hexpat-pickle" = callPackage
    ({ mkDerivation, base, bytestring, containers
     , extensible-exceptions, hexpat, text, utf8-string
     }:
     mkDerivation {
       pname = "hexpat-pickle";
       version = "0.6";
       sha256 = "35fd19c2eb6ffaf2bd248e2fae0a3f0d546155044b9d15f872bd935f13d101cc";
       libraryHaskellDepends = [
         base bytestring containers extensible-exceptions hexpat text
         utf8-string
       ];
       homepage = "http://code.haskell.org/hexpat-pickle/";
       description = "XML picklers based on hexpat, source-code-similar to those of the HXT package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hexpat-pickle-generic" = callPackage
    ({ mkDerivation, base, bytestring, hexpat, QuickCheck
     , test-framework, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "hexpat-pickle-generic";
       version = "0.1.7";
       sha256 = "3a5655154f8ad30501a6327d4b4b0ceeb7a9758bea4024b0fce84da7822d1050";
       libraryHaskellDepends = [ base bytestring hexpat text ];
       testHaskellDepends = [
         base bytestring QuickCheck test-framework
         test-framework-quickcheck2
       ];
       description = "Picklers for de/serialising Generic data types to and from XML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hexpat-tagsoup" = callPackage
    ({ mkDerivation, base, hexpat, tagsoup }:
     mkDerivation {
       pname = "hexpat-tagsoup";
       version = "0.1";
       sha256 = "529d54a4e42e917310a81b9a09eb3999034aff3341dcda2982a016b50c210111";
       libraryHaskellDepends = [ base hexpat tagsoup ];
       description = "Parse (possibly malformed) HTML to hexpat tree";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hexpr" = callPackage
    ({ mkDerivation, base, data-ref, either, mtl, parsec, transformers
     }:
     mkDerivation {
       pname = "hexpr";
       version = "0.0.0.0";
       sha256 = "9b97a71dc842c30d17fe9fe8863ab9641ded3ef7010494c6157918dafa5ff572";
       libraryHaskellDepends = [
         base data-ref either mtl parsec transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/Zankoku-Okuno/hexpr/";
       description = "A framework for symbolic, homoiconic languages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hexquote" = callPackage
    ({ mkDerivation, base, bytestring, containers, parsec
     , template-haskell
     }:
     mkDerivation {
       pname = "hexquote";
       version = "0.1";
       sha256 = "0843617c10e81c7c5f133004649a5b6662f01eaf13375af95adb8b3085d5203b";
       libraryHaskellDepends = [
         base bytestring containers parsec template-haskell
       ];
       description = "Hexadecimal ByteString literals, with placeholders that bind variables";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hexstring" = callPackage
    ({ mkDerivation, aeson, base, base16-bytestring, binary, bytestring
     , hspec, text
     }:
     mkDerivation {
       pname = "hexstring";
       version = "0.11.1";
       sha256 = "40d8dbfe22f572ffdb73f28c448b228a75008e83cc3bf78e939add0c9d800914";
       libraryHaskellDepends = [
         aeson base base16-bytestring binary bytestring text
       ];
       testHaskellDepends = [ base binary bytestring hspec text ];
       homepage = "http://www.leonmergen.com/opensource.html";
       description = "Fast and safe representation of a hex string";
       license = stdenv.lib.licenses.mit;
     }) {};

  "heyefi" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, configurator
     , containers, directory, exceptions, filepath, HandsomeSoup, hspec
     , hspec-wai, http-types, hxt, iso8601-time, MissingH, mtl
     , multipart, optparse-applicative, random, silently, stm, tar
     , temporary, text, time, transformers, unix, unordered-containers
     , utf8-string, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "heyefi";
       version = "1.0.0.0";
       sha256 = "76faae3d15478468c5c77021e8de886143da550e11e540fbd0e4abf8e1f24886";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring case-insensitive configurator directory exceptions
         filepath HandsomeSoup http-types hxt iso8601-time MissingH mtl
         multipart optparse-applicative random stm tar temporary text time
         transformers unix unordered-containers utf8-string wai warp
       ];
       testHaskellDepends = [
         base bytestring case-insensitive configurator containers directory
         exceptions filepath HandsomeSoup hspec hspec-wai http-types hxt
         iso8601-time MissingH mtl multipart optparse-applicative random
         silently stm tar temporary text time transformers unix
         unordered-containers utf8-string wai wai-extra warp
       ];
       homepage = "https://github.com/ryantm/heyefi";
       description = "A server for Eye-Fi SD cards";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "hfann" = callPackage
    ({ mkDerivation, base, doublefann, fann }:
     mkDerivation {
       pname = "hfann";
       version = "0.4.2";
       sha256 = "5a25fc2af7f99f1ba0d25394f7f98c657c24aa5d9a193bfdce71981f3311f926";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ doublefann ];
       libraryPkgconfigDepends = [ fann ];
       executableHaskellDepends = [ base ];
       executableSystemDepends = [ doublefann ];
       description = "Haskell binding to the FANN library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {doublefann = null; fann = null;};

  "hfd" = callPackage
    ({ mkDerivation, base, bytestring, haskeline, iteratee, MissingH
     , MonadCatchIO-transformers, network, transformers
     }:
     mkDerivation {
       pname = "hfd";
       version = "0.0.2";
       sha256 = "a44cc58088e771ec0ead9e5eda187ce412e50f5e9e1aaaed5664cd0fcd81c0d8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring haskeline iteratee MissingH
         MonadCatchIO-transformers network transformers
       ];
       jailbreak = true;
       description = "Flash debugger";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hfiar" = callPackage
    ({ mkDerivation, base, eprocess, mtl, wx, wxcore }:
     mkDerivation {
       pname = "hfiar";
       version = "2.1.1";
       sha256 = "e1b46428ae814b7d1a8dbfaf805b8a4e518eda4e28f919b317a5b5dbd81858cb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base eprocess mtl ];
       executableHaskellDepends = [ wx wxcore ];
       jailbreak = true;
       homepage = "http://github.com/elbrujohalcon/hfiar";
       description = "Four in a Row in Haskell!!";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hflags" = callPackage
    ({ mkDerivation, base, containers, template-haskell, text }:
     mkDerivation {
       pname = "hflags";
       version = "0.4";
       sha256 = "a441ba0890c8c4cede8ff0c4179ae2878e4f294347db5abfe2dcd6398ee8ff9f";
       libraryHaskellDepends = [ base containers template-haskell text ];
       homepage = "http://github.com/errge/hflags";
       description = "Command line flag parser, very similar to Google's gflags";
       license = "unknown";
     }) {};

  "hfmt" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, Cabal, Diff, directory
     , filepath, haskell-src-exts, hindent, hlint, HUnit
     , optparse-applicative, pipes, pretty, stylish-haskell
     , test-framework, test-framework-hunit, text
     }:
     mkDerivation {
       pname = "hfmt";
       version = "0.0.2.2";
       sha256 = "36610511a051f13e8b604f090eff467ff88bf40d2edc809d99d7246b9ac22d5f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal directory filepath haskell-src-exts hindent hlint HUnit
         pipes stylish-haskell text
       ];
       executableHaskellDepends = [
         ansi-wl-pprint base Diff optparse-applicative pipes pretty
       ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       homepage = "http://github.com/danstiner/hfmt";
       description = "Haskell source code formatter";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hfoil" = callPackage
    ({ mkDerivation, base, directory, haskeline, hmatrix, HTTP, linear
     , not-gloss, parsec, transformers
     }:
     mkDerivation {
       pname = "hfoil";
       version = "0.2.0.2";
       sha256 = "417e52d9817d74051e41ff1c24434be002fa32d04fa271d220a2b11ca8f3964b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory haskeline hmatrix HTTP linear not-gloss parsec
         transformers
       ];
       executableHaskellDepends = [ base ];
       description = "Hess-Smith panel code for inviscid 2-d airfoil analysis";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hformat" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, hspec, text }:
     mkDerivation {
       pname = "hformat";
       version = "0.1.0.0";
       sha256 = "722f3d6bcf285477c93c68bcf62a23312cc8715d573989d87c8c1a6d0e725323";
       libraryHaskellDepends = [ base base-unicode-symbols text ];
       testHaskellDepends = [ base base-unicode-symbols hspec text ];
       homepage = "http://github.com/mvoidex/hformat";
       description = "Simple Haskell formatting";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hfov" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hfov";
       version = "1.0.2";
       sha256 = "34810fc4760503f9fbb929134dced7f4274d4167351636d5dd531950bbac1c13";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/nornagon/hfov";
       description = "Field-of-view calculation for low-resolution 2D raster grids";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hfractal" = callPackage
    ({ mkDerivation, array, base, colour, containers, data-accessor
     , data-accessor-template, gd, GLUT, OpenGL, OpenGLRaw
     }:
     mkDerivation {
       pname = "hfractal";
       version = "0.4.2.5";
       sha256 = "bff00c6a27455b70326087f3c2dd7e9185ac84f5f2fbdeabda8a425cf9e91818";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base colour containers data-accessor data-accessor-template
         gd GLUT OpenGL OpenGLRaw
       ];
       homepage = "http://github.com/cmh/Hfractal";
       description = "OpenGL fractal renderer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hfsevents_0_1_5" = callPackage
    ({ mkDerivation, base, bytestring, cereal, mtl, text, unix }:
     mkDerivation {
       pname = "hfsevents";
       version = "0.1.5";
       sha256 = "b348be81f278bcbf384a59029a0135c4aef6b687f2a7168a66aeea54a494e942";
       libraryHaskellDepends = [ base bytestring cereal mtl text unix ];
       jailbreak = true;
       homepage = "http://github.com/luite/hfsevents";
       description = "File/folder watching for OS X";
       license = stdenv.lib.licenses.bsd3;
       platforms = [ "x86_64-darwin" ];
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hfsevents" = callPackage
    ({ mkDerivation, base, bytestring, cereal, mtl, text, unix }:
     mkDerivation {
       pname = "hfsevents";
       version = "0.1.6";
       sha256 = "74c3f3f3a5e55fff320c352a2d481069ff915860a0ab970864c6a0e6b65d3f05";
       libraryHaskellDepends = [ base bytestring cereal mtl text unix ];
       homepage = "http://github.com/luite/hfsevents";
       description = "File/folder watching for OS X";
       license = stdenv.lib.licenses.bsd3;
       platforms = [ "x86_64-darwin" ];
     }) {};

  "hfusion" = callPackage
    ({ mkDerivation, base, containers, haskell-src, mtl, pretty, syb }:
     mkDerivation {
       pname = "hfusion";
       version = "0.0.6.1";
       sha256 = "f948b5f64537130f547896ba3a3611284f945d9458345f3d96c21a8d58d4f116";
       libraryHaskellDepends = [
         base containers haskell-src mtl pretty syb
       ];
       homepage = "http://www.fing.edu.uy/inco/proyectos/fusion";
       description = "A library for fusing a subset of Haskell programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hg-buildpackage" = callPackage
    ({ mkDerivation, base, directory, HSH, hslogger, MissingH, network
     , parsec, regex-compat, regex-posix, unix
     }:
     mkDerivation {
       pname = "hg-buildpackage";
       version = "1.0.4";
       sha256 = "186257f596849e789a4f3a17c574692e717d427510e332ae24b1673e1a5d5133";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory HSH hslogger MissingH network parsec regex-compat
         regex-posix unix
       ];
       description = "Tools to help manage Debian packages with Mercurial";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hgal" = callPackage
    ({ mkDerivation, array, base, containers, mtl }:
     mkDerivation {
       pname = "hgal";
       version = "2.0.0.2";
       sha256 = "f1b642052ea8f168dfeba8bcac1a2b697a86eb6a70dc6aca130490e27f441c9f";
       libraryHaskellDepends = [ array base containers mtl ];
       description = "library for computation automorphism group and canonical labelling of a graph";
       license = "GPL";
     }) {};

  "hgalib" = callPackage
    ({ mkDerivation, array, base, haskell98, mtl }:
     mkDerivation {
       pname = "hgalib";
       version = "0.2";
       sha256 = "3c57cb3e3b5ce2ec7686a443f5215e7e02e6bf138c41776b0e6dbc1c60a54821";
       libraryHaskellDepends = [ array base haskell98 mtl ];
       description = "Haskell Genetic Algorithm Library";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hgdbmi" = callPackage
    ({ mkDerivation, base, directory, HUnit, parsec, process, stm
     , template-haskell, temporary, test-framework, test-framework-hunit
     , unix
     }:
     mkDerivation {
       pname = "hgdbmi";
       version = "0.2";
       sha256 = "64b2da438b023c731b12375fb65cc638eb41c5c814100727623b81a4d2bcd5bd";
       libraryHaskellDepends = [ base parsec process stm unix ];
       testHaskellDepends = [
         base directory HUnit process template-haskell temporary
         test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "https://github.com/copton/hgdbmi";
       description = "GDB Machine Interface: program-driven control of GDB";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hgearman" = callPackage
    ({ mkDerivation, base, binary, bytestring, monad-control, mtl
     , network, resource-pool, transformers, transformers-base
     , unordered-containers
     }:
     mkDerivation {
       pname = "hgearman";
       version = "0.1.0.2";
       sha256 = "b37b94d79007088191990734ae23f71bd9efbef4a14ba0a01af733a34fbbd12d";
       libraryHaskellDepends = [
         base binary bytestring monad-control mtl network resource-pool
         transformers transformers-base unordered-containers
       ];
       jailbreak = true;
       description = "A Gearman client for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hgen" = callPackage
    ({ mkDerivation, base, directory, filepath, hylolib, mtl, random }:
     mkDerivation {
       pname = "hgen";
       version = "1.4.0";
       sha256 = "65c5543d966c3023bb6778a941a84f5b7648c51e8a203543c2d58b3c29a81fa4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath hylolib mtl random
       ];
       homepage = "http://www.glyc.dc.uba.ar/intohylo/hgen.php";
       description = "Random generation of modal and hybrid logic formulas";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hgeometric" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "hgeometric";
       version = "0.0.2.2";
       sha256 = "4d53479a52a9b5778406ca6a0825b9eda8f5f16980c6461b29e328ba6a058650";
       libraryHaskellDepends = [ base containers ];
       homepage = "ftp://ftp.cs.man.ac.uk/pub/toby/gpc/";
       description = "A geometric library with bindings to GPC";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hgeometry" = callPackage
    ({ mkDerivation, array, base, bifunctors, bytestring, containers
     , data-clist, doctest, fixed-vector, hexpat, lens, linear, mtl
     , parsec, random, semigroups, singletons, text, validation, vector
     , vinyl
     }:
     mkDerivation {
       pname = "hgeometry";
       version = "0.4.0.0";
       sha256 = "8db0a79006967beabf10fc96d05921f6e198636309c86cd4a233c98194ede603";
       libraryHaskellDepends = [
         base bifunctors bytestring containers data-clist fixed-vector
         hexpat lens linear mtl parsec random semigroups singletons text
         validation vector vinyl
       ];
       testHaskellDepends = [ array base data-clist doctest lens linear ];
       jailbreak = true;
       homepage = "http://fstaals.net/software/hgeometry";
       description = "Data types for geometric objects, geometric algorithms, and data structures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hgettext" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, filepath
     , haskell-src-exts, process, setlocale, uniplate
     }:
     mkDerivation {
       pname = "hgettext";
       version = "0.1.30";
       sha256 = "26453a4d359c99c41d462db9f8c9144d172523b3fa7076117a877e6c43f3ffdd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers directory filepath process setlocale
       ];
       executableHaskellDepends = [ base haskell-src-exts uniplate ];
       homepage = "https://github.com/vasylp/hgettext";
       description = "Bindings to libintl.h (gettext, bindtextdomain)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hgithub" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bytestring, case-insensitive, cmdargs, directory, http-enumerator
     , text
     }:
     mkDerivation {
       pname = "hgithub";
       version = "0.1.0";
       sha256 = "543089b1c045a6d38fc3f173d79e226725a8de2d696b0ea82deb14f2d35fbd15";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring bytestring case-insensitive
         http-enumerator text
       ];
       executableHaskellDepends = [ base cmdargs directory ];
       jailbreak = true;
       homepage = "https://github.com/noteed/hgithub";
       description = "Haskell bindings to the GitHub API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hgl-example" = callPackage
    ({ mkDerivation, array, base, HGL, HTam, random, utility-ht }:
     mkDerivation {
       pname = "hgl-example";
       version = "0.0.2";
       sha256 = "b973e9554656b996993ba58a56806524024d27450fa80e2fe5218c1147942f2e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base HGL HTam random utility-ht
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/hgl-example/";
       description = "Various animations generated using HGL";
       license = "GPL";
       broken = true;
     }) {HTam = null;};

  "hgom" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, mtl, parsec
     , wl-pprint
     }:
     mkDerivation {
       pname = "hgom";
       version = "0.6";
       sha256 = "bbea4b39837a577d51c0c4204df123cb5d2db2e2642df7a80105d61e6e73ad2a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath mtl parsec wl-pprint
       ];
       homepage = "http://github.com/polux/hgom";
       description = "An haskell port of the java version of gom";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hgopher" = callPackage
    ({ mkDerivation, base, bytestring, network }:
     mkDerivation {
       pname = "hgopher";
       version = "0.1.0.0";
       sha256 = "8ed7f3298557486c934aa8cc2f20166e1b6a6e620df9bb6e4e4ab3e2505cde48";
       libraryHaskellDepends = [ base bytestring network ];
       jailbreak = true;
       description = "Gopher server";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hgrev" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, filepath
     , process, template-haskell
     }:
     mkDerivation {
       pname = "hgrev";
       version = "0.1.5";
       sha256 = "e23dbba95f6f1cf9becb165c4233d5d744c8af0b57c049d4d9986d4e504658f6";
       libraryHaskellDepends = [
         aeson base bytestring directory filepath process template-haskell
       ];
       homepage = "https://github.com/LukeHoersten/hgrev";
       description = "Compile Mercurial (hg) version info into Haskell code";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hgrib" = callPackage
    ({ mkDerivation, base, c2hs, directory, grib_api, hspec
     , transformers
     }:
     mkDerivation {
       pname = "hgrib";
       version = "0.3.1.0";
       sha256 = "d3e0d4b1088934c230c566458e327b535733de602aa96ca68fc9236b65e3d73b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base transformers ];
       librarySystemDepends = [ grib_api ];
       libraryToolDepends = [ c2hs ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base directory hspec ];
       jailbreak = true;
       homepage = "https://github.com/mjakob/hgrib";
       description = "Unofficial bindings for GRIB API";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {grib_api = null;};

  "hharp" = callPackage
    ({ mkDerivation, base, harp }:
     mkDerivation {
       pname = "hharp";
       version = "0.1.1.1";
       sha256 = "f5868e6f1f34f5448c4865f286ba06b186a47fc61894d20707dedb2b9214b65e";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ harp ];
       jailbreak = true;
       homepage = "http://www.harphttp.org";
       description = "Binding to libharp";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {harp = null;};

  "hi" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, bytestring, directory
     , doctest, filepath, hspec, HUnit, optparse-applicative, parsec
     , process, silently, split, template, temporary, text, time
     }:
     mkDerivation {
       pname = "hi";
       version = "1.2.0.0";
       sha256 = "091e82568ffada19e196eeead484f4764399288b0ba5f9729abd1ec4ee918399";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-wl-pprint base bytestring directory filepath
         optparse-applicative parsec process split template temporary text
         time
       ];
       executableHaskellDepends = [
         ansi-wl-pprint base bytestring directory filepath
         optparse-applicative parsec process split template temporary text
         time
       ];
       testHaskellDepends = [
         ansi-wl-pprint base bytestring directory doctest filepath hspec
         HUnit optparse-applicative parsec process silently split template
         temporary text time
       ];
       jailbreak = true;
       homepage = "https://github.com/fujimura/hi";
       description = "Generate scaffold for cabal project";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hi3status" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, dbus, dyre
     , network, prefix-units, process, regex-pcre-builtin, text, time
     , transformers, vector
     }:
     mkDerivation {
       pname = "hi3status";
       version = "0.1.1.0";
       sha256 = "de4c03916349148592e2f3b92a26f5f0b315762b8af61cfe41b556f427a43366";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base binary bytestring dbus dyre network prefix-units process
         regex-pcre-builtin text time transformers vector
       ];
       executableHaskellDepends = [ base dbus process ];
       description = "Status line for i3bar";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hiccup" = callPackage
    ({ mkDerivation, base, bytestring, containers, haskell98, HUnit
     , mtl, parsec, random, readline, time
     }:
     mkDerivation {
       pname = "hiccup";
       version = "0.40";
       sha256 = "e5f5f633d30b60f55d5d172357a017ae7d70f8b3d345de6cfec1fc7e63c97fea";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers haskell98 HUnit mtl parsec random
         readline time
       ];
       homepage = "http://hiccup.googlecode.com/";
       description = "Relatively efficient Tcl interpreter with support for basic operations";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hichi" = callPackage
    ({ mkDerivation, array, base, bytestring, mtl, network }:
     mkDerivation {
       pname = "hichi";
       version = "0.0.1";
       sha256 = "784f70cfbfe9cf73da4e5c452c794cfbafe682a5e06e31419436d89f38c6acb8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base bytestring mtl network ];
       description = "haskell robot for IChat protocol";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hid_0_2_1" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, hidapi, transformers }:
     mkDerivation {
       pname = "hid";
       version = "0.2.1";
       sha256 = "b0d5c499189207c41943c14b0b0ba5b9b19a504d30e670f4a49111bd808e5ba3";
       libraryHaskellDepends = [ base bytestring transformers ];
       libraryPkgconfigDepends = [ hidapi ];
       libraryToolDepends = [ c2hs ];
       description = "Interface to hidapi library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) hidapi;};

  "hid" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, hidapi, transformers }:
     mkDerivation {
       pname = "hid";
       version = "0.2.1.1";
       sha256 = "290cddbf84e35b25d7140a1a670747981d87786ad2f918e97c8f335b9a15bd5c";
       libraryHaskellDepends = [ base bytestring transformers ];
       libraryPkgconfigDepends = [ hidapi ];
       libraryToolDepends = [ c2hs ];
       homepage = "https://github.com/phaazon/hid";
       description = "Interface to hidapi library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) hidapi;};

  "hidapi" = callPackage
    ({ mkDerivation, base, bytestring, deepseq-generics, systemd }:
     mkDerivation {
       pname = "hidapi";
       version = "0.1.3";
       sha256 = "20167e4f7d5d2c2220daf829ae7b4874a3e8dd983f49fa724ea88ac8ef568662";
       libraryHaskellDepends = [ base bytestring deepseq-generics ];
       librarySystemDepends = [ systemd ];
       homepage = "https://github.com/vahokif/haskell-hidapi";
       description = "Haskell bindings to HIDAPI";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) systemd;};

  "hieraclus" = callPackage
    ({ mkDerivation, base, containers, HUnit, mtl, multiset }:
     mkDerivation {
       pname = "hieraclus";
       version = "0.1.2.1";
       sha256 = "ef9eec9bf69d8c788bae17b5856c3b7411e27ab9868c26ca002dee2f5b75d285";
       libraryHaskellDepends = [ base containers HUnit mtl multiset ];
       description = "Automated clustering of arbitrary elements in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hierarchical-clustering" = callPackage
    ({ mkDerivation, array, base, containers, hspec, HUnit, QuickCheck
     }:
     mkDerivation {
       pname = "hierarchical-clustering";
       version = "0.4.6";
       sha256 = "75f17f09b9c38d51a208edee10da2f4706ee784b5cdfe8efc31f7f86bbcdccb1";
       libraryHaskellDepends = [ array base containers ];
       testHaskellDepends = [ base hspec HUnit QuickCheck ];
       description = "Fast algorithms for single, average/UPGMA and complete linkage clustering";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hierarchical-clustering-diagrams" = callPackage
    ({ mkDerivation, base, diagrams-cairo, diagrams-lib
     , hierarchical-clustering, hspec, HUnit
     }:
     mkDerivation {
       pname = "hierarchical-clustering-diagrams";
       version = "0.3.2";
       sha256 = "5923407983deb4b77da5af13ad764a3c3fb083aa1f2665c889961c8ae1f7cc1a";
       libraryHaskellDepends = [
         base diagrams-lib hierarchical-clustering
       ];
       testHaskellDepends = [
         base diagrams-cairo diagrams-lib hierarchical-clustering hspec
         HUnit
       ];
       jailbreak = true;
       description = "Draw diagrams of dendrograms made by hierarchical-clustering";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hierarchical-exceptions" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "hierarchical-exceptions";
       version = "1.0.1";
       sha256 = "b52a5a13d417a65eec7ca10211a8a1ec988142f6b3c06651953496ffe6e1f0fb";
       libraryHaskellDepends = [ base template-haskell ];
       description = "Template Haskell functions to easily create exception hierarchies";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "hierarchy" = callPackage
    ({ mkDerivation, base, directory, doctest, exceptions, filepath
     , free, hspec, hspec-expectations, mmorph, monad-control, mtl
     , pipes, semigroups, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "hierarchy";
       version = "0.3.1";
       sha256 = "4ff6dcb89691dbf20de993964ad32904508f5b6569af1e83eaaaf73a271c9c5f";
       libraryHaskellDepends = [
         base exceptions free mmorph monad-control mtl pipes semigroups
         transformers transformers-base transformers-compat
       ];
       testHaskellDepends = [
         base directory doctest filepath hspec hspec-expectations mtl pipes
         semigroups transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/jwiegley/hierarchy";
       description = "Pipes-based library for predicated traversal of generated trees";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hiernotify" = callPackage
    ({ mkDerivation, base, directory, filepath, mtl, old-time, stm
     , timers-updatable
     }:
     mkDerivation {
       pname = "hiernotify";
       version = "2011.4.12";
       sha256 = "05628dad56d84d198acb15d7c903d55b76af9ff31abf7d3cf1c932b04ce4afc6";
       libraryHaskellDepends = [
         base directory filepath mtl old-time stm timers-updatable
       ];
       homepage = "http://github.com/paolino/hiernotify";
       description = "Notification library for a filesystem hierarchy";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "highWaterMark" = callPackage
    ({ mkDerivation, base, ghc }:
     mkDerivation {
       pname = "highWaterMark";
       version = "0.1.1";
       sha256 = "37858277dac56c5befdd854cba392ed69969b0e9f903773d2500b8bc7f869baf";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ghc ];
       homepage = "http://www.cs.mu.oz.au/~bjpop/code.html";
       description = "Memory usage statistics";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "higher-leveldb" = callPackage
    ({ mkDerivation, base, bytestring, cereal, data-default, hspec
     , leveldb-haskell, lifted-base, monad-control, mtl, process
     , resourcet, transformers, transformers-base
     }:
     mkDerivation {
       pname = "higher-leveldb";
       version = "0.3.0.0";
       sha256 = "668557a64c3df44ab1ddb3f9ffd9bdaf2a88fb6f56b7712daf8ee8418370f051";
       libraryHaskellDepends = [
         base bytestring cereal data-default leveldb-haskell lifted-base
         monad-control mtl resourcet transformers transformers-base
       ];
       testHaskellDepends = [
         base bytestring cereal hspec leveldb-haskell lifted-base
         monad-control mtl process resourcet transformers transformers-base
       ];
       jailbreak = true;
       homepage = "https://github.com/jeremyjh/higher-leveldb";
       description = "A rich monadic API for working with leveldb databases";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "higherorder" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "higherorder";
       version = "0.0";
       sha256 = "5fc7ed69f3b128fee776837270358f77c82693bf951b9e36d1d75325d3849819";
       revision = "1";
       editedCabalFile = "c587250ea9c4828876f3837e82e5b1543e0dc2cc59bb4ec59ce0d947bae3d459";
       libraryHaskellDepends = [ base ];
       description = "Some higher order functions for Bool and []";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "highjson" = callPackage
    ({ mkDerivation, attoparsec, base, buffer-builder, bytestring
     , containers, hashable, hspec, hvect, QuickCheck, scientific, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "highjson";
       version = "0.2.0.2";
       sha256 = "7fd64bb5206b6d16d420e34eb7f3fefc6d888be518f0dc635a77ed51d63f1f1f";
       libraryHaskellDepends = [
         attoparsec base buffer-builder bytestring containers hashable hvect
         scientific text unordered-containers vector
       ];
       testHaskellDepends = [ base hspec QuickCheck text ];
       homepage = "https://github.com/agrafix/highjson";
       description = "Very fast JSON serialisation and parsing library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "highlight-versions" = callPackage
    ({ mkDerivation, ansi-terminal, base, Cabal, containers, hackage-db
     }:
     mkDerivation {
       pname = "highlight-versions";
       version = "0.1.3.5";
       sha256 = "475a6c4fd63a684ccd681d613c47567f08688209c6c80a06ad027bfa7f9b675a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base Cabal containers hackage-db
       ];
       description = "Highlight package versions which differ from the latest version on Hackage";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "highlighter" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, filepath, mtl
     , pcre-light, text
     }:
     mkDerivation {
       pname = "highlighter";
       version = "0.2.2";
       sha256 = "3d88a570d7e682cab28652ebc585a790a9e061c5be1d998573e23dd19e0d68f4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html bytestring filepath mtl pcre-light text
       ];
       executableHaskellDepends = [
         base blaze-html bytestring filepath mtl pcre-light text
       ];
       description = "source code highlighting";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "highlighter2" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
     , containers, filepath, mtl, pcre-light, text
     }:
     mkDerivation {
       pname = "highlighter2";
       version = "0.2.5";
       sha256 = "917718f0633c61184c5f768a817002bb8c8138759c846d245e1ea62862ffcdbe";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html bytestring containers filepath mtl pcre-light text
       ];
       executableHaskellDepends = [
         base blaze-html blaze-markup bytestring containers filepath mtl
         pcre-light text
       ];
       description = "source code highlighting";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "highlighting-kate_0_5_11" = callPackage
    ({ mkDerivation, base, blaze-html, containers, Diff, directory
     , filepath, mtl, parsec, pcre-light, process, utf8-string
     }:
     mkDerivation {
       pname = "highlighting-kate";
       version = "0.5.11";
       sha256 = "7c17c7f1d95dc4e2e18100e1685b8715e538bd03d187a9b3a3de19eb19f9cf49";
       revision = "1";
       editedCabalFile = "64831c173318277f3aa35f0d54000fe4d613219c5917a0a5f250de7ae549c146";
       configureFlags = [ "-fpcre-light" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html containers mtl parsec pcre-light utf8-string
       ];
       executableHaskellDepends = [ base blaze-html containers filepath ];
       testHaskellDepends = [
         base blaze-html containers Diff directory filepath process
       ];
       jailbreak = true;
       homepage = "http://github.com/jgm/highlighting-kate";
       description = "Syntax highlighting";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "highlighting-kate_0_5_11_1" = callPackage
    ({ mkDerivation, base, blaze-html, containers, Diff, directory
     , filepath, mtl, parsec, pcre-light, process, utf8-string
     }:
     mkDerivation {
       pname = "highlighting-kate";
       version = "0.5.11.1";
       sha256 = "7b5af011fb86b0358c186245840c95c4c43ada3d98f7b9060d9ce2a0c2e5c2fc";
       revision = "1";
       editedCabalFile = "efd5828486ec9cf5638ea09498f6be0d12d8c443ad514e083e33e745dead70b1";
       configureFlags = [ "-fpcre-light" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html containers mtl parsec pcre-light utf8-string
       ];
       executableHaskellDepends = [ base blaze-html containers filepath ];
       testHaskellDepends = [
         base blaze-html containers Diff directory filepath process
       ];
       jailbreak = true;
       homepage = "http://github.com/jgm/highlighting-kate";
       description = "Syntax highlighting";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "highlighting-kate_0_5_12" = callPackage
    ({ mkDerivation, base, blaze-html, containers, Diff, directory
     , filepath, mtl, parsec, pcre-light, process, utf8-string
     }:
     mkDerivation {
       pname = "highlighting-kate";
       version = "0.5.12";
       sha256 = "11c059b745937181768cfbab5fb22835bf261fefd505839e7053571607bcec45";
       revision = "1";
       editedCabalFile = "bd211d26df545362aa69036a1a8279e5d326cb53a7de5cd959f09b80b611a335";
       configureFlags = [ "-fpcre-light" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html containers mtl parsec pcre-light utf8-string
       ];
       executableHaskellDepends = [ base blaze-html containers filepath ];
       testHaskellDepends = [
         base blaze-html containers Diff directory filepath process
       ];
       homepage = "http://github.com/jgm/highlighting-kate";
       description = "Syntax highlighting";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "highlighting-kate_0_6" = callPackage
    ({ mkDerivation, base, blaze-html, containers, Diff, directory
     , filepath, mtl, parsec, pcre-light, process, utf8-string
     }:
     mkDerivation {
       pname = "highlighting-kate";
       version = "0.6";
       sha256 = "b39dc194386eb7613a5e9935023b1173010800c3a9b0b7fe09c0601f97236398";
       revision = "1";
       editedCabalFile = "7466b389fd27b0520d371b2b225cb6024e9b7dd371cffa78169c219ab449558b";
       configureFlags = [ "-fpcre-light" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html containers mtl parsec pcre-light utf8-string
       ];
       executableHaskellDepends = [ base blaze-html containers filepath ];
       testHaskellDepends = [
         base blaze-html containers Diff directory filepath process
       ];
       homepage = "http://github.com/jgm/highlighting-kate";
       description = "Syntax highlighting";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "highlighting-kate" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, containers, Diff
     , directory, filepath, mtl, parsec, pcre-light, process
     , utf8-string
     }:
     mkDerivation {
       pname = "highlighting-kate";
       version = "0.6.1";
       sha256 = "cb57caf861bda046043575772ffc7fd4cd21dd63a0ecdf26b624c7e930e0f30e";
       configureFlags = [ "-fpcre-light" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html bytestring containers mtl parsec pcre-light
         utf8-string
       ];
       executableHaskellDepends = [ base blaze-html containers filepath ];
       testHaskellDepends = [
         base blaze-html containers Diff directory filepath process
       ];
       homepage = "http://github.com/jgm/highlighting-kate";
       description = "Syntax highlighting";
       license = "GPL";
     }) {};

  "hills" = callPackage
    ({ mkDerivation, array, base, bytestring, directory, filepath
     , optparse-applicative, text, transformers
     }:
     mkDerivation {
       pname = "hills";
       version = "0.1.2.1";
       sha256 = "cf5e5c6a00e48b70c099e2259b4af0f4340f07feb1e3cbe08e3c2e0045f40ca1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring directory filepath optparse-applicative text
         transformers
       ];
       homepage = "http://www.bubblycloud.com/hills/";
       description = "Generate STL models from SRTM elevation data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "himerge" = callPackage
    ({ mkDerivation, base, directory, glib, gtk, haskell98, mozembed
     , old-time, parallel, process, unix
     }:
     mkDerivation {
       pname = "himerge";
       version = "0.20";
       sha256 = "0050ccd646e67c3c0cc95b773d0700654c0a99b76a64bf8f65fce3ea79a17947";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory glib gtk haskell98 mozembed old-time parallel
         process unix
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/himerge";
       description = "Haskell Graphical User Interface for Emerge";
       license = "GPL";
       broken = true;
     }) {mozembed = null;};

  "himg" = callPackage
    ({ mkDerivation, base, bytestring, directory, gtk, HTTP
     , http-conduit, network, temporary
     }:
     mkDerivation {
       pname = "himg";
       version = "0.1.0.0";
       sha256 = "23016aa72e85101e10aa336491f92b43cbb27e048d05d6fbd17a58674c4aca27";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring directory gtk HTTP http-conduit network temporary
       ];
       executableHaskellDepends = [
         base bytestring directory gtk HTTP http-conduit network temporary
       ];
       jailbreak = true;
       homepage = "http://github.com/Fuuzetsu/himg";
       description = "Simple gtk2hs image viewer. Point it at an image and fire away.";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "himpy" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, binary, bytestring
     , cereal, containers, MissingH, NetSNMP, network, old-time
     , protobuf, regex-posix, stm, text, type-level
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "himpy";
       version = "0.5.0";
       sha256 = "2f62c7cd9a0532d42e33bca6fedab7167bf76249dc2d0d6b3451210cd3deef66";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson attoparsec base binary bytestring cereal containers MissingH
         NetSNMP network old-time protobuf regex-posix stm text type-level
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/pyr/himpy";
       description = "multithreaded snmp poller for riemann";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hindent_4_4_1" = callPackage
    ({ mkDerivation, applicative-quoters, base, data-default
     , descriptive, directory, ghc-prim, haskell-src-exts, hspec
     , monad-loops, mtl, text, transformers
     }:
     mkDerivation {
       pname = "hindent";
       version = "4.4.1";
       sha256 = "0f2320ce8937b83f724e8685d47ebed8300ecad5e925425230f42ac4fe0f87c1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base data-default haskell-src-exts monad-loops mtl text
         transformers
       ];
       executableHaskellDepends = [
         applicative-quoters base descriptive directory ghc-prim
         haskell-src-exts text
       ];
       testHaskellDepends = [
         base data-default directory haskell-src-exts hspec monad-loops mtl
         text
       ];
       jailbreak = true;
       homepage = "http://www.github.com/chrisdone/hindent";
       description = "Extensible Haskell pretty printer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hindent_4_4_2" = callPackage
    ({ mkDerivation, applicative-quoters, base, data-default
     , descriptive, directory, ghc-prim, haskell-src-exts, hspec
     , monad-loops, mtl, text, transformers
     }:
     mkDerivation {
       pname = "hindent";
       version = "4.4.2";
       sha256 = "311ef9a88fc0ed3ebd566a0139095dba1e09c530aedc8d98436f097d27d6e391";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base data-default haskell-src-exts monad-loops mtl text
         transformers
       ];
       executableHaskellDepends = [
         applicative-quoters base descriptive directory ghc-prim
         haskell-src-exts text
       ];
       testHaskellDepends = [
         base data-default directory haskell-src-exts hspec monad-loops mtl
         text
       ];
       jailbreak = true;
       homepage = "http://www.github.com/chrisdone/hindent";
       description = "Extensible Haskell pretty printer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hindent_4_5_4" = callPackage
    ({ mkDerivation, applicative-quoters, base, data-default
     , descriptive, directory, ghc-prim, haskell-src-exts, hspec
     , monad-loops, mtl, text, transformers
     }:
     mkDerivation {
       pname = "hindent";
       version = "4.5.4";
       sha256 = "20723594709861cb3618ea90cb07e0cdfe20a8cd2ed0ca9d6c66ca5eeae4fe26";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base data-default haskell-src-exts monad-loops mtl text
         transformers
       ];
       executableHaskellDepends = [
         applicative-quoters base descriptive directory ghc-prim
         haskell-src-exts text
       ];
       testHaskellDepends = [
         base data-default directory haskell-src-exts hspec monad-loops mtl
         text
       ];
       jailbreak = true;
       homepage = "http://www.github.com/chrisdone/hindent";
       description = "Extensible Haskell pretty printer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hindent_4_5_5" = callPackage
    ({ mkDerivation, applicative-quoters, base, data-default
     , descriptive, directory, ghc-prim, haskell-src-exts, hspec
     , monad-loops, mtl, text, transformers
     }:
     mkDerivation {
       pname = "hindent";
       version = "4.5.5";
       sha256 = "a2a5ccc62a6f8975e621b271e43ae9ac6a2315c652df7317ecc0221c9f11c662";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base data-default haskell-src-exts monad-loops mtl text
         transformers
       ];
       executableHaskellDepends = [
         applicative-quoters base descriptive directory ghc-prim
         haskell-src-exts text
       ];
       testHaskellDepends = [
         base data-default directory haskell-src-exts hspec monad-loops mtl
         text
       ];
       jailbreak = true;
       homepage = "http://www.github.com/chrisdone/hindent";
       description = "Extensible Haskell pretty printer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hindent" = callPackage
    ({ mkDerivation, base, data-default, descriptive, directory
     , ghc-prim, haskell-src-exts, hspec, monad-loops, mtl, text
     , transformers
     }:
     mkDerivation {
       pname = "hindent";
       version = "4.6.1";
       sha256 = "04e8ffb44b46a45cd6425233efe595d6e412a20c71b69749f72c036bca4870f5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base data-default haskell-src-exts monad-loops mtl text
         transformers
       ];
       executableHaskellDepends = [
         base descriptive directory ghc-prim haskell-src-exts text
       ];
       testHaskellDepends = [
         base data-default directory haskell-src-exts hspec monad-loops mtl
         text
       ];
       doCheck = false;
       homepage = "http://www.github.com/chrisdone/hindent";
       description = "Extensible Haskell pretty printer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hinduce-associations-apriori" = callPackage
    ({ mkDerivation, base, containers, deepseq, hinduce-missingh
     , parallel, vector
     }:
     mkDerivation {
       pname = "hinduce-associations-apriori";
       version = "0.0.0.0";
       sha256 = "ff14ddaf10b064975fe10c60adecc71d27c4f43c36e45c7878dbd7dcab504c00";
       libraryHaskellDepends = [
         base containers deepseq hinduce-missingh parallel vector
       ];
       homepage = "https://github.com/roberth/hinduce-associations-apriori";
       description = "Apriori algorithm for association rule mining";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hinduce-classifier" = callPackage
    ({ mkDerivation, base, hinduce-missingh, layout }:
     mkDerivation {
       pname = "hinduce-classifier";
       version = "0.0.0.1";
       sha256 = "ea536f4e5b111f1e97dccdcfa74d67603dd115f6b3d5aa69145edfd94d48bdb1";
       libraryHaskellDepends = [ base hinduce-missingh layout ];
       description = "Interface and utilities for classifiers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hinduce-classifier-decisiontree" = callPackage
    ({ mkDerivation, base, convertible, hinduce-classifier
     , hinduce-missingh, layout
     }:
     mkDerivation {
       pname = "hinduce-classifier-decisiontree";
       version = "0.0.0.1";
       sha256 = "b4c5a4e9c14e47f02f3d5afc05c7ae5369aab77c6a427664615ef8bb1625bfc1";
       libraryHaskellDepends = [
         base convertible hinduce-classifier hinduce-missingh layout
       ];
       description = "Decision Tree Classifiers for hInduce";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hinduce-examples" = callPackage
    ({ mkDerivation, base, containers, convertible, csv
     , hinduce-associations-apriori, hinduce-classifier
     , hinduce-classifier-decisiontree, hinduce-missingh, layout, vector
     }:
     mkDerivation {
       pname = "hinduce-examples";
       version = "0.0.0.2";
       sha256 = "9c2c064171367a992efe5ac535700bd1275ec1e49422d016f6ab441911cb569e";
       libraryHaskellDepends = [
         base containers convertible csv hinduce-associations-apriori
         hinduce-classifier hinduce-classifier-decisiontree hinduce-missingh
         layout vector
       ];
       description = "Example data for hInduce";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hinduce-missingh" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hinduce-missingh";
       version = "0.0.0.0";
       sha256 = "3f49b5de2e40a348642a941135ae4796d75569afc3a374628b986f88d1770698";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/roberth/hinduce-missingh";
       description = "Utility functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hinotify_0_3_7" = callPackage
    ({ mkDerivation, base, containers, directory, unix }:
     mkDerivation {
       pname = "hinotify";
       version = "0.3.7";
       sha256 = "0b702d104f35ca925c748deb9e2a1faaaf6b7b517e48a39a8c8f7d1ad3ebf544";
       libraryHaskellDepends = [ base containers directory unix ];
       homepage = "https://github.com/kolmodin/hinotify.git";
       description = "Haskell binding to inotify";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hinotify" = callPackage
    ({ mkDerivation, base, containers, directory, unix }:
     mkDerivation {
       pname = "hinotify";
       version = "0.3.8.1";
       sha256 = "37d46e32c362ff1e2d9c8d79a553e0d2e59e009d46708163fb05a07e1a71810d";
       libraryHaskellDepends = [ base containers directory unix ];
       testHaskellDepends = [ base directory ];
       homepage = "https://github.com/kolmodin/hinotify.git";
       description = "Haskell binding to inotify";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hinquire" = callPackage
    ({ mkDerivation, base, bifunctors, QuickCheck, test-framework
     , test-framework-quickcheck2, test-framework-th
     }:
     mkDerivation {
       pname = "hinquire";
       version = "0.1.1";
       sha256 = "a187676d2e93a17fa003b05612ab28aa49fa077b4b0a5d969d7162e143c4a0d6";
       libraryHaskellDepends = [
         base bifunctors QuickCheck test-framework
         test-framework-quickcheck2 test-framework-th
       ];
       testHaskellDepends = [
         base bifunctors QuickCheck test-framework
         test-framework-quickcheck2 test-framework-th
       ];
       jailbreak = true;
       homepage = "https://github.com/joneshf/hinquire";
       description = "Generate armet style query strings";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hinstaller" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, directory, filepath
     , process, template-haskell
     }:
     mkDerivation {
       pname = "hinstaller";
       version = "2008.2.16";
       sha256 = "0c5172fb5b64d7c3d9a2908c9cb0936e7a2a606e20fa6e8ebc361e8e52c7aed1";
       libraryHaskellDepends = [
         base bytestring Cabal directory filepath process template-haskell
       ];
       homepage = "http://www.wellquite.org/hinstaller/";
       description = "Installer wrapper for Haskell applications";
       license = "LGPL";
     }) {};

  "hint_0_4_2_1" = callPackage
    ({ mkDerivation, base, directory, exceptions, extensible-exceptions
     , filepath, ghc, ghc-mtl, ghc-paths, HUnit, mtl, random, unix
     , utf8-string
     }:
     mkDerivation {
       pname = "hint";
       version = "0.4.2.1";
       sha256 = "0f78ea7bab351a8dbb4eeb87ef3b42c25a7e463dbac6e14e42418f1d7c218559";
       revision = "2";
       editedCabalFile = "e8d9cdfd463c48cbaea0dc6fecfdeddb0a8a2076a8c127fc14cde6017aa64ac6";
       libraryHaskellDepends = [
         base directory exceptions extensible-exceptions filepath ghc
         ghc-mtl ghc-paths mtl random unix utf8-string
       ];
       testHaskellDepends = [
         base directory exceptions extensible-exceptions filepath HUnit mtl
       ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/jcpetruzza/hint";
       description = "Runtime Haskell interpreter (GHC API wrapper)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hint_0_4_2_2" = callPackage
    ({ mkDerivation, base, directory, exceptions, extensible-exceptions
     , filepath, ghc, ghc-mtl, ghc-paths, HUnit, mtl, random, unix
     }:
     mkDerivation {
       pname = "hint";
       version = "0.4.2.2";
       sha256 = "dc806797435029b37f903ba482fa526cb0dbe34264a607d2dfbda38b79b564bf";
       libraryHaskellDepends = [
         base directory exceptions extensible-exceptions filepath ghc
         ghc-mtl ghc-paths mtl random unix
       ];
       testHaskellDepends = [
         base directory exceptions extensible-exceptions filepath HUnit mtl
       ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/jcpetruzza/hint";
       description = "Runtime Haskell interpreter (GHC API wrapper)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hint" = callPackage
    ({ mkDerivation, base, directory, exceptions, extensible-exceptions
     , filepath, ghc, ghc-mtl, ghc-paths, HUnit, mtl, random, unix
     }:
     mkDerivation {
       pname = "hint";
       version = "0.4.2.3";
       sha256 = "cf2b3f98ba6929e2e79dfc373e101ee6ae1711a5706e718cf0152733da4a40b7";
       libraryHaskellDepends = [
         base directory exceptions extensible-exceptions filepath ghc
         ghc-mtl ghc-paths mtl random unix
       ];
       testHaskellDepends = [
         base directory exceptions extensible-exceptions filepath HUnit mtl
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://hub.darcs.net/jcpetruzza/hint";
       description = "Runtime Haskell interpreter (GHC API wrapper)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hint-server" = callPackage
    ({ mkDerivation, base, eprocess, exceptions, hint, monad-loops, mtl
     }:
     mkDerivation {
       pname = "hint-server";
       version = "1.4.2";
       sha256 = "c579a71d68272dc463ba9625027615bd323fdbbe8780bd462d05694c375866e7";
       libraryHaskellDepends = [
         base eprocess exceptions hint monad-loops mtl
       ];
       description = "A server process that runs hint";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hinvaders" = callPackage
    ({ mkDerivation, base, haskell98, random }:
     mkDerivation {
       pname = "hinvaders";
       version = "0.1";
       sha256 = "108430a374bb8b3dee663726bb57a16cd121d3fe96352d051f77cd13d9d76507";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskell98 random ];
       homepage = "http://www.cs.mu.oz.au/~bjpop/code.html";
       description = "Space Invaders";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hinze-streams" = callPackage
    ({ mkDerivation, base, haskell98, Stream }:
     mkDerivation {
       pname = "hinze-streams";
       version = "1.0";
       sha256 = "58b37e10f96dfa63abe32cbacada854aa850856f0ee3b9fc1736a9a11997f28c";
       libraryHaskellDepends = [ base haskell98 Stream ];
       homepage = "http://code.haskell.org/~dons/code/hinze-streams";
       description = "Streams and Unique Fixed Points";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hipbot" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, blaze-builder, bytestring
     , either, exceptions, http-client, http-client-tls, http-types, jwt
     , lens, mtl, network-uri, postgresql-simple, resource-pool, safe
     , stm, text, time, transformers, unordered-containers, utf8-string
     , wai, wai-lens, webcrank, webcrank-wai, wreq
     }:
     mkDerivation {
       pname = "hipbot";
       version = "0.5";
       sha256 = "1a064b44ee92b6b6554ef5a2304d19ebf59699e896844203685ff326ee4a9e29";
       revision = "1";
       editedCabalFile = "6ac1673be45c18dc010eeeef508a021ec9fef4e0a4e05864733f91aec8508ab8";
       libraryHaskellDepends = [
         aeson base bifunctors blaze-builder bytestring either exceptions
         http-client http-client-tls http-types jwt lens mtl network-uri
         postgresql-simple resource-pool safe stm text time transformers
         unordered-containers utf8-string wai wai-lens webcrank webcrank-wai
         wreq
       ];
       jailbreak = true;
       homepage = "https://github.com/purefn/hipbot";
       description = "A library for building HipChat Bots";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hipe" = callPackage
    ({ mkDerivation, base, containers, hgeometry, hxt, parsec, split
     , text, text-format
     }:
     mkDerivation {
       pname = "hipe";
       version = "0.2.0.0";
       sha256 = "5095bcdbddb5de034d75ac12e783a4684454792e7c371bd4a23deebcebe70af9";
       libraryHaskellDepends = [
         base containers hgeometry hxt parsec split text text-format
       ];
       homepage = "http://fstaals.net/software/hipe";
       description = "Support for reading and writing ipe7 files (http://ipe7.sourceforge.net)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hips" = callPackage
    ({ mkDerivation, base, bytestring, directory, functors, mtl }:
     mkDerivation {
       pname = "hips";
       version = "0.1";
       sha256 = "79d73cda138038529f1aefb414685b2b298c236257720fb7e2b35db8d48a7954";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory functors mtl
       ];
       homepage = "http://closure.ath.cx/hips";
       description = "an IPS patcher";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hircules" = callPackage
    ({ mkDerivation, base, containers, directory, gtk, mtl, network
     , old-locale, old-time, time, utf8-string
     }:
     mkDerivation {
       pname = "hircules";
       version = "0.4.1";
       sha256 = "1d9f0ff9c4596d128df8502b5fdb3c0903257a17bd9ef7b41508b011470d49c4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory gtk mtl network old-locale old-time time
         utf8-string
       ];
       description = "IRC client";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hirt" = callPackage
    ({ mkDerivation, attoparsec, base, cmdargs, containers, csv
     , hlbfgsb, hmatrix, mwc-random, numeric-extras, random, statistics
     , text, text-format, vector, vector-space
     }:
     mkDerivation {
       pname = "hirt";
       version = "0.0.1.1";
       sha256 = "1b14b4f4d8618afb4c734e2bda2f649edd31cddcca65929d7811f427e9239669";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base cmdargs containers csv hlbfgsb hmatrix mwc-random
         numeric-extras random statistics text text-format vector
         vector-space
       ];
       jailbreak = true;
       homepage = "https://people.ksp.sk/~ivan/hirt";
       description = "Calculates IRT 2PL and 3PL models";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hissmetrics" = callPackage
    ({ mkDerivation, base, bytestring, conduit, http-conduit
     , http-types, text, time
     }:
     mkDerivation {
       pname = "hissmetrics";
       version = "0.5.1";
       sha256 = "cd3068da1f8892d9b3f409c0681164088db12535a3191ba4acf06bf26cf7e0e7";
       libraryHaskellDepends = [
         base bytestring conduit http-conduit http-types text time
       ];
       jailbreak = true;
       homepage = "https://github.com/prowdsponsor/hissmetrics";
       description = "Unofficial API bindings to KISSmetrics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hist-pl" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, cmdargs
     , containers, hist-pl-dawg, hist-pl-fusion, hist-pl-lexicon
     , hist-pl-lmf, hist-pl-transliter, morfeusz, pipes, polimorf, text
     }:
     mkDerivation {
       pname = "hist-pl";
       version = "0.3.2";
       sha256 = "eb78b24aad7e2e7c480dff146819ed70af797e129cccf3d966d08b41dc988605";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base containers hist-pl-lexicon hist-pl-transliter morfeusz
         text
       ];
       executableHaskellDepends = [
         aeson-pretty base bytestring cmdargs containers hist-pl-dawg
         hist-pl-fusion hist-pl-lexicon hist-pl-lmf pipes polimorf
       ];
       jailbreak = true;
       homepage = "https://github.com/kawu/hist-pl/tree/master/umbrella";
       description = "Umbrella package for the historical dictionary of Polish";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hist-pl-dawg" = callPackage
    ({ mkDerivation, base, binary, containers, dawg, text, text-binary
     }:
     mkDerivation {
       pname = "hist-pl-dawg";
       version = "0.2.1";
       sha256 = "4f4225b4edc73b7dbc42f93287b76734138da665d3a633ddafb1191297e210be";
       libraryHaskellDepends = [
         base binary containers dawg text text-binary
       ];
       homepage = "https://github.com/kawu/hist-pl/tree/master/dawg";
       description = "A generic, DAWG-based dictionary";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hist-pl-fusion" = callPackage
    ({ mkDerivation, base, binary, containers, dawg, hist-pl-dawg
     , hist-pl-lexicon, polimorf, text, text-binary
     }:
     mkDerivation {
       pname = "hist-pl-fusion";
       version = "0.5.3";
       sha256 = "036b5311881e37b00024ebcce86cfb453ab1827c609b8a01c9a08337384e5547";
       libraryHaskellDepends = [
         base binary containers dawg hist-pl-dawg hist-pl-lexicon polimorf
         text text-binary
       ];
       homepage = "https://github.com/kawu/hist-pl/tree/master/fusion";
       description = "Merging historical dictionary with PoliMorf";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hist-pl-lexicon" = callPackage
    ({ mkDerivation, base, binary, containers, dawg, directory
     , filepath, hist-pl-dawg, hist-pl-types, pipes, text, transformers
     }:
     mkDerivation {
       pname = "hist-pl-lexicon";
       version = "0.6.1";
       sha256 = "1333640e60d59980e2a38d81daa70c04edd23c4c55787175350513428b0a58ad";
       libraryHaskellDepends = [
         base binary containers dawg directory filepath hist-pl-dawg
         hist-pl-types pipes text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/kawu/hist-pl/tree/master/lexicon";
       description = "A binary representation of the historical dictionary of Polish";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hist-pl-lmf" = callPackage
    ({ mkDerivation, base, hist-pl-types, polysoup, text }:
     mkDerivation {
       pname = "hist-pl-lmf";
       version = "0.1.0";
       sha256 = "75f33f9ff5c5fd29d37f11eeacbc0d6ff7a58879ee70b6190f13bde84af8db90";
       libraryHaskellDepends = [ base hist-pl-types polysoup text ];
       jailbreak = true;
       homepage = "https://github.com/kawu/hist-pl/tree/master/lmf";
       description = "LMF parsing for the historical dictionary of Polish";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hist-pl-transliter" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "hist-pl-transliter";
       version = "0.1.1";
       sha256 = "2b6f88a11e6802e452ad43293dad326f068e6476aebacb9e5610a863a0e7de90";
       libraryHaskellDepends = [ base parsec ];
       homepage = "https://github.com/kawu/hist-pl/tree/master/transliter";
       description = "A simple EDSL for transliteration rules";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hist-pl-types" = callPackage
    ({ mkDerivation, base, binary, text, text-binary }:
     mkDerivation {
       pname = "hist-pl-types";
       version = "0.1.0";
       sha256 = "3bd142adc913d4c3dfe095abe6ff48722fab5e8c7e23c2c7045771d683542344";
       libraryHaskellDepends = [ base binary text text-binary ];
       jailbreak = true;
       homepage = "https://github.com/kawu/hist-pl/tree/master/types";
       description = "Types in the historical dictionary of Polish";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "histogram-fill_0_8_3_0" = callPackage
    ({ mkDerivation, base, deepseq, monad-primitive, primitive, vector
     }:
     mkDerivation {
       pname = "histogram-fill";
       version = "0.8.3.0";
       sha256 = "6fd4308a37eec69c47387d2df76f156c5c6137351efbc423eabdfde36476384d";
       libraryHaskellDepends = [
         base deepseq monad-primitive primitive vector
       ];
       homepage = "https://github.com/Shimuuar/histogram-fill/";
       description = "Library for histograms creation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "histogram-fill" = callPackage
    ({ mkDerivation, base, deepseq, ghc-prim, monad-primitive
     , primitive, vector
     }:
     mkDerivation {
       pname = "histogram-fill";
       version = "0.8.4.1";
       sha256 = "385919434a933b7ad4c7c262308186e4057d6e2e653fa98fa020f949d4c7557d";
       libraryHaskellDepends = [
         base deepseq ghc-prim monad-primitive primitive vector
       ];
       homepage = "https://github.com/Shimuuar/histogram-fill/";
       description = "Library for histograms creation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "histogram-fill-binary" = callPackage
    ({ mkDerivation, base, binary, histogram-fill, vector }:
     mkDerivation {
       pname = "histogram-fill-binary";
       version = "0.6.2.1";
       sha256 = "22ea6f6453ae85486621d05afaed5e3903be4b41464594f5e8a040840304672f";
       libraryHaskellDepends = [ base binary histogram-fill vector ];
       homepage = "https://github.com/Shimuuar/histogram-fill/";
       description = "Binary instances for histogram-fill package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "histogram-fill-cereal" = callPackage
    ({ mkDerivation, base, cereal, histogram-fill, vector }:
     mkDerivation {
       pname = "histogram-fill-cereal";
       version = "0.6.2.0";
       sha256 = "55c7212207e03e55e01f6ce5715ee75f4029520804410ca61a6310b398b1769d";
       libraryHaskellDepends = [ base cereal histogram-fill vector ];
       homepage = "http://bitbucket.org/Shimuuar/histogram-fill-cereal/";
       description = "Library for histograms creation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "historian" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, process
     , regex-compat, regex-posix
     }:
     mkDerivation {
       pname = "historian";
       version = "0.0.1";
       sha256 = "268b006916b1d4bcfc5090d47c2b5ae677f8c2e10c1be47f24538a04b095ead1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath process regex-compat regex-posix
       ];
       jailbreak = true;
       description = "Extract the interesting bits from shell history";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hit_0_6_2" = callPackage
    ({ mkDerivation, attoparsec, base, bytedump, bytestring, containers
     , cryptohash, hourglass, HUnit, mtl, parsec, patience, QuickCheck
     , random, system-fileio, system-filepath, test-framework
     , test-framework-quickcheck2, unix-compat, vector, zlib
     , zlib-bindings
     }:
     mkDerivation {
       pname = "hit";
       version = "0.6.2";
       sha256 = "1a9ea48c708332c55ccb8182fd4662ffdd9914f1b19520fd9c1e6d44ec928e1e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring containers cryptohash hourglass mtl
         parsec patience random system-fileio system-filepath unix-compat
         vector zlib zlib-bindings
       ];
       testHaskellDepends = [
         base bytedump bytestring hourglass HUnit QuickCheck test-framework
         test-framework-quickcheck2
       ];
       homepage = "http://github.com/vincenthz/hit";
       description = "Git operations in haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hit" = callPackage
    ({ mkDerivation, attoparsec, base, byteable, bytedump, bytestring
     , containers, cryptohash, hourglass, mtl, parsec, patience, random
     , system-fileio, system-filepath, tasty, tasty-quickcheck
     , unix-compat, utf8-string, vector, zlib, zlib-bindings
     }:
     mkDerivation {
       pname = "hit";
       version = "0.6.3";
       sha256 = "db86b3712029a4e40d1306dd6cc9ca2c9f4c77fe65a2b74106f1cbd2de26e471";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base byteable bytestring containers cryptohash hourglass
         mtl parsec patience random system-fileio system-filepath
         unix-compat utf8-string vector zlib zlib-bindings
       ];
       testHaskellDepends = [
         base bytedump bytestring hourglass tasty tasty-quickcheck
       ];
       homepage = "http://github.com/vincenthz/hit";
       description = "Git operations in haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hjcase" = callPackage
    ({ mkDerivation, aeson, base, bytestring, HUnit, test-framework
     , test-framework-hunit, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "hjcase";
       version = "0.2.0.0";
       sha256 = "53c2db8dd460ad2b49eeb5df1b5e0a27e5ae92573c785886914d4c2c89583734";
       libraryHaskellDepends = [
         aeson base bytestring HUnit test-framework test-framework-hunit
         text unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/seagreen/hjcase";
       description = "Jcase library for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hjpath" = callPackage
    ({ mkDerivation, base, containers, hjson, parsec }:
     mkDerivation {
       pname = "hjpath";
       version = "3.0.1";
       sha256 = "12aa694ac8f1ef4bd26e46504c183fee2f3087b5f85365bb07f9602222efbf72";
       libraryHaskellDepends = [ base containers hjson parsec ];
       homepage = "http://bitcheese.net/wiki/code/hjpath";
       description = "XPath-like syntax for querying JSON";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hjs" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , mtl, parsec, regex-compat
     }:
     mkDerivation {
       pname = "hjs";
       version = "0.2.1";
       sha256 = "117e44a03323603941365c80830d04da85a46a90d9fa0321ea82cdd575ac643e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers directory mtl parsec regex-compat
       ];
       homepage = "http://www.haskell.org/haskellwiki/Libraries_and_tools/HJS";
       description = "JavaScript Parser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hjsmin_0_1_4_7" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, Cabal, containers
     , HUnit, language-javascript, optparse-applicative, QuickCheck
     , test-framework, test-framework-hunit, text
     }:
     mkDerivation {
       pname = "hjsmin";
       version = "0.1.4.7";
       sha256 = "0e157fa21ad14996e9b416f78c4af595459064dc63a3cbb3ed38e3788d8e89bf";
       revision = "1";
       editedCabalFile = "8b24f51f4fa13d3837421f03ef731625bde85e0e2913bc43377098d44d9c2521";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring containers language-javascript text
       ];
       executableHaskellDepends = [
         base blaze-builder bytestring containers language-javascript
         optparse-applicative text
       ];
       testHaskellDepends = [
         base blaze-builder bytestring Cabal containers HUnit
         language-javascript QuickCheck test-framework test-framework-hunit
         text
       ];
       homepage = "http://github.com/alanz/hjsmin";
       description = "Haskell implementation of a javascript minifier";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hjsmin_0_1_4_8" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, Cabal, containers
     , HUnit, language-javascript, optparse-applicative, QuickCheck
     , test-framework, test-framework-hunit, text
     }:
     mkDerivation {
       pname = "hjsmin";
       version = "0.1.4.8";
       sha256 = "439f3524795e34b9999818155d2d3de0fe00ec856b3f57cb20d2e22d3e220188";
       revision = "1";
       editedCabalFile = "626a6e3677688c88a40f61f25025b67382c28826b908e55e4f98b9be1681c061";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring containers language-javascript text
       ];
       executableHaskellDepends = [
         base blaze-builder bytestring containers language-javascript
         optparse-applicative text
       ];
       testHaskellDepends = [
         base blaze-builder bytestring Cabal containers HUnit
         language-javascript QuickCheck test-framework test-framework-hunit
         text
       ];
       homepage = "http://github.com/erikd/hjsmin";
       description = "Haskell implementation of a javascript minifier";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hjsmin_0_1_5_0" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, Cabal, containers
     , HUnit, language-javascript, optparse-applicative, QuickCheck
     , test-framework, test-framework-hunit, text
     }:
     mkDerivation {
       pname = "hjsmin";
       version = "0.1.5.0";
       sha256 = "f4d81fd8a1cbe65642ff749aeb5866ed9487613a54d7efe6566805fe3f3bf1d7";
       revision = "1";
       editedCabalFile = "3f4d4ae3a1f8b219a975059ebe9957e45f260ed1e6802d886ad3f5ddc931c684";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring containers language-javascript text
       ];
       executableHaskellDepends = [
         base blaze-builder bytestring containers language-javascript
         optparse-applicative text
       ];
       testHaskellDepends = [
         base blaze-builder bytestring Cabal containers HUnit
         language-javascript QuickCheck test-framework test-framework-hunit
         text
       ];
       homepage = "http://github.com/erikd/hjsmin";
       description = "Haskell implementation of a javascript minifier";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hjsmin_0_1_5_1" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, Cabal, containers
     , HUnit, language-javascript, optparse-applicative, QuickCheck
     , test-framework, test-framework-hunit, text
     }:
     mkDerivation {
       pname = "hjsmin";
       version = "0.1.5.1";
       sha256 = "d1e36c8fe5dfd46819425877ca7fc6a5b422fce138de9787b7409850252decff";
       revision = "1";
       editedCabalFile = "84b6550796b29b1ee7bec20c47223fe3e2e0c57abc52bc2565b2ac6e7e929351";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring containers language-javascript text
       ];
       executableHaskellDepends = [
         base blaze-builder bytestring containers language-javascript
         optparse-applicative text
       ];
       testHaskellDepends = [
         base blaze-builder bytestring Cabal containers HUnit
         language-javascript QuickCheck test-framework test-framework-hunit
         text
       ];
       homepage = "http://github.com/erikd/hjsmin";
       description = "Haskell implementation of a javascript minifier";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hjsmin" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, Cabal, containers
     , HUnit, language-javascript, optparse-applicative, QuickCheck
     , test-framework, test-framework-hunit, text
     }:
     mkDerivation {
       pname = "hjsmin";
       version = "0.1.5.2";
       sha256 = "c2d04fe6b1f45d88d6b2e382b0fdf648a18b0cd913c2688af7ab77d7c27dd330";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring containers language-javascript text
       ];
       executableHaskellDepends = [
         base blaze-builder bytestring containers language-javascript
         optparse-applicative text
       ];
       testHaskellDepends = [
         base blaze-builder bytestring Cabal containers HUnit
         language-javascript QuickCheck test-framework test-framework-hunit
         text
       ];
       homepage = "http://github.com/erikd/hjsmin";
       description = "Haskell implementation of a javascript minifier";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hjson" = callPackage
    ({ mkDerivation, base, containers, parsec }:
     mkDerivation {
       pname = "hjson";
       version = "1.3.2";
       sha256 = "684699c938131f1e394b90546e8bbe1249a3eebfe7b5a6a96b544b7c7d79a9e4";
       libraryHaskellDepends = [ base containers parsec ];
       description = "JSON parsing library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hjson-query" = callPackage
    ({ mkDerivation, base, containers, hjson }:
     mkDerivation {
       pname = "hjson-query";
       version = "1.0.2";
       sha256 = "9d56f4ef84397f490c444e292e0edebbb750feb57216970e4818fc5b6a36486a";
       libraryHaskellDepends = [ base containers hjson ];
       description = "library for querying from JSON";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hjsonpointer" = callPackage
    ({ mkDerivation, aeson, base, http-types, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "hjsonpointer";
       version = "0.3.0.0";
       sha256 = "9d6ae61f5be1e538a50e1f386b45af3dfb20b0199c61c2b2a643f592f0c78915";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base QuickCheck text unordered-containers vector
       ];
       executableHaskellDepends = [ aeson base ];
       testHaskellDepends = [
         aeson base http-types HUnit test-framework test-framework-hunit
         test-framework-quickcheck2 text unordered-containers vector
       ];
       homepage = "https://github.com/seagreen/hjsonpointer";
       description = "JSON Pointer library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hjsonschema" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, containers
     , directory, file-embed, filepath, hashable, hjsonpointer
     , http-client, http-types, HUnit, mtl, regexpr, scientific
     , test-framework, test-framework-hunit, text, transformers
     , unordered-containers, vector, wai-app-static, warp
     }:
     mkDerivation {
       pname = "hjsonschema";
       version = "0.8.0.1";
       sha256 = "aeada3426b294cfc43a7cfac053aae0ee1fd06a5c551ecd0d3a6d725e47c89dc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers file-embed hashable hjsonpointer
         http-client http-types mtl regexpr scientific text transformers
         unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson base text unordered-containers vector
       ];
       testHaskellDepends = [
         aeson async base bytestring directory filepath HUnit test-framework
         test-framework-hunit text vector wai-app-static warp
       ];
       jailbreak = true;
       homepage = "https://github.com/seagreen/hjsonschema";
       description = "JSON Schema library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hkdf" = callPackage
    ({ mkDerivation, base, byteable, bytestring, cryptohash, hspec }:
     mkDerivation {
       pname = "hkdf";
       version = "0.0.1.1";
       sha256 = "5a1a00abb49577abed25c76b75592ab3bbffe696b1b5884af5d0ea35b8cb7463";
       libraryHaskellDepends = [ base byteable bytestring cryptohash ];
       testHaskellDepends = [ base byteable bytestring cryptohash hspec ];
       homepage = "http://github.com/j1r1k/hkdf";
       description = "Implementation of HKDF (RFC 5869)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hlatex" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, containers, derive
     , directory, filepath, frquotes, mtl, process, template-haskell
     , transformers, uniplate, utf8-string
     }:
     mkDerivation {
       pname = "hlatex";
       version = "0.3.1";
       sha256 = "1ea8a1097244818b694afd3f71aa2e56e8873b3019d3dcc973885be491a28d8e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-unicode-symbols containers derive directory filepath mtl
         process template-haskell transformers uniplate utf8-string
       ];
       executableHaskellDepends = [
         base base-unicode-symbols containers frquotes mtl transformers
       ];
       description = "A library to build valid LaTeX files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hlbfgsb" = callPackage
    ({ mkDerivation, base, gfortran, HUnit, test-framework
     , test-framework-hunit, vector
     }:
     mkDerivation {
       pname = "hlbfgsb";
       version = "0.0.1.0";
       sha256 = "bd19cedef0448d9360136b256ca1aeac5b97804bc48129e233f997b8722a5959";
       libraryHaskellDepends = [ base vector ];
       librarySystemDepends = [ gfortran ];
       libraryToolDepends = [ gfortran ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit vector
       ];
       homepage = "http://people.ksp.sk/~ivan/hlbfgsb";
       description = "Haskell binding to L-BFGS-B version 3.0";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gfortran;};

  "hlcm" = callPackage
    ({ mkDerivation, array, base, bytestring, bytestring-csv
     , containers, haskell98, parallel
     }:
     mkDerivation {
       pname = "hlcm";
       version = "0.2.2";
       sha256 = "ca9883b6be64d7c82748f530d33d9ae9e37c5912aada28444c4c5c370560d893";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring haskell98 parallel
       ];
       executableHaskellDepends = [
         array base bytestring bytestring-csv containers haskell98 parallel
       ];
       jailbreak = true;
       homepage = "http://membres-liglab.imag.fr/termier/HLCM/hlcm.html";
       description = "Fast algorithm for mining closed frequent itemsets";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hleap" = callPackage
    ({ mkDerivation, aeson, base, containers, data-default, mtl, text
     , unordered-containers, websockets
     }:
     mkDerivation {
       pname = "hleap";
       version = "0.1.2.6";
       sha256 = "5a0612ff7a1f111ced1cff7b039b33d74909acede53053d702c0311abfd4389b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base containers data-default mtl text unordered-containers
         websockets
       ];
       executableHaskellDepends = [
         aeson base containers data-default mtl text unordered-containers
         websockets
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/bwbush/hleap";
       description = "Web Socket interface to Leap Motion controller";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hledger_0_23_3" = callPackage
    ({ mkDerivation, base, cmdargs, containers, csv, directory
     , filepath, haskeline, hledger-lib, HUnit, mtl, old-locale
     , old-time, parsec, pretty-show, process, regexpr, safe
     , shakespeare, shakespeare-text, split, tabular, test-framework
     , test-framework-hunit, text, time, transformers, utf8-string
     , wizards
     }:
     mkDerivation {
       pname = "hledger";
       version = "0.23.3";
       sha256 = "f5ec84df326fa4526886be7b875a727dbc73e811c5153baa51abb55b1d971983";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cmdargs containers directory filepath haskeline hledger-lib
         HUnit mtl old-locale old-time parsec pretty-show process regexpr
         safe shakespeare shakespeare-text split tabular text time
         utf8-string wizards
       ];
       executableHaskellDepends = [
         base cmdargs containers directory filepath haskeline hledger-lib
         HUnit mtl old-locale old-time parsec pretty-show process regexpr
         safe shakespeare shakespeare-text split tabular text time
         utf8-string wizards
       ];
       testHaskellDepends = [
         base cmdargs containers csv directory filepath haskeline
         hledger-lib HUnit mtl old-locale old-time parsec pretty-show
         process regexpr safe shakespeare shakespeare-text split tabular
         test-framework test-framework-hunit text time transformers wizards
       ];
       jailbreak = true;
       homepage = "http://hledger.org";
       description = "The main command-line interface for the hledger accounting tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hledger_0_24" = callPackage
    ({ mkDerivation, base, cmdargs, containers, csv, directory
     , filepath, haskeline, hledger-lib, HUnit, mtl, old-locale
     , old-time, parsec, pretty-show, process, regex-tdfa, regexpr, safe
     , shakespeare, shakespeare-text, split, tabular, test-framework
     , test-framework-hunit, text, time, transformers, utf8-string
     , wizards
     }:
     mkDerivation {
       pname = "hledger";
       version = "0.24";
       sha256 = "ccb94db74d0f41a7d77d10701a8baee849abe02e6ed0e57a3940a728c2a362b8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cmdargs containers csv directory filepath haskeline
         hledger-lib HUnit mtl old-locale old-time parsec pretty-show
         process regex-tdfa regexpr safe shakespeare shakespeare-text split
         tabular text time utf8-string wizards
       ];
       executableHaskellDepends = [
         base cmdargs containers csv directory filepath haskeline
         hledger-lib HUnit mtl old-locale old-time parsec pretty-show
         process regex-tdfa regexpr safe shakespeare shakespeare-text split
         tabular text time utf8-string wizards
       ];
       testHaskellDepends = [
         base cmdargs containers csv directory filepath haskeline
         hledger-lib HUnit mtl old-locale old-time parsec pretty-show
         process regex-tdfa regexpr safe shakespeare shakespeare-text split
         tabular test-framework test-framework-hunit text time transformers
         wizards
       ];
       jailbreak = true;
       homepage = "http://hledger.org";
       description = "The main command-line interface for the hledger accounting tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hledger_0_24_1" = callPackage
    ({ mkDerivation, base, cmdargs, containers, csv, directory
     , filepath, haskeline, hledger-lib, HUnit, mtl, old-locale
     , old-time, parsec, pretty-show, process, regex-tdfa, regexpr, safe
     , shakespeare, shakespeare-text, split, tabular, test-framework
     , test-framework-hunit, text, time, transformers, utf8-string
     , wizards
     }:
     mkDerivation {
       pname = "hledger";
       version = "0.24.1";
       sha256 = "685b018c3213c07cf1b7060d21c946143eeb2579f5e25b032ae5243f725b094c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cmdargs containers csv directory filepath haskeline
         hledger-lib HUnit mtl old-locale old-time parsec pretty-show
         process regex-tdfa regexpr safe shakespeare shakespeare-text split
         tabular text time utf8-string wizards
       ];
       executableHaskellDepends = [
         base cmdargs containers csv directory filepath haskeline
         hledger-lib HUnit mtl old-locale old-time parsec pretty-show
         process regex-tdfa regexpr safe shakespeare shakespeare-text split
         tabular text time utf8-string wizards
       ];
       testHaskellDepends = [
         base cmdargs containers csv directory filepath haskeline
         hledger-lib HUnit mtl old-locale old-time parsec pretty-show
         process regex-tdfa regexpr safe shakespeare shakespeare-text split
         tabular test-framework test-framework-hunit text time transformers
         wizards
       ];
       jailbreak = true;
       homepage = "http://hledger.org";
       description = "The main command-line interface for the hledger accounting tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hledger_0_26" = callPackage
    ({ mkDerivation, base, base-compat, cmdargs, containers, csv
     , directory, filepath, haskeline, hledger-lib, HUnit, mtl
     , mtl-compat, old-time, parsec, pretty-show, process, regex-tdfa
     , safe, shakespeare, split, tabular, terminfo, test-framework
     , test-framework-hunit, text, time, transformers
     , unordered-containers, utf8-string, wizards
     }:
     mkDerivation {
       pname = "hledger";
       version = "0.26";
       sha256 = "758d9645d735c71d431ccdc8befd684da7fd9816d15e1ebfb10be794a2913dbe";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-compat cmdargs containers csv directory filepath
         haskeline hledger-lib HUnit mtl mtl-compat old-time parsec
         pretty-show process regex-tdfa safe shakespeare split tabular
         terminfo text time unordered-containers utf8-string wizards
       ];
       executableHaskellDepends = [
         base base-compat cmdargs containers csv directory filepath
         haskeline hledger-lib HUnit mtl mtl-compat old-time parsec
         pretty-show process regex-tdfa safe shakespeare split tabular text
         time unordered-containers utf8-string wizards
       ];
       testHaskellDepends = [
         base base-compat cmdargs containers csv directory filepath
         haskeline hledger-lib HUnit mtl mtl-compat old-time parsec
         pretty-show process regex-tdfa safe shakespeare split tabular
         test-framework test-framework-hunit text time transformers wizards
       ];
       jailbreak = true;
       homepage = "http://hledger.org";
       description = "The main command-line interface for the hledger accounting tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hledger" = callPackage
    ({ mkDerivation, base, base-compat, cmdargs, containers, csv
     , directory, filepath, haskeline, hledger-lib, HUnit, mtl
     , mtl-compat, old-time, parsec, pretty-show, process, regex-tdfa
     , safe, shakespeare, split, tabular, terminfo, test-framework
     , test-framework-hunit, text, time, unordered-containers
     , utf8-string, wizards
     }:
     mkDerivation {
       pname = "hledger";
       version = "0.27";
       sha256 = "0aecdf586a46c24d6d67659157d1edbfc0d78afb50ea7cfbec1a01bf86b792b0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-compat cmdargs containers csv directory filepath
         haskeline hledger-lib HUnit mtl mtl-compat old-time parsec
         pretty-show process regex-tdfa safe shakespeare split tabular
         terminfo text time unordered-containers utf8-string wizards
       ];
       executableHaskellDepends = [
         base base-compat cmdargs containers csv directory filepath
         haskeline hledger-lib HUnit mtl mtl-compat old-time parsec
         pretty-show process regex-tdfa safe shakespeare split tabular
         terminfo text time unordered-containers utf8-string wizards
       ];
       testHaskellDepends = [
         base base-compat cmdargs containers csv directory filepath
         haskeline hledger-lib HUnit mtl mtl-compat old-time parsec
         pretty-show process regex-tdfa safe shakespeare split tabular
         terminfo test-framework test-framework-hunit text time
         unordered-containers utf8-string wizards
       ];
       homepage = "http://hledger.org";
       description = "Command-line interface for the hledger accounting tool";
       license = "GPL";
     }) {};

  "hledger-chart" = callPackage
    ({ mkDerivation, base, Chart, cmdargs, colour, containers, hledger
     , hledger-lib, HUnit, safe, time
     }:
     mkDerivation {
       pname = "hledger-chart";
       version = "0.16.1";
       sha256 = "96a91cb36df98f7c43805c7dea6ec0e65115a8945ff5ddf043294731c03065fa";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Chart cmdargs colour containers hledger hledger-lib HUnit safe
         time
       ];
       jailbreak = true;
       homepage = "http://hledger.org";
       description = "A pie chart image generator for the hledger accounting tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hledger-diff" = callPackage
    ({ mkDerivation, base, hledger-lib, time }:
     mkDerivation {
       pname = "hledger-diff";
       version = "0.2.0.5";
       sha256 = "437034c916d99bfc13240e0cc7a563bef4029ddda526eb4bf0e452ef29be8e67";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base hledger-lib time ];
       homepage = "https://github.com/gebner/hledger-diff";
       description = "Compares the transactions in two ledger files";
       license = stdenv.lib.licenses.gpl3;
       maintainers = with stdenv.lib.maintainers; [ gebner ];
     }) {};

  "hledger-interest" = callPackage
    ({ mkDerivation, base, Cabal, Decimal, hledger-lib, mtl, time }:
     mkDerivation {
       pname = "hledger-interest";
       version = "1.4.4";
       sha256 = "d6ad4a75d810d64c9f70a19ff2b51fe37d79313c4bb1b78d95e5ddcc5998769a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal Decimal hledger-lib mtl time
       ];
       homepage = "http://github.com/peti/hledger-interest";
       description = "computes interest for a given account";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "hledger-irr" = callPackage
    ({ mkDerivation, base, Cabal, Decimal, hledger-lib, statistics
     , time
     }:
     mkDerivation {
       pname = "hledger-irr";
       version = "0.1.1.8";
       sha256 = "7dd9f5c870c508534c1c00d653ee4319cead5b912a446a8c3b4ef941caae3162";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal Decimal hledger-lib statistics time
       ];
       description = "computes the internal rate of return of an investment";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hledger-lib_0_23_3" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, containers, csv
     , directory, filepath, HUnit, mtl, old-locale, old-time, parsec
     , pretty-show, regex-tdfa, regexpr, safe, split, test-framework
     , test-framework-hunit, time, transformers, utf8-string
     }:
     mkDerivation {
       pname = "hledger-lib";
       version = "0.23.3";
       sha256 = "71b5f1103f3075f7352a94cb88e7e1e9892996b09cd73e1b7c94b635330fc646";
       libraryHaskellDepends = [
         base bytestring cmdargs containers csv directory filepath HUnit mtl
         old-locale old-time parsec pretty-show regex-tdfa regexpr safe
         split time transformers utf8-string
       ];
       testHaskellDepends = [
         base cmdargs containers csv directory filepath HUnit mtl old-locale
         old-time parsec pretty-show regex-tdfa regexpr safe split
         test-framework test-framework-hunit time transformers
       ];
       jailbreak = true;
       homepage = "http://hledger.org";
       description = "Core data types, parsers and utilities for the hledger accounting tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hledger-lib_0_24" = callPackage
    ({ mkDerivation, array, base, blaze-markup, bytestring, cmdargs
     , containers, csv, Decimal, directory, filepath, HUnit, mtl
     , old-locale, old-time, parsec, pretty-show, regex-tdfa, regexpr
     , safe, split, test-framework, test-framework-hunit, time
     , transformers, utf8-string
     }:
     mkDerivation {
       pname = "hledger-lib";
       version = "0.24";
       sha256 = "da1a0742e2aa136d4a6ea1a6f76e4cbbdb8ea2f4ae10d1000a37fc42a0a218e4";
       libraryHaskellDepends = [
         array base blaze-markup bytestring cmdargs containers csv Decimal
         directory filepath HUnit mtl old-locale old-time parsec pretty-show
         regex-tdfa regexpr safe split time transformers utf8-string
       ];
       testHaskellDepends = [
         array base blaze-markup cmdargs containers csv Decimal directory
         filepath HUnit mtl old-locale old-time parsec pretty-show
         regex-tdfa regexpr safe split test-framework test-framework-hunit
         time transformers
       ];
       jailbreak = true;
       homepage = "http://hledger.org";
       description = "Core data types, parsers and utilities for the hledger accounting tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hledger-lib_0_24_1" = callPackage
    ({ mkDerivation, array, base, blaze-markup, bytestring, cmdargs
     , containers, csv, Decimal, directory, filepath, HUnit, mtl
     , old-locale, old-time, parsec, pretty-show, regex-tdfa, regexpr
     , safe, split, test-framework, test-framework-hunit, time
     , transformers, utf8-string
     }:
     mkDerivation {
       pname = "hledger-lib";
       version = "0.24.1";
       sha256 = "cc1a100cf8080b5b43c84426ab52a00dd80ae7bbd24da9e1496491e1c4f19fb2";
       libraryHaskellDepends = [
         array base blaze-markup bytestring cmdargs containers csv Decimal
         directory filepath HUnit mtl old-locale old-time parsec pretty-show
         regex-tdfa regexpr safe split time transformers utf8-string
       ];
       testHaskellDepends = [
         array base blaze-markup cmdargs containers csv Decimal directory
         filepath HUnit mtl old-locale old-time parsec pretty-show
         regex-tdfa regexpr safe split test-framework test-framework-hunit
         time transformers
       ];
       homepage = "http://hledger.org";
       description = "Core data types, parsers and utilities for the hledger accounting tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hledger-lib_0_26" = callPackage
    ({ mkDerivation, array, base, base-compat, blaze-markup, bytestring
     , cmdargs, containers, csv, Decimal, directory, filepath, HUnit
     , mtl, mtl-compat, old-time, parsec, pretty-show, regex-tdfa, safe
     , split, test-framework, test-framework-hunit, time, transformers
     , utf8-string
     }:
     mkDerivation {
       pname = "hledger-lib";
       version = "0.26";
       sha256 = "d002f4640fc4ab8d5ce8485097b579e50245645e31260c90300a76378b69a532";
       libraryHaskellDepends = [
         array base base-compat blaze-markup bytestring cmdargs containers
         csv Decimal directory filepath HUnit mtl mtl-compat old-time parsec
         pretty-show regex-tdfa safe split time transformers utf8-string
       ];
       testHaskellDepends = [
         array base base-compat blaze-markup cmdargs containers csv Decimal
         directory filepath HUnit mtl mtl-compat old-time parsec pretty-show
         regex-tdfa safe split test-framework test-framework-hunit time
         transformers
       ];
       homepage = "http://hledger.org";
       description = "Core data types, parsers and utilities for the hledger accounting tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hledger-lib" = callPackage
    ({ mkDerivation, array, base, base-compat, blaze-markup, bytestring
     , cmdargs, containers, csv, Decimal, deepseq, directory, filepath
     , HUnit, mtl, mtl-compat, old-time, parsec, pretty-show, regex-tdfa
     , safe, split, test-framework, test-framework-hunit, time
     , transformers, uglymemo, utf8-string
     }:
     mkDerivation {
       pname = "hledger-lib";
       version = "0.27";
       sha256 = "77c47900106e65411743097cd0855b5484e1439b0de4c5ee6d2a0c5748672606";
       libraryHaskellDepends = [
         array base base-compat blaze-markup bytestring cmdargs containers
         csv Decimal deepseq directory filepath HUnit mtl mtl-compat
         old-time parsec pretty-show regex-tdfa safe split time transformers
         uglymemo utf8-string
       ];
       testHaskellDepends = [
         array base base-compat blaze-markup bytestring cmdargs containers
         csv Decimal deepseq directory filepath HUnit mtl mtl-compat
         old-time parsec pretty-show regex-tdfa safe split test-framework
         test-framework-hunit time transformers uglymemo utf8-string
       ];
       homepage = "http://hledger.org";
       description = "Core data types, parsers and functionality for the hledger accounting tools";
       license = "GPL";
     }) {};

  "hledger-ui" = callPackage
    ({ mkDerivation, base, base-compat, brick, cmdargs, containers
     , data-default, filepath, hledger, hledger-lib, HUnit, lens
     , pretty-show, safe, split, time, transformers, vector, vty
     }:
     mkDerivation {
       pname = "hledger-ui";
       version = "0.27.3";
       sha256 = "87dcd09479acc3e84a883d427c988a110451dee75a5e1f1c9d5ea2b34e99c4c1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base base-compat brick cmdargs containers data-default filepath
         hledger hledger-lib HUnit lens pretty-show safe split time
         transformers vector vty
       ];
       homepage = "http://hledger.org";
       description = "Curses-style user interface for the hledger accounting tool";
       license = "GPL";
     }) {};

  "hledger-vty" = callPackage
    ({ mkDerivation, base, cmdargs, hledger, hledger-lib, HUnit, safe
     , time, vty
     }:
     mkDerivation {
       pname = "hledger-vty";
       version = "0.16.1";
       sha256 = "0805483dd2369b68b55628ffb87c43b691e1e1e44041ebf7fed99adfaf4a5881";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs hledger hledger-lib HUnit safe time vty
       ];
       jailbreak = true;
       homepage = "http://hledger.org";
       description = "A curses-style console interface for the hledger accounting tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hledger-web_0_24_1" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
     , clientsession, cmdargs, conduit-extra, data-default, directory
     , filepath, hjsmin, hledger, hledger-lib, hspec, http-client
     , http-conduit, HUnit, json, network-conduit, old-locale, parsec
     , regexpr, safe, shakespeare, template-haskell, text, time
     , transformers, wai, wai-extra, wai-handler-launch, warp, yaml
     , yesod, yesod-core, yesod-static, yesod-test
     }:
     mkDerivation {
       pname = "hledger-web";
       version = "0.24.1";
       sha256 = "208862584be4ed5feed2471797db940ab631e01f023a389290fdd979520ecbbb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html blaze-markup bytestring clientsession cmdargs
         conduit-extra data-default directory filepath hjsmin hledger
         hledger-lib http-client http-conduit HUnit json network-conduit
         old-locale parsec regexpr safe shakespeare template-haskell text
         time transformers wai wai-extra wai-handler-launch warp yaml yesod
         yesod-core yesod-static
       ];
       executableHaskellDepends = [
         base blaze-html blaze-markup bytestring clientsession cmdargs
         conduit-extra data-default directory filepath hjsmin hledger
         hledger-lib http-client http-conduit HUnit json network-conduit
         old-locale parsec regexpr safe shakespeare template-haskell text
         time transformers wai wai-extra wai-handler-launch warp yaml yesod
         yesod-core yesod-static
       ];
       testHaskellDepends = [ base hspec yesod yesod-test ];
       jailbreak = true;
       homepage = "http://hledger.org";
       description = "A web interface for the hledger accounting tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hledger-web_0_26" = callPackage
    ({ mkDerivation, base, base-compat, blaze-html, blaze-markup
     , bytestring, clientsession, cmdargs, conduit-extra, data-default
     , directory, filepath, hjsmin, hledger, hledger-lib, hspec
     , http-client, http-conduit, HUnit, json, parsec, safe, shakespeare
     , template-haskell, text, time, transformers, wai, wai-extra
     , wai-handler-launch, warp, yaml, yesod, yesod-core, yesod-form
     , yesod-static, yesod-test
     }:
     mkDerivation {
       pname = "hledger-web";
       version = "0.26";
       sha256 = "51f7bb993ba8107aa18aae4dd78023e14e6ad8fc2f0f84941746eb09bc243905";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-compat blaze-html blaze-markup bytestring clientsession
         cmdargs conduit-extra data-default directory filepath hjsmin
         hledger hledger-lib http-client http-conduit HUnit json parsec safe
         shakespeare template-haskell text time transformers wai wai-extra
         wai-handler-launch warp yaml yesod yesod-core yesod-form
         yesod-static
       ];
       executableHaskellDepends = [
         base base-compat blaze-html blaze-markup bytestring clientsession
         cmdargs conduit-extra data-default directory filepath hjsmin
         hledger hledger-lib http-client http-conduit HUnit json parsec safe
         shakespeare template-haskell text time transformers wai wai-extra
         wai-handler-launch warp yaml yesod yesod-core yesod-form
         yesod-static
       ];
       testHaskellDepends = [ base base-compat hspec yesod yesod-test ];
       jailbreak = true;
       homepage = "http://hledger.org";
       description = "A web interface for the hledger accounting tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hledger-web" = callPackage
    ({ mkDerivation, base, base-compat, blaze-html, blaze-markup
     , bytestring, clientsession, cmdargs, conduit-extra, data-default
     , directory, filepath, hjsmin, hledger, hledger-lib, hspec
     , http-client, http-conduit, HUnit, json, parsec, safe, shakespeare
     , template-haskell, text, time, transformers, wai, wai-extra
     , wai-handler-launch, warp, yaml, yesod, yesod-core, yesod-form
     , yesod-static, yesod-test
     }:
     mkDerivation {
       pname = "hledger-web";
       version = "0.27";
       sha256 = "92722fa89b09b9d1fd2f66703083e84e0a03a97b6aea08c9064723d4858df1ef";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-compat blaze-html blaze-markup bytestring clientsession
         cmdargs conduit-extra data-default directory filepath hjsmin
         hledger hledger-lib http-client http-conduit HUnit json parsec safe
         shakespeare template-haskell text time transformers wai wai-extra
         wai-handler-launch warp yaml yesod yesod-core yesod-form
         yesod-static
       ];
       executableHaskellDepends = [
         base base-compat blaze-html blaze-markup bytestring clientsession
         cmdargs conduit-extra data-default directory filepath hjsmin
         hledger hledger-lib http-client http-conduit HUnit json parsec safe
         shakespeare template-haskell text time transformers wai wai-extra
         wai-handler-launch warp yaml yesod yesod-core yesod-form
         yesod-static
       ];
       testHaskellDepends = [
         base base-compat blaze-html blaze-markup bytestring clientsession
         cmdargs conduit-extra data-default directory filepath hjsmin
         hledger hledger-lib hspec http-client http-conduit HUnit json
         parsec safe shakespeare template-haskell text time transformers wai
         wai-extra wai-handler-launch warp yaml yesod yesod-core yesod-form
         yesod-static yesod-test
       ];
       homepage = "http://hledger.org";
       description = "Web interface for the hledger accounting tool";
       license = "GPL";
     }) {};

  "hlibBladeRF" = callPackage
    ({ mkDerivation, base, bindings-DSL, bytestring, hlint, libbladeRF
     }:
     mkDerivation {
       pname = "hlibBladeRF";
       version = "0.1.0.6";
       sha256 = "bc663bf05dd04294b24810a3e9991b0769190899f4849195697412e09d2a6196";
       libraryHaskellDepends = [ base bindings-DSL bytestring ];
       libraryPkgconfigDepends = [ libbladeRF ];
       testHaskellDepends = [ base hlint ];
       jailbreak = true;
       homepage = "https://victoredwardocallaghan.github.io/hlibBladeRF";
       description = "Haskell binding to libBladeRF SDR library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) libbladeRF;};

  "hlibev" = callPackage
    ({ mkDerivation, base, ev, network }:
     mkDerivation {
       pname = "hlibev";
       version = "0.4.0";
       sha256 = "dc37dafa42fad03228f353eaa0cda8d57eaf2f8c2558c3de29d2425526e02610";
       libraryHaskellDepends = [ base network ];
       librarySystemDepends = [ ev ];
       homepage = "http://github.com/aycanirican/hlibev";
       description = "FFI interface to libev";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {ev = null;};

  "hlibfam" = callPackage
    ({ mkDerivation, base, fam }:
     mkDerivation {
       pname = "hlibfam";
       version = "0.2";
       sha256 = "cd87f9f3f9718e00643b311f7e3cee1a8347003598a125e7d0b8de2bb0e33d83";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ fam ];
       description = "FFI interface to libFAM";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) fam;};

  "hlibgit2_0_18_0_13" = callPackage
    ({ mkDerivation, base, bindings-DSL, openssl, process, zlib }:
     mkDerivation {
       pname = "hlibgit2";
       version = "0.18.0.13";
       sha256 = "1f163efc2f799b00675120787c9bd9bff6817f244da93e11a9dcc239437954af";
       libraryHaskellDepends = [ base bindings-DSL zlib ];
       librarySystemDepends = [ openssl ];
       testHaskellDepends = [ base process ];
       description = "Low-level bindings to libgit2";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openssl;};

  "hlibgit2_0_18_0_14" = callPackage
    ({ mkDerivation, base, bindings-DSL, git, openssl, process, zlib }:
     mkDerivation {
       pname = "hlibgit2";
       version = "0.18.0.14";
       sha256 = "c00ebb6fcaf73d45ddc131610ffe77f826157b6cc385fe704f9247101fa3af3b";
       libraryHaskellDepends = [ base bindings-DSL zlib ];
       librarySystemDepends = [ openssl ];
       testHaskellDepends = [ base process ];
       testToolDepends = [ git ];
       description = "Low-level bindings to libgit2";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) git; inherit (pkgs) openssl;};

  "hlibgit2" = callPackage
    ({ mkDerivation, base, bindings-DSL, git, openssl, process, zlib }:
     mkDerivation {
       pname = "hlibgit2";
       version = "0.18.0.15";
       sha256 = "1170c1f71b39d13699018c29688c005c7aa2d07d8bbbb9d383a9a85e5d4c5601";
       libraryHaskellDepends = [ base bindings-DSL zlib ];
       librarySystemDepends = [ openssl ];
       testHaskellDepends = [ base process ];
       testToolDepends = [ git ];
       description = "Low-level bindings to libgit2";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) git; inherit (pkgs) openssl;};

  "hlibsass_0_1_4_0" = callPackage
    ({ mkDerivation, base, hspec, libsass }:
     mkDerivation {
       pname = "hlibsass";
       version = "0.1.4.0";
       sha256 = "2673ff4a4189bdfda61e5b936e1e91c4de29ede91db40055511a835ccbd35818";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ libsass ];
       testHaskellDepends = [ base hspec ];
       homepage = "https://github.com/jakubfijalkowski/hlibsass";
       description = "Low-level bindings to Libsass";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libsass;};

  "hlibsass" = callPackage
    ({ mkDerivation, base, hspec, libsass }:
     mkDerivation {
       pname = "hlibsass";
       version = "0.1.5.0";
       sha256 = "ce3e9a15d01c1b61d41b03e9b05ecd9b4b9aaf6da7d591086181b74e18d25bb8";
       configureFlags = [ "-fexternallibsass" ];
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ libsass ];
       testHaskellDepends = [ base hspec ];
       homepage = "https://github.com/jakubfijalkowski/hlibsass";
       description = "Low-level bindings to Libsass";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) libsass;};

  "hlint_1_9_13" = callPackage
    ({ mkDerivation, ansi-terminal, base, cmdargs, containers, cpphs
     , directory, extra, filepath, haskell-src-exts, hscolour, process
     , transformers, uniplate
     }:
     mkDerivation {
       pname = "hlint";
       version = "1.9.13";
       sha256 = "8a5c837a5d6b347d445350610b54ef1cfb5f0b83714cced420376f39e84144b2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base cmdargs containers cpphs directory extra
         filepath haskell-src-exts hscolour process transformers uniplate
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~ndm/hlint/";
       description = "Source code suggestions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hlint_1_9_14" = callPackage
    ({ mkDerivation, ansi-terminal, base, cmdargs, containers, cpphs
     , directory, extra, filepath, haskell-src-exts, hscolour, process
     , transformers, uniplate
     }:
     mkDerivation {
       pname = "hlint";
       version = "1.9.14";
       sha256 = "f4d68b0ab086e5cefc215a08b424944bd92a84dc39e485e912701585de82ff3e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base cmdargs containers cpphs directory extra
         filepath haskell-src-exts hscolour process transformers uniplate
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~ndm/hlint/";
       description = "Source code suggestions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hlint_1_9_16" = callPackage
    ({ mkDerivation, ansi-terminal, base, cmdargs, containers, cpphs
     , directory, extra, filepath, haskell-src-exts, hscolour, process
     , transformers, uniplate
     }:
     mkDerivation {
       pname = "hlint";
       version = "1.9.16";
       sha256 = "63b17fe15587ffd7e26a9afd3a78cfbe5bf07fdb63db2b83ba4fa3eca996d387";
       revision = "1";
       editedCabalFile = "4e3f4397ef78f431aadf4644b37ec01d624dd14dd70fec81953a509546182b8a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base cmdargs containers cpphs directory extra
         filepath haskell-src-exts hscolour process transformers uniplate
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~ndm/hlint/";
       description = "Source code suggestions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hlint_1_9_19" = callPackage
    ({ mkDerivation, ansi-terminal, base, cmdargs, containers, cpphs
     , directory, extra, filepath, haskell-src-exts, hscolour, process
     , transformers, uniplate
     }:
     mkDerivation {
       pname = "hlint";
       version = "1.9.19";
       sha256 = "371d30b6544ee5210062dcdb9ced8c3e8aaa4a368001c036d6e03fcc6c5c911f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base cmdargs containers cpphs directory extra
         filepath haskell-src-exts hscolour process transformers uniplate
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~ndm/hlint/";
       description = "Source code suggestions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hlint_1_9_20" = callPackage
    ({ mkDerivation, ansi-terminal, base, cmdargs, containers, cpphs
     , directory, extra, filepath, haskell-src-exts, hscolour, process
     , transformers, uniplate
     }:
     mkDerivation {
       pname = "hlint";
       version = "1.9.20";
       sha256 = "f0c3b0199146ba8247165dad428c53b61d7ce985166df7272faa020236f8a6da";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base cmdargs containers cpphs directory extra
         filepath haskell-src-exts hscolour process transformers uniplate
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~ndm/hlint/";
       description = "Source code suggestions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hlint_1_9_21" = callPackage
    ({ mkDerivation, ansi-terminal, base, cmdargs, containers, cpphs
     , directory, extra, filepath, haskell-src-exts, hscolour, process
     , transformers, uniplate
     }:
     mkDerivation {
       pname = "hlint";
       version = "1.9.21";
       sha256 = "8694a193e0f55b9a74ddd4fb44a242872f91e36ea59dd96ab489562a65cb6393";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base cmdargs containers cpphs directory extra
         filepath haskell-src-exts hscolour process transformers uniplate
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~ndm/hlint/";
       description = "Source code suggestions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hlint_1_9_22" = callPackage
    ({ mkDerivation, ansi-terminal, base, cmdargs, containers, cpphs
     , directory, extra, filepath, haskell-src-exts, hscolour, process
     , refact, transformers, uniplate
     }:
     mkDerivation {
       pname = "hlint";
       version = "1.9.22";
       sha256 = "5f6e377238899b87e83b38c1a6a8bfee68d6c50dba2229454a081115cd5c19f7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base cmdargs containers cpphs directory extra
         filepath haskell-src-exts hscolour process refact transformers
         uniplate
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~ndm/hlint/";
       description = "Source code suggestions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hlint_1_9_26" = callPackage
    ({ mkDerivation, ansi-terminal, base, cmdargs, containers, cpphs
     , directory, extra, filepath, haskell-src-exts, hscolour, process
     , refact, transformers, uniplate
     }:
     mkDerivation {
       pname = "hlint";
       version = "1.9.26";
       sha256 = "f9dcb152d05472c16572e9519494b376c12b748a886f79f74ffcfcb973c33553";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base cmdargs containers cpphs directory extra
         filepath haskell-src-exts hscolour process refact transformers
         uniplate
       ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/ndmitchell/hlint#readme";
       description = "Source code suggestions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hlint" = callPackage
    ({ mkDerivation, ansi-terminal, base, cmdargs, containers, cpphs
     , directory, extra, filepath, haskell-src-exts, hscolour, process
     , refact, transformers, uniplate
     }:
     mkDerivation {
       pname = "hlint";
       version = "1.9.28";
       sha256 = "eb06658a19c362a1f522dc495a6d5e5a90af68cefbcc178713aa8ee0a4c7f710";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base cmdargs containers cpphs directory extra
         filepath haskell-src-exts hscolour process refact transformers
         uniplate
       ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/ndmitchell/hlint#readme";
       description = "Source code suggestions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hlogger" = callPackage
    ({ mkDerivation, base, old-locale, time }:
     mkDerivation {
       pname = "hlogger";
       version = "0.0.3.0";
       sha256 = "8ed88ca5ef4e0c0997f468ada7c80cc608912da6306d87f9d914f4e3bbd572e0";
       libraryHaskellDepends = [ base old-locale time ];
       homepage = "http://www.pontarius.org/sub-projects/hlogger/";
       description = "Simple, concurrent, extendable and easy-to-use logging library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hlongurl" = callPackage
    ({ mkDerivation, base, bytestring, curl, json, regex-base
     , regex-posix
     }:
     mkDerivation {
       pname = "hlongurl";
       version = "0.9.3";
       sha256 = "65d3cbcdb1de5f90358bd314b7fb11929aadf95f63e409df035efe24373b52da";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base curl json ];
       executableHaskellDepends = [
         base bytestring curl regex-base regex-posix
       ];
       description = "Library and utility interfacing to longurl.org";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hls" = callPackage
    ({ mkDerivation, base, containers, hcg-minus, hps }:
     mkDerivation {
       pname = "hls";
       version = "0.15";
       sha256 = "d4a423f6817c9a6a6bdf4afa5ac24279cfaeb0ddb25db71343bd4f6cb7776240";
       libraryHaskellDepends = [ base containers hcg-minus hps ];
       homepage = "http://rd.slavepianos.org/t/hls";
       description = "Haskell Lindenmayer Systems";
       license = "GPL";
     }) {};

  "hlwm" = callPackage
    ({ mkDerivation, base, monads-tf, stm, transformers, unix, X11 }:
     mkDerivation {
       pname = "hlwm";
       version = "0.1.0.1";
       sha256 = "f165e77b1ce116bdefbc67845b21618f7b71140c5c5b6c7725f8a50d0809e2ee";
       revision = "1";
       editedCabalFile = "ce22b9186e03c83f13e56b33630f4af561b604c51374c23dc1ef4e24ced9a54e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base monads-tf stm transformers unix X11
       ];
       executableHaskellDepends = [
         base monads-tf stm transformers unix X11
       ];
       jailbreak = true;
       description = "Bindings to the herbstluftwm window manager";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "hly" = callPackage
    ({ mkDerivation, base, directory, filepath, hmt, process }:
     mkDerivation {
       pname = "hly";
       version = "0.15";
       sha256 = "48c270fbd3ad721fc7563d2ebce4430aba3542d48bc8ae1b6b6ebc34b0fb5aa4";
       libraryHaskellDepends = [ base directory filepath hmt process ];
       homepage = "http://rd.slavepianos.org/t/hly";
       description = "Haskell LilyPond";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmark" = callPackage
    ({ mkDerivation, base, bytestring, random, safe
     , tokyocabinet-haskell, utf8-string
     }:
     mkDerivation {
       pname = "hmark";
       version = "1.2";
       sha256 = "eff5358aedb4e8740f05f72cb198986dad28766b6ddf84598d0cb256166491e8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring random safe tokyocabinet-haskell utf8-string
       ];
       executableHaskellDepends = [ base ];
       homepage = "http://bitcheese.net/wiki/code/hmark";
       description = "A tool and library for Markov chains based text generation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmarkup" = callPackage
    ({ mkDerivation, base, containers, mtl, network, parsec, xhtml }:
     mkDerivation {
       pname = "hmarkup";
       version = "3000.0.1";
       sha256 = "a210e8e4a58994b1d244f0e64d8a1b8050f0913b81a9e8dcdf2d80159a0cce5c";
       libraryHaskellDepends = [
         base containers mtl network parsec xhtml
       ];
       description = "Simple wikitext-like markup format implementation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmatrix_0_16_1_0" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, deepseq
     , openblasCompat, random, split, storable-complex, vector
     }:
     mkDerivation {
       pname = "hmatrix";
       version = "0.16.1.0";
       sha256 = "b058f602025bca37f81f68f30022c8d3d909cebe5f6c3c9b13ecb7815982b349";
       configureFlags = [ "-fopenblas" ];
       libraryHaskellDepends = [
         array base binary bytestring deepseq random split storable-complex
         vector
       ];
       librarySystemDepends = [ openblasCompat ];
       preConfigure = "sed -i hmatrix.cabal -e 's@/usr/@/dont/hardcode/paths/@'";
       homepage = "https://github.com/albertoruiz/hmatrix";
       description = "Numeric Linear Algebra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openblasCompat;};

  "hmatrix_0_16_1_1" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, deepseq
     , openblasCompat, random, split, storable-complex, vector
     }:
     mkDerivation {
       pname = "hmatrix";
       version = "0.16.1.1";
       sha256 = "601250f7157fa54c34c9fe86e21258edcc9be71d090f65555eb21795533af0c6";
       configureFlags = [ "-fopenblas" ];
       libraryHaskellDepends = [
         array base binary bytestring deepseq random split storable-complex
         vector
       ];
       librarySystemDepends = [ openblasCompat ];
       preConfigure = "sed -i hmatrix.cabal -e 's@/usr/@/dont/hardcode/paths/@'";
       homepage = "https://github.com/albertoruiz/hmatrix";
       description = "Numeric Linear Algebra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openblasCompat;};

  "hmatrix_0_16_1_2" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, deepseq
     , openblasCompat, random, split, storable-complex, vector
     }:
     mkDerivation {
       pname = "hmatrix";
       version = "0.16.1.2";
       sha256 = "02d3fefd4f17c2cb242a633561e29c66ff6387effe72ab55dc0ec15046d33424";
       configureFlags = [ "-fopenblas" ];
       libraryHaskellDepends = [
         array base binary bytestring deepseq random split storable-complex
         vector
       ];
       librarySystemDepends = [ openblasCompat ];
       preConfigure = "sed -i hmatrix.cabal -e 's@/usr/@/dont/hardcode/paths/@'";
       homepage = "https://github.com/albertoruiz/hmatrix";
       description = "Numeric Linear Algebra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openblasCompat;};

  "hmatrix_0_16_1_3" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, deepseq
     , openblasCompat, random, split, storable-complex, vector
     }:
     mkDerivation {
       pname = "hmatrix";
       version = "0.16.1.3";
       sha256 = "e543cda9dca6f90bcf85610ebf364339c054b61a203ecb42332c370f7eb36457";
       configureFlags = [ "-fopenblas" ];
       libraryHaskellDepends = [
         array base binary bytestring deepseq random split storable-complex
         vector
       ];
       librarySystemDepends = [ openblasCompat ];
       preConfigure = "sed -i hmatrix.cabal -e 's@/usr/@/dont/hardcode/paths/@'";
       homepage = "https://github.com/albertoruiz/hmatrix";
       description = "Numeric Linear Algebra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openblasCompat;};

  "hmatrix_0_16_1_4" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, deepseq
     , openblasCompat, random, split, storable-complex, vector
     }:
     mkDerivation {
       pname = "hmatrix";
       version = "0.16.1.4";
       sha256 = "9a2b653d138f32459535e1732c4bd538283c4bea44f1cdc18c71f01a83beb0af";
       configureFlags = [ "-fopenblas" ];
       libraryHaskellDepends = [
         array base binary bytestring deepseq random split storable-complex
         vector
       ];
       librarySystemDepends = [ openblasCompat ];
       preConfigure = "sed -i hmatrix.cabal -e 's@/usr/@/dont/hardcode/paths/@'";
       homepage = "https://github.com/albertoruiz/hmatrix";
       description = "Numeric Linear Algebra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openblasCompat;};

  "hmatrix_0_16_1_5" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, deepseq
     , openblasCompat, random, split, storable-complex, vector
     }:
     mkDerivation {
       pname = "hmatrix";
       version = "0.16.1.5";
       sha256 = "78ce199c65752838e904b07cc443a37f42fc0ed54cf56893a1a1fc9f858f41b5";
       configureFlags = [ "-fopenblas" ];
       libraryHaskellDepends = [
         array base binary bytestring deepseq random split storable-complex
         vector
       ];
       librarySystemDepends = [ openblasCompat ];
       preConfigure = "sed -i hmatrix.cabal -e 's@/usr/@/dont/hardcode/paths/@'";
       homepage = "https://github.com/albertoruiz/hmatrix";
       description = "Numeric Linear Algebra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openblasCompat;};

  "hmatrix" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, deepseq
     , openblasCompat, random, split, storable-complex, vector
     }:
     mkDerivation {
       pname = "hmatrix";
       version = "0.17.0.1";
       sha256 = "2d94d4733862fd974f30a720bea9e2997343b78fc8e50427e787b1937b89508c";
       configureFlags = [ "-fopenblas" ];
       libraryHaskellDepends = [
         array base binary bytestring deepseq random split storable-complex
         vector
       ];
       librarySystemDepends = [ openblasCompat ];
       preConfigure = "sed -i hmatrix.cabal -e 's@/usr/@/dont/hardcode/paths/@'";
       homepage = "https://github.com/albertoruiz/hmatrix";
       description = "Numeric Linear Algebra";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) openblasCompat;};

  "hmatrix-banded" = callPackage
    ({ mkDerivation, base, hmatrix, liblapack, transformers }:
     mkDerivation {
       pname = "hmatrix-banded";
       version = "0.0";
       sha256 = "52a90b2094eacfbeb87befaa6a2ae44924dc175c9245b61574967a6ae1a84f16";
       libraryHaskellDepends = [ base hmatrix transformers ];
       librarySystemDepends = [ liblapack ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/hmatrix-banded/";
       description = "HMatrix interface to LAPACK functions for banded matrices";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) liblapack;};

  "hmatrix-csv" = callPackage
    ({ mkDerivation, base, bytestring, cassava, hmatrix, vector }:
     mkDerivation {
       pname = "hmatrix-csv";
       version = "0.1.0.2";
       sha256 = "6b5abd3d3c0b4d121006bdfd622989150e0a8c69234c3e63f616579fe8ef7631";
       libraryHaskellDepends = [ base bytestring cassava hmatrix vector ];
       homepage = "https://github.com/grtlr/hmatrix-csv";
       description = "CSV encoding and decoding for hmatrix";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hmatrix-glpk" = callPackage
    ({ mkDerivation, base, containers, glpk, hmatrix }:
     mkDerivation {
       pname = "hmatrix-glpk";
       version = "0.5.0.0";
       sha256 = "ca90e4f1b8e95547ad70bf16c4334504ec2d5d446dad8b0fd0d4929e4ccbc551";
       libraryHaskellDepends = [ base containers hmatrix ];
       librarySystemDepends = [ glpk ];
       homepage = "https://github.com/albertoruiz/hmatrix";
       description = "Linear Programming based on GLPK";
       license = "GPL";
     }) {inherit (pkgs) glpk;};

  "hmatrix-gsl_0_16_0_2" = callPackage
    ({ mkDerivation, array, base, gsl, hmatrix, process, random, vector
     }:
     mkDerivation {
       pname = "hmatrix-gsl";
       version = "0.16.0.2";
       sha256 = "d51728d6d35fe1d86fbaff95eafe9b5acfc05faaa8fc404e7187cabbc52e06d1";
       libraryHaskellDepends = [
         array base hmatrix process random vector
       ];
       libraryPkgconfigDepends = [ gsl ];
       homepage = "https://github.com/albertoruiz/hmatrix";
       description = "Numerical computation";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gsl;};

  "hmatrix-gsl_0_16_0_3" = callPackage
    ({ mkDerivation, array, base, gsl, hmatrix, process, random, vector
     }:
     mkDerivation {
       pname = "hmatrix-gsl";
       version = "0.16.0.3";
       sha256 = "6f12c798c7e9263d6defc1622600233de54ca067d17784934d02849c5d4e0f1e";
       libraryHaskellDepends = [
         array base hmatrix process random vector
       ];
       libraryPkgconfigDepends = [ gsl ];
       homepage = "https://github.com/albertoruiz/hmatrix";
       description = "Numerical computation";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gsl;};

  "hmatrix-gsl" = callPackage
    ({ mkDerivation, array, base, gsl, hmatrix, process, random, vector
     }:
     mkDerivation {
       pname = "hmatrix-gsl";
       version = "0.17.0.0";
       sha256 = "fc50e9f80adee9f93874b20aae1a8009a1dcd94316784827618d5ad192e578c9";
       libraryHaskellDepends = [
         array base hmatrix process random vector
       ];
       libraryPkgconfigDepends = [ gsl ];
       homepage = "https://github.com/albertoruiz/hmatrix";
       description = "Numerical computation";
       license = "GPL";
     }) {inherit (pkgs) gsl;};

  "hmatrix-gsl-stats_0_2_1" = callPackage
    ({ mkDerivation, base, binary, blas, hmatrix, liblapack
     , storable-complex
     }:
     mkDerivation {
       pname = "hmatrix-gsl-stats";
       version = "0.2.1";
       sha256 = "d205fa83f2ad04690d6758757008aad4888760f2147fee2ec78e75dacadddee9";
       libraryHaskellDepends = [ base binary hmatrix storable-complex ];
       librarySystemDepends = [ blas liblapack ];
       homepage = "http://code.haskell.org/hmatrix-gsl-stats";
       description = "GSL Statistics interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};

  "hmatrix-gsl-stats_0_4_1" = callPackage
    ({ mkDerivation, base, binary, gsl, hmatrix, storable-complex }:
     mkDerivation {
       pname = "hmatrix-gsl-stats";
       version = "0.4.1";
       sha256 = "f823f72bc3eb4eeae419c22dc645e3483a71aacdcc5e4af32f67b2d6458a6f84";
       libraryHaskellDepends = [ base binary hmatrix storable-complex ];
       libraryPkgconfigDepends = [ gsl ];
       homepage = "http://code.haskell.org/hmatrix-gsl-stats";
       description = "GSL Statistics interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gsl;};

  "hmatrix-gsl-stats_0_4_1_1" = callPackage
    ({ mkDerivation, base, binary, gsl, hmatrix, storable-complex }:
     mkDerivation {
       pname = "hmatrix-gsl-stats";
       version = "0.4.1.1";
       sha256 = "9da3fd493c5490697cc2dda4c2cc301c88500e027b1919c941f39ab310a0dd1d";
       libraryHaskellDepends = [ base binary hmatrix storable-complex ];
       libraryPkgconfigDepends = [ gsl ];
       homepage = "http://code.haskell.org/hmatrix-gsl-stats";
       description = "GSL Statistics interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gsl;};

  "hmatrix-gsl-stats" = callPackage
    ({ mkDerivation, base, binary, gsl, hmatrix, storable-complex
     , vector
     }:
     mkDerivation {
       pname = "hmatrix-gsl-stats";
       version = "0.4.1.3";
       sha256 = "d4852352ed9b5ee4b8e7f519d512047e5976804563151c3bd092589248fc7738";
       libraryHaskellDepends = [
         base binary hmatrix storable-complex vector
       ];
       libraryPkgconfigDepends = [ gsl ];
       homepage = "http://code.haskell.org/hmatrix-gsl-stats";
       description = "GSL Statistics interface";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) gsl;};

  "hmatrix-mmap" = callPackage
    ({ mkDerivation, base, hmatrix, mmap }:
     mkDerivation {
       pname = "hmatrix-mmap";
       version = "0.0.5";
       sha256 = "0df95f0bdfb3baab6ca4982b86617aed503640b8084283038118128e7b70e10f";
       libraryHaskellDepends = [ base hmatrix mmap ];
       homepage = "http://github.com/alanfalloon/hmatrix-mmap";
       description = "Memory map Vector from disk into memory efficiently";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmatrix-nipals" = callPackage
    ({ mkDerivation, base, hmatrix }:
     mkDerivation {
       pname = "hmatrix-nipals";
       version = "0.2";
       sha256 = "322bdf452889dbaeccca42e28afb3ebd85bf594da754cdee2a1f43121dbfd529";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base hmatrix ];
       homepage = "http://github.com/alanfalloon/hmatrix-nipals";
       description = "NIPALS method for Principal Components Analysis on large data-sets";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmatrix-quadprogpp" = callPackage
    ({ mkDerivation, base, hmatrix, QuadProgpp, vector }:
     mkDerivation {
       pname = "hmatrix-quadprogpp";
       version = "0.2.0.2";
       sha256 = "83c5fd9f3ce2cde9fbad74d6d54b446548e36575f64540e1cbf6f678bcefda0b";
       libraryHaskellDepends = [ base hmatrix vector ];
       librarySystemDepends = [ QuadProgpp ];
       description = "Bindings to the QuadProg++ quadratic programming library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {QuadProgpp = null;};

  "hmatrix-repa" = callPackage
    ({ mkDerivation, base, hmatrix, repa, vector }:
     mkDerivation {
       pname = "hmatrix-repa";
       version = "0.1.2.1";
       sha256 = "48298694cb8da0f830022576b7fc7dd08bad0c39e98ed00bff828d40e914a077";
       libraryHaskellDepends = [ base hmatrix repa vector ];
       homepage = "http://code.haskell.org/hmatrix-repa";
       description = "Adaptors for interoperability between hmatrix and repa";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmatrix-special" = callPackage
    ({ mkDerivation, base, hmatrix, hmatrix-gsl }:
     mkDerivation {
       pname = "hmatrix-special";
       version = "0.4.0.0";
       sha256 = "1fba0cc75e22df1655ac5771180b26f8ce706783363c825aa6fac8cff5f02933";
       libraryHaskellDepends = [ base hmatrix hmatrix-gsl ];
       homepage = "https://github.com/albertoruiz/hmatrix";
       description = "Interface to GSL special functions";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmatrix-static" = callPackage
    ({ mkDerivation, array, base, haskell-src-meta, hmatrix, parsec
     , template-haskell, tfp
     }:
     mkDerivation {
       pname = "hmatrix-static";
       version = "0.3.0.2";
       sha256 = "f1fd51e1869285c0d079b1df99c64e21d8c246b6605ee9bd8d4c654626925de2";
       libraryHaskellDepends = [
         array base haskell-src-meta hmatrix parsec template-haskell tfp
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/hmatrix-static/";
       description = "hmatrix with vector and matrix sizes encoded in types";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmatrix-svdlibc" = callPackage
    ({ mkDerivation, base, hmatrix }:
     mkDerivation {
       pname = "hmatrix-svdlibc";
       version = "0.3.1";
       sha256 = "55466aaa04138feb5f8f9893be49d7e3e59b57251a576d25b6729118860d2456";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base hmatrix ];
       executableHaskellDepends = [ base hmatrix ];
       jailbreak = true;
       homepage = "http://github.com/bgamari/hmatrix-svdlibc";
       description = "SVDLIBC bindings for HMatrix";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmatrix-syntax" = callPackage
    ({ mkDerivation, base, haskell-src-exts, haskell-src-meta, hmatrix
     , template-haskell
     }:
     mkDerivation {
       pname = "hmatrix-syntax";
       version = "0.1.2.1";
       sha256 = "0b0d000f1c9d282c63997139fe2908523744c5a37e9ad00688c94180486fc563";
       libraryHaskellDepends = [
         base haskell-src-exts haskell-src-meta hmatrix template-haskell
       ];
       jailbreak = true;
       homepage = "http://github.com/reinerp/hmatrix-syntax";
       description = "MATLAB-like syntax for hmatrix vectors and matrices";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmatrix-tests" = callPackage
    ({ mkDerivation, base, deepseq, hmatrix, hmatrix-gsl, HUnit
     , QuickCheck, random
     }:
     mkDerivation {
       pname = "hmatrix-tests";
       version = "0.5.0.0";
       sha256 = "a47819899e6eb7844ad6b863dece79d347cf897cb313f59ee62bbeb608661634";
       libraryHaskellDepends = [
         base deepseq hmatrix hmatrix-gsl HUnit QuickCheck random
       ];
       testHaskellDepends = [ base HUnit QuickCheck random ];
       homepage = "https://github.com/albertoruiz/hmatrix";
       description = "Tests for hmatrix";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hmeap" = callPackage
    ({ mkDerivation, array, base, bytestring, bytestring-lexing
     , delimited-text, parsec
     }:
     mkDerivation {
       pname = "hmeap";
       version = "0.15";
       sha256 = "7001c536e953d3fd5b34d6abec31b248324a2cfc84128f9a0bf269fabbb811a6";
       libraryHaskellDepends = [
         array base bytestring bytestring-lexing delimited-text parsec
       ];
       homepage = "http://rd.slavepianos.org/t/hmeap";
       description = "Haskell Meapsoft Parser";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmeap-utils" = callPackage
    ({ mkDerivation, array, base, bytestring, bytestring-lexing
     , delimited-text, gnuplot, hmatrix, hmeap, hosc, hsc3, parsec
     }:
     mkDerivation {
       pname = "hmeap-utils";
       version = "0.14";
       sha256 = "082f0813f5da160f41ca630c8075aa0f4044f17557e13997cba2cf7dfcdfd5b6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring bytestring-lexing delimited-text gnuplot
         hmatrix hmeap hosc hsc3 parsec
       ];
       jailbreak = true;
       homepage = "http://slavepianos.org/rd/?t=hmeap-utils";
       description = "Haskell Meapsoft Parser Utilities";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmemdb" = callPackage
    ({ mkDerivation, base, binary, containers, monad-stm, stm
     , transformers
     }:
     mkDerivation {
       pname = "hmemdb";
       version = "0.4.0.0";
       sha256 = "bc8c323bff436e9789d131ce226e42df561f80fedb1d9b818ffb5b15a74dbf7d";
       libraryHaskellDepends = [
         base binary containers monad-stm stm transformers
       ];
       description = "In-memory relational database";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hmenu" = callPackage
    ({ mkDerivation, base, MissingH, process }:
     mkDerivation {
       pname = "hmenu";
       version = "0.1.0.1";
       sha256 = "374320143bdac2e9771639b8d30492791c2c34641f496cea618ccbd0fdb7a37a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base MissingH process ];
       jailbreak = true;
       description = "CLI fuzzy finder and launcher";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmidi" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "hmidi";
       version = "0.2.2.0";
       sha256 = "8b2924618203f50042cec2bdf6724a20ebd8cd41bfff8b241e6e0d960c8718ce";
       libraryHaskellDepends = [ base stm ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "Binding to the OS level MIDI services";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hmk" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, parsec, pcre-light, process, unix
     }:
     mkDerivation {
       pname = "hmk";
       version = "0.9.7.4";
       sha256 = "c952fbf1dcf7dc99958a92efa387004ba600ed168c5b2ae221327909a79a23a1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [
         base bytestring containers directory filepath mtl parsec pcre-light
         process unix
       ];
       homepage = "http://www.github.com/mboes/hmk";
       description = "A make alternative based on Plan9's mk";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmm" = callPackage
    ({ mkDerivation, array, base, data-memocombinators, list-extras
     , logfloat
     }:
     mkDerivation {
       pname = "hmm";
       version = "0.2.1.1";
       sha256 = "61e06e1daca7f0f2add080e35011672aa8ccf20f650a1a010a1e690a2d8bed21";
       libraryHaskellDepends = [
         array base data-memocombinators list-extras logfloat
       ];
       homepage = "https://github.com/mikeizbicki/hmm";
       description = "A hidden markov model library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmm-hmatrix" = callPackage
    ({ mkDerivation, array, base, containers, explicit-exception
     , hmatrix, lazy-csv, non-empty, random, semigroups, transformers
     , utility-ht
     }:
     mkDerivation {
       pname = "hmm-hmatrix";
       version = "0.0.1";
       sha256 = "903cf5d3bfaea8383d6242e3e48d807cf07b954217a0948aae78dbabc79e71ce";
       libraryHaskellDepends = [
         array base containers explicit-exception hmatrix lazy-csv non-empty
         random semigroups transformers utility-ht
       ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/thielema/hmm-hmatrix";
       description = "Hidden Markov Models using HMatrix primitives";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hmp3" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, mersenne-random, ncurses, old-time, pcre-light
     , process, unix, zlib
     }:
     mkDerivation {
       pname = "hmp3";
       version = "1.5.2.1";
       sha256 = "63d125153a4cee4fe562b5f33450a7c3a200c7be15aefb95ba4c2a1a9bffd84d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base binary bytestring containers directory mersenne-random
         old-time pcre-light process unix zlib
       ];
       executableSystemDepends = [ ncurses ];
       homepage = "http://www.cse.unsw.edu.au/~dons/hmp3.html";
       description = "An ncurses mp3 player written in Haskell";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) ncurses;};

  "hmpfr" = callPackage
    ({ mkDerivation, base, integer-gmp, mpfr }:
     mkDerivation {
       pname = "hmpfr";
       version = "0.3.3.5";
       sha256 = "c4f17c265406145d9beccca5c88390af5fa80844aa2ee76310139ec75dcdf801";
       libraryHaskellDepends = [ base integer-gmp ];
       librarySystemDepends = [ mpfr ];
       homepage = "http://code.google.com/p/hmpfr/";
       description = "Haskell binding to the MPFR library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mpfr;};

  "hmt" = callPackage
    ({ mkDerivation, array, base, bytestring, colour, containers
     , data-ordlist, directory, filepath, lazy-csv, logict
     , multiset-comb, parsec, permutation, primes, safe, split
     , utf8-string
     }:
     mkDerivation {
       pname = "hmt";
       version = "0.15";
       sha256 = "498df72d63766f4b8ea3a98d09d7bfd73c14743b9d0885b80dae509ba07e3314";
       libraryHaskellDepends = [
         array base bytestring colour containers data-ordlist directory
         filepath lazy-csv logict multiset-comb parsec permutation primes
         safe split utf8-string
       ];
       homepage = "http://rd.slavepianos.org/t/hmt";
       description = "Haskell Music Theory";
       license = "GPL";
     }) {};

  "hmt-diagrams" = callPackage
    ({ mkDerivation, base, cairo, colour, filepath, hcg-minus
     , hcg-minus-cairo, hmt, html-minimalist, process, xml
     }:
     mkDerivation {
       pname = "hmt-diagrams";
       version = "0.15";
       sha256 = "95be338168d2b2e92c2bfc09977e3b5c78213410f6ab1de3043d8cbfc258c4bc";
       libraryHaskellDepends = [
         base cairo colour filepath hcg-minus hcg-minus-cairo hmt
         html-minimalist process xml
       ];
       homepage = "http://rd.slavepianos.org/t/hmt-diagrams";
       description = "Haskell Music Theory Diagrams";
       license = "GPL";
     }) {};

  "hmumps" = callPackage
    ({ mkDerivation, base, containers, haskeline, mtl, parsec
     , QuickCheck, regex-compat, syb, text
     }:
     mkDerivation {
       pname = "hmumps";
       version = "0.1.1";
       sha256 = "c2ca741b0ed9316a69b3d1eae08f4c6ef44e2e40482cb0f903d2fd7d9aee7119";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers haskeline mtl parsec QuickCheck regex-compat syb
         text
       ];
       jailbreak = true;
       description = "Interpreter for the MUMPS langugae";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hnetcdf" = callPackage
    ({ mkDerivation, base, c2hs, containers, directory, either, errors
     , filepath, hmatrix, HUnit, netcdf, QuickCheck, repa
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , transformers, vector
     }:
     mkDerivation {
       pname = "hnetcdf";
       version = "0.3.0.0";
       sha256 = "3a8c5c30a9210e4a7af213a0d0967515f692876f23c78582f7896559d69f098c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers either errors filepath hmatrix repa transformers
         vector
       ];
       librarySystemDepends = [ netcdf ];
       libraryToolDepends = [ c2hs ];
       executableHaskellDepends = [ base containers hmatrix repa vector ];
       testHaskellDepends = [
         base containers directory errors hmatrix HUnit QuickCheck repa
         test-framework test-framework-hunit test-framework-quickcheck2
         vector
       ];
       testSystemDepends = [ netcdf ];
       jailbreak = true;
       homepage = "https://github.com/ian-ross/hnetcdf";
       description = "Haskell NetCDF library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) netcdf;};

  "hnix" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, containers, data-fix
     , parsers, tasty, tasty-hunit, tasty-th, text, transformers
     , trifecta, unordered-containers
     }:
     mkDerivation {
       pname = "hnix";
       version = "0.2.1";
       sha256 = "2a1a0fbb24288ff74b4380ca792bfd7b369c4970e20c158ef0afe547bde120f8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-wl-pprint base containers data-fix parsers text transformers
         trifecta unordered-containers
       ];
       executableHaskellDepends = [
         ansi-wl-pprint base containers data-fix
       ];
       testHaskellDepends = [
         base containers data-fix tasty tasty-hunit tasty-th text
       ];
       homepage = "http://github.com/jwiegley/hnix";
       description = "Haskell implementation of the Nix language";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hnn" = callPackage
    ({ mkDerivation, base, binary, bytestring, hmatrix, mwc-random
     , random, vector, vector-binary-instances, zlib
     }:
     mkDerivation {
       pname = "hnn";
       version = "0.2.0.0";
       sha256 = "5cea3b1ab4be9df69328ad31c77fbf3daf0be39c0c92e17e15709ea582ce228e";
       libraryHaskellDepends = [
         base binary bytestring hmatrix mwc-random random vector
         vector-binary-instances zlib
       ];
       homepage = "http://github.com/alpmestan/hnn";
       description = "A reasonably fast and simple neural network library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hnop" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hnop";
       version = "0.1";
       sha256 = "225bf9f244298337b0634bb9905eace0c3eea9faa9e2fff4a30c1fcbea4bdc69";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       license = stdenv.lib.licenses.unfree;
     }) {};

  "ho-rewriting" = callPackage
    ({ mkDerivation, base, compdata, containers, mtl, patch-combinators
     }:
     mkDerivation {
       pname = "ho-rewriting";
       version = "0.2";
       sha256 = "c962e3c2b5e7943bfbc7c781070b35cb81d4c39d2afc221c207dc4bb38785acd";
       revision = "1";
       editedCabalFile = "564496857e81054420e85172517d838ecd0b7d0cca6f324c52b92ef5a2fe820c";
       libraryHaskellDepends = [
         base compdata containers mtl patch-combinators
       ];
       testHaskellDepends = [ base compdata patch-combinators ];
       homepage = "https://github.com/emilaxelsson/ho-rewriting";
       description = "Generic rewrite rules with safe treatment of variables and binders";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hoauth" = callPackage
    ({ mkDerivation, base, binary, bytestring, crypto-pubkey-types
     , curl, dataenc, entropy, mtl, old-locale, random, RSA, SHA, time
     , utf8-string
     }:
     mkDerivation {
       pname = "hoauth";
       version = "0.3.5";
       sha256 = "17cb7fe7f07d84c6dfeb77932e7a441482e0ff121893d79be2c7af26761b731b";
       libraryHaskellDepends = [
         base binary bytestring crypto-pubkey-types curl dataenc entropy mtl
         old-locale random RSA SHA time utf8-string
       ];
       description = "A Haskell implementation of OAuth 1.0a protocol.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoauth2_0_4_3" = callPackage
    ({ mkDerivation, aeson, base, bytestring, bytestring-show
     , http-conduit, http-types, monad-control, mtl, random, text
     , transformers
     }:
     mkDerivation {
       pname = "hoauth2";
       version = "0.4.3";
       sha256 = "6f531f635c62cc7c42fb3e33193833adfdf789aafa2d2c754be2f23c609ab0e2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring bytestring-show http-conduit http-types
         monad-control mtl random text transformers
       ];
       executableHaskellDepends = [
         aeson base bytestring http-conduit http-types text
       ];
       jailbreak = true;
       homepage = "https://github.com/freizl/hoauth2";
       description = "hoauth2";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoauth2_0_4_6" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-conduit, http-types
     , text
     }:
     mkDerivation {
       pname = "hoauth2";
       version = "0.4.6";
       sha256 = "97234e47514c80252644edc4873140e64c16349bcf39e8e9d971cd7577a8c2ea";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring http-conduit http-types text
       ];
       executableHaskellDepends = [
         aeson base bytestring http-conduit http-types text
       ];
       jailbreak = true;
       homepage = "https://github.com/freizl/hoauth2";
       description = "hoauth2";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoauth2_0_4_7" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-conduit, http-types
     , text
     }:
     mkDerivation {
       pname = "hoauth2";
       version = "0.4.7";
       sha256 = "b8273ca42a060b27fc9cc9ed18bb6dfdcb329073f388de4167a4767996b98bf8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring http-conduit http-types text
       ];
       executableHaskellDepends = [
         aeson base bytestring http-conduit http-types text
       ];
       jailbreak = true;
       homepage = "https://github.com/freizl/hoauth2";
       description = "hoauth2";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoauth2_0_4_8" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-conduit, http-types
     , text
     }:
     mkDerivation {
       pname = "hoauth2";
       version = "0.4.8";
       sha256 = "6e489820dee16b926225e58555032e32d345b234b5a798db6e5a1d63d2843093";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring http-conduit http-types text
       ];
       executableHaskellDepends = [
         aeson base bytestring http-conduit http-types text
       ];
       jailbreak = true;
       homepage = "https://github.com/freizl/hoauth2";
       description = "hoauth2";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoauth2_0_5_0" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, http-conduit
     , http-types, text, wai, warp
     }:
     mkDerivation {
       pname = "hoauth2";
       version = "0.5.0";
       sha256 = "8aedac3c8276965a6ace7c634f6c26932a13062e02d8139de3d6278eacd41c2d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring http-conduit http-types text
       ];
       executableHaskellDepends = [
         aeson base bytestring containers http-conduit http-types text wai
         warp
       ];
       jailbreak = true;
       homepage = "https://github.com/freizl/hoauth2";
       description = "hoauth2";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoauth2_0_5_0_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, http-conduit
     , http-types, text, wai, warp
     }:
     mkDerivation {
       pname = "hoauth2";
       version = "0.5.0.1";
       sha256 = "17766cb63f0f232b6ad21d855e32fa88da7d4f5ae5c545f391c5b92d4cd57468";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring http-conduit http-types text
       ];
       executableHaskellDepends = [
         aeson base bytestring containers http-conduit http-types text wai
         warp
       ];
       jailbreak = true;
       homepage = "https://github.com/freizl/hoauth2";
       description = "Haskell OAuth2 authentication client";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoauth2_0_5_2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, http-conduit
     , http-types, text, wai, warp
     }:
     mkDerivation {
       pname = "hoauth2";
       version = "0.5.2";
       sha256 = "68a8d591d47e24f3a2bfe5b103512dee48805217af771c1de64612fc19f8084f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring http-conduit http-types text
       ];
       executableHaskellDepends = [
         aeson base bytestring containers http-conduit http-types text wai
         warp
       ];
       homepage = "https://github.com/freizl/hoauth2";
       description = "Haskell OAuth2 authentication client";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoauth2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, http-conduit
     , http-types, text, wai, warp
     }:
     mkDerivation {
       pname = "hoauth2";
       version = "0.5.3";
       sha256 = "650c867a16801120065c67a32fd5c3c60a0f083411c95273c8108e694bde3332";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring http-conduit http-types text
       ];
       executableHaskellDepends = [
         aeson base bytestring containers http-conduit http-types text wai
         warp
       ];
       homepage = "https://github.com/freizl/hoauth2";
       description = "Haskell OAuth2 authentication client";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hob" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , glib, gtk-largeTreeStore, gtk3, gtksourceview3, hspec, mtl, pango
     , system-filepath, text, transformers, vector
     }:
     mkDerivation {
       pname = "hob";
       version = "0.0.1.0";
       sha256 = "4c7610f0e8558d68940535814999b467e55d2a03c58005ca4301d158f8ea5ad4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers filepath glib gtk-largeTreeStore gtk3
         gtksourceview3 mtl pango system-filepath text transformers vector
       ];
       executableHaskellDepends = [
         base bytestring containers directory filepath gtk3 gtksourceview3
         mtl text
       ];
       testHaskellDepends = [
         base containers gtk3 gtksourceview3 hspec mtl text
       ];
       jailbreak = true;
       homepage = "http://svalaskevicius.github.io/hob/";
       description = "A source code editor aiming for the convenience of use";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hobbes" = callPackage
    ({ mkDerivation, base, filemanip, filepath, fsnotify
     , system-filepath, text
     }:
     mkDerivation {
       pname = "hobbes";
       version = "0.2.2";
       sha256 = "ad8b5044cf198b6590f572992554e29f9a6ac08ae23618b64421e154da3031df";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base filemanip filepath fsnotify system-filepath text
       ];
       jailbreak = true;
       homepage = "http://github.com/jhickner/hobbes";
       description = "A small file watcher for OSX";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hobbits" = callPackage
    ({ mkDerivation, base, deepseq, haskell-src-exts, haskell-src-meta
     , mtl, syb, tagged, template-haskell, th-expand-syns, transformers
     , type-equality
     }:
     mkDerivation {
       pname = "hobbits";
       version = "1.1.1";
       sha256 = "1aa60e29544face622e4c049f467833f23a54caa69ba23e8f047e34bb744c660";
       libraryHaskellDepends = [
         base deepseq haskell-src-exts haskell-src-meta mtl syb tagged
         template-haskell th-expand-syns transformers type-equality
       ];
       jailbreak = true;
       description = "A library for canonically representing terms with binding";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoe" = callPackage
    ({ mkDerivation, base, exceptions, hint, mtl, optparse-declarative
     , regex-posix, split, text, time
     }:
     mkDerivation {
       pname = "hoe";
       version = "1.1.0";
       sha256 = "60bb1df0c5314fd318935fd47bd258e7d103744d42e8bc3e7220414a2512053d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base exceptions hint mtl optparse-declarative regex-posix split
         text time
       ];
       homepage = "http://github.com/tanakh/hoe";
       description = "hoe: Haskell One-liner Evaluator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hofix-mtl" = callPackage
    ({ mkDerivation, base, mtl, star-to-star, template-haskell }:
     mkDerivation {
       pname = "hofix-mtl";
       version = "1.0";
       sha256 = "6defa97fe708cda43b87eff95fe86473f6413e97e70c75383fd694dd726b9af6";
       libraryHaskellDepends = [ base mtl star-to-star template-haskell ];
       jailbreak = true;
       description = "defining @mtl@-ready monads as * -> * fixed-points";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hog" = callPackage
    ({ mkDerivation, base, cmdargs, filepath, irc, network, old-locale
     , time, unix
     }:
     mkDerivation {
       pname = "hog";
       version = "0.1.1";
       sha256 = "2dace9ad6cd0659e36c79ec113958c3b20351249365a2979e517ee5fab3fb756";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs filepath irc network old-locale time unix
       ];
       jailbreak = true;
       description = "Simple IRC logger bot";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hogg" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, HUnit, mtl
     , old-locale, random, time
     }:
     mkDerivation {
       pname = "hogg";
       version = "0.4.1.2";
       sha256 = "9c4e1821558dde698e35db775b4f1b2a1fff399e583a6c67bfcd6508d55b4f36";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers HUnit mtl old-locale random time
       ];
       homepage = "http://www.kfish.org/software/hogg/";
       description = "Library and tools to manipulate the Ogg container format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hogre" = callPackage
    ({ mkDerivation, base, cgen, cgen-hs, grgen, OGRE, OgreMain }:
     mkDerivation {
       pname = "hogre";
       version = "0.1.5";
       sha256 = "e404ec94260538ebdba51dffad8d24f5e6e959381461e43af50521c9a8b3af59";
       libraryHaskellDepends = [ base cgen ];
       librarySystemDepends = [ OgreMain ];
       libraryPkgconfigDepends = [ OGRE ];
       libraryToolDepends = [ cgen-hs grgen ];
       doHaddock = false;
       homepage = "http://anttisalonen.github.com/hogre";
       description = "Haskell binding to a subset of OGRE";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {OGRE = null; OgreMain = null; cgen-hs = null; grgen = null;};

  "hogre-examples" = callPackage
    ({ mkDerivation, base, hogre, OgreMain }:
     mkDerivation {
       pname = "hogre-examples";
       version = "0.1.4";
       sha256 = "af68f11d0778ed4c3b9645d92cc39b9e06f2bd1fef03bdb95240af021926f883";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base hogre ];
       executableSystemDepends = [ OgreMain ];
       homepage = "http://github.com/anttisalonen/hogre-examples";
       description = "Examples for using Hogre";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {OgreMain = null;};

  "hois" = callPackage
    ({ mkDerivation, base, OIS, X11 }:
     mkDerivation {
       pname = "hois";
       version = "0.1.0.0";
       sha256 = "93b0a206c243f4cf313d12e4d90bf3f88c378cee8d4d4911b2c79fa35c3b8b2b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ OIS ];
       executableHaskellDepends = [ base X11 ];
       jailbreak = true;
       description = "OIS bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {OIS = null;};

  "hoist-error" = callPackage
    ({ mkDerivation, base, either, mtl }:
     mkDerivation {
       pname = "hoist-error";
       version = "0.1.0.2";
       sha256 = "1fd00441ad981323aed41442896d3a262ce29dc54771e654a952944a73530591";
       revision = "2";
       editedCabalFile = "fca4ac245a1bddf638317290deb580d05d1539c6a700b02744ce61e259e2e879";
       libraryHaskellDepends = [ base either mtl ];
       description = "Some convenience facilities for hoisting errors into a monad";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hold-em" = callPackage
    ({ mkDerivation, base, random, safe }:
     mkDerivation {
       pname = "hold-em";
       version = "0.1.0.0";
       sha256 = "99e415c95ae946bce74ada24304271b9c87b9ec341266adad40535fda3a158c8";
       libraryHaskellDepends = [ base random safe ];
       jailbreak = true;
       description = "An engine for Texas hold'em Poker";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hole" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "hole";
       version = "0.1.1";
       sha256 = "cc0c35a3803d6b3d5d59467bffabc62da49d4d907a3bfdc82ab1ac34f9416a15";
       libraryHaskellDepends = [ base containers ];
       description = "Higher kinded type removal";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "holey-format" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "holey-format";
       version = "2.1.0";
       sha256 = "c1aadd830dbd955d827e7a0662d9ea2d2b91ed3bd7118edbc35a4f7f8871c68d";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "holy-project_0_1_1_1" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, Cabal
     , directory, filepath, hastache, http-conduit, HUnit, lens
     , lens-aeson, process, QuickCheck, random, smallcheck, split, syb
     , tasty, tasty-hunit, tasty-quickcheck, tasty-smallcheck, text
     , time, unix
     }:
     mkDerivation {
       pname = "holy-project";
       version = "0.1.1.1";
       sha256 = "92cf2e44cd2376101beda6374bb0a19bf36cdf7e132d519b5201ac673ead646d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal base bytestring directory filepath hastache
         http-conduit lens lens-aeson process random split syb text time
         unix
       ];
       executableHaskellDepends = [
         aeson ansi-terminal base bytestring Cabal directory filepath
         hastache http-conduit HUnit lens lens-aeson process QuickCheck
         random smallcheck split syb tasty tasty-hunit tasty-quickcheck
         tasty-smallcheck text time unix
       ];
       testHaskellDepends = [
         base bytestring Cabal HUnit QuickCheck smallcheck tasty tasty-hunit
         tasty-quickcheck tasty-smallcheck
       ];
       doCheck = false;
       homepage = "http://github.com/yogsototh/holy-project";
       description = "Start your Haskell project with cabal, git and tests";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "holy-project_0_2_0_0" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, Cabal
     , directory, filepath, hastache, http-conduit, HUnit, lens
     , lens-aeson, process, QuickCheck, random, smallcheck, split, syb
     , tasty, tasty-hunit, tasty-quickcheck, tasty-smallcheck, text
     , time, unix
     }:
     mkDerivation {
       pname = "holy-project";
       version = "0.2.0.0";
       sha256 = "4f8feb2326214304a0326843383b3cf8e35862fb372f279c148f103ebbd09616";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal base bytestring directory filepath hastache
         http-conduit lens lens-aeson process random split syb text time
         unix
       ];
       executableHaskellDepends = [
         aeson ansi-terminal base bytestring Cabal directory filepath
         hastache http-conduit HUnit lens lens-aeson process QuickCheck
         random smallcheck split syb tasty tasty-hunit tasty-quickcheck
         tasty-smallcheck text time unix
       ];
       testHaskellDepends = [
         base bytestring Cabal HUnit QuickCheck smallcheck tasty tasty-hunit
         tasty-quickcheck tasty-smallcheck
       ];
       doCheck = false;
       homepage = "http://github.com/yogsototh/holy-project";
       description = "Start your Haskell project with cabal, git and tests";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "holy-project" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, base, bytestring, Cabal
     , directory, filepath, hastache, http-conduit, HUnit, lens
     , lens-aeson, process, QuickCheck, random, smallcheck, split, syb
     , tasty, tasty-hunit, tasty-quickcheck, tasty-smallcheck, text
     , time, unix
     }:
     mkDerivation {
       pname = "holy-project";
       version = "0.2.0.1";
       sha256 = "b0f60f48377986212ee45a7ab360f4ef32578d4fa4b65cc21132f9c1e90a2814";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal base bytestring directory filepath hastache
         http-conduit lens lens-aeson process random split syb text time
         unix
       ];
       executableHaskellDepends = [
         aeson ansi-terminal base bytestring Cabal directory filepath
         hastache http-conduit HUnit lens lens-aeson process QuickCheck
         random smallcheck split syb tasty tasty-hunit tasty-quickcheck
         tasty-smallcheck text time unix
       ];
       testHaskellDepends = [
         base bytestring Cabal HUnit QuickCheck smallcheck tasty tasty-hunit
         tasty-quickcheck tasty-smallcheck
       ];
       doCheck = false;
       homepage = "http://github.com/yogsototh/holy-project";
       description = "Start your Haskell project with cabal, git and tests";
       license = stdenv.lib.licenses.mit;
     }) {};

  "homeomorphic" = callPackage
    ({ mkDerivation, base, containers, mtl, QuickCheck }:
     mkDerivation {
       pname = "homeomorphic";
       version = "0.1";
       sha256 = "cce4b27e9d415fe3678db0a26d99ade60e0c4aebc6082bfe7d520bf0db2aa1f2";
       libraryHaskellDepends = [ base containers mtl QuickCheck ];
       homepage = "http://www-users.cs.york.ac.uk/~ndm/homeomorphic/";
       description = "Homeomorphic Embedding Test";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hommage" = callPackage
    ({ mkDerivation, array, base, directory, haskell98, random, time }:
     mkDerivation {
       pname = "hommage";
       version = "0.0.6";
       sha256 = "932d4d2adb93f678dd6deb2ff20b7a0859abd527447db35a4cec54f8c0d87f14";
       libraryHaskellDepends = [
         array base directory haskell98 random time
       ];
       description = "Haskell Offline Music Manipulation And Generation EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hommage-ds" = callPackage
    ({ mkDerivation, array, base, DirectSound, haskell98, hommage }:
     mkDerivation {
       pname = "hommage-ds";
       version = "0.0.5";
       sha256 = "648b229e3911102e4cbe670c88ede2fddc1b14e68f610b2a170ef269f4bfdc3e";
       libraryHaskellDepends = [
         array base DirectSound haskell98 hommage
       ];
       jailbreak = true;
       homepage = "substitut-fuer-feinmotorik/projects/haskellommage";
       description = "DirectSound extension (Windows) for the Hommage sound library";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "homplexity" = callPackage
    ({ mkDerivation, base, containers, cpphs, deepseq, directory
     , filepath, happy, haskell-src-exts, hflags, template-haskell
     , uniplate
     }:
     mkDerivation {
       pname = "homplexity";
       version = "0.4.3.0";
       sha256 = "556d2ac1f9b9468419686f7adec903838961d44b4621917589588ef5d7748377";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers cpphs deepseq directory filepath haskell-src-exts
         hflags template-haskell uniplate
       ];
       executableToolDepends = [ happy ];
       testHaskellDepends = [ base haskell-src-exts uniplate ];
       jailbreak = true;
       homepage = "https://github.com/mgajda/homplexity";
       description = "Haskell code quality tool";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "honi" = callPackage
    ({ mkDerivation, base, bytestring, freenect, hspec, HUnit, OpenNI2
     , text
     }:
     mkDerivation {
       pname = "honi";
       version = "0.1.0.0";
       sha256 = "d1f97235b6ff4bc498807024a27aeca9d345ddec31f9f63e086d24854e0c3c3c";
       libraryHaskellDepends = [ base bytestring text ];
       librarySystemDepends = [ freenect OpenNI2 ];
       testHaskellDepends = [ base hspec HUnit ];
       testSystemDepends = [ freenect OpenNI2 ];
       description = "OpenNI 2 binding";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {OpenNI2 = null; inherit (pkgs) freenect;};

  "honk" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "honk";
       version = "1.3.0.0";
       sha256 = "0efade5c453d04dcef66575e99c38353dec42fbd05ac31c7dfafaa8464e15280";
       libraryHaskellDepends = [ base ];
       homepage = "https://lambda.xyz/honk/";
       description = "Cross-platform interface to the PC speaker";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "hoobuddy" = callPackage
    ({ mkDerivation, aeson, base, bytestring, Cabal, directory
     , filepath, hoogle, monad-loops, mtl, process, yaml
     }:
     mkDerivation {
       pname = "hoobuddy";
       version = "0.1.0.1";
       sha256 = "cdaa04576caa7c638d55eece107775136651a5a27e4b25cb1163bb1c01343850";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring Cabal directory filepath hoogle monad-loops
         mtl process yaml
       ];
       jailbreak = true;
       homepage = "http://github.com/gilligan/hoobuddy";
       description = "Simple tool for fetching and merging hoogle data";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hood" = callPackage
    ({ mkDerivation, array, base, FPretty, ghc-prim }:
     mkDerivation {
       pname = "hood";
       version = "0.3";
       sha256 = "f1962dfb05d01a345335872fa36509999755c71a9381b4941bd04a9cb72b6122";
       revision = "1";
       editedCabalFile = "f9b9df9c7f747b1da4f96477fab00305b5a28132eabc224e76db75b1bae34a64";
       libraryHaskellDepends = [ array base FPretty ghc-prim ];
       homepage = "http://ku-fpg.github.io/software/hood";
       description = "Debugging by observing in place";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hood-off" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hood-off";
       version = "0.2";
       sha256 = "ccde80c586484a59e404f05455e85cebf483869dbc0dba75611f46e81d363297";
       libraryHaskellDepends = [ base ];
       description = "Dummy package to disable Hood without having to remove all the calls to observe";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hood2" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "hood2";
       version = "0.2.1";
       sha256 = "02f42887e0917e943342a6bfc628c030d837780f6d55c0b07255712fe90fd147";
       libraryHaskellDepends = [ array base ];
       homepage = "http://www.ittc.ku.edu/csdl/fpg/Hood";
       description = "Debugging by observing in place";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hoodie" = callPackage
    ({ mkDerivation, array, astar, base, containers, hfov, monad-loops
     , mtl, ncurses, random
     }:
     mkDerivation {
       pname = "hoodie";
       version = "0.1.0.0";
       sha256 = "dc388c411cb3d11ffd2eb096d162a733581f558e929e66f1f57b0cf4b1be7ce0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array astar base containers hfov monad-loops mtl ncurses random
       ];
       jailbreak = true;
       description = "A small, toy roguelike";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoodle" = callPackage
    ({ mkDerivation, base, cmdargs, configurator, containers, directory
     , filepath, hoodle-core, mtl
     }:
     mkDerivation {
       pname = "hoodle";
       version = "0.4.0";
       sha256 = "b8ea55295da7902ae272f26c6473dc36ee5481deeca1eb9b8b263c05d78ff579";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cmdargs configurator containers directory filepath hoodle-core
         mtl
       ];
       executableHaskellDepends = [ base cmdargs hoodle-core ];
       homepage = "http://ianwookim.org/hoodle";
       description = "Executable for hoodle";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoodle-builder" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, double-conversion
     , hoodle-types, lens, strict, text
     }:
     mkDerivation {
       pname = "hoodle-builder";
       version = "0.3.0";
       sha256 = "a76ef986e072c7334fe7359c80043481fc96d01211b818ad7fc5bd1adc1b8a3c";
       libraryHaskellDepends = [
         base blaze-builder bytestring double-conversion hoodle-types lens
         strict text
       ];
       description = "text builder for hoodle file format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoodle-core" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base
     , base64-bytestring, binary, bytestring, cairo, case-insensitive
     , cereal, configurator, containers, coroutine-object, Diff
     , directory, either, errors, filepath, fsnotify, gd, gtk
     , handa-gdata, hoodle-builder, hoodle-parser, hoodle-publish
     , hoodle-render, hoodle-types, http-types, lens, libX11, libXi
     , monad-loops, mtl, network-uri, old-locale, pango, poppler
     , process, pureMD5, stm, strict, svgcairo, system-filepath
     , template-haskell, text, time, transformers, transformers-free
     , unordered-containers, uuid, vector, websockets, xournal-parser
     }:
     mkDerivation {
       pname = "hoodle-core";
       version = "0.15.0";
       sha256 = "330f355427738c2f3407982658a607a4e1bc0dfdd23deb056dc3926d173c0010";
       libraryHaskellDepends = [
         aeson aeson-pretty array attoparsec base base64-bytestring binary
         bytestring cairo case-insensitive cereal configurator containers
         coroutine-object Diff directory either errors filepath fsnotify gd
         gtk handa-gdata hoodle-builder hoodle-parser hoodle-publish
         hoodle-render hoodle-types http-types lens monad-loops mtl
         network-uri old-locale pango poppler process pureMD5 stm strict
         svgcairo system-filepath template-haskell text time transformers
         transformers-free unordered-containers uuid vector websockets
         xournal-parser
       ];
       librarySystemDepends = [ libX11 libXi ];
       homepage = "http://ianwookim.org/hoodle";
       description = "Core library for hoodle";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXi;};

  "hoodle-extra" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base
     , base64-bytestring, binary, bytestring, cmdargs, conduit
     , containers, directory, either, filepath, hoodle-parser
     , hoodle-types, http-conduit, lens, monad-loops, mtl
     , network-simple, process, pureMD5, resourcet, text, time
     , transformers, unordered-containers, xournal-parser
     }:
     mkDerivation {
       pname = "hoodle-extra";
       version = "0.1";
       sha256 = "1eeaba3cc1e215cdd3254dd4ae55e97ff90311aba8f976c946f614a222261dd7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson aeson-pretty attoparsec base base64-bytestring binary
         bytestring cmdargs conduit containers directory either filepath
         hoodle-parser hoodle-types http-conduit lens monad-loops mtl
         network-simple process pureMD5 resourcet text time transformers
         unordered-containers xournal-parser
       ];
       homepage = "http://ianwookim.org/hoodle";
       description = "extra hoodle tools";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoodle-parser" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, either
     , hoodle-types, lens, mtl, strict, text, transformers
     , xournal-types
     }:
     mkDerivation {
       pname = "hoodle-parser";
       version = "0.3.0";
       sha256 = "4f946ad314df7fff43a83ce292228b8aa5aaf1d1d9d79d59e2c431a599e9e762";
       libraryHaskellDepends = [
         attoparsec base bytestring containers either hoodle-types lens mtl
         strict text transformers xournal-types
       ];
       homepage = "http://ianwookim.org/hoodle";
       description = "Hoodle file parser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoodle-publish" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, cairo, cmdargs
     , containers, directory, directory-tree, filepath, gtk
     , hoodle-parser, hoodle-render, hoodle-types, HTTP, io-streams
     , lens, mtl, network-uri, pdf-toolbox-core, pdf-toolbox-document
     , process, transformers, unordered-containers, uuid
     }:
     mkDerivation {
       pname = "hoodle-publish";
       version = "0.2.0";
       sha256 = "b5283d38c5e6ea5708650922538008d0026828e9bd037d6b6af101001cf1a2db";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring cairo containers directory
         directory-tree filepath gtk hoodle-parser hoodle-render
         hoodle-types HTTP io-streams lens mtl network-uri pdf-toolbox-core
         pdf-toolbox-document process transformers unordered-containers uuid
       ];
       executableHaskellDepends = [
         base cmdargs directory directory-tree filepath gtk
       ];
       homepage = "http://ianwookim.org/hoodle";
       description = "publish hoodle files as a static web site";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoodle-render" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, cairo
     , containers, directory, filepath, gd, gtk, hashable, hoodle-types
     , lens, monad-loops, mtl, poppler, stm, strict, svgcairo, time
     , transformers, unix, unordered-containers, uuid
     }:
     mkDerivation {
       pname = "hoodle-render";
       version = "0.5.0";
       sha256 = "910882d3bfd2b3970b71f8984b03e2ba64509561905966f6db9615495d92c010";
       libraryHaskellDepends = [
         base base64-bytestring bytestring cairo containers directory
         filepath gd gtk hashable hoodle-types lens monad-loops mtl poppler
         stm strict svgcairo time transformers unix unordered-containers
         uuid
       ];
       description = "Hoodle file renderer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoodle-types" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, lens, mtl
     , strict, text, uuid
     }:
     mkDerivation {
       pname = "hoodle-types";
       version = "0.3.0";
       sha256 = "253ffbd51a6c4cfd673030f4b97b55dd350e12f22e96d98a318344ab831d7d56";
       libraryHaskellDepends = [
         base bytestring cereal containers lens mtl strict text uuid
       ];
       description = "Data types for programs for hoodle file format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoogle_4_2_36" = callPackage
    ({ mkDerivation, aeson, array, base, binary, blaze-builder
     , bytestring, Cabal, case-insensitive, cmdargs, conduit, containers
     , deepseq, directory, filepath, haskell-src-exts, http-types
     , old-locale, parsec, process, QuickCheck, random, resourcet, safe
     , shake, tagsoup, temporary, text, time, transformers, uniplate
     , unix, vector, vector-algorithms, wai, warp
     }:
     mkDerivation {
       pname = "hoogle";
       version = "4.2.36";
       sha256 = "dbc56f460960936c6e07582ce85cfc7c440707ac692aee33bb224e2701bdc5c0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary blaze-builder bytestring case-insensitive conduit
         containers deepseq directory filepath haskell-src-exts http-types
         parsec process QuickCheck random resourcet safe text transformers
         uniplate unix vector vector-algorithms wai
       ];
       executableHaskellDepends = [
         aeson array base binary blaze-builder bytestring Cabal
         case-insensitive cmdargs conduit containers deepseq directory
         filepath haskell-src-exts http-types old-locale parsec process
         QuickCheck random resourcet safe shake tagsoup text time
         transformers uniplate unix vector vector-algorithms wai warp
       ];
       testHaskellDepends = [ base directory filepath process temporary ];
       jailbreak = true;
       homepage = "http://www.haskell.org/hoogle/";
       description = "Haskell API Search";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoogle_4_2_37" = callPackage
    ({ mkDerivation, aeson, array, base, binary, blaze-builder
     , bytestring, Cabal, case-insensitive, cmdargs, conduit, containers
     , deepseq, directory, filepath, haskell-src-exts, http-types
     , old-locale, parsec, process, QuickCheck, random, resourcet, safe
     , shake, tagsoup, temporary, text, time, transformers, uniplate
     , unix, vector, vector-algorithms, wai, warp
     }:
     mkDerivation {
       pname = "hoogle";
       version = "4.2.37";
       sha256 = "a461cbf488043aefac1807e1ddd08f437500a837a10f56610535defdce1cf57b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary blaze-builder bytestring case-insensitive conduit
         containers deepseq directory filepath haskell-src-exts http-types
         parsec process QuickCheck random resourcet safe text transformers
         uniplate unix vector vector-algorithms wai
       ];
       executableHaskellDepends = [
         aeson array base binary blaze-builder bytestring Cabal
         case-insensitive cmdargs conduit containers deepseq directory
         filepath haskell-src-exts http-types old-locale parsec process
         QuickCheck random resourcet safe shake tagsoup text time
         transformers uniplate unix vector vector-algorithms wai warp
       ];
       testHaskellDepends = [ base directory filepath process temporary ];
       jailbreak = true;
       homepage = "http://www.haskell.org/hoogle/";
       description = "Haskell API Search";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoogle_4_2_38" = callPackage
    ({ mkDerivation, aeson, array, base, binary, blaze-builder
     , bytestring, Cabal, case-insensitive, cmdargs, conduit, containers
     , deepseq, directory, filepath, haskell-src-exts, http-types
     , old-locale, parsec, process, QuickCheck, random, resourcet, safe
     , shake, tagsoup, temporary, text, time, transformers, uniplate
     , unix, vector, vector-algorithms, wai, warp
     }:
     mkDerivation {
       pname = "hoogle";
       version = "4.2.38";
       sha256 = "0a15a4070d59157467d4fc34ba6597b62dbde45999381f6cf5954d0bd9104d46";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary blaze-builder bytestring case-insensitive conduit
         containers deepseq directory filepath haskell-src-exts http-types
         parsec process QuickCheck random resourcet safe text transformers
         uniplate unix vector vector-algorithms wai
       ];
       executableHaskellDepends = [
         aeson array base binary blaze-builder bytestring Cabal
         case-insensitive cmdargs conduit containers deepseq directory
         filepath haskell-src-exts http-types old-locale parsec process
         QuickCheck random resourcet safe shake tagsoup text time
         transformers uniplate unix vector vector-algorithms wai warp
       ];
       testHaskellDepends = [ base directory filepath process temporary ];
       jailbreak = true;
       homepage = "http://www.haskell.org/hoogle/";
       description = "Haskell API Search";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoogle_4_2_39" = callPackage
    ({ mkDerivation, aeson, array, base, binary, blaze-builder
     , bytestring, Cabal, case-insensitive, cmdargs, conduit, containers
     , deepseq, directory, filepath, haskell-src-exts, http-types
     , old-locale, parsec, process, QuickCheck, random, resourcet, safe
     , shake, tagsoup, temporary, text, time, transformers, uniplate
     , unix, vector, vector-algorithms, wai, warp
     }:
     mkDerivation {
       pname = "hoogle";
       version = "4.2.39";
       sha256 = "a994e05c7367aa41429446bf1fccc7366bd71c077e8134c28d2a3d4847807a58";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary blaze-builder bytestring case-insensitive conduit
         containers deepseq directory filepath haskell-src-exts http-types
         parsec process QuickCheck random resourcet safe text transformers
         uniplate unix vector vector-algorithms wai
       ];
       executableHaskellDepends = [
         aeson array base binary blaze-builder bytestring Cabal
         case-insensitive cmdargs conduit containers deepseq directory
         filepath haskell-src-exts http-types old-locale parsec process
         QuickCheck random resourcet safe shake tagsoup text time
         transformers uniplate unix vector vector-algorithms wai warp
       ];
       testHaskellDepends = [ base directory filepath process temporary ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.haskell.org/hoogle/";
       description = "Haskell API Search";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoogle_4_2_40" = callPackage
    ({ mkDerivation, aeson, array, base, binary, blaze-builder
     , bytestring, Cabal, case-insensitive, cmdargs, conduit, containers
     , deepseq, directory, filepath, haskell-src-exts, http-types
     , old-locale, parsec, process, QuickCheck, random, resourcet, safe
     , shake, tagsoup, temporary, text, time, transformers, uniplate
     , unix, vector, vector-algorithms, wai, warp
     }:
     mkDerivation {
       pname = "hoogle";
       version = "4.2.40";
       sha256 = "1bffb489e76f7212e26b5ea376d4a5a83efad5ec020d2601a7683cfd70e39485";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary blaze-builder bytestring case-insensitive conduit
         containers deepseq directory filepath haskell-src-exts http-types
         parsec process QuickCheck random resourcet safe text transformers
         uniplate unix vector vector-algorithms wai
       ];
       executableHaskellDepends = [
         aeson array base binary blaze-builder bytestring Cabal
         case-insensitive cmdargs conduit containers deepseq directory
         filepath haskell-src-exts http-types old-locale parsec process
         QuickCheck random resourcet safe shake tagsoup text time
         transformers uniplate unix vector vector-algorithms wai warp
       ];
       testHaskellDepends = [ base directory filepath process temporary ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.haskell.org/hoogle/";
       description = "Haskell API Search";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoogle_4_2_41" = callPackage
    ({ mkDerivation, aeson, array, base, binary, blaze-builder
     , bytestring, Cabal, case-insensitive, cmdargs, conduit, containers
     , deepseq, directory, filepath, haskell-src-exts, http-types
     , old-locale, parsec, process, QuickCheck, random, resourcet, safe
     , shake, tagsoup, temporary, text, time, transformers, uniplate
     , unix, vector, vector-algorithms, wai, warp
     }:
     mkDerivation {
       pname = "hoogle";
       version = "4.2.41";
       sha256 = "a6b80301849314399f622d8c68c3b46cb0ae85a65f625f47817f23d40ed7a1be";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary blaze-builder bytestring case-insensitive conduit
         containers deepseq directory filepath haskell-src-exts http-types
         parsec process QuickCheck random resourcet safe text transformers
         uniplate unix vector vector-algorithms wai
       ];
       executableHaskellDepends = [
         aeson array base binary blaze-builder bytestring Cabal
         case-insensitive cmdargs conduit containers deepseq directory
         filepath haskell-src-exts http-types old-locale parsec process
         QuickCheck random resourcet safe shake tagsoup text time
         transformers uniplate unix vector vector-algorithms wai warp
       ];
       testHaskellDepends = [ base directory filepath process temporary ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.haskell.org/hoogle/";
       description = "Haskell API Search";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoogle_4_2_42" = callPackage
    ({ mkDerivation, aeson, array, base, binary, blaze-builder
     , bytestring, Cabal, case-insensitive, cmdargs, conduit, containers
     , deepseq, directory, filepath, haskell-src-exts, http-types
     , old-locale, parsec, process, QuickCheck, random, resourcet, safe
     , shake, tagsoup, temporary, text, time, transformers, uniplate
     , unix, vector, vector-algorithms, wai, warp
     }:
     mkDerivation {
       pname = "hoogle";
       version = "4.2.42";
       sha256 = "32ed4637d53fe1c0ee032e3692b74a4a0bb5d38d30b302450631aa6f6805dccb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary blaze-builder bytestring case-insensitive conduit
         containers deepseq directory filepath haskell-src-exts http-types
         parsec process QuickCheck random resourcet safe text transformers
         uniplate unix vector vector-algorithms wai
       ];
       executableHaskellDepends = [
         aeson array base binary blaze-builder bytestring Cabal
         case-insensitive cmdargs conduit containers deepseq directory
         filepath haskell-src-exts http-types old-locale parsec process
         QuickCheck random resourcet safe shake tagsoup text time
         transformers uniplate unix vector vector-algorithms wai warp
       ];
       testHaskellDepends = [ base directory filepath process temporary ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.haskell.org/hoogle/";
       description = "Haskell API Search";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoogle" = callPackage
    ({ mkDerivation, aeson, array, base, binary, blaze-builder
     , bytestring, Cabal, case-insensitive, cmdargs, conduit, containers
     , deepseq, directory, filepath, haskell-src-exts, http-types
     , old-locale, parsec, process, QuickCheck, random, resourcet, safe
     , shake, tagsoup, temporary, text, time, transformers, uniplate
     , unix, vector, vector-algorithms, wai, warp
     }:
     mkDerivation {
       pname = "hoogle";
       version = "4.2.43";
       sha256 = "eb30df565d363cd5d98821c51b0daf93493dec3bfe95c016922c95a20efa7c17";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary blaze-builder bytestring case-insensitive conduit
         containers deepseq directory filepath haskell-src-exts http-types
         parsec process QuickCheck random resourcet safe text transformers
         uniplate unix vector vector-algorithms wai
       ];
       executableHaskellDepends = [
         aeson array base binary blaze-builder bytestring Cabal
         case-insensitive cmdargs conduit containers deepseq directory
         filepath haskell-src-exts http-types old-locale parsec process
         QuickCheck random resourcet safe shake tagsoup text time
         transformers uniplate unix vector vector-algorithms wai warp
       ];
       testHaskellDepends = [ base directory filepath process temporary ];
       doCheck = false;
       homepage = "http://www.haskell.org/hoogle/";
       description = "Haskell API Search";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hoogle-index" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, directory
     , errors, filepath, hoogle, optparse-applicative, process
     , temporary, transformers
     }:
     mkDerivation {
       pname = "hoogle-index";
       version = "0.4.3";
       sha256 = "353175f271d6a4df1ad8434bb9b088bada47d8dfe2f624ed4f0d1c92c7d6c380";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal containers directory errors filepath hoogle
         optparse-applicative process temporary transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/bgamari/hoogle-index";
       description = "Easily generate Hoogle indices for installed packages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hooks-dir" = callPackage
    ({ mkDerivation, base, directory, process, text }:
     mkDerivation {
       pname = "hooks-dir";
       version = "0.1.1.0";
       sha256 = "ab685c202841e2d35d225b151786133309af38694818ac7aefc84e44ebc58d3f";
       libraryHaskellDepends = [ base directory process text ];
       homepage = "https://github.com/ibotty/hooks-dir";
       description = "run executables in a directory as hooks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hoopl_3_10_2_1" = callPackage
    ({ mkDerivation, base, containers, filepath, mtl, parsec
     , test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "hoopl";
       version = "3.10.2.1";
       sha256 = "7c06a2a9e8871eff74fdbbf2aa0a2201a31a5687f5acf7a5ba8a3611325440b0";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [
         base containers filepath mtl parsec test-framework
         test-framework-hunit
       ];
       homepage = "http://ghc.cs.tufts.edu/hoopl/";
       description = "A library to support dataflow analysis and optimization";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoovie" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, configurator
     , directory, enumerator, file-embed, filepath, HDBC, HDBC-sqlite3
     , mtl, network, network-info, network-multicast, old-locale
     , old-time, process, regex-compat, snap-core, snap-server, text
     , time, transformers, unix, xml
     }:
     mkDerivation {
       pname = "hoovie";
       version = "0.1.1";
       sha256 = "891056abfca2c3ec1deb108870ee9ad945987697ee56a0406edbf17be43488bc";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-builder bytestring configurator directory enumerator
         file-embed filepath HDBC HDBC-sqlite3 mtl network network-info
         network-multicast old-locale old-time process regex-compat
         snap-core snap-server text time transformers unix xml
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/pvdbrand/hoovie";
       description = "Haskell Media Server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hopencc" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, opencc, QuickCheck
     , utf8-string
     }:
     mkDerivation {
       pname = "hopencc";
       version = "0.1.0.0";
       sha256 = "dc4379ad9c203841b93dac39a59f30019ea84685d5562434bf1f2790076cf4f9";
       libraryHaskellDepends = [ base bytestring utf8-string ];
       libraryPkgconfigDepends = [ opencc ];
       libraryToolDepends = [ c2hs ];
       testHaskellDepends = [ base QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/MnO2/hopencc";
       description = "Haskell binding to libopencc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {opencc = null;};

  "hopencl" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, HUnit, OpenCL, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "hopencl";
       version = "0.2.1";
       sha256 = "68627a79e3a415bcbec696ab64a1cf67bd7d811970ae30d642d8f1e24396b9cd";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ OpenCL ];
       libraryToolDepends = [ c2hs ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       homepage = "https://github.com/merijn/hopencl";
       description = "Haskell bindings for OpenCL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {OpenCL = null;};

  "hopenpgp-tools_0_13" = callPackage
    ({ mkDerivation, aeson, alex, ansi-wl-pprint, array, attoparsec
     , base, base16-bytestring, bytestring, cereal, cereal-conduit
     , conduit, conduit-extra, containers, crypto-pubkey, cryptohash
     , directory, errors, fgl, graphviz, happy, hOpenPGP, ixset, lens
     , monad-loops, old-locale, openpgp-asciiarmor, optparse-applicative
     , resourcet, text, time, transformers, unordered-containers, yaml
     }:
     mkDerivation {
       pname = "hopenpgp-tools";
       version = "0.13";
       sha256 = "5f5bb47f51f216620094e8c984968aa476e4c37fbb9b1825b9e394de9834841f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson ansi-wl-pprint array attoparsec base base16-bytestring
         bytestring cereal cereal-conduit conduit conduit-extra containers
         crypto-pubkey cryptohash directory errors fgl graphviz hOpenPGP
         ixset lens monad-loops old-locale openpgp-asciiarmor
         optparse-applicative resourcet text time transformers
         unordered-containers yaml
       ];
       executableToolDepends = [ alex happy ];
       homepage = "http://floss.scru.org/hopenpgp-tools";
       description = "hOpenPGP-based command-line tools";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hopenpgp-tools_0_14_1" = callPackage
    ({ mkDerivation, aeson, alex, ansi-wl-pprint, array, attoparsec
     , base, base16-bytestring, binary, binary-conduit, bytestring
     , conduit, conduit-extra, containers, crypto-pubkey, cryptohash
     , directory, errors, fgl, graphviz, happy, hOpenPGP, ixset, lens
     , monad-loops, old-locale, openpgp-asciiarmor, optparse-applicative
     , resourcet, text, time, transformers, unordered-containers
     , wl-pprint-extras, yaml
     }:
     mkDerivation {
       pname = "hopenpgp-tools";
       version = "0.14.1";
       sha256 = "9ccd2c7db137f1a5e9caef9e4b8ca9a1bf7e952c8a7005fa5d9c226fb6f97532";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson ansi-wl-pprint array attoparsec base base16-bytestring binary
         binary-conduit bytestring conduit conduit-extra containers
         crypto-pubkey cryptohash directory errors fgl graphviz hOpenPGP
         ixset lens monad-loops old-locale openpgp-asciiarmor
         optparse-applicative resourcet text time transformers
         unordered-containers wl-pprint-extras yaml
       ];
       executableToolDepends = [ alex happy ];
       homepage = "http://floss.scru.org/hopenpgp-tools";
       description = "hOpenPGP-based command-line tools";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hopenpgp-tools_0_16_3" = callPackage
    ({ mkDerivation, aeson, alex, ansi-wl-pprint, array, attoparsec
     , base, base16-bytestring, binary, binary-conduit, bytestring
     , conduit, conduit-extra, containers, crypto-pubkey, cryptohash
     , directory, errors, fgl, graphviz, happy, hOpenPGP, ixset-typed
     , lens, monad-loops, openpgp-asciiarmor, optparse-applicative
     , resourcet, text, time, time-locale-compat, transformers
     , unordered-containers, wl-pprint-extras, yaml
     }:
     mkDerivation {
       pname = "hopenpgp-tools";
       version = "0.16.3";
       sha256 = "8ecdffae493b7ceaf3520f28883d9e12c6cdaaf444e3230c1c8c876d4cc9d25f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson ansi-wl-pprint array attoparsec base base16-bytestring binary
         binary-conduit bytestring conduit conduit-extra containers
         crypto-pubkey cryptohash directory errors fgl graphviz hOpenPGP
         ixset-typed lens monad-loops openpgp-asciiarmor
         optparse-applicative resourcet text time time-locale-compat
         transformers unordered-containers wl-pprint-extras yaml
       ];
       executableToolDepends = [ alex happy ];
       homepage = "http://floss.scru.org/hopenpgp-tools";
       description = "hOpenPGP-based command-line tools";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hopenpgp-tools" = callPackage
    ({ mkDerivation, aeson, alex, ansi-wl-pprint, array, attoparsec
     , base, base16-bytestring, binary, binary-conduit, bytestring
     , conduit, conduit-extra, containers, crypto-pubkey, cryptohash
     , directory, errors, fgl, graphviz, happy, hOpenPGP, ixset-typed
     , lens, monad-loops, openpgp-asciiarmor, optparse-applicative
     , resourcet, text, time, time-locale-compat, transformers
     , unordered-containers, wl-pprint-extras, wl-pprint-terminfo, yaml
     }:
     mkDerivation {
       pname = "hopenpgp-tools";
       version = "0.17";
       sha256 = "051b0609099646057981eda5dc4cc8073fa9cf070ef814ca50b5a39fd09d2fe6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson ansi-wl-pprint array attoparsec base base16-bytestring binary
         binary-conduit bytestring conduit conduit-extra containers
         crypto-pubkey cryptohash directory errors fgl graphviz hOpenPGP
         ixset-typed lens monad-loops openpgp-asciiarmor
         optparse-applicative resourcet text time time-locale-compat
         transformers unordered-containers wl-pprint-extras
         wl-pprint-terminfo yaml
       ];
       executableToolDepends = [ alex happy ];
       homepage = "http://floss.scru.org/hopenpgp-tools";
       description = "hOpenPGP-based command-line tools";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hopenssl" = callPackage
    ({ mkDerivation, base, bytestring, mtl, openssl }:
     mkDerivation {
       pname = "hopenssl";
       version = "1.7";
       sha256 = "9ee64bb5834e475a6bdfa1fb578e6a966f74bebb8be95685a9d695cffb4c46ff";
       libraryHaskellDepends = [ base bytestring mtl ];
       librarySystemDepends = [ openssl ];
       homepage = "http://github.com/peti/hopenssl";
       description = "FFI bindings to OpenSSL's EVP digest interface";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {inherit (pkgs) openssl;};

  "hopfield" = callPackage
    ({ mkDerivation, array, base, deepseq, directory, erf
     , exact-combinatorics, hmatrix, hspec, HUnit, imagemagick
     , JuicyPixels, MagickCore, monad-loops, MonadRandom
     , optparse-applicative, parallel, probability, QuickCheck, random
     , random-fu, rvar, split, vector
     }:
     mkDerivation {
       pname = "hopfield";
       version = "0.1.0.2";
       sha256 = "fc8729fbd142945258092585e6f3afe83bf123310b7673d3c83837074819f9b2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base deepseq erf exact-combinatorics hmatrix monad-loops
         MonadRandom parallel probability QuickCheck random random-fu rvar
         split vector
       ];
       librarySystemDepends = [ imagemagick MagickCore ];
       executableHaskellDepends = [
         base directory JuicyPixels MonadRandom optparse-applicative random
         vector
       ];
       testHaskellDepends = [
         base erf exact-combinatorics hspec HUnit MonadRandom parallel
         QuickCheck random vector
       ];
       homepage = "https://github.com/imperialhopfield/hopfield";
       description = "Hopfield Networks, Boltzmann Machines and Clusters";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {MagickCore = null; inherit (pkgs) imagemagick;};

  "hopfield-networks" = callPackage
    ({ mkDerivation, base, matrix, MonadRandom, QuickCheck, split
     , test-framework, test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "hopfield-networks";
       version = "0.1.0.0";
       sha256 = "4d23b2be13a23382ab3b691edf8d826a3b01fd97a1ee7c26532a1f6da66472b4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base matrix MonadRandom split vector ];
       executableHaskellDepends = [
         base matrix MonadRandom QuickCheck split vector
       ];
       testHaskellDepends = [
         base matrix MonadRandom QuickCheck test-framework
         test-framework-quickcheck2 vector
       ];
       homepage = "https://github.com/ajtulloch/hopfield-networks";
       description = "Hopfield Networks for unsupervised learning in Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hopfli" = callPackage
    ({ mkDerivation, base, bytestring, hspec, QuickCheck, zlib }:
     mkDerivation {
       pname = "hopfli";
       version = "0.2.1.0";
       sha256 = "c3af486ae287728d01662cc13f552a80a9cc3274c9a20f58c5a37ecbd49ea5e7";
       libraryHaskellDepends = [ base bytestring zlib ];
       testHaskellDepends = [ base bytestring hspec QuickCheck zlib ];
       jailbreak = true;
       homepage = "https://github.com/ananthakumaran/hopfli";
       description = "zlib compatible compression using Zopfli Compression Algorithm";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "hoppy-generator" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, haskell-src
     , mtl
     }:
     mkDerivation {
       pname = "hoppy-generator";
       version = "0.1.0";
       sha256 = "b21263c50e730e903873c59dcbb9e88ce35db066713c22938e2b87e12e7d0fad";
       libraryHaskellDepends = [
         base containers directory filepath haskell-src mtl
       ];
       homepage = "http://khumba.net/projects/hoppy";
       description = "C++ FFI generator - Code generator";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "hoppy-runtime" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hoppy-runtime";
       version = "0.1.0";
       sha256 = "b0f7721ef01bb4f1b4b7e9debbb6c18d0ec06eae058ef3c7160f64a026e05ddb";
       libraryHaskellDepends = [ base ];
       homepage = "http://khumba.net/projects/hoppy";
       description = "C++ FFI generator - Runtime support";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "hoppy-std" = callPackage
    ({ mkDerivation, base, filepath, haskell-src, hoppy-generator }:
     mkDerivation {
       pname = "hoppy-std";
       version = "0.1.0";
       sha256 = "adde5ad934f9e52d69e9c7f246d208d2a9ded339434c4bde8633d5193ba03d78";
       libraryHaskellDepends = [
         base filepath haskell-src hoppy-generator
       ];
       homepage = "http://khumba.net/projects/hoppy";
       description = "C++ FFI generator - Standard library bindings";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "hops" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, attoparsec, base, bytestring
     , conduit, conduit-extra, containers, deepseq, directory, filepath
     , http-conduit, http-types, optparse-applicative, parallel, process
     , QuickCheck, resourcet, scientific, text, transformers, vector
     }:
     mkDerivation {
       pname = "hops";
       version = "0.4.1";
       sha256 = "e28a457b5f75c3e375f17143244da60e7754c6948bb0f8826c6d5efcbcf07d49";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson ansi-terminal attoparsec base bytestring conduit
         conduit-extra containers deepseq directory filepath http-conduit
         http-types optparse-applicative parallel resourcet scientific text
         transformers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring containers deepseq process
         QuickCheck scientific text vector
       ];
       homepage = "http://akc.is/hops";
       description = "Handy Operations on Power Series";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hoq" = callPackage
    ({ mkDerivation, alex, array, base, bifunctors, bytestring
     , filepath, happy, mtl, pretty, readline, void
     }:
     mkDerivation {
       pname = "hoq";
       version = "0.3";
       sha256 = "67bd939f6932ed6910cccd07d180745ae5b91aa854ae73d85f3344f571c02c41";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bifunctors bytestring filepath mtl pretty readline void
       ];
       executableToolDepends = [ alex happy ];
       homepage = "http://github.com/valis/hoq";
       description = "A language based on homotopy type theory with an interval type";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "horizon" = callPackage
    ({ mkDerivation, AC-Angle, base, time }:
     mkDerivation {
       pname = "horizon";
       version = "0.1.1";
       sha256 = "a4793eac44e445ef4ecb8ef3de1c4308c91ba7368051737fcbec65da413ca2e3";
       libraryHaskellDepends = [ AC-Angle base time ];
       jailbreak = true;
       homepage = "https://github.com/intractable/horizon";
       description = "Sunrise and sunset UTC approximations from latitude and longitude coordinates";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hosc" = callPackage
    ({ mkDerivation, base, binary, blaze-builder, bytestring
     , data-binary-ieee754, network, QuickCheck, test-framework
     , test-framework-quickcheck2, time, transformers
     }:
     mkDerivation {
       pname = "hosc";
       version = "0.15";
       sha256 = "8e35a78a5619f57148a07e0b5995c209175a0ae3f1f4e1c5c8c9dc54822de2fa";
       libraryHaskellDepends = [
         base binary blaze-builder bytestring data-binary-ieee754 network
         time transformers
       ];
       testHaskellDepends = [
         base bytestring QuickCheck test-framework
         test-framework-quickcheck2
       ];
       homepage = "http://rd.slavepianos.org/t/hosc";
       description = "Haskell Open Sound Control";
       license = "GPL";
     }) {};

  "hosc-json" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bifunctors, bytestring
     , hosc, json, text, unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "hosc-json";
       version = "0.15";
       sha256 = "1176584e51da323ed80d556957ca07869cbb32758dbef8f34b4eda922d995a69";
       libraryHaskellDepends = [
         aeson attoparsec base bifunctors bytestring hosc json text
         unordered-containers utf8-string vector
       ];
       homepage = "http://rd.slavepianos.org/t/hosc-json";
       description = "Haskell Open Sound Control JSON Serialisation";
       license = "GPL";
     }) {};

  "hosc-utils" = callPackage
    ({ mkDerivation, base, bytestring, cgi, haskeline, hosc, hosc-json
     , hsc3, json, text, transformers, utf8-string, websockets
     , www-minus
     }:
     mkDerivation {
       pname = "hosc-utils";
       version = "0.15";
       sha256 = "b4b6662ea50a20009c4b0c03b638675fbf20f69389fa432ca91e6f515e4c657e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cgi haskeline hosc hosc-json hsc3 json text
         transformers utf8-string websockets www-minus
       ];
       jailbreak = true;
       homepage = "http://rd.slavepianos.org/?t=hosc-utils";
       description = "Haskell Open Sound Control Utilities";
       license = "GPL";
       broken = true;
     }) {www-minus = null;};

  "hostname" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hostname";
       version = "1.0";
       sha256 = "9b43dab1b6da521f35685b20555da00738c8e136eb972458c786242406a9cf5c";
       libraryHaskellDepends = [ base ];
       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 }:
     mkDerivation {
       pname = "hostname-validate";
       version = "1.0.0";
       sha256 = "7fafb1e0cfe19d453030754962e74cdb8f3e791ec5b974623cbf26872779c857";
       libraryHaskellDepends = [ attoparsec base bytestring ];
       description = "Validate hostnames e.g. localhost or foo.co.uk.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hosts-server" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, data-default, dns
     , iproute, network
     }:
     mkDerivation {
       pname = "hosts-server";
       version = "0.1.1";
       sha256 = "1eab2b1e7cfdb7e32494323008a0957dc5399568a009bdf5a83816868a7ab3bc";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base bytestring data-default dns iproute network
       ];
       jailbreak = true;
       homepage = "https://github.com/yihuang/hosts-server";
       description = "An dns server which is extremely easy to config";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hothasktags" = callPackage
    ({ mkDerivation, array, base, containers, cpphs, filemanip
     , filepath, Glob, haskell-src-exts, optparse-applicative, split
     }:
     mkDerivation {
       pname = "hothasktags";
       version = "0.3.5";
       sha256 = "6f0ed1707e5470aacef8e8ab959f430e356a05a0ed40b4b0a37c176cc3a89426";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers cpphs filemanip filepath Glob
         haskell-src-exts optparse-applicative split
       ];
       homepage = "http://github.com/luqui/hothasktags";
       description = "Generates ctags for Haskell, incorporating import lists and qualified imports";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hotswap" = callPackage
    ({ mkDerivation, base, plugins }:
     mkDerivation {
       pname = "hotswap";
       version = "0.1.9.13";
       sha256 = "1ba28b05a598b4e1212c78c63dd2e064444030aeb169fc8854d85dcff723c1b0";
       libraryHaskellDepends = [ base plugins ];
       jailbreak = true;
       homepage = "https://github.com/mikeplus64/hotswap";
       description = "Simple code hotswapping";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hourglass_0_2_6" = callPackage
    ({ mkDerivation, base, deepseq, mtl, old-locale, tasty, tasty-hunit
     , tasty-quickcheck, time
     }:
     mkDerivation {
       pname = "hourglass";
       version = "0.2.6";
       sha256 = "a3a62b434c863848cb8ad97e0fb7e1712875a9a864115b8f3f324f934baf2e09";
       revision = "1";
       editedCabalFile = "e4662df1d8323dab05b2afa1e4d20ade73b2b879c215919ec6b91f3e4871d314";
       libraryHaskellDepends = [ base deepseq ];
       testHaskellDepends = [
         base deepseq mtl old-locale tasty tasty-hunit tasty-quickcheck time
       ];
       homepage = "https://github.com/vincenthz/hs-hourglass";
       description = "simple performant time related library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hourglass_0_2_8" = callPackage
    ({ mkDerivation, base, deepseq, mtl, old-locale, tasty, tasty-hunit
     , tasty-quickcheck, time
     }:
     mkDerivation {
       pname = "hourglass";
       version = "0.2.8";
       sha256 = "929efeb149782375a5a2c18ac4302dfd019e693e93bd68fc17d9e2e4aa73b3d8";
       revision = "1";
       editedCabalFile = "df23ba9b63af9fd6ed50bdbde1c2a2b43dc702e68a85722a49cd1ff1b21894b5";
       libraryHaskellDepends = [ base deepseq ];
       testHaskellDepends = [
         base deepseq mtl old-locale tasty tasty-hunit tasty-quickcheck time
       ];
       homepage = "https://github.com/vincenthz/hs-hourglass";
       description = "simple performant time related library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hourglass" = callPackage
    ({ mkDerivation, base, deepseq, mtl, old-locale, tasty, tasty-hunit
     , tasty-quickcheck, time
     }:
     mkDerivation {
       pname = "hourglass";
       version = "0.2.9";
       sha256 = "9b54f163a1ecad98fbd14cb9737c28001b2648106d98cbd68fb2f5cfed090af6";
       libraryHaskellDepends = [ base deepseq ];
       testHaskellDepends = [
         base deepseq mtl old-locale tasty tasty-hunit tasty-quickcheck time
       ];
       homepage = "https://github.com/vincenthz/hs-hourglass";
       description = "simple performant time related library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hourglass-fuzzy-parsing" = callPackage
    ({ mkDerivation, base, hourglass, parsec }:
     mkDerivation {
       pname = "hourglass-fuzzy-parsing";
       version = "0.1.0.1";
       sha256 = "67f8ff2a79d3cc1c2b19ef124aba3118650d4e151da519f1f0a0188b7ee015a1";
       libraryHaskellDepends = [ base hourglass parsec ];
       homepage = "https://gitlab.com/doshitan/hourglass-fuzzy-parsing";
       description = "A small library for parsing more human friendly date/time formats";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hp2any-core" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , directory, filepath, network, old-locale, process, time
     }:
     mkDerivation {
       pname = "hp2any-core";
       version = "0.11.2";
       sha256 = "3e583e758f048a030b2e08f2d5950a4b620d9ccff97510afb91a22fede4abcbe";
       libraryHaskellDepends = [
         attoparsec base bytestring containers directory filepath network
         old-locale process time
       ];
       homepage = "http://www.haskell.org/haskellwiki/Hp2any";
       description = "Heap profiling helper library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hp2any-graph" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , freeglut, GLUT, hp2any-core, mesa, network, OpenGL, parseargs
     , process
     }:
     mkDerivation {
       pname = "hp2any-graph";
       version = "0.5.4.2";
       sha256 = "34a62dfaa5ef2f86906f3db54175edd6ca0d843ea843d704eeb7186171ac41fa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base hp2any-core OpenGL ];
       executableHaskellDepends = [
         base bytestring containers directory filepath GLUT hp2any-core
         network OpenGL parseargs process
       ];
       executableSystemDepends = [ freeglut mesa ];
       homepage = "http://www.haskell.org/haskellwiki/Hp2any";
       description = "Real-time heap graphing utility and profile stream server with a reusable graphing module";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) freeglut; inherit (pkgs) mesa;};

  "hp2any-manager" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers
     , directory, filepath, glade, glib, gtk, gtkglext, hp2any-core
     , hp2any-graph, OpenGL, time
     }:
     mkDerivation {
       pname = "hp2any-manager";
       version = "0.4.6";
       sha256 = "3b2b557562c6d46dc7e20aec6a21cee63dd678c67f9f32a8d001fbbfa91f7290";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring cairo containers directory filepath glade
         glib gtk gtkglext hp2any-core hp2any-graph OpenGL time
       ];
       homepage = "http://www.haskell.org/haskellwiki/Hp2any";
       description = "A utility to visualise and compare heap profiles";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hp2html" = callPackage
    ({ mkDerivation, base, containers, filepath }:
     mkDerivation {
       pname = "hp2html";
       version = "0.2";
       sha256 = "8a37889619567261adbc9cb635cdf129aad776e65348250bc534350348e16087";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers filepath ];
       description = "A tool for converting GHC heap-profiles to HTML";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hp2pretty" = callPackage
    ({ mkDerivation, array, attoparsec, base, containers, filepath
     , floatshow, mtl, text
     }:
     mkDerivation {
       pname = "hp2pretty";
       version = "0.6";
       sha256 = "8c6cd408b7dc2bdb60aee98b6781773df5be80c339612173fc9043490342aaae";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array attoparsec base containers filepath floatshow mtl text
       ];
       homepage = "http://code.mathr.co.uk/hp2pretty";
       description = "generate pretty graphs from heap profiles";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hpack" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, base-compat, deepseq
     , directory, filepath, Glob, hspec, interpolate, mockery, temporary
     , text, unordered-containers, yaml
     }:
     mkDerivation {
       pname = "hpack";
       version = "0.9.0";
       sha256 = "8f8f40556c84e949895c50253c2d84c758ac8d452921a6e3ddd5dd6daeadc8a2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base-compat deepseq directory filepath Glob text
         unordered-containers yaml
       ];
       executableHaskellDepends = [
         aeson base base-compat deepseq directory filepath Glob text
         unordered-containers yaml
       ];
       testHaskellDepends = [
         aeson aeson-qq base base-compat deepseq directory filepath Glob
         hspec interpolate mockery temporary text unordered-containers yaml
       ];
       jailbreak = true;
       homepage = "https://github.com/sol/hpack#readme";
       description = "An alternative format for Haskell packages";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hpaco" = callPackage
    ({ mkDerivation, aeson, base, cmdargs, filepath, hpaco-lib, strict
     , utf8-string, yaml
     }:
     mkDerivation {
       pname = "hpaco";
       version = "0.28.0.5";
       sha256 = "a96b02990a6a420c09a1a99de6d54e98778649aad51ebb992f8d48cf3919060e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base cmdargs filepath hpaco-lib strict utf8-string yaml
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/tdammers/hpaco";
       description = "Modular template compiler";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hpaco-lib" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, data-variant
     , file-embed, filepath, mtl, parsec, safe, split, strict
     , transformers
     }:
     mkDerivation {
       pname = "hpaco-lib";
       version = "0.28.0.5";
       sha256 = "157bcd30eb92a3e7a7d0ced0323c43b11517c1d878c75d3af146c770e3acd4d8";
       libraryHaskellDepends = [
         aeson base bytestring containers data-variant file-embed filepath
         mtl parsec safe split strict transformers
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/tdammers/hpaco";
       description = "Modular template compiler library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hpage" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, cabal-macosx, containers
     , directory, eprocess, filepath, FindBin, haskell-src-exts, hint
     , hint-server, monad-loops, mtl, process, time, wx, wxcore
     }:
     mkDerivation {
       pname = "hpage";
       version = "0.12.2";
       sha256 = "129d599b5d4e766974bebb2bf4351e167e52fbaefb50252c9571ed4207c4826a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal cabal-macosx containers directory eprocess
         filepath FindBin haskell-src-exts hint hint-server monad-loops mtl
         process time wx wxcore
       ];
       jailbreak = true;
       homepage = "http://haskell.hpage.com";
       description = "A scrapbook for Haskell developers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hpapi" = callPackage
    ({ mkDerivation, base, papi }:
     mkDerivation {
       pname = "hpapi";
       version = "0.0.1.0";
       sha256 = "5abcb6a590de65be0f6db0a591ef77743fddf1321a0c2886715aa75a4db60758";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ papi ];
       description = "Binding for the PAPI library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {papi = null;};

  "hpaste" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, blaze-markup
     , bytestring, cgi, ConfigFile, containers, css, Diff, directory
     , download-curl, feed, filepath, haskell-src-exts, HJScript, hlint
     , hscolour, mime-mail, MissingH, MonadCatchIO-transformers, mtl
     , named-formlet, network, old-locale, postgresql-simple, process
     , safe, snap-app, snap-core, snap-server, text, time, transformers
     , utf8-string
     }:
     mkDerivation {
       pname = "hpaste";
       version = "1.2.0";
       sha256 = "d53ac03b69bbe3d31f328d8492ac9b27226afa4552cff02dfb2895912a760ddd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-builder blaze-html blaze-markup bytestring cgi
         ConfigFile containers css Diff directory download-curl feed
         filepath haskell-src-exts HJScript hlint hscolour mime-mail
         MissingH MonadCatchIO-transformers mtl named-formlet network
         old-locale postgresql-simple process safe snap-app snap-core
         snap-server text time transformers utf8-string
       ];
       jailbreak = true;
       homepage = "http://hpaste.org/";
       description = "Haskell paste web site";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hpasteit" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath
     , http-conduit, http-types, lifted-base, network
     , optparse-applicative, process, safe, utf8-string
     }:
     mkDerivation {
       pname = "hpasteit";
       version = "0.3.3";
       sha256 = "95abf4cfa363118ca603296e671029b146b5bdaa32393ea353562a7b5fc045ca";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory filepath http-conduit http-types
         lifted-base network optparse-applicative process safe utf8-string
       ];
       jailbreak = true;
       homepage = "http://github.com/parcs/hpasteit";
       description = "A command-line client for hpaste.org";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hpc_0_6_0_2" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, time }:
     mkDerivation {
       pname = "hpc";
       version = "0.6.0.2";
       sha256 = "95e6f1e5ccfe9e6415eec9d7bb3eccc2c113cecf2079d1f792646269ab4c0aaf";
       libraryHaskellDepends = [
         base containers directory filepath time
       ];
       description = "Code Coverage Library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hpc-coveralls_0_9_0" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, cmdargs
     , containers, curl, directory, directory-tree, hpc, HUnit, process
     , pureMD5, regex-posix, retry, safe, split
     }:
     mkDerivation {
       pname = "hpc-coveralls";
       version = "0.9.0";
       sha256 = "0601c2f7ed840df815715d00a977c20796a9fd59b0890ada8e13d539c7016a46";
       revision = "2";
       editedCabalFile = "a4efcf6cf7c8f29662298b3bf13bc43309bbce300ae3f5e445234466ab2ac59d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring cmdargs containers curl directory
         directory-tree hpc process pureMD5 retry safe split
       ];
       executableHaskellDepends = [
         aeson async base bytestring cmdargs containers curl directory
         directory-tree hpc process pureMD5 regex-posix retry safe split
       ];
       testHaskellDepends = [ base HUnit ];
       jailbreak = true;
       homepage = "https://github.com/guillaume-nargeot/hpc-coveralls";
       description = "Coveralls.io support for Haskell.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hpc-coveralls" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, Cabal, cmdargs
     , containers, curl, directory, directory-tree, hpc, HUnit, process
     , pureMD5, regex-posix, retry, safe, split, transformers
     }:
     mkDerivation {
       pname = "hpc-coveralls";
       version = "1.0.3";
       sha256 = "44eee01aa01c1e6f1b4d2d5c738d9d66b82fed99f690d529bd1d717f61297734";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring Cabal cmdargs containers curl directory
         directory-tree hpc process pureMD5 retry safe split transformers
       ];
       executableHaskellDepends = [
         aeson async base bytestring Cabal cmdargs containers curl directory
         directory-tree hpc process pureMD5 regex-posix retry safe split
         transformers
       ];
       testHaskellDepends = [ base HUnit ];
       homepage = "https://github.com/guillaume-nargeot/hpc-coveralls";
       description = "Coveralls.io support for Haskell.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hpc-strobe" = callPackage
    ({ mkDerivation, base, filepath, hpc }:
     mkDerivation {
       pname = "hpc-strobe";
       version = "0.1";
       sha256 = "ac0072560d9c663fcf199c0fd73301c0235d8e741bdfa24fac041971dc25fcb9";
       libraryHaskellDepends = [ base filepath hpc ];
       description = "Hpc-generated strobes for a running Haskell program";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hpc-tracer" = callPackage
    ({ mkDerivation, array, base, containers, haskell98, hpc, network
     , parsec, pretty, process, unix
     }:
     mkDerivation {
       pname = "hpc-tracer";
       version = "0.3.1";
       sha256 = "918e884a60d10c3e8c01f68396a14a3aa2d99800001cf111b326dd40a9f250d5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers haskell98 hpc network parsec pretty process
         unix
       ];
       description = "Tracer with AJAX interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hpdft" = callPackage
    ({ mkDerivation, base, bytestring, directory, parsec, text
     , utf8-string, zlib
     }:
     mkDerivation {
       pname = "hpdft";
       version = "0.1.0.1";
       sha256 = "eef161524fb320b84fa9183c804a08bf2a3442308f226790f5b3f9c16055b5be";
       libraryHaskellDepends = [
         base bytestring directory parsec text utf8-string zlib
       ];
       homepage = "https://github.com/k16shikano/hpdft";
       description = "tools to poke pdf using haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hplayground" = callPackage
    ({ mkDerivation, base, containers, data-default, haste-compiler
     , haste-perch, monads-tf, transformers
     }:
     mkDerivation {
       pname = "hplayground";
       version = "0.1.3.1";
       sha256 = "7b052c254d1256f7413a2c5ebf9899c8539ba6255398b30ab88a1a020089d997";
       libraryHaskellDepends = [
         base containers data-default haste-compiler haste-perch monads-tf
         transformers
       ];
       homepage = "https://github.com/agocorona/hplayground";
       description = "monadic, reactive Formlets running in the Web browser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hplaylist" = callPackage
    ({ mkDerivation, base, directory, filepath, process }:
     mkDerivation {
       pname = "hplaylist";
       version = "0.2";
       sha256 = "de3cd65835325e1872633f524d7426ace820b9727c32677e73914a8796beb307";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath process ];
       description = "Application for managing playlist files on a music player";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hpodder" = callPackage
    ({ mkDerivation, base, ConfigFile, directory, filepath, HaXml, HDBC
     , HDBC-sqlite3, hslogger, MissingH, mtl, network, old-time, parsec
     , process, unix
     }:
     mkDerivation {
       pname = "hpodder";
       version = "1.1.6";
       sha256 = "aa7128db85cb96bfb584846269fe4e0cfe612b1b5415ac87ebce753ce125293e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base ConfigFile directory filepath HaXml HDBC HDBC-sqlite3 hslogger
         MissingH mtl network old-time parsec process unix
       ];
       jailbreak = true;
       homepage = "http://software.complete.org/hpodder";
       description = "Podcast Aggregator (downloader)";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hpp" = callPackage
    ({ mkDerivation, base, directory, filepath, time, transformers }:
     mkDerivation {
       pname = "hpp";
       version = "0.3.0.0";
       sha256 = "315ae6e38a713c1ba914416cd22f271508e981c763ed52701aa71f1be262aae4";
       revision = "1";
       editedCabalFile = "5ef421d204fc6528ed11e44bb4c507fd7f25e5afc33f80b6a78275af909aa0de";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory filepath time transformers
       ];
       executableHaskellDepends = [ base directory filepath time ];
       homepage = "https://github.com/acowley/hpp";
       description = "A Haskell pre-processor";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hpqtypes" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , data-default-class, exceptions, HUnit, lifted-base, monad-control
     , mtl, postgresql, QuickCheck, random, resource-pool, scientific
     , test-framework, test-framework-hunit, text, time, transformers
     , transformers-base, unordered-containers, vector
     }:
     mkDerivation {
       pname = "hpqtypes";
       version = "1.4.4";
       sha256 = "4e1bcfc35caaa8abcee28316f8b0bdd6fadbebe223bacfb3118dec4d980fee36";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers data-default-class exceptions
         lifted-base monad-control mtl resource-pool text time transformers
         transformers-base vector
       ];
       librarySystemDepends = [ postgresql ];
       executableHaskellDepends = [
         aeson base bytestring exceptions HUnit lifted-base monad-control
         mtl QuickCheck random scientific test-framework
         test-framework-hunit text time transformers-base
         unordered-containers vector
       ];
       homepage = "https://github.com/scrive/hpqtypes";
       description = "Haskell bindings to libpqtypes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) postgresql;};

  "hprotoc_2_1_4" = callPackage
    ({ mkDerivation, alex, array, base, binary, bytestring, containers
     , directory, filepath, haskell-src-exts, mtl, parsec
     , protocol-buffers, protocol-buffers-descriptor, utf8-string
     }:
     mkDerivation {
       pname = "hprotoc";
       version = "2.1.4";
       sha256 = "124d310f0a541b2267483f05e60dc3edd65933abfc51fbe67320deaab5470405";
       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 ];
       jailbreak = true;
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hprotoc_2_1_5" = callPackage
    ({ mkDerivation, alex, array, base, binary, bytestring, containers
     , directory, filepath, haskell-src-exts, mtl, parsec
     , protocol-buffers, protocol-buffers-descriptor, utf8-string
     }:
     mkDerivation {
       pname = "hprotoc";
       version = "2.1.5";
       sha256 = "463ce252cbcf6246bb80cc30efa14580b5370e8e5c5c83debfe1b24833b52353";
       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 ];
       jailbreak = true;
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hprotoc_2_1_6" = callPackage
    ({ mkDerivation, alex, array, base, binary, bytestring, containers
     , directory, filepath, haskell-src-exts, mtl, parsec
     , protocol-buffers, protocol-buffers-descriptor, utf8-string
     }:
     mkDerivation {
       pname = "hprotoc";
       version = "2.1.6";
       sha256 = "a2eeff72064c8edae02700e76dc5b37eec5a9bb080a562ac71ea1e4ffca099ef";
       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 ];
       jailbreak = true;
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hprotoc_2_1_7" = callPackage
    ({ mkDerivation, alex, array, base, binary, bytestring, containers
     , directory, filepath, haskell-src-exts, mtl, parsec
     , protocol-buffers, protocol-buffers-descriptor, utf8-string
     }:
     mkDerivation {
       pname = "hprotoc";
       version = "2.1.7";
       sha256 = "58032d6cb20d218908949b78770bb53a130baa8287fcbbf5e85a60dbb73fad86";
       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 ];
       jailbreak = true;
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hprotoc_2_1_9" = callPackage
    ({ mkDerivation, alex, array, base, binary, bytestring, containers
     , directory, filepath, haskell-src-exts, mtl, parsec
     , protocol-buffers, protocol-buffers-descriptor, utf8-string
     }:
     mkDerivation {
       pname = "hprotoc";
       version = "2.1.9";
       sha256 = "70961b74f932e7f6a4615eb5ae39e9d72db1b53ec33998dc66b053f2c09a6bf5";
       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 ];
       jailbreak = true;
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hprotoc" = callPackage
    ({ mkDerivation, alex, array, base, binary, bytestring, containers
     , directory, filepath, haskell-src-exts, mtl, parsec
     , protocol-buffers, protocol-buffers-descriptor, utf8-string
     }:
     mkDerivation {
       pname = "hprotoc";
       version = "2.1.12";
       sha256 = "c99c4ceb0a8dad2186c5e2af16898eed5a16d8646052d2fa8c4f29ee39ee1add";
       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 ];
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hprotoc_2_2_0" = callPackage
    ({ mkDerivation, alex, array, base, binary, bytestring, containers
     , directory, filepath, haskell-src-exts, mtl, parsec
     , protocol-buffers, protocol-buffers-descriptor, utf8-string
     }:
     mkDerivation {
       pname = "hprotoc";
       version = "2.2.0";
       sha256 = "12461b7b11b90486f7b40cd21d3839f089695341e090eeac3a6fb85e715b50be";
       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 ];
       jailbreak = true;
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hprotoc-fork" = callPackage
    ({ mkDerivation, alex, array, base, binary, bytestring, containers
     , directory, filepath, haskell-src-exts, mtl, parsec
     , protocol-buffers-descriptor-fork, protocol-buffers-fork
     , utf8-string
     }:
     mkDerivation {
       pname = "hprotoc-fork";
       version = "2.0.16.1";
       sha256 = "3971dc76b9e6ea2a281d00e648b46454230f3b9e2d0065e3f8c63056496c77b9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers directory filepath
         haskell-src-exts mtl parsec protocol-buffers-descriptor-fork
         protocol-buffers-fork utf8-string
       ];
       libraryToolDepends = [ alex ];
       executableHaskellDepends = [
         array base binary bytestring containers directory filepath
         haskell-src-exts mtl parsec protocol-buffers-descriptor-fork
         protocol-buffers-fork utf8-string
       ];
       executableToolDepends = [ alex ];
       jailbreak = true;
       homepage = "http://darcs.factisresearch.com/pub/protocol-buffers-fork/";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hps" = callPackage
    ({ mkDerivation, base, directory, filepath, hcg-minus, random }:
     mkDerivation {
       pname = "hps";
       version = "0.15";
       sha256 = "30df792e10ce0a2d2886ce5b6b081e95640cc00d02d9f2aa6426e7919eccb54e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base hcg-minus ];
       executableHaskellDepends = [
         base directory filepath hcg-minus random
       ];
       homepage = "http://rd.slavepianos.org/?t=hps";
       description = "Haskell Postscript";
       license = "GPL";
     }) {};

  "hps-cairo" = callPackage
    ({ mkDerivation, base, cairo, gtk, hps, random }:
     mkDerivation {
       pname = "hps-cairo";
       version = "0.11";
       sha256 = "e741e016ad94279108e11fbc1977f6d5b145b49506d599086a98e1880d06d3f7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base cairo gtk hps ];
       executableHaskellDepends = [ base cairo gtk hps random ];
       jailbreak = true;
       homepage = "http://slavepianos.org/rd/?t=hps-cairo";
       description = "Cairo rendering for the haskell postscript library";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hps-kmeans" = callPackage
    ({ mkDerivation, base, vector }:
     mkDerivation {
       pname = "hps-kmeans";
       version = "0.1.0.0";
       sha256 = "cc21a972364cb294bffe0365014a79fd490369984412044c00d19d4976f63e70";
       libraryHaskellDepends = [ base vector ];
       jailbreak = true;
       homepage = "http://stathacking.com/hps-kmeans";
       description = "A nice implementation of the k-Means algorithm";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "hpuz" = callPackage
    ({ mkDerivation, array, base, bytestring, c2hs, parsec }:
     mkDerivation {
       pname = "hpuz";
       version = "1.1.2";
       sha256 = "13e6c357228dabab1414da694476c873811d7537f5fe8fc14ff6c6c156836912";
       libraryHaskellDepends = [ array base bytestring parsec ];
       libraryToolDepends = [ c2hs ];
       homepage = "https://github.com/ccasin/hpuz";
       description = "Haskell bindings for libpuz";
       license = "unknown";
     }) {};

  "hpygments" = callPackage
    ({ mkDerivation, aeson, base, bytestring, process, process-extras
     }:
     mkDerivation {
       pname = "hpygments";
       version = "0.2.0";
       sha256 = "92c55c9217b261fd9bbd041acc0907234740c49e3b304d31ea54c64df5dc2c38";
       libraryHaskellDepends = [
         aeson base bytestring process process-extras
       ];
       jailbreak = true;
       homepage = "https://github.com/davidlazar/hpygments";
       description = "Highlight source code using Pygments";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hpylos" = callPackage
    ({ mkDerivation, array, base, containers, EEConfig, GLUT, OpenGL }:
     mkDerivation {
       pname = "hpylos";
       version = "1.0";
       sha256 = "0af208f05e222bb1a4b150f832c9cd3535ed24f8d3669693fc83bc357af2b7ed";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers EEConfig GLUT OpenGL
       ];
       homepage = "http://sourceforge.net/projects/hpylos/";
       description = "AI of Pylos game with GLUT interface";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hpyrg" = callPackage
    ({ mkDerivation, base, lens, optparse-applicative, parsec, text }:
     mkDerivation {
       pname = "hpyrg";
       version = "0.1.0.0";
       sha256 = "5c6f97a6eeb7afeb0b117209de76c72ea4d4d3d05462a2079cf8806e7ff4ad01";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base lens optparse-applicative parsec text
       ];
       description = "pyrg utility done right";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hquantlib" = callPackage
    ({ mkDerivation, base, containers, hmatrix, hmatrix-gsl
     , hmatrix-special, HUnit, mersenne-random, parallel, QuickCheck
     , statistics, test-framework, test-framework-hunit
     , test-framework-quickcheck2, time, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "hquantlib";
       version = "0.0.2.5";
       sha256 = "6063f698be72203b6d9517756098169af3e5a3d45d229ad1d88f2105979004d9";
       libraryHaskellDepends = [
         base containers hmatrix hmatrix-gsl hmatrix-special mersenne-random
         parallel statistics time vector vector-algorithms
       ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/paulrzcz/hquantlib.git";
       description = "HQuantLib is a port of essencial parts of QuantLib to Haskell";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hquery" = callPackage
    ({ mkDerivation, base, bytestring, containers, filepath, HUnit
     , parsec, test-framework, test-framework-hunit, text, xmlhtml
     }:
     mkDerivation {
       pname = "hquery";
       version = "0.1.1.0";
       sha256 = "c849769d0b233f8cde0a447664b126dff40eb242cc92259b2d86bb38f75a145e";
       libraryHaskellDepends = [ base containers parsec text xmlhtml ];
       testHaskellDepends = [
         base bytestring filepath HUnit parsec test-framework
         test-framework-hunit text xmlhtml
       ];
       description = "A query language for transforming HTML5";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hranker" = callPackage
    ({ mkDerivation, base, HCL, NonEmpty }:
     mkDerivation {
       pname = "hranker";
       version = "0.1.1";
       sha256 = "ed7c9e82263619844cf5971a91023c7fac8df368230b3484e996dd92a5c4e241";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base HCL NonEmpty ];
       description = "Basic utility for ranking a list of items";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hreader" = callPackage
    ({ mkDerivation, base, exceptions, hset, mmorph, monad-control, mtl
     , tagged, transformers-base
     }:
     mkDerivation {
       pname = "hreader";
       version = "1.0.2";
       sha256 = "49e1e805966fab3f82ef2e1f2565b2a760b73026f392410b53df6c2c8b8f59d4";
       libraryHaskellDepends = [
         base exceptions hset mmorph monad-control mtl tagged
         transformers-base
       ];
       testHaskellDepends = [ base hset transformers-base ];
       homepage = "https://bitbucket.org/s9gf4ult/hreader";
       description = "Generalization of MonadReader and ReaderT using hset";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hricket" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "hricket";
       version = "0.5";
       sha256 = "ee901dde72538136de81f0e0613ffb5db2a75de4fb2f79c4826cc499014f17fe";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers ];
       jailbreak = true;
       homepage = "http://github.com/Raynes/Hricket";
       description = "A Cricket scoring application";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hruby" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, QuickCheck
     , ruby, scientific, stm, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "hruby";
       version = "0.3.2";
       sha256 = "bac4446634deb4acb91217b016c2be04dc8006df7ba4245c2c03dd686bf64fd8";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring scientific stm text
         unordered-containers vector
       ];
       librarySystemDepends = [ ruby ];
       testHaskellDepends = [
         aeson attoparsec base QuickCheck text vector
       ];
       description = "Embed a Ruby intepreter in your Haskell program !";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {inherit (pkgs) ruby;};

  "hs-GeoIP" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, GeoIP }:
     mkDerivation {
       pname = "hs-GeoIP";
       version = "0.3";
       sha256 = "8e5ff6a132d8944336f10dcaa69d8852cdd7953a5ff18248ae06cb2819a1ab8c";
       libraryHaskellDepends = [ base bytestring deepseq ];
       librarySystemDepends = [ GeoIP ];
       homepage = "http://github.com/ozataman/hs-GeoIP";
       description = "Haskell bindings to the MaxMind GeoIPCity database via the C library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {GeoIP = null;};

  "hs-bibutils_5_0" = callPackage
    ({ mkDerivation, base, syb }:
     mkDerivation {
       pname = "hs-bibutils";
       version = "5.0";
       sha256 = "54403646b4530649e9a48b01f0d23818566d62691c651ba4ff9889278c85eca1";
       libraryHaskellDepends = [ base syb ];
       homepage = "http://gorgias.mine.nu/repos/hs-bibutils/";
       description = "Haskell bindings to bibutils, the bibliography conversion utilities";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs-bibutils" = callPackage
    ({ mkDerivation, base, syb }:
     mkDerivation {
       pname = "hs-bibutils";
       version = "5.5";
       sha256 = "95f9f34be9f3145da8acc8a0e9de379236cfe31c5a9bc0eb9489e77402a4c55d";
       libraryHaskellDepends = [ base syb ];
       homepage = "http://istitutocolli.org/repos/hs-bibutils/";
       description = "Haskell bindings to bibutils, the bibliography conversion utilities";
       license = "GPL";
     }) {};

  "hs-blake2" = callPackage
    ({ mkDerivation, b2, base, bytestring, bytestring-arbitrary
     , QuickCheck, tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "hs-blake2";
       version = "0.0.2";
       sha256 = "043efd374194998f4ea54a3e43713fb6a2c6f233673eb0deadf8950f22c31e44";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ b2 ];
       testHaskellDepends = [
         base bytestring bytestring-arbitrary QuickCheck tasty
         tasty-quickcheck
       ];
       testSystemDepends = [ b2 ];
       jailbreak = true;
       homepage = "https://github.com/tsuraan/hs-blake2";
       description = "A cryptohash-inspired library for blake2";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) b2;};

  "hs-captcha" = callPackage
    ({ mkDerivation, base, bytestring, gd, random }:
     mkDerivation {
       pname = "hs-captcha";
       version = "1.0";
       sha256 = "c8eab698e6e32221b2f77c99f823fe9ee4b636ae115da0bb0ca05a14e93cad09";
       libraryHaskellDepends = [ base bytestring gd random ];
       homepage = "http://www.dankna.com/software/";
       description = "Generate images suitable for use as CAPTCHAs in online web-form security";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hs-carbon" = callPackage
    ({ mkDerivation, base, deepseq, HUnit, mtl, parallel, random }:
     mkDerivation {
       pname = "hs-carbon";
       version = "0.1.1.0";
       sha256 = "a360d5ec2f060681bdfd4232830e71a34463c0bd2f2ee4089b6df75d30b9313b";
       libraryHaskellDepends = [ base deepseq mtl parallel random ];
       testHaskellDepends = [ base HUnit ];
       description = "A Haskell framework for parallel monte carlo simulations";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hs-carbon-examples" = callPackage
    ({ mkDerivation, base, deepseq, gloss, hs-carbon, monad-loops, mtl
     , tf-random
     }:
     mkDerivation {
       pname = "hs-carbon-examples";
       version = "0.0.0.1";
       sha256 = "5f307372920791a5211effd6ee1904256b472ba5ab6cdb27253e7faac7378fc1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base deepseq gloss hs-carbon monad-loops mtl tf-random
       ];
       description = "Example Monte Carlo simulations implemented with Carbon";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs-cdb" = callPackage
    ({ mkDerivation, array, base, bytestring, bytestring-mmap
     , directory, filepath, mtl
     }:
     mkDerivation {
       pname = "hs-cdb";
       version = "0.1.1";
       sha256 = "80fe9453431fedf4d075a1b663f51c42c9d61a91b53ba89252f8cc5acbf8f31e";
       libraryHaskellDepends = [
         array base bytestring bytestring-mmap directory filepath mtl
       ];
       homepage = "http://github.com/adamsmasher/hs-cdb";
       description = "A library for reading CDB (Constant Database) files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs-dotnet" = callPackage
    ({ mkDerivation, base, ghc-prim, ole32, oleaut32 }:
     mkDerivation {
       pname = "hs-dotnet";
       version = "0.4.0";
       sha256 = "a790c77a525cb2217df6c5f97516514564f1f6b0ca4afa009a45b061f60f50d0";
       libraryHaskellDepends = [ base ghc-prim ];
       librarySystemDepends = [ ole32 oleaut32 ];
       description = "Pragmatic .NET interop for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {ole32 = null; oleaut32 = null;};

  "hs-duktape" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, bytestring, hspec
     , hspec-expectations-pretty-diff, raw-strings-qq, template-haskell
     , text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "hs-duktape";
       version = "0.1.1";
       sha256 = "0fa193ba3ccd8e603fecf91624a2e02762f5f959370bfea829aecd245f4be906";
       libraryHaskellDepends = [
         aeson base bytestring text transformers unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-qq base bytestring hspec hspec-expectations-pretty-diff
         raw-strings-qq template-haskell text
       ];
       homepage = "https://github.com/myfreeweb/hs-duktape";
       description = "Haskell bindings for a very compact embedded ECMAScript (JavaScript) engine";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs-excelx" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, text, time
     , xml-conduit, zip-archive
     }:
     mkDerivation {
       pname = "hs-excelx";
       version = "0.6.0.0";
       sha256 = "850ed56a4d92ad05db4616fa7ce3b2a6db08024f469856434099588e9a72178a";
       libraryHaskellDepends = [
         base bytestring containers mtl text time xml-conduit zip-archive
       ];
       jailbreak = true;
       description = "HS-Excelx provides basic read-only access to Excel 2007 and 2010 documents in XLSX format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hs-ffmpeg" = callPackage
    ({ mkDerivation, base, bytestring, haskell98 }:
     mkDerivation {
       pname = "hs-ffmpeg";
       version = "0.3.4";
       sha256 = "a1607f5db460afca8c8d5af25eb50da15b29f7d6ad63f7ecd3daac3b5a6ea248";
       libraryHaskellDepends = [ base bytestring haskell98 ];
       jailbreak = true;
       homepage = "http://patch-tag.com/r/VasylPasternak/hs-ffmpeg";
       description = "Bindings to FFMPEG library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs-fltk" = callPackage
    ({ mkDerivation, base, fltk, fltk_images }:
     mkDerivation {
       pname = "hs-fltk";
       version = "0.2.5";
       sha256 = "fde3fd46ae27c8f0f3ce3ca9d51f284482094f8e239bd08e98e0d71484777d59";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ fltk fltk_images ];
       homepage = "http://www.cs.helsinki.fi/u/ekarttun/hs-fltk/";
       description = "Binding to GUI library FLTK";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {fltk = null; fltk_images = null;};

  "hs-gchart" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "hs-gchart";
       version = "0.4.1";
       sha256 = "a9905eb488ba0032d4f8c550a28de0ee93ae3eb18cc215caee2de2f9db9bbe5a";
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://github.com/deepakjois/hs-gchart";
       description = "Haskell wrapper for the Google Chart API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs-gen-iface" = callPackage
    ({ mkDerivation, base, Cabal, containers, filepath, haskell-names
     , haskell-packages, haskell-src-exts, hse-cpp, mtl, tagged
     }:
     mkDerivation {
       pname = "hs-gen-iface";
       version = "0.5.0";
       sha256 = "9acf324e7610af9440a9e4a65a3fd291b51246f3240888bd77aeccfb8fbd7fd7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers filepath haskell-names haskell-packages
         haskell-src-exts hse-cpp mtl tagged
       ];
       description = "Utility to generate haskell-names interface files";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs-gizapp" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, parsec
     , process
     }:
     mkDerivation {
       pname = "hs-gizapp";
       version = "0.1.0.3";
       sha256 = "95e9b95af8b680a110e14592cfee0a2725c081996210042e08c98a52e5d0fcc8";
       libraryHaskellDepends = [
         base containers directory filepath parsec process
       ];
       jailbreak = true;
       description = "Haskell wrapper around the GIZA++ toolkit";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hs-inspector" = callPackage
    ({ mkDerivation, base, haskell-src, hspec }:
     mkDerivation {
       pname = "hs-inspector";
       version = "0.5.2.0";
       sha256 = "c85b9792dde90be15eddedcf8737e0704e40cecb7b839f95e9f6816d0a953171";
       libraryHaskellDepends = [ base haskell-src ];
       testHaskellDepends = [ base haskell-src hspec ];
       description = "Haskell source code analyzer";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hs-java" = callPackage
    ({ mkDerivation, array, base, binary, binary-state, bytestring
     , containers, control-monad-exception, data-binary-ieee754
     , data-default, directory, filepath, Glob, LibZip, MissingH, mtl
     , parsec, utf8-string
     }:
     mkDerivation {
       pname = "hs-java";
       version = "0.3.4";
       sha256 = "07ffa9e97e200af838c27a137e5d2f0240bd38772a35018ad14973972eff66e3";
       libraryHaskellDepends = [
         array base binary binary-state bytestring containers
         control-monad-exception data-binary-ieee754 data-default directory
         filepath Glob LibZip MissingH mtl parsec utf8-string
       ];
       description = "Java .class files assembler/disassembler";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs-json-rpc" = callPackage
    ({ mkDerivation, aeson, base, bytestring, HTTP, network, text }:
     mkDerivation {
       pname = "hs-json-rpc";
       version = "0.0.0.1";
       sha256 = "6cc85a11e851c13c1e0c2a0981a094c9bc0b58e515b57be05e60317a27f59f62";
       libraryHaskellDepends = [
         aeson base bytestring HTTP network text
       ];
       homepage = "http://patch-tag.com/r/Azel/hs-json-rpc";
       description = "JSON-RPC client library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs-logo" = callPackage
    ({ mkDerivation, base, cmdargs, colour, containers, diagrams-core
     , diagrams-lib, diagrams-svg, HUnit, mtl, parsec, parsec-numbers
     , QuickCheck, random, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "hs-logo";
       version = "0.5.1";
       sha256 = "2344114e3b463c6e274854f25a91b6a07de9815c50e9375e38c789c0ae24f97a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs colour containers diagrams-core diagrams-lib
         diagrams-svg mtl parsec parsec-numbers random
       ];
       testHaskellDepends = [
         base cmdargs colour containers diagrams-core diagrams-lib
         diagrams-svg HUnit mtl parsec parsec-numbers QuickCheck random
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://deepakjois.github.com/hs-logo";
       description = "Logo interpreter written in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs-mesos" = callPackage
    ({ mkDerivation, base, bytestring, lens, managed, mesos, protobuf
     , QuickCheck, tasty, tasty-hunit, tasty-quickcheck
     , template-haskell
     }:
     mkDerivation {
       pname = "hs-mesos";
       version = "0.20.3.0";
       sha256 = "b095ec5641e2819926e4324539bcbbd3c1c859cee5ec424bb697db12cb7035b5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring lens managed template-haskell
       ];
       librarySystemDepends = [ mesos protobuf ];
       executableHaskellDepends = [ base bytestring lens ];
       executableSystemDepends = [ mesos ];
       testHaskellDepends = [
         base bytestring lens managed QuickCheck tasty tasty-hunit
         tasty-quickcheck
       ];
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mesos; inherit (pkgs) protobuf;};

  "hs-nombre-generator" = callPackage
    ({ mkDerivation, base, HandsomeSoup, hxt, random }:
     mkDerivation {
       pname = "hs-nombre-generator";
       version = "0.2.1.0";
       sha256 = "9c3cf49fdd13b07c11cc3406486863b0ccf48c8067ad8a18c368ae122d3a62ae";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base HandsomeSoup hxt random ];
       jailbreak = true;
       description = "Name generator";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs-pgms" = callPackage
    ({ mkDerivation, array, base, directory, glib, gtk, MonadPrompt
     , mtl, random
     }:
     mkDerivation {
       pname = "hs-pgms";
       version = "0.1.0.1";
       sha256 = "6070cadc719ce83ce68cd497c069f35c85672c1ee0750701aa78fe8a1e989a18";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base MonadPrompt mtl random ];
       executableHaskellDepends = [
         array base directory glib gtk MonadPrompt mtl random
       ];
       description = "Programmer's Mine Sweeper in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs-php-session" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "hs-php-session";
       version = "0.0.9.3";
       sha256 = "0e717e90933f9e861d9cf374baa0dedac51d8ae7a1746ef2f7bd098fe38c8df7";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "https://github.com/elblake/hs-php-session";
       description = "PHP session and values serialization";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hs-pkg-config" = callPackage
    ({ mkDerivation, base, data-default-class, text }:
     mkDerivation {
       pname = "hs-pkg-config";
       version = "0.2.1.0";
       sha256 = "104e39324e9ece701a21bf3f428b5d0382fd8f426b65b4ef1f54ab41cc9d6227";
       revision = "1";
       editedCabalFile = "9337acf593d6f7e1d54f81886cb3736001a127e3b75ba01bd97a99d77565f784";
       libraryHaskellDepends = [ base data-default-class text ];
       homepage = "https://github.com/trskop/hs-pkg-config";
       description = "Create pkg-config configuration files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hs-pkpass" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, conduit
     , directory, filesystem-conduit, old-locale, random
     , shakespeare-text, shelly, system-filepath, text, time
     , transformers, unordered-containers, uuid, zip-archive
     }:
     mkDerivation {
       pname = "hs-pkpass";
       version = "0.4";
       sha256 = "ae16f7a94c6e6284107c959684bea153fbde98a9fd7ee5cb7b495ca4a2a04c06";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring conduit directory
         filesystem-conduit old-locale random shakespeare-text shelly
         system-filepath text time transformers unordered-containers uuid
         zip-archive
       ];
       jailbreak = true;
       homepage = "https://github.com/tazjin/hs-pkpass";
       description = "A library for Passbook pass creation & signing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs-re" = callPackage
    ({ mkDerivation, array, base, regex-base, regex-posix }:
     mkDerivation {
       pname = "hs-re";
       version = "0.1.0";
       sha256 = "6bf143a1d791e34af15c80210073465446dbf1f453ff5d414833452f1dd4a767";
       libraryHaskellDepends = [ array base regex-base regex-posix ];
       jailbreak = true;
       description = "Easy to use Regex";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hs-scrape" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default
     , exceptions, hspec, html-conduit, lens, retry, safe, tasty
     , tasty-hunit, text, transformers, url, wreq, xml-conduit
     }:
     mkDerivation {
       pname = "hs-scrape";
       version = "0.1.0.0";
       sha256 = "dbf8b3f9d74708510bd6327efa86d7488a38830402eb363be18c0dd94fcbbf70";
       libraryHaskellDepends = [
         base bytestring containers data-default exceptions hspec
         html-conduit lens retry safe text transformers url wreq xml-conduit
       ];
       testHaskellDepends = [
         base containers hspec tasty tasty-hunit xml-conduit
       ];
       jailbreak = true;
       homepage = "https://github.com/codygman/hs-scrape/";
       description = "Simple and easy web scraping and automation in Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hs-twitter" = callPackage
    ({ mkDerivation, base, HTTP, json, mime, network, old-locale
     , old-time, random, utf8-string
     }:
     mkDerivation {
       pname = "hs-twitter";
       version = "0.2.8";
       sha256 = "f056b212006bcd5dc14ead931356fc7c94d17db8b78a004cabbd967670690be5";
       libraryHaskellDepends = [
         base HTTP json mime network old-locale old-time random utf8-string
       ];
       description = "Haskell binding to the Twitter API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs-twitterarchiver" = callPackage
    ({ mkDerivation, base, HTTP, json, mtl, network, pretty }:
     mkDerivation {
       pname = "hs-twitterarchiver";
       version = "0.2";
       sha256 = "8f6158df101b35ecfef31bf8095b66421b594fc400d59b841edd38611b62f51c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base HTTP json mtl network pretty ];
       homepage = "https://github.com/deepakjois/hs-twitterarchiver";
       description = "Commandline Twitter feed archiver";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs-vcard" = callPackage
    ({ mkDerivation, base, old-locale, time }:
     mkDerivation {
       pname = "hs-vcard";
       version = "0.1";
       sha256 = "25fc5cebe2008015768b3b5d6185307b13d36d3644a6db5bc3918d38977e6761";
       libraryHaskellDepends = [ base old-locale time ];
       homepage = "http://qrcard.us/";
       description = "Implements the RFC 2426 vCard 3.0 spec";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs2048" = callPackage
    ({ mkDerivation, base, doctest, Glob, hlint, hspec, HUnit, process
     , QuickCheck, random, regex-compat
     }:
     mkDerivation {
       pname = "hs2048";
       version = "0.1.0";
       sha256 = "faceda8c73f3f5e977ef4edcea339399ea639ee151fc411f0111ad8021a7a9c2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base random ];
       executableHaskellDepends = [ base random ];
       testHaskellDepends = [
         base doctest Glob hlint hspec HUnit process QuickCheck random
         regex-compat
       ];
       jailbreak = true;
       homepage = "https://github.com/tfausak/hs2048";
       description = "A 2048 clone in Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hs2bf" = callPackage
    ({ mkDerivation, array, base, containers, directory, filepath
     , haskell-src, mtl
     }:
     mkDerivation {
       pname = "hs2bf";
       version = "0.6.2";
       sha256 = "95ba3fa0b17bdd9efc8a8203611c11174aada4f9fff14c62f199b3f840bfa0d3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory filepath haskell-src mtl
       ];
       homepage = "http://www.xanxys.net/hs2bf/";
       description = "Haskell to Brainfuck compiler";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hs2dot" = callPackage
    ({ mkDerivation, base, directory, haskell-src, haskell-src-exts
     , haskell98, split
     }:
     mkDerivation {
       pname = "hs2dot";
       version = "0.1.4";
       sha256 = "fd2a874e3fa254235bbaaf8ceb5afa2360714447180ca3b7ed96367b3165cb5d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory haskell-src haskell-src-exts haskell98 split
       ];
       jailbreak = true;
       homepage = "http://www.github.com/finnsson/hs2graphviz";
       description = "Generate graphviz-code from Haskell-code";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsConfigure" = callPackage
    ({ mkDerivation, base, directory, filepath, process, unix }:
     mkDerivation {
       pname = "hsConfigure";
       version = "0.1.0.2";
       sha256 = "6cf0e57e4b7c9bdfcb1a9d6c88cc0d35402ec10a242cef0d01a50d2885fa3aa5";
       revision = "2";
       editedCabalFile = "ab3264ebf799e07e40fd913b9061197b346a7d84145908566155231e62a45c02";
       libraryHaskellDepends = [ base directory filepath process unix ];
       homepage = "http://github.com/YoshikuniJujo/hsConfigure/wiki";
       description = "By using this package, you can make application configurable";
       license = "LGPL";
     }) {};

  "hsSqlite3" = callPackage
    ({ mkDerivation, base, bindings-sqlite3, bytestring, mtl
     , utf8-string
     }:
     mkDerivation {
       pname = "hsSqlite3";
       version = "0.1";
       sha256 = "ca7c9828c37c4f452063147edf3a1347f9f5afd21c5cf547fbe233ce18d7ba72";
       libraryHaskellDepends = [
         base bindings-sqlite3 bytestring mtl utf8-string
       ];
       jailbreak = true;
       description = "Sqlite3 bindings";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsXenCtrl" = callPackage
    ({ mkDerivation, array, base, bytestring, dlist, mtl, xenctrl }:
     mkDerivation {
       pname = "hsXenCtrl";
       version = "0.2.0";
       sha256 = "379faf489cf541d64ec6938d04e8449046bbf168c2c48d748980a53b99a7b57f";
       libraryHaskellDepends = [ array base bytestring dlist mtl ];
       librarySystemDepends = [ xenctrl ];
       jailbreak = true;
       homepage = "http://haskell.org/haskellwiki/HsXenCtrl";
       description = "FFI bindings to the Xen Control library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {xenctrl = null;};

  "hsass_0_3_0" = callPackage
    ({ mkDerivation, base, bytestring, data-default-class, filepath
     , hlibsass, hspec, hspec-discover, monad-loops, temporary
     , transformers
     }:
     mkDerivation {
       pname = "hsass";
       version = "0.3.0";
       sha256 = "aed53b65af089a08c41414f2d724b9af5127f113ab4c0d025ce1cdc83e72a597";
       libraryHaskellDepends = [
         base bytestring data-default-class filepath hlibsass monad-loops
         transformers
       ];
       testHaskellDepends = [
         base bytestring data-default-class hspec hspec-discover temporary
       ];
       homepage = "https://github.com/jakubfijalkowski/hsass";
       description = "Integrating Sass into Haskell applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsass" = callPackage
    ({ mkDerivation, base, bytestring, data-default-class, filepath
     , hlibsass, hspec, hspec-discover, monad-loops, temporary
     , transformers
     }:
     mkDerivation {
       pname = "hsass";
       version = "0.4.0";
       sha256 = "512faf0e01e720395699066139379fb2e5e5f456f465c72d58282b75b6ec0f9d";
       libraryHaskellDepends = [
         base bytestring data-default-class filepath hlibsass monad-loops
         transformers
       ];
       testHaskellDepends = [
         base bytestring data-default-class hspec hspec-discover temporary
       ];
       homepage = "https://github.com/jakubfijalkowski/hsass";
       description = "Integrating Sass into Haskell applications";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hsay" = callPackage
    ({ mkDerivation, base, Hclip, HTTP, process, unix }:
     mkDerivation {
       pname = "hsay";
       version = "1.1.0";
       sha256 = "34ef6fd63f7b35eef1357160c1ae1e07fe8ebbd2a8ff2a87d9ae8114883f5961";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base Hclip HTTP process unix ];
       jailbreak = true;
       description = "(ab)Use Google Translate as a speech synthesiser";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "hsb2hs" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , preprocessor-tools
     }:
     mkDerivation {
       pname = "hsb2hs";
       version = "0.3.1";
       sha256 = "8ad800820554f273ada083dfce2f463d920fb1ceb053255023a4c883b090f9d8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory filepath preprocessor-tools
       ];
       description = "Preprocesses a file, adding blobs from files as string literals";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsbackup" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, directory, filepath
     , hashed-storage, old-locale, strict, time
     }:
     mkDerivation {
       pname = "hsbackup";
       version = "0.1.1";
       sha256 = "bf9472ba5168f346bd87243d7b25aab45b4177b2c4b456a52bb5b1e3065934bc";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs directory filepath hashed-storage
         old-locale strict time
       ];
       description = "simple utility for rolling filesystem backups";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsbencher" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, data-default
     , directory, filepath, GenericPretty, HUnit, io-streams, mtl
     , process, random, test-framework, test-framework-hunit, text, time
     , unix
     }:
     mkDerivation {
       pname = "hsbencher";
       version = "1.20.0.5";
       sha256 = "30f94d5d1fd68cfbe814571786dee348d3aa6607463973c78cd83603820517bb";
       libraryHaskellDepends = [
         async base bytestring containers data-default directory filepath
         GenericPretty io-streams mtl process random time unix
       ];
       testHaskellDepends = [
         base bytestring containers directory HUnit test-framework
         test-framework-hunit text time
       ];
       description = "Launch and gather data from Haskell and non-Haskell benchmarks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsbencher-codespeed" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default
     , directory, filepath, hsbencher, HTTP, http-conduit, http-types
     , json, mtl, network, resourcet, time
     }:
     mkDerivation {
       pname = "hsbencher-codespeed";
       version = "0.1.0.1";
       sha256 = "85a228b4f7e5317c2034d6f50baf08758c1944806df5b08ac0a0fd3a0e5370a8";
       libraryHaskellDepends = [
         base bytestring containers data-default directory filepath
         hsbencher HTTP http-conduit http-types json mtl network resourcet
         time
       ];
       description = "Backend for uploading benchmark data to CodeSpeed";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsbencher-fusion" = callPackage
    ({ mkDerivation, base, bytestring, containers, criterion, csv
     , data-default, directory, filepath, handa-gdata, hsbencher
     , http-conduit, mtl, network, split, statistics, text, time
     }:
     mkDerivation {
       pname = "hsbencher-fusion";
       version = "0.3.15.2";
       sha256 = "994c15a8b1231964e96f43abb435701556094f834c455bc5d7a5e7fd4b95e276";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers data-default directory filepath
         handa-gdata hsbencher http-conduit mtl network time
       ];
       executableHaskellDepends = [
         base bytestring containers criterion csv handa-gdata hsbencher mtl
         split statistics text
       ];
       description = "Backend for uploading benchmark data to Google Fusion Tables";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsc2hs" = callPackage
    ({ mkDerivation, base, containers, directory, process }:
     mkDerivation {
       pname = "hsc2hs";
       version = "0.67.20120610";
       sha256 = "7f471d3912fd8432a5940e3dde0e92abf6743adb452d5c2ff79dea7795bedb4d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers directory process ];
       jailbreak = true;
       description = "A preprocessor that helps with writing Haskell bindings to C code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsc3" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, data-default
     , data-ordlist, directory, filepath, hashable, hosc, network
     , process, random, safe, split, transformers
     }:
     mkDerivation {
       pname = "hsc3";
       version = "0.15.1";
       sha256 = "0aae1ad15dd2698e7b035ce512b9963364fa668ccac66c4aa1670b8433c1a5a9";
       libraryHaskellDepends = [
         base binary bytestring containers data-default data-ordlist
         directory filepath hashable hosc network process random safe split
         transformers
       ];
       homepage = "http://rd.slavepianos.org/t/hsc3";
       description = "Haskell SuperCollider";
       license = "GPL";
     }) {};

  "hsc3-auditor" = callPackage
    ({ mkDerivation, base, filepath, hmt, hosc, hsc3, hsc3-sf-hsndfile
     }:
     mkDerivation {
       pname = "hsc3-auditor";
       version = "0.15";
       sha256 = "c39410b6a2512cc4f315296924bae559cfaf8919a2d0bd72fbb122700df0e40a";
       libraryHaskellDepends = [
         base filepath hmt hosc hsc3 hsc3-sf-hsndfile
       ];
       homepage = "http://rd.slavepianos.org/t/hsc3-auditor";
       description = "Haskell SuperCollider Auditor";
       license = "GPL";
     }) {};

  "hsc3-cairo" = callPackage
    ({ mkDerivation, base, cairo, gtk, hosc, hsc3, split }:
     mkDerivation {
       pname = "hsc3-cairo";
       version = "0.14";
       sha256 = "3ad66f4f8d17dda98ab3cdf762aa3930aeaf82fba2db70d78bc74fada5abc2b8";
       libraryHaskellDepends = [ base cairo gtk hosc hsc3 split ];
       jailbreak = true;
       homepage = "http://rd.slavepianos.org/?t=hsc3-cairo";
       description = "haskell supercollider cairo drawing";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsc3-data" = callPackage
    ({ mkDerivation, base, bifunctors, Glob, hcg-minus, hmt, hsc3-lang
     , hsc3-plot, hsc3-sf-hsndfile, safe, split, SVGPath, xml
     }:
     mkDerivation {
       pname = "hsc3-data";
       version = "0.15";
       sha256 = "ed2072aaa1ea34aa95a5ee6819d8f4d74341508de8687b396f94472795cd410c";
       libraryHaskellDepends = [
         base bifunctors Glob hcg-minus hmt hsc3-lang hsc3-plot
         hsc3-sf-hsndfile safe split SVGPath xml
       ];
       homepage = "http://rd.slavepianos.org/t/hsc3-data";
       description = "haskell supercollider data";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsc3-db" = callPackage
    ({ mkDerivation, base, hsc3, safe }:
     mkDerivation {
       pname = "hsc3-db";
       version = "0.15";
       sha256 = "747d622739ff652fa2478f8ee0cd1d483c8d4ef69b96639da98436d40086436a";
       libraryHaskellDepends = [ base hsc3 safe ];
       homepage = "http://rd.slavepianos.org/t/hsc3-db";
       description = "Haskell SuperCollider Unit Generator Database";
       license = "GPL";
     }) {};

  "hsc3-dot" = callPackage
    ({ mkDerivation, base, directory, filepath, hsc3, process }:
     mkDerivation {
       pname = "hsc3-dot";
       version = "0.15";
       sha256 = "15a4fa74e42db672219c23ef3eb7dda7588a548bc9ee1e7cae7a08fe4b7862b2";
       libraryHaskellDepends = [ base directory filepath hsc3 process ];
       homepage = "http://rd.slavepianos.org/t/hsc3-dot";
       description = "haskell supercollider graph drawing";
       license = "GPL";
     }) {};

  "hsc3-forth" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, hashable
     , hosc, hsc3, hsc3-db, hsc3-dot, mtl, unix
     }:
     mkDerivation {
       pname = "hsc3-forth";
       version = "0.15";
       sha256 = "9c22fa0d9da9e9667b9f355604ecd1a24f9a6f9e35ab02a80b9b8b900337782c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath hashable hosc hsc3 hsc3-db
         hsc3-dot mtl unix
       ];
       homepage = "http://rd.slavepianos.org/t/hsc3-forth";
       description = "FORTH SUPERCOLLIDER";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsc3-graphs" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, cairo, containers
     , data-default, directory, filepath, hashable, hls, hmt, hosc, hps
     , hsc3, hsc3-cairo, hsc3-lang, hsc3-sf, hsc3-unsafe, hsc3-utils
     , hsharc, MonadRandom, primes, process, random, random-shuffle
     , sc3-rdu, she, split
     }:
     mkDerivation {
       pname = "hsc3-graphs";
       version = "0.15";
       sha256 = "6868d3cb0493d3e2898dfc3296b4656a1819bc3ffdc8804a8a7c72a8017da9b4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring cairo containers data-default
         directory filepath hls hmt hosc hps hsc3 hsc3-cairo hsc3-lang
         hsc3-sf hsc3-unsafe hsc3-utils hsharc MonadRandom primes random
         random-shuffle sc3-rdu she split
       ];
       executableHaskellDepends = [
         array base binary bytestring cairo containers directory filepath
         hashable hls hmt hosc hps hsc3 hsc3-cairo hsc3-lang hsc3-sf
         hsc3-unsafe hsharc MonadRandom primes process random random-shuffle
         sc3-rdu split
       ];
       jailbreak = true;
       homepage = "http://rd.slavepianos.org/t/hsc3-graphs";
       description = "Haskell SuperCollider Graphs";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsc3-lang" = callPackage
    ({ mkDerivation, array, base, bifunctors, bytestring, containers
     , data-default, data-ordlist, dlist, hashable, hmatrix-special
     , hosc, hsc3, MonadRandom, random, random-shuffle, split
     , transformers, vector
     }:
     mkDerivation {
       pname = "hsc3-lang";
       version = "0.15";
       sha256 = "0ec6d7f76d191e6097e46d72a22eb1ecc42d2238f412272de40c1088d64c1627";
       libraryHaskellDepends = [
         array base bifunctors bytestring containers data-default
         data-ordlist dlist hashable hmatrix-special hosc hsc3 MonadRandom
         random random-shuffle split transformers vector
       ];
       homepage = "http://rd.slavepianos.org/t/hsc3-lang";
       description = "Haskell SuperCollider Language";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsc3-lisp" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, hashable
     , hosc, hsc3, hsc3-dot, husk-scheme, mtl, safe, unix
     }:
     mkDerivation {
       pname = "hsc3-lisp";
       version = "0.15";
       sha256 = "1d08f8d832a76df1b8d675ea61f5d521b4ed66d8baff6ce0aeded1bde38d85cc";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath hashable hosc hsc3 hsc3-dot
         husk-scheme mtl safe unix
       ];
       homepage = "http://rd.slavepianos.org/t/hsc3-lisp";
       description = "LISP SUPERCOLLIDER";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsc3-plot" = callPackage
    ({ mkDerivation, base, directory, filepath, hosc, hsc3, hsc3-lang
     , process, split, statistics, vector
     }:
     mkDerivation {
       pname = "hsc3-plot";
       version = "0.15";
       sha256 = "63d2e35837e403fad8dcd063f81b1dedbb1978c2192ea12677115d4cca24b6ec";
       libraryHaskellDepends = [
         base directory filepath hosc hsc3 hsc3-lang process split
         statistics vector
       ];
       homepage = "http://rd.slavepianos.org/t/hsc3-plot";
       description = "Haskell SuperCollider Plotting";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsc3-process" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default
     , directory, filepath, hosc, hsc3, process, time, time-compat
     , transformers
     }:
     mkDerivation {
       pname = "hsc3-process";
       version = "0.10.0";
       sha256 = "ace3a309858541f5ec377403391d71176653601bcac3fa69adfa9576a74ae6c0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers data-default directory filepath hosc
         hsc3 process time time-compat transformers
       ];
       executableHaskellDepends = [ base data-default hosc hsc3 ];
       homepage = "https://github.com/kaoskorobase/hsc3-process";
       description = "Create and control scsynth processes";
       license = "GPL";
     }) {};

  "hsc3-rec" = callPackage
    ({ mkDerivation, base, hsc3 }:
     mkDerivation {
       pname = "hsc3-rec";
       version = "0.14.1";
       sha256 = "d4dd8e94f65c8caf3e437f6c49a345048c14138c6b070018a815c440f2260155";
       libraryHaskellDepends = [ base hsc3 ];
       jailbreak = true;
       homepage = "http://rd.slavepianos.org/?t=hsc3-rec";
       description = "Haskell SuperCollider Record Variants";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsc3-rw" = callPackage
    ({ mkDerivation, base, directory, haskell-src-exts, parsec
     , polyparse, split, syb, transformers
     }:
     mkDerivation {
       pname = "hsc3-rw";
       version = "0.15";
       sha256 = "17fd21044aec0ee2b70118b3da1d63cfc9d1f89d2b98bf8ae39c381b14e096c9";
       libraryHaskellDepends = [
         base directory haskell-src-exts parsec polyparse split syb
         transformers
       ];
       homepage = "http://rd.slavepianos.org/?t=hsc3-rw";
       description = "hsc3 re-writing";
       license = "GPL";
     }) {};

  "hsc3-server" = callPackage
    ({ mkDerivation, base, bitset, bytestring, containers, data-default
     , failure, hashtables, hosc, hsc3, hsc3-process, lifted-base
     , ListZipper, monad-control, QuickCheck, random, resourcet
     , test-framework, test-framework-quickcheck2, transformers
     , transformers-base, unix
     }:
     mkDerivation {
       pname = "hsc3-server";
       version = "0.10.0";
       sha256 = "57bcb588adc0cabc5114919c32c240be63de704545b4803ac44e447364059c02";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bitset bytestring containers data-default failure hashtables
         hosc hsc3 hsc3-process lifted-base ListZipper monad-control
         resourcet transformers transformers-base
       ];
       executableHaskellDepends = [
         base hosc hsc3 random transformers unix
       ];
       testHaskellDepends = [
         base failure QuickCheck random test-framework
         test-framework-quickcheck2 transformers
       ];
       homepage = "https://github.com/kaoskorobase/hsc3-server";
       description = "SuperCollider server resource management and synchronization";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsc3-sf" = callPackage
    ({ mkDerivation, base, bytestring, hosc }:
     mkDerivation {
       pname = "hsc3-sf";
       version = "0.15";
       sha256 = "27f3f4e7dbd9738d423fe12547e6da12ef45da4a281e6eb1833a8bb8217ee3b5";
       libraryHaskellDepends = [ base bytestring hosc ];
       homepage = "http://rd.slavepianos.org/t/hsc3-sf";
       description = "Haskell SuperCollider SoundFile";
       license = "GPL";
     }) {};

  "hsc3-sf-hsndfile" = callPackage
    ({ mkDerivation, array, base, hsc3-sf, hsndfile, hsndfile-vector
     , vector
     }:
     mkDerivation {
       pname = "hsc3-sf-hsndfile";
       version = "0.15";
       sha256 = "512895c97b150d59a5a7b026f6a842accde1932492b78de5c5f428f484d67a86";
       libraryHaskellDepends = [
         array base hsc3-sf hsndfile hsndfile-vector vector
       ];
       homepage = "http://rd.slavepianos.org/t/hsc3-sf-hsndfile";
       description = "Haskell SuperCollider SoundFile";
       license = "GPL";
     }) {};

  "hsc3-unsafe" = callPackage
    ({ mkDerivation, base, hsc3 }:
     mkDerivation {
       pname = "hsc3-unsafe";
       version = "0.14";
       sha256 = "d28f7fa55216e4d0199b9d8d008627d866fb95300ef88530fc1882d04fc7dc4f";
       libraryHaskellDepends = [ base hsc3 ];
       jailbreak = true;
       homepage = "http://rd.slavepianos.org/?t=hsc3-unsafe";
       description = "Unsafe Haskell SuperCollider";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsc3-utils" = callPackage
    ({ mkDerivation, base, directory, filepath, hashable, hosc, hsc3
     , hsc3-dot, hsc3-rw, hsc3-sf, process
     }:
     mkDerivation {
       pname = "hsc3-utils";
       version = "0.15";
       sha256 = "3d664fffb74e758265d504ca3707c542364912263ba7ce1f87f26461cd176fdf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory filepath hashable hosc hsc3 hsc3-sf
       ];
       executableHaskellDepends = [
         base filepath hsc3 hsc3-dot hsc3-rw process
       ];
       homepage = "http://rd.slavepianos.org/t/hsc3-utils";
       description = "Haskell SuperCollider Utilities";
       license = "GPL";
     }) {};

  "hscamwire" = callPackage
    ({ mkDerivation, array, base, camwire_1394, dc1394_control, raw1394
     , time, unix
     }:
     mkDerivation {
       pname = "hscamwire";
       version = "0.2.1";
       sha256 = "6c796c6f8a379559b8e089fc2193b8de2edd0a76dba270b06fa2417002e3962a";
       libraryHaskellDepends = [ array base time unix ];
       librarySystemDepends = [ camwire_1394 dc1394_control raw1394 ];
       jailbreak = true;
       description = "Haskell bindings to IIDC1394 cameras, via Camwire";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {camwire_1394 = null; dc1394_control = null; raw1394 = null;};

  "hscassandra" = callPackage
    ({ mkDerivation, base, bytestring, cassandra-thrift, containers
     , mtl, network, old-time, Thrift
     }:
     mkDerivation {
       pname = "hscassandra";
       version = "0.0.7";
       sha256 = "c419ce941fe74b481a477437f84e136b70313f803826ab2e1ef8eaace609591a";
       libraryHaskellDepends = [
         base bytestring cassandra-thrift containers mtl network old-time
         Thrift
       ];
       homepage = "https://github.com/necrobious/hscassandra";
       description = "cassandra database interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hscd" = callPackage
    ({ mkDerivation, aeson, base, bytestring, ghc-prim, HTTP }:
     mkDerivation {
       pname = "hscd";
       version = "0.0.3";
       sha256 = "599631ee86846a6cb5e5417007abf2dbd383ddbc9d64d04869cbbda0d61b4ef2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ aeson base bytestring ghc-prim HTTP ];
       executableHaskellDepends = [ aeson base bytestring ghc-prim HTTP ];
       jailbreak = true;
       homepage = "https://bitbucket.org/sebasmagri/hscd";
       description = "Command line client and library for SoundCloud.com";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsclock" = callPackage
    ({ mkDerivation, base, cairo, glib, gtk, old-time }:
     mkDerivation {
       pname = "hsclock";
       version = "1.0";
       sha256 = "ce9a53a4f1aa45813d8a40f38afc528fc032a1d114e602d4b363ec9db01b053d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base cairo glib gtk old-time ];
       homepage = "http://haskell.org/gtk2hs/archives/2006/01/26/cairo-eye-candy/";
       description = "An elegant analog clock using Haskell, GTK and Cairo";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hscolour_1_20_3" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "hscolour";
       version = "1.20.3";
       sha256 = "3adb816fba3ecdf9f1ee5fb23feb0611b0762f7e8c2a282c2def5cc2f5483d96";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [ base containers ];
       homepage = "http://code.haskell.org/~malcolm/hscolour/";
       description = "Colourise Haskell code";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hscolour_1_22" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "hscolour";
       version = "1.22";
       sha256 = "3c8fae274c63d4dd6bce8fd3017be84e4bccc50585900eeb792c0eb9efee15c7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [ base containers ];
       homepage = "http://code.haskell.org/~malcolm/hscolour/";
       description = "Colourise Haskell code";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hscolour_1_23" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "hscolour";
       version = "1.23";
       sha256 = "97167eaecc309eff51317d6e925881bc9f27921bd52692121f0fc5aaee1791b0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [ base containers ];
       homepage = "http://code.haskell.org/~malcolm/hscolour/";
       description = "Colourise Haskell code";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hscolour" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "hscolour";
       version = "1.24";
       sha256 = "54bc45137ba06bd876cf98424f974e325e9b236bd5c18d1c5b2ea0351b1d9332";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [ base containers ];
       homepage = "http://code.haskell.org/~malcolm/hscolour/";
       description = "Colourise Haskell code";
       license = "GPL";
     }) {};

  "hscope" = callPackage
    ({ mkDerivation, base, bytestring, cereal, cpphs, deepseq
     , directory, haskell-src-exts, mtl, process, pure-cdb, test-simple
     , uniplate, Unixutils, vector
     }:
     mkDerivation {
       pname = "hscope";
       version = "0.4.3";
       sha256 = "6d632a174906977d51d06a368437cdc83fdce9888eb362135e9dc0249258532a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cereal cpphs deepseq directory haskell-src-exts mtl
         process pure-cdb uniplate vector
       ];
       testHaskellDepends = [
         base directory mtl process test-simple Unixutils
       ];
       homepage = "https://github.com/bosu/hscope";
       description = "cscope like browser for Haskell code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hscrtmpl" = callPackage
    ({ mkDerivation, base, directory, process, regex-compat, time
     , time-locale-compat
     }:
     mkDerivation {
       pname = "hscrtmpl";
       version = "1.4";
       sha256 = "31c642da0e9c90b961160214e4a91e6aba9acbd1253eec009f4d626e360be5ab";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory process regex-compat time time-locale-compat
       ];
       homepage = "http://hub.darcs.net/dino/hscrtmpl";
       description = "Haskell shell script template";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hscuid" = callPackage
    ({ mkDerivation, base, containers, formatting, hostname, random
     , text, time, transformers, unix
     }:
     mkDerivation {
       pname = "hscuid";
       version = "1.2.0.0";
       sha256 = "b4b03b2005cc3e6651b2e221ce5dcdf73026b8f6ab175d0f5a8fe6b427ebb505";
       libraryHaskellDepends = [
         base formatting hostname random text time transformers unix
       ];
       testHaskellDepends = [ base containers ];
       homepage = "https://github.com/eightyeight/hscuid";
       description = "Collision-resistant IDs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hscurses" = callPackage
    ({ mkDerivation, base, exceptions, mtl, old-locale, old-time, unix
     }:
     mkDerivation {
       pname = "hscurses";
       version = "1.4.2.0";
       sha256 = "728533d95eedf42c485ad493031eae5b07cab4b797d1b0ec6576d07208404e57";
       revision = "1";
       editedCabalFile = "185f294036aaced6a4cf72c994339286e8e7886f5a327c3ccac898066985c528";
       libraryHaskellDepends = [
         base exceptions mtl old-locale old-time unix
       ];
       homepage = "https://github.com/skogsbaer/hscurses";
       description = "NCurses bindings for Haskell";
       license = "LGPL";
     }) {};

  "hscurses-fish-ex" = callPackage
    ({ mkDerivation, base, hscurses, random, safe, unix }:
     mkDerivation {
       pname = "hscurses-fish-ex";
       version = "1.3.1";
       sha256 = "fad7a0fca21b9130869df65773df120e0cdbf7e4c53e55ca12d402cac616ebe8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base hscurses random safe unix ];
       homepage = "http://ui3.info/darcs/hscurses-fish-ex/";
       description = "hscurses swimming fish example";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsdev_0_1_3_4" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, array, attoparsec, base
     , bytestring, Cabal, containers, deepseq, directory, exceptions
     , filepath, ghc, ghc-mod, ghc-paths, haddock-api, haskell-src-exts
     , hdocs, HTTP, lens, monad-loops, mtl, network, process
     , regex-pcre-builtin, scientific, template-haskell, text, time
     , transformers, uniplate, unix, unordered-containers, vector
     }:
     mkDerivation {
       pname = "hsdev";
       version = "0.1.3.4";
       sha256 = "0d4b077751b7ff07cc39a1dd6a6c9614b07e7152639c8c47086ae99128e741d4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty array attoparsec base bytestring Cabal
         containers deepseq directory exceptions filepath ghc ghc-mod
         ghc-paths haddock-api haskell-src-exts hdocs HTTP lens monad-loops
         mtl network process regex-pcre-builtin scientific template-haskell
         text time transformers uniplate unix unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson aeson-pretty base bytestring containers deepseq directory
         exceptions filepath ghc haskell-src-exts monad-loops mtl network
         process text transformers unordered-containers vector
       ];
       testHaskellDepends = [ base ];
       homepage = "https://github.com/mvoidex/hsdev";
       description = "Haskell development library and tool with support of autocompletion, symbol info, go to declaration, find references etc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsdev" = callPackage
    ({ mkDerivation, aeson, aeson-lens, aeson-pretty, array, async
     , attoparsec, base, bin-package-db, bytestring, Cabal, containers
     , cpphs, data-default, deepseq, directory, exceptions, filepath
     , fsnotify, ghc, ghc-mod, ghc-paths, ghc-syb-utils, haddock-api
     , haskell-src-exts, hdocs, hformat, hlint, hspec, HTTP, lens
     , lifted-base, monad-control, monad-loops
     , MonadCatchIO-transformers, mtl, network, optparse-applicative
     , process, regex-pcre-builtin, scientific, simple-log, syb
     , template-haskell, text, text-region, time, transformers
     , transformers-base, uniplate, unix, unordered-containers, vector
     }:
     mkDerivation {
       pname = "hsdev";
       version = "0.1.6.3";
       sha256 = "57e43ec24f607dee63ebf9655b30ceafe4c80967b88a5739da806a37633221ab";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty array async attoparsec base bin-package-db
         bytestring Cabal containers cpphs data-default deepseq directory
         exceptions filepath fsnotify ghc ghc-mod ghc-paths ghc-syb-utils
         haddock-api haskell-src-exts hdocs hformat hlint HTTP lens
         lifted-base monad-control monad-loops MonadCatchIO-transformers mtl
         network optparse-applicative process regex-pcre-builtin scientific
         simple-log syb template-haskell text text-region time transformers
         transformers-base uniplate unix unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson aeson-pretty base bytestring containers deepseq directory
         exceptions filepath ghc haskell-src-exts lens monad-loops mtl
         network optparse-applicative process text transformers
         unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-lens async base containers data-default deepseq hformat
         hspec lens mtl text
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/mvoidex/hsdev";
       description = "Haskell development library and tool with support of autocompletion, symbol info, go to declaration, find references etc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsdif" = callPackage
    ({ mkDerivation, base, bytestring, hosc }:
     mkDerivation {
       pname = "hsdif";
       version = "0.14";
       sha256 = "b54676cfaaf943ad1a1dcf605524e57568caf47e26768c0325cedf8abed1b5f3";
       libraryHaskellDepends = [ base bytestring hosc ];
       jailbreak = true;
       homepage = "http://rd.slavepianos.org/?t=hsdif";
       description = "Haskell SDIF";
       license = "GPL";
     }) {};

  "hsdip" = callPackage
    ({ mkDerivation, base, cairo, containers, HUnit, parsec }:
     mkDerivation {
       pname = "hsdip";
       version = "0.1";
       sha256 = "04f196ad26e6f69284f569d7b208c4ed80d7be68bd0af0b81932b3251cbb1c43";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base cairo containers HUnit parsec ];
       homepage = "http://neugierig.org/software/darcs/hsdip/";
       description = "hsdip - a Diplomacy parser/renderer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsdns" = callPackage
    ({ mkDerivation, adns, base, containers, network }:
     mkDerivation {
       pname = "hsdns";
       version = "1.6.1";
       sha256 = "64c1475d7625733c9fafe804ae809d459156f6a96a922adf99e5d8e02553c368";
       libraryHaskellDepends = [ base containers network ];
       librarySystemDepends = [ adns ];
       homepage = "http://github.com/peti/hsdns";
       description = "Asynchronous DNS Resolver";
       license = stdenv.lib.licenses.gpl3;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {inherit (pkgs) adns;};

  "hsdns-cache" = callPackage
    ({ mkDerivation, base, hsdns, network, SafeSemaphore, text, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "hsdns-cache";
       version = "1.0.4";
       sha256 = "31a18caf24e40456bb65cac139ecf2124c640c3724bafef98f02184fa71008b8";
       libraryHaskellDepends = [
         base hsdns network SafeSemaphore text time unordered-containers
       ];
       homepage = "https://github.com/bazqux/hsdns-cache";
       description = "Caching asynchronous DNS resolver";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hse-cpp" = callPackage
    ({ mkDerivation, base, cpphs, haskell-src-exts }:
     mkDerivation {
       pname = "hse-cpp";
       version = "0.1";
       sha256 = "a075790dd132107b8005478179fcaf7e37a78c3011ca536ff0d95e0b437c2b38";
       libraryHaskellDepends = [ base cpphs haskell-src-exts ];
       description = "Preprocess+parse haskell code";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hsebaysdk_0_3_0_0" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-client, http-types
     , text, time, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "hsebaysdk";
       version = "0.3.0.0";
       sha256 = "cf3946191b3b84eb68c7bd24e7d61718670c4c0491c5afe2fa51f5368a9ab3ae";
       libraryHaskellDepends = [
         aeson base bytestring http-client http-types text time transformers
         unordered-containers
       ];
       homepage = "https://github.com/creichert/hsebaysdk";
       description = "Haskell eBay SDK";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsebaysdk" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-client, http-types
     , text, time, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "hsebaysdk";
       version = "0.3.0.1";
       sha256 = "52f97122cdaba3c3b8a71691ed87fb3eb6dd93506652a8b11282af696c3f6279";
       libraryHaskellDepends = [
         aeson base bytestring http-client http-types text time transformers
         unordered-containers
       ];
       homepage = "https://github.com/creichert/hsebaysdk";
       description = "Haskell eBay SDK";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsemail" = callPackage
    ({ mkDerivation, base, doctest, hspec, mtl, old-time, parsec }:
     mkDerivation {
       pname = "hsemail";
       version = "1.7.7";
       sha256 = "25aac3890ff09812be47639ad52cd7be622dc9b193e5a0be115bda12ffcd989b";
       libraryHaskellDepends = [ base mtl old-time parsec ];
       testHaskellDepends = [ base doctest hspec old-time parsec ];
       homepage = "http://github.com/peti/hsemail";
       description = "Internet Message Parsers";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "hsemail-ns" = callPackage
    ({ mkDerivation, base, mtl, old-time, parsec }:
     mkDerivation {
       pname = "hsemail-ns";
       version = "1.3.2";
       sha256 = "9afc3dda1ad6b6a04f3851b40dc82b165bdd27400bbdfc4f2fd21fb5b4bda00d";
       libraryHaskellDepends = [ base mtl old-time parsec ];
       jailbreak = true;
       homepage = "http://patch-tag.com/r/hsemail-ns/home";
       description = "Internet Message Parsers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsenv" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, directory, file-embed
     , filepath, http-streams, io-streams, mtl, process, safe, split
     , unix
     }:
     mkDerivation {
       pname = "hsenv";
       version = "0.5";
       sha256 = "0338efdfda4a8e5383dc577cbaa19a9254b63ded06c104557ac90cd3d14d52ce";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal directory file-embed filepath http-streams
         io-streams mtl process safe split unix
       ];
       jailbreak = true;
       homepage = "https://github.com/tmhedberg/hsenv";
       description = "Virtual Haskell Environment builder";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hserv" = callPackage
    ({ mkDerivation, base, cmdargs, wai-app-static, warp }:
     mkDerivation {
       pname = "hserv";
       version = "0.1.0.3";
       sha256 = "4382033dac11c95c2d08b200b7a88bfa33588eaddba98f304cbf3d6e479b76b7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base cmdargs wai-app-static warp ];
       homepage = "http://github.com/rejuvyesh/hserv";
       description = "Simple http server in haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hset" = callPackage
    ({ mkDerivation, base, deepseq, HUnit, tagged, type-fun }:
     mkDerivation {
       pname = "hset";
       version = "2.2.0";
       sha256 = "b8747a0826aeaca2ca814e7a334f9de5a02f36ac83faea5e1c32c8f6040bf130";
       libraryHaskellDepends = [ base deepseq tagged type-fun ];
       testHaskellDepends = [ base HUnit tagged ];
       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, hspec, HUnit
     , iconv, text, time
     }:
     mkDerivation {
       pname = "hsexif";
       version = "0.6.0.7";
       sha256 = "35b68bd3c956143760a149479a2debe4ccc1f63acf13e592c741b1f5cb63b3ce";
       libraryHaskellDepends = [
         base binary bytestring containers iconv text time
       ];
       testHaskellDepends = [
         base binary bytestring containers hspec HUnit iconv text time
       ];
       homepage = "https://github.com/emmanueltouzery/hsexif";
       description = "EXIF handling library in pure Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsfacter" = callPackage
    ({ mkDerivation, base, containers, language-puppet, text }:
     mkDerivation {
       pname = "hsfacter";
       version = "0.2.1";
       sha256 = "18ac5293ed38dd53aa82792f1c66029bb0e8db1027afd404c7a55fe981b7f7c8";
       libraryHaskellDepends = [ base containers language-puppet text ];
       homepage = "http://lpuppet.banquise.net";
       description = "A small and ugly library that emulates the output of the puppet facter program";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsfcsh" = callPackage
    ({ mkDerivation, base, hdaemonize, hslogger, network, process }:
     mkDerivation {
       pname = "hsfcsh";
       version = "0.0.1";
       sha256 = "0c4fa3442e8da7b003e21e472cec2f0d18188ae86ab081d69d8e6a3ec67481b9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base hdaemonize hslogger network process
       ];
       jailbreak = true;
       homepage = "https://github.com/Yuras/hsfcsh";
       description = "Incremental builder for flash";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsfilt" = callPackage
    ({ mkDerivation, base, ghc }:
     mkDerivation {
       pname = "hsfilt";
       version = "0.1.0.0";
       sha256 = "88f87fc0952fc8ea8894c3fddf060fc5ad01b70f37db4268de9c8c438c2b7318";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ghc ];
       jailbreak = true;
       description = "Z-decoder";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hsgnutls" = callPackage
    ({ mkDerivation, base, bytestring, gcrypt, gnutls, mtl, old-time }:
     mkDerivation {
       pname = "hsgnutls";
       version = "0.2.3.2";
       sha256 = "d54a46500f0fefab2ffa3d36d39d36efa812580163251621904a62b226faa3d9";
       libraryHaskellDepends = [ base bytestring mtl old-time ];
       librarySystemDepends = [ gcrypt gnutls ];
       homepage = "http://www.cs.helsinki.fi/u/ekarttun/hsgnutls";
       description = "Library wrapping the GnuTLS API";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gcrypt = null; inherit (pkgs) gnutls;};

  "hsgnutls-yj" = callPackage
    ({ mkDerivation, base, bytestring, gcrypt, gnutls, mtl, old-time }:
     mkDerivation {
       pname = "hsgnutls-yj";
       version = "0.2.3.3";
       sha256 = "1cecc821949e4d737652044bb5db9603e56dc3e11e0202f6b757cc2ef73cb615";
       libraryHaskellDepends = [ base bytestring mtl old-time ];
       librarySystemDepends = [ gcrypt gnutls ];
       homepage = "http://www.cs.helsinki.fi/u/ekarttun/hsgnutls";
       description = "Library wrapping the GnuTLS API";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gcrypt = null; inherit (pkgs) gnutls;};

  "hsgsom" = callPackage
    ({ mkDerivation, base, containers, random, stm, time }:
     mkDerivation {
       pname = "hsgsom";
       version = "0.2.0";
       sha256 = "b6895c0a61f024f4c4793789b3f403cc034f4fb7933caf98ae5dd598b7a28380";
       libraryHaskellDepends = [ base containers random stm time ];
       description = "An implementation of the GSOM clustering algorithm";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsgtd" = callPackage
    ({ mkDerivation, ansi-terminal, base, containers, directory
     , haskeline, mtl
     }:
     mkDerivation {
       pname = "hsgtd";
       version = "0.2";
       sha256 = "86616afa153ffaab71a71ff0cd1bdf8b9ecedca2abcd3525f30ddb0f3f295167";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base containers directory haskeline mtl
       ];
       homepage = "http://www.mlesniak.com/haskell/gettings-things-done-in-haskell/";
       description = "Console-based gettings-things-done application";
       license = "GPL";
     }) {};

  "hsharc" = callPackage
    ({ mkDerivation, base, xml }:
     mkDerivation {
       pname = "hsharc";
       version = "0.14";
       sha256 = "6e1b64b855ccadd417305ded3a4b08fd833a99f9f8ed6c3cbb88fc18c901f1d7";
       libraryHaskellDepends = [ base xml ];
       homepage = "http://rd.slavepianos.org/?t=hsharc";
       description = "Haskell SHARC bindings";
       license = "GPL";
     }) {};

  "hsignal_0_2_7" = callPackage
    ({ mkDerivation, array, base, binary, blas, bytestring, hmatrix
     , hmatrix-gsl, hmatrix-gsl-stats, hstatistics, liblapack, mtl
     , storable-complex
     }:
     mkDerivation {
       pname = "hsignal";
       version = "0.2.7";
       sha256 = "4077770e4984050a2e0b9f17d293df6ac5af82e1b771eb82fb97969985b0e5a8";
       libraryHaskellDepends = [
         array base binary bytestring hmatrix hmatrix-gsl hmatrix-gsl-stats
         hstatistics mtl storable-complex
       ];
       librarySystemDepends = [ blas liblapack ];
       prePatch = "rm -v Setup.lhs";
       homepage = "http://code.haskell.org/hsignal";
       description = "Signal processing and EEG data analysis";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) blas; inherit (pkgs) liblapack;};

  "hsignal_0_2_7_1" = callPackage
    ({ mkDerivation, array, base, binary, blas, bytestring, gsl
     , hmatrix, hmatrix-gsl, hmatrix-gsl-stats, hstatistics, liblapack
     , mtl, storable-complex
     }:
     mkDerivation {
       pname = "hsignal";
       version = "0.2.7.1";
       sha256 = "1d60937f674a283a0fbc2531f73bb954c7208a10efd6fc8b8967e6fe5850efb7";
       libraryHaskellDepends = [
         array base binary bytestring hmatrix hmatrix-gsl hmatrix-gsl-stats
         hstatistics mtl storable-complex
       ];
       librarySystemDepends = [ blas liblapack ];
       libraryPkgconfigDepends = [ gsl ];
       prePatch = "rm -v Setup.lhs";
       homepage = "http://code.haskell.org/hsignal";
       description = "Signal processing and EEG data analysis";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) blas; inherit (pkgs) gsl; 
         inherit (pkgs) liblapack;};

  "hsignal" = callPackage
    ({ mkDerivation, array, base, binary, blas, bytestring, gsl
     , hmatrix, hmatrix-gsl, hmatrix-gsl-stats, hstatistics, liblapack
     , mtl, storable-complex, vector
     }:
     mkDerivation {
       pname = "hsignal";
       version = "0.2.7.4";
       sha256 = "290436ca76d13a4435da0b33d20a69663d955abcf361661cf9835e7eedb4f53a";
       libraryHaskellDepends = [
         array base binary bytestring hmatrix hmatrix-gsl hmatrix-gsl-stats
         hstatistics mtl storable-complex vector
       ];
       librarySystemDepends = [ blas liblapack ];
       libraryPkgconfigDepends = [ gsl ];
       homepage = "http://code.haskell.org/hsignal";
       description = "Signal processing and EEG data analysis";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) blas; inherit (pkgs) gsl; 
         inherit (pkgs) liblapack;};

  "hsilop" = callPackage
    ({ mkDerivation, base, directory, filepath, haskeline, xdg-basedir
     }:
     mkDerivation {
       pname = "hsilop";
       version = "0.2.0.0";
       sha256 = "5bafb93485ef7a4da921a248824770c3df38a86d20f88b79538ac0d76933d026";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath haskeline xdg-basedir
       ];
       homepage = "https://github.com/Rnhmjoj/hsilop";
       description = "RPN calculator";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hsimport" = callPackage
    ({ mkDerivation, attoparsec, base, cmdargs, directory, dyre
     , filepath, haskell-src-exts, lens, mtl, split, tasty, tasty-golden
     , text
     }:
     mkDerivation {
       pname = "hsimport";
       version = "0.7";
       sha256 = "54d59d8d182f8a575f540def41c9184f530b6e2ed73e05d27f82c4c5de261857";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base cmdargs directory dyre haskell-src-exts lens mtl
         split text
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base filepath haskell-src-exts tasty tasty-golden
       ];
       description = "A command line program for extending the import list of a Haskell source file";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsini" = callPackage
    ({ mkDerivation, base, bytestring, containers, HUnit, mtl, parsec
     , QuickCheck, tasty, tasty-hunit, tasty-quickcheck, tasty-th
     }:
     mkDerivation {
       pname = "hsini";
       version = "0.4.2";
       sha256 = "b98aa37900b03403bf8bcb40d300ef539a8dc50476a219e8f19c41ff057379fe";
       libraryHaskellDepends = [ base bytestring containers mtl parsec ];
       testHaskellDepends = [
         base bytestring containers HUnit mtl parsec QuickCheck tasty
         tasty-hunit tasty-quickcheck tasty-th
       ];
       description = "Package for user configuration files (INI)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hskeleton" = callPackage
    ({ mkDerivation, base, Cabal }:
     mkDerivation {
       pname = "hskeleton";
       version = "0.1.1";
       sha256 = "5ca8bd48b3b7c5129211152e0589e6eb1d8a38bff39130e1e5f7672472ec0638";
       libraryHaskellDepends = [ base Cabal ];
       description = "Skeleton for new Haskell programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hslackbuilder" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, process, unix }:
     mkDerivation {
       pname = "hslackbuilder";
       version = "0.0.2";
       sha256 = "b8140af5f5726b53aa2f16a54a57f295e65285fe8e3a34e3e74f2a0c0d9f9c48";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal directory filepath process unix
       ];
       homepage = "http://code.haskell.org/~arossato/hslackbuilder";
       description = "HSlackBuilder automatically generates slackBuild scripts from a cabal package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hslibsvm" = callPackage
    ({ mkDerivation, base, containers, svm }:
     mkDerivation {
       pname = "hslibsvm";
       version = "2.89.0.1";
       sha256 = "4e9bee5bce423698d686eb48ae6736b96455954383e1310208fc462141e05503";
       libraryHaskellDepends = [ base containers ];
       librarySystemDepends = [ svm ];
       description = "A FFI binding to libsvm";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {svm = null;};

  "hslinks" = callPackage
    ({ mkDerivation, base, Cabal, hint, MemoTrie, process, regex-compat
     }:
     mkDerivation {
       pname = "hslinks";
       version = "0.6.1";
       sha256 = "a11f557a5eaa5688c7585ed26834c8f5ed27a57d67756c82b09f4d3a776311b7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal hint MemoTrie process regex-compat
       ];
       description = "Resolves links to Haskell identifiers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hslogger_1_2_6" = callPackage
    ({ mkDerivation, base, containers, directory, mtl, network
     , old-locale, process, time, unix
     }:
     mkDerivation {
       pname = "hslogger";
       version = "1.2.6";
       sha256 = "7372e5d69a6a73011a677b914910f916b4cef59b1475eb635a1bd945043a1c7b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory mtl network old-locale process time unix
       ];
       jailbreak = true;
       homepage = "http://software.complete.org/hslogger";
       description = "Versatile logging framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hslogger_1_2_8" = callPackage
    ({ mkDerivation, base, containers, directory, mtl, network
     , old-locale, process, time, unix
     }:
     mkDerivation {
       pname = "hslogger";
       version = "1.2.8";
       sha256 = "de3572c313d5c453c7407bfab07edf052a523fd25c8cbc41457b0ed14e94ec44";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory mtl network old-locale process time unix
       ];
       homepage = "http://software.complete.org/hslogger";
       description = "Versatile logging framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hslogger" = callPackage
    ({ mkDerivation, base, containers, directory, mtl, network
     , old-locale, process, time, unix
     }:
     mkDerivation {
       pname = "hslogger";
       version = "1.2.9";
       sha256 = "be62cc2783876b9e6d857c5ae60ab4408131fc51314a7b7d971212395f0fb476";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory mtl network old-locale process time unix
       ];
       homepage = "http://software.complete.org/hslogger";
       description = "Versatile logging framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hslogger-reader" = callPackage
    ({ mkDerivation, attoparsec, base, hslogger, optparse-applicative
     , text, text-icu, time
     }:
     mkDerivation {
       pname = "hslogger-reader";
       version = "1.0.1";
       sha256 = "61d0b5f870ef3b5a436ad7e89a2f97ecd4c2bdd3b65998ffe4c71480313dc148";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ attoparsec base hslogger text time ];
       executableHaskellDepends = [
         attoparsec base hslogger optparse-applicative text text-icu time
       ];
       jailbreak = true;
       homepage = "http://github.com/prophet-on-that/hslogger-reader";
       description = "Parsing hslogger-produced logs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hslogger-template" = callPackage
    ({ mkDerivation, base, hslogger, mtl, template-haskell }:
     mkDerivation {
       pname = "hslogger-template";
       version = "2.0.3";
       sha256 = "b324e500ee3e05e653ff1ca427895195a53c56ee0c0bc1f2da5f7ad29f14afe0";
       libraryHaskellDepends = [ base hslogger mtl template-haskell ];
       description = "Automatic generation of hslogger functions";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "hslogger4j" = callPackage
    ({ mkDerivation, hslogger }:
     mkDerivation {
       pname = "hslogger4j";
       version = "0.2";
       sha256 = "b66ca641c584532f3aaf5166c2be49f3292e32cce688865e92cf5f8b6463d757";
       libraryHaskellDepends = [ hslogger ];
       doHaddock = false;
       homepage = "http://hslogger4j.googlecode.com/";
       description = "DEPRECATED hslogger handlers for log4j's XMLLayout";
       license = "LGPL";
     }) {};

  "hslogstash" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
     , conduit, conduit-extra, containers, data-default, hedis, hspec
     , http-client, http-conduit, http-types, iconv, lens, lens-aeson
     , network, parallel-io, QuickCheck, resourcet, split, stm
     , stm-chans, stm-conduit, stm-firehose, text, text-format, time
     , transformers, unordered-containers, vector, wai
     }:
     mkDerivation {
       pname = "hslogstash";
       version = "0.4.2";
       sha256 = "88a4a555b3342e4ffd0f930793e56da9c9405731a8c066237ee36402f2a5be80";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder bytestring conduit
         conduit-extra containers data-default hedis http-client
         http-conduit http-types iconv lens lens-aeson network parallel-io
         resourcet stm stm-chans stm-conduit stm-firehose text text-format
         time transformers unordered-containers vector wai
       ];
       testHaskellDepends = [
         base conduit hspec QuickCheck split stm transformers
       ];
       homepage = "https://github.com/bartavelle/hslogstash";
       description = "A library to work with, or as, a logstash server";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hslua_0_3_13" = callPackage
    ({ mkDerivation, base, lua5_1, mtl }:
     mkDerivation {
       pname = "hslua";
       version = "0.3.13";
       sha256 = "e95774d21ac4378e799af4b8dce9068bfedd3109bf13b717d9ecb5817f86430a";
       configureFlags = [ "-fsystem-lua" ];
       libraryHaskellDepends = [ base mtl ];
       libraryPkgconfigDepends = [ lua5_1 ];
       testHaskellDepends = [ base ];
       description = "A Lua language interpreter embedding in Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) lua5_1;};

  "hslua_0_4_0" = callPackage
    ({ mkDerivation, base, bytestring, hspec, hspec-contrib, HUnit
     , lua5_1, text
     }:
     mkDerivation {
       pname = "hslua";
       version = "0.4.0";
       sha256 = "77a865a3258656c2536c154d18ac38873a371685fde6ba03a3436f65f7bda050";
       revision = "2";
       editedCabalFile = "43f6956aba870857548523718d3d5645e422187964e5158d14a9c17d96671ccb";
       configureFlags = [ "-fsystem-lua" ];
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ lua5_1 ];
       testHaskellDepends = [
         base bytestring hspec hspec-contrib HUnit text
       ];
       description = "A Lua language interpreter embedding in Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) lua5_1;};

  "hslua" = callPackage
    ({ mkDerivation, base, bytestring, hspec, hspec-contrib, HUnit
     , lua5_1, QuickCheck, quickcheck-instances, text
     }:
     mkDerivation {
       pname = "hslua";
       version = "0.4.1";
       sha256 = "2df2b4f0566ef2244506f9830e0207fce3bece7c331129f69f446c722136173f";
       configureFlags = [ "-fsystem-lua" ];
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ lua5_1 ];
       testHaskellDepends = [
         base bytestring hspec hspec-contrib HUnit QuickCheck
         quickcheck-instances text
       ];
       description = "A Lua language interpreter embedding in Haskell";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) lua5_1;};

  "hsmagick" = callPackage
    ({ mkDerivation, base, bytestring, bzip2, directory, filepath
     , freetype2, GraphicsMagick, jasper, lcms, libjpeg, libpng, libxml2
     , pretty, process, tiff, wmflite, zlib
     }:
     mkDerivation {
       pname = "hsmagick";
       version = "0.5";
       sha256 = "5710926dd9efc9b28183dfe26be7cec9f77a0d58201e27c9071568dd1a5fdfad";
       libraryHaskellDepends = [
         base bytestring directory filepath pretty process
       ];
       librarySystemDepends = [
         bzip2 jasper libjpeg libpng tiff wmflite zlib
       ];
       libraryPkgconfigDepends = [
         freetype2 GraphicsMagick lcms libxml2
       ];
       homepage = "https://github.com/vincentg/hsmagick";
       description = "FFI bindings for the GraphicsMagick library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {GraphicsMagick = null; inherit (pkgs) bzip2; freetype2 = null; 
         inherit (pkgs) jasper; inherit (pkgs) lcms; 
         inherit (pkgs) libjpeg; inherit (pkgs) libpng; 
         inherit (pkgs) libxml2; tiff = null; wmflite = null; 
         inherit (pkgs) zlib;};

  "hsmisc" = callPackage
    ({ mkDerivation, base, containers, HUnit, mtl, old-locale, parsec
     , time
     }:
     mkDerivation {
       pname = "hsmisc";
       version = "1.2";
       sha256 = "528563ea0af5d4c94b8e225257077c6b7e91b99cfb9f421c8057e1a2485056d8";
       libraryHaskellDepends = [
         base containers mtl old-locale parsec time
       ];
       testHaskellDepends = [ base containers HUnit mtl ];
       homepage = "http://hub.darcs.net/dino/hsmisc";
       description = "A collection of miscellaneous modules";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsmtpclient" = callPackage
    ({ mkDerivation, array, base, directory, network, old-time }:
     mkDerivation {
       pname = "hsmtpclient";
       version = "1.0";
       sha256 = "4f73a384e908b730f7a55f4c78985c5f7ca94bfea0ca972d193616c432cfeb21";
       libraryHaskellDepends = [ array base directory network old-time ];
       homepage = "http://code.google.com/p/hsmtpclient/";
       description = "Simple SMTP Client";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsndfile" = callPackage
    ({ mkDerivation, base, c2hs, libsndfile }:
     mkDerivation {
       pname = "hsndfile";
       version = "0.8.0";
       sha256 = "e97e7ef4c26b0dba9400d9a77d3d5001735f64094b93f9733443f58f7f568efb";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ libsndfile ];
       libraryToolDepends = [ c2hs ];
       homepage = "http://haskell.org/haskellwiki/Hsndfile";
       description = "Haskell bindings for libsndfile";
       license = stdenv.lib.licenses.lgpl21;
     }) {inherit (pkgs) libsndfile;};

  "hsndfile-storablevector" = callPackage
    ({ mkDerivation, base, hsndfile, storablevector }:
     mkDerivation {
       pname = "hsndfile-storablevector";
       version = "0.5.2";
       sha256 = "3f6d1571b557940afa03bc3cd7de687e50eff9f76751507ed8b1477b49e0f2d8";
       libraryHaskellDepends = [ base hsndfile storablevector ];
       homepage = "http://haskell.org/haskellwiki/Hsndfile";
       description = "Haskell bindings for libsndfile (Data.StorableVector interface)";
       license = stdenv.lib.licenses.lgpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsndfile-vector" = callPackage
    ({ mkDerivation, base, hsndfile, vector }:
     mkDerivation {
       pname = "hsndfile-vector";
       version = "0.5.2";
       sha256 = "2ffe11eb9a3e63aae24e8e06d2e04e8ca4a617ccf1238843cc71517a905b2895";
       libraryHaskellDepends = [ base hsndfile vector ];
       homepage = "http://haskell.org/haskellwiki/Hsndfile";
       description = "Haskell bindings for libsndfile (Data.Vector interface)";
       license = stdenv.lib.licenses.lgpl2;
     }) {};

  "hsnock" = callPackage
    ({ mkDerivation, base, HUnit, parsec, QuickCheck, readline
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "hsnock";
       version = "0.5.1";
       sha256 = "1c2e9bb9ea7d92b9935ae8afa2b8a4febf382e8bc27c770d4e274ed1b2a704c2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base parsec readline ];
       executableHaskellDepends = [ base parsec readline ];
       testHaskellDepends = [
         base HUnit parsec QuickCheck readline test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/mrdomino/hsnock/";
       description = "Nock 5K interpreter";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsnoise" = callPackage
    ({ mkDerivation, base, vector }:
     mkDerivation {
       pname = "hsnoise";
       version = "0.0.2";
       sha256 = "f4d705f523c6f5980400985abaff75fb64d435b37fcb1d2c3e349c577fbd1d39";
       libraryHaskellDepends = [ base vector ];
       homepage = "https://github.com/colinhect/hsnoise";
       description = "A coherent 3d noise library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsns" = callPackage
    ({ mkDerivation, base, network, pcap }:
     mkDerivation {
       pname = "hsns";
       version = "0.5.3";
       sha256 = "6e41661adfa0947ea92863ea98f7e3c4a42cae3c663a8d9993ab43420b4c7f64";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base network pcap ];
       description = "a miniature network sniffer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsnsq" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, attoparsec-binary, base
     , bytestring, containers, hostname, hslogger, mtl, network, pipes
     , pipes-attoparsec, pipes-network, stm, stm-chans, text
     }:
     mkDerivation {
       pname = "hsnsq";
       version = "0.1.2.0";
       sha256 = "cb1199e0eef3440f7fc8b9539400a51981a10c12dd1f12adb63989ac9c671532";
       libraryHaskellDepends = [
         aeson async attoparsec attoparsec-binary base bytestring containers
         hostname hslogger mtl network pipes pipes-attoparsec pipes-network
         stm stm-chans text
       ];
       jailbreak = true;
       homepage = "https://github.com/gamelost/hsnsq";
       description = "Haskell NSQ client";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "hsntp" = callPackage
    ({ mkDerivation, array, base, mtl, network, old-time, random, unix
     }:
     mkDerivation {
       pname = "hsntp";
       version = "0.1";
       sha256 = "cd2b45ace6764395f0574ce995c0db0c3769dd032086c35f675b4a1fbea1855f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base mtl network old-time random ];
       executableHaskellDepends = [ unix ];
       homepage = "http://www.cs.helsinki.fi/u/ekarttun/util/";
       description = "Libraries to use SNTP protocol and small client/server implementations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsoptions" = callPackage
    ({ mkDerivation, base, containers, directory, HUnit, parsec
     , QuickCheck, regex-compat, regex-posix, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "hsoptions";
       version = "1.0.0.0";
       sha256 = "c13af099d97541e419c1929d0b12506b573092235a0d79cb1b7af1a7ea8b9ab0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory parsec regex-compat regex-posix
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base containers directory HUnit parsec QuickCheck regex-compat
         regex-posix test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/josercruz01/hsoptions";
       description = "Haskell library that supports command-line flag processing";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsp" = callPackage
    ({ mkDerivation, base, mtl, text }:
     mkDerivation {
       pname = "hsp";
       version = "0.10.0";
       sha256 = "4ed3905a9db91001bde09f060290833af462e87e35476ab0def1579a1ff7ceab";
       libraryHaskellDepends = [ base mtl text ];
       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;
     }) {};

  "hsp-cgi" = callPackage
    ({ mkDerivation, base, containers, harp, hsp, network }:
     mkDerivation {
       pname = "hsp-cgi";
       version = "0.4.4";
       sha256 = "36049bd050c56d27584448934e6575a9453184c1abcc2f120b4cc4fa31f53d54";
       libraryHaskellDepends = [ base containers harp hsp network ];
       homepage = "http://code.google.com/p/hsp";
       description = "Facilitates running Haskell Server Pages web pages as CGI programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsparklines" = callPackage
    ({ mkDerivation, base, bytestring, dataenc, gd }:
     mkDerivation {
       pname = "hsparklines";
       version = "0.1.0";
       sha256 = "c68f5cbbbd1c755b8bfc906b4cc8a02ebd2dc06f4e0cfffe784f15758023ea83";
       libraryHaskellDepends = [ base bytestring dataenc gd ];
       homepage = "http://www.jasani.org/search/label/hsparklines";
       description = "Sparklines for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsparql" = callPackage
    ({ mkDerivation, base, bytestring, containers, HTTP, http-types
     , HUnit, MissingH, mtl, network, network-uri, rdf4h, test-framework
     , test-framework-hunit, text, wai, warp, xml
     }:
     mkDerivation {
       pname = "hsparql";
       version = "0.2.7";
       sha256 = "0f00e2d8a1294da1e60077b5da641a2f089326eaeb8766eb6e2eb1622328b6a7";
       libraryHaskellDepends = [
         base bytestring HTTP MissingH mtl network network-uri rdf4h text
         xml
       ];
       testHaskellDepends = [
         base containers http-types HUnit network-uri rdf4h test-framework
         test-framework-hunit text wai warp
       ];
       homepage = "https://github.com/robstewart57/hsparql";
       description = "A SPARQL query generator and DSL, and a client to query a SPARQL server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspear" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-lexing, split
     , utf8-string, zlib
     }:
     mkDerivation {
       pname = "hspear";
       version = "0.14";
       sha256 = "30c41dcd085dc934db18dc2a2f6ba7c3f68c7504df9d805a6e0eeb776bda6ac0";
       libraryHaskellDepends = [
         base bytestring bytestring-lexing split utf8-string zlib
       ];
       homepage = "http://rd.slavepianos.org/?t=hspear";
       description = "Haskell Spear Parser";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec_2_1_2" = callPackage
    ({ mkDerivation, base, directory, hspec-core, hspec-discover
     , hspec-expectations, hspec-meta, HUnit, QuickCheck, stringbuilder
     , transformers
     }:
     mkDerivation {
       pname = "hspec";
       version = "2.1.2";
       sha256 = "fe16b0b5b6ece20622aa160a56b57aa11ee458c3c4af743ff673d5f5ce23c312";
       libraryHaskellDepends = [
         base hspec-core hspec-discover hspec-expectations HUnit QuickCheck
         transformers
       ];
       testHaskellDepends = [
         base directory hspec-core hspec-meta stringbuilder
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec_2_1_3" = callPackage
    ({ mkDerivation, base, directory, hspec-core, hspec-discover
     , hspec-expectations, hspec-meta, HUnit, QuickCheck, stringbuilder
     , transformers
     }:
     mkDerivation {
       pname = "hspec";
       version = "2.1.3";
       sha256 = "c23d19f9b839879bef6ef54d4b644d88cb6a89912c699e8f2f6b13797cbca286";
       libraryHaskellDepends = [
         base hspec-core hspec-discover hspec-expectations HUnit QuickCheck
         transformers
       ];
       testHaskellDepends = [
         base directory hspec-core hspec-meta stringbuilder
       ];
       jailbreak = true;
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec_2_1_4" = callPackage
    ({ mkDerivation, base, directory, hspec-core, hspec-discover
     , hspec-expectations, hspec-meta, HUnit, QuickCheck, stringbuilder
     , transformers
     }:
     mkDerivation {
       pname = "hspec";
       version = "2.1.4";
       sha256 = "d720e3e0eeb86408bb22d4bdeeef9d4759cafaba29ae484274c70cb62bd81c3c";
       libraryHaskellDepends = [
         base hspec-core hspec-discover hspec-expectations HUnit QuickCheck
         transformers
       ];
       testHaskellDepends = [
         base directory hspec-core hspec-meta stringbuilder
       ];
       jailbreak = true;
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec_2_1_5" = callPackage
    ({ mkDerivation, base, directory, hspec-core, hspec-discover
     , hspec-expectations, hspec-meta, HUnit, QuickCheck, stringbuilder
     , transformers
     }:
     mkDerivation {
       pname = "hspec";
       version = "2.1.5";
       sha256 = "4c5747c7676303d520d7981b6d30c99cea7c58918c0fe6d510b05370a18d4852";
       libraryHaskellDepends = [
         base hspec-core hspec-discover hspec-expectations HUnit QuickCheck
         transformers
       ];
       testHaskellDepends = [
         base directory hspec-core hspec-meta stringbuilder
       ];
       jailbreak = true;
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec_2_1_6" = callPackage
    ({ mkDerivation, base, directory, hspec-core, hspec-discover
     , hspec-expectations, hspec-meta, HUnit, QuickCheck, stringbuilder
     , transformers
     }:
     mkDerivation {
       pname = "hspec";
       version = "2.1.6";
       sha256 = "70a3f0e4a30aa69c3e12c5c9301772bdb24d6305cce45d1dac639f486f029079";
       libraryHaskellDepends = [
         base hspec-core hspec-discover hspec-expectations HUnit QuickCheck
         transformers
       ];
       testHaskellDepends = [
         base directory hspec-core hspec-meta stringbuilder
       ];
       jailbreak = true;
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec_2_1_7" = callPackage
    ({ mkDerivation, base, directory, hspec-core, hspec-discover
     , hspec-expectations, hspec-meta, HUnit, QuickCheck, stringbuilder
     , transformers
     }:
     mkDerivation {
       pname = "hspec";
       version = "2.1.7";
       sha256 = "9bbbf7b8804de50387dc07f674ae493e3abb3559cd25c678f01b16ad0f76d924";
       libraryHaskellDepends = [
         base hspec-core hspec-discover hspec-expectations HUnit QuickCheck
         transformers
       ];
       testHaskellDepends = [
         base directory hspec-core hspec-meta stringbuilder
       ];
       jailbreak = true;
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec_2_1_10" = callPackage
    ({ mkDerivation, base, directory, hspec-core, hspec-discover
     , hspec-expectations, hspec-meta, HUnit, QuickCheck, stringbuilder
     , transformers
     }:
     mkDerivation {
       pname = "hspec";
       version = "2.1.10";
       sha256 = "f8fad4636ac0c89373c1b82e77fed8702ac84278597107ba9407052b9453a154";
       libraryHaskellDepends = [
         base hspec-core hspec-discover hspec-expectations HUnit QuickCheck
         transformers
       ];
       testHaskellDepends = [
         base directory hspec-core hspec-meta stringbuilder
       ];
       jailbreak = true;
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec_2_2_1" = callPackage
    ({ mkDerivation, base, directory, hspec-core, hspec-discover
     , hspec-expectations, hspec-meta, HUnit, QuickCheck, stringbuilder
     , transformers
     }:
     mkDerivation {
       pname = "hspec";
       version = "2.2.1";
       sha256 = "c27fdf9181c182a0f1829f1217c9455b157526e0d50bc6bd4823e1464839f17a";
       libraryHaskellDepends = [
         base hspec-core hspec-discover hspec-expectations HUnit QuickCheck
         transformers
       ];
       testHaskellDepends = [
         base directory hspec-core hspec-meta stringbuilder
       ];
       jailbreak = true;
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec" = callPackage
    ({ mkDerivation, base, directory, hspec-core, hspec-discover
     , hspec-expectations, hspec-meta, HUnit, QuickCheck, stringbuilder
     , transformers
     }:
     mkDerivation {
       pname = "hspec";
       version = "2.2.2";
       sha256 = "91310e6feb10c31b23ec2739422f8ed25ed43bc606bd355cb034a66bb297c9d9";
       libraryHaskellDepends = [
         base hspec-core hspec-discover hspec-expectations HUnit QuickCheck
         transformers
       ];
       testHaskellDepends = [
         base directory hspec-core hspec-meta stringbuilder
       ];
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-attoparsec" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, hspec
     , hspec-expectations, text
     }:
     mkDerivation {
       pname = "hspec-attoparsec";
       version = "0.1.0.2";
       sha256 = "ea7a8b3f2989abde8c8537cec1a2ae312e88df80086b9b01ed12e5324137fb64";
       libraryHaskellDepends = [
         attoparsec base bytestring hspec-expectations text
       ];
       testHaskellDepends = [
         attoparsec base bytestring hspec hspec-expectations text
       ];
       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 }:
     mkDerivation {
       pname = "hspec-checkers";
       version = "0.1.0.1";
       sha256 = "9703ad134d1711b17301d760cebc36814c48a0e4e5712590514c93e6ec278dab";
       libraryHaskellDepends = [ base checkers hspec ];
       testHaskellDepends = [ base checkers hspec ];
       description = "Allows to use checkers properties from hspec";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hspec-contrib" = callPackage
    ({ mkDerivation, base, hspec, hspec-core, HUnit, QuickCheck }:
     mkDerivation {
       pname = "hspec-contrib";
       version = "0.3.0";
       sha256 = "c4f62a0e23468716d735581ffa1899b4741c5ee43e696e40d7d03dd511f7da00";
       libraryHaskellDepends = [ base hspec-core HUnit ];
       testHaskellDepends = [ base hspec hspec-core HUnit QuickCheck ];
       homepage = "http://hspec.github.io/";
       description = "Contributed functionality for Hspec";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-core_2_1_2" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, deepseq
     , hspec-expectations, hspec-meta, HUnit, process, QuickCheck
     , quickcheck-io, random, setenv, silently, tf-random, time
     , transformers
     }:
     mkDerivation {
       pname = "hspec-core";
       version = "2.1.2";
       sha256 = "70cbba8a880341d18e1676683d3ed9fb914dc9050d91dfc35cadbc7242767ad7";
       revision = "1";
       editedCabalFile = "ab3c13605e6eb8611e072ba26b44fca048471b575ce25bc1fa306f3927928e50";
       libraryHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations HUnit
         QuickCheck quickcheck-io random setenv tf-random time transformers
       ];
       testHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations hspec-meta
         HUnit process QuickCheck quickcheck-io random setenv silently
         tf-random time transformers
       ];
       jailbreak = true;
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-core_2_1_3" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, deepseq
     , hspec-expectations, hspec-meta, HUnit, process, QuickCheck
     , quickcheck-io, random, setenv, silently, tf-random, time
     , transformers
     }:
     mkDerivation {
       pname = "hspec-core";
       version = "2.1.3";
       sha256 = "abf891baa5028d95b67678be99c244a0f6e6de5864360d8f317e921c4b353f50";
       revision = "1";
       editedCabalFile = "fa18945958e6775a9e9322860109cf784c04f8092dd25049f278d14bb59e82c6";
       libraryHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations HUnit
         QuickCheck quickcheck-io random setenv tf-random time transformers
       ];
       testHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations hspec-meta
         HUnit process QuickCheck quickcheck-io random setenv silently
         tf-random time transformers
       ];
       jailbreak = true;
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-core_2_1_4" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, deepseq
     , hspec-expectations, hspec-meta, HUnit, process, QuickCheck
     , quickcheck-io, random, setenv, silently, tf-random, time
     , transformers
     }:
     mkDerivation {
       pname = "hspec-core";
       version = "2.1.4";
       sha256 = "474a7331052ec931396f1c44ed210b912a04fea4d3b62bf222ce803a03fb4a74";
       revision = "1";
       editedCabalFile = "a89d1f76840e870576c3533a943cac2a97483ced1e8bbf39333c885e25ad8050";
       libraryHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations HUnit
         QuickCheck quickcheck-io random setenv tf-random time transformers
       ];
       testHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations hspec-meta
         HUnit process QuickCheck quickcheck-io random setenv silently
         tf-random time transformers
       ];
       jailbreak = true;
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-core_2_1_5" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, deepseq
     , hspec-expectations, hspec-meta, HUnit, process, QuickCheck
     , quickcheck-io, random, setenv, silently, tf-random, time
     , transformers
     }:
     mkDerivation {
       pname = "hspec-core";
       version = "2.1.5";
       sha256 = "cb017a14049e1147ec2116e40b2e94b34c1f0ee15bc6bf71cdef67cce6f249fd";
       revision = "1";
       editedCabalFile = "873942e4a33150db7490168cc86505b1cf8deb5eab4a4e46e70364f5d06dc0a2";
       libraryHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations HUnit
         QuickCheck quickcheck-io random setenv tf-random time transformers
       ];
       testHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations hspec-meta
         HUnit process QuickCheck quickcheck-io random setenv silently
         tf-random time transformers
       ];
       jailbreak = true;
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-core_2_1_6" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, deepseq
     , hspec-expectations, hspec-meta, HUnit, process, QuickCheck
     , quickcheck-io, random, setenv, silently, tf-random, time
     , transformers
     }:
     mkDerivation {
       pname = "hspec-core";
       version = "2.1.6";
       sha256 = "8507fcdb0487d9f4c1ade1bddb073247d1798bc47e7462e95926e195e8d6af7a";
       revision = "1";
       editedCabalFile = "73696ada0e40e10ca366c30d3bf4b78b3433d117dd854457f6148af4678a17f6";
       libraryHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations HUnit
         QuickCheck quickcheck-io random setenv tf-random time transformers
       ];
       testHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations hspec-meta
         HUnit process QuickCheck quickcheck-io random setenv silently
         tf-random time transformers
       ];
       jailbreak = true;
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-core_2_1_7" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, deepseq
     , hspec-expectations, hspec-meta, HUnit, process, QuickCheck
     , quickcheck-io, random, setenv, silently, tf-random, time
     , transformers
     }:
     mkDerivation {
       pname = "hspec-core";
       version = "2.1.7";
       sha256 = "4b0045de536f7c0a4b76dd45b6c4d118282f3b57f98c6912450e798514d6dcc5";
       revision = "1";
       editedCabalFile = "062ce2d96948739fbb2911e1b6eebc4d569b9d5f0a7dbfa2de7d33b5a447bd68";
       libraryHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations HUnit
         QuickCheck quickcheck-io random setenv tf-random time transformers
       ];
       testHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations hspec-meta
         HUnit process QuickCheck quickcheck-io random setenv silently
         tf-random time transformers
       ];
       jailbreak = true;
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-core_2_1_10" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, deepseq
     , hspec-expectations, hspec-meta, HUnit, process, QuickCheck
     , quickcheck-io, random, setenv, silently, tf-random, time
     , transformers
     }:
     mkDerivation {
       pname = "hspec-core";
       version = "2.1.10";
       sha256 = "682e7e77e6f6256caefa6c0582d89dbee8efd864ac14a98cfba4707a9eb20ee0";
       revision = "1";
       editedCabalFile = "a49e372a1d7070a92d6f74b2be8e590ad9ed65be6efe89ce6873ac170b41a7f1";
       libraryHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations HUnit
         QuickCheck quickcheck-io random setenv tf-random time transformers
       ];
       testHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations hspec-meta
         HUnit process QuickCheck quickcheck-io random setenv silently
         tf-random time transformers
       ];
       jailbreak = true;
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-core_2_2_1" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, deepseq
     , hspec-expectations, hspec-meta, HUnit, process, QuickCheck
     , quickcheck-io, random, setenv, silently, tf-random, time
     , transformers
     }:
     mkDerivation {
       pname = "hspec-core";
       version = "2.2.1";
       sha256 = "af50b465accc865bdbce450f04b1ba69348cae71523a5212c2aa50a995ad4e75";
       revision = "1";
       editedCabalFile = "2a97857496ff09dadfb4bf65122ca54c395070a4d0f6fe7a3cff3d734dc02852";
       libraryHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations HUnit
         QuickCheck quickcheck-io random setenv tf-random time transformers
       ];
       testHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations hspec-meta
         HUnit process QuickCheck quickcheck-io random setenv silently
         tf-random time transformers
       ];
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-core" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, deepseq
     , hspec-expectations, hspec-meta, HUnit, process, QuickCheck
     , quickcheck-io, random, setenv, silently, tf-random, time
     , transformers
     }:
     mkDerivation {
       pname = "hspec-core";
       version = "2.2.2";
       sha256 = "01344835b8de81371087d187dbdb1011eea2c7e41132ed4edad643136d464398";
       libraryHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations HUnit
         QuickCheck quickcheck-io random setenv tf-random time transformers
       ];
       testHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations hspec-meta
         HUnit process QuickCheck quickcheck-io random setenv silently
         tf-random time transformers
       ];
       homepage = "http://hspec.github.io/";
       description = "A Testing Framework for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-discover_2_1_2" = callPackage
    ({ mkDerivation, base, directory, filepath, hspec-meta }:
     mkDerivation {
       pname = "hspec-discover";
       version = "2.1.2";
       sha256 = "29ac3cdc9f5dde4c3f411ff4f610b70f2a56be2a0efcd5d0db4f91945709627f";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [ base directory filepath hspec-meta ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://hspec.github.io/";
       description = "Automatically discover and run Hspec tests";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-discover_2_1_3" = callPackage
    ({ mkDerivation, base, directory, filepath, hspec-meta }:
     mkDerivation {
       pname = "hspec-discover";
       version = "2.1.3";
       sha256 = "60fb35311408307e3505807a7249c0687a5f1d837b15681799b634b8cdb1e81c";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [ base directory filepath hspec-meta ];
       doHaddock = false;
       homepage = "http://hspec.github.io/";
       description = "Automatically discover and run Hspec tests";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-discover_2_1_4" = callPackage
    ({ mkDerivation, base, directory, filepath, hspec-meta }:
     mkDerivation {
       pname = "hspec-discover";
       version = "2.1.4";
       sha256 = "1cefef3a34d8bd4105163671fb23d44149f6905808edbf024807662dbbf44bd9";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [ base directory filepath hspec-meta ];
       doHaddock = false;
       homepage = "http://hspec.github.io/";
       description = "Automatically discover and run Hspec tests";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-discover_2_1_5" = callPackage
    ({ mkDerivation, base, directory, filepath, hspec-meta }:
     mkDerivation {
       pname = "hspec-discover";
       version = "2.1.5";
       sha256 = "048cfe590c7cb86430196887256bf1bdea3f9330b5f133912bc058f8fb2b7a0d";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [ base directory filepath hspec-meta ];
       doHaddock = false;
       homepage = "http://hspec.github.io/";
       description = "Automatically discover and run Hspec tests";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-discover_2_1_6" = callPackage
    ({ mkDerivation, base, directory, filepath, hspec-meta }:
     mkDerivation {
       pname = "hspec-discover";
       version = "2.1.6";
       sha256 = "58067af4f44e9619f9656c4e9ef99db00ade81c5343f97891de769f208b44f6e";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [ base directory filepath hspec-meta ];
       doHaddock = false;
       homepage = "http://hspec.github.io/";
       description = "Automatically discover and run Hspec tests";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-discover_2_1_7" = callPackage
    ({ mkDerivation, base, directory, filepath, hspec-meta }:
     mkDerivation {
       pname = "hspec-discover";
       version = "2.1.7";
       sha256 = "8042eaa49b9a76dd89125f9b14978aee36e2e8526b171b3fa01d14dd929d093e";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [ base directory filepath hspec-meta ];
       doHaddock = false;
       homepage = "http://hspec.github.io/";
       description = "Automatically discover and run Hspec tests";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-discover_2_1_10" = callPackage
    ({ mkDerivation, base, directory, filepath, hspec-meta }:
     mkDerivation {
       pname = "hspec-discover";
       version = "2.1.10";
       sha256 = "efb14e44b9beef570d55c2db4904002bf61e7744cd00a3a5fc8c236b8f071a0b";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [ base directory filepath hspec-meta ];
       doHaddock = false;
       homepage = "http://hspec.github.io/";
       description = "Automatically discover and run Hspec tests";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-discover_2_2_1" = callPackage
    ({ mkDerivation, base, directory, filepath, hspec-meta }:
     mkDerivation {
       pname = "hspec-discover";
       version = "2.2.1";
       sha256 = "112ea28befc8e5b441fe99029bbbb83ad5dde2a994908facc610667ad0fb76c5";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [ base directory filepath hspec-meta ];
       doHaddock = false;
       homepage = "http://hspec.github.io/";
       description = "Automatically discover and run Hspec tests";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-discover" = callPackage
    ({ mkDerivation, base, directory, filepath, hspec-meta }:
     mkDerivation {
       pname = "hspec-discover";
       version = "2.2.2";
       sha256 = "4279c668ee8b537ad8192db47ba4a2c30fd49a90f6f5858bd7d2c835e752e81f";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [ base directory filepath hspec-meta ];
       doHaddock = false;
       homepage = "http://hspec.github.io/";
       description = "Automatically discover and run Hspec tests";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-expectations_0_6_1" = callPackage
    ({ mkDerivation, base, hspec, HUnit, markdown-unlit, silently }:
     mkDerivation {
       pname = "hspec-expectations";
       version = "0.6.1";
       sha256 = "f2d350cf26f7879c830926f49546fa4cdf4e751073fc65f124b1ab96866d2167";
       revision = "1";
       editedCabalFile = "113bfa34c077f32a1e83dcb9456dc9f3e79281b183644363174a781105688271";
       libraryHaskellDepends = [ base HUnit ];
       testHaskellDepends = [ base hspec HUnit markdown-unlit silently ];
       homepage = "https://github.com/sol/hspec-expectations#readme";
       description = "Catchy combinators for HUnit";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-expectations_0_6_1_1" = callPackage
    ({ mkDerivation, base, hspec, HUnit, markdown-unlit, silently }:
     mkDerivation {
       pname = "hspec-expectations";
       version = "0.6.1.1";
       sha256 = "3d4ef50cb6b51eb0de3ce97193029fd337d4b71de452f3d2c7eb467199586638";
       libraryHaskellDepends = [ base HUnit ];
       testHaskellDepends = [ base hspec HUnit markdown-unlit silently ];
       homepage = "https://github.com/sol/hspec-expectations#readme";
       description = "Catchy combinators for HUnit";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-expectations_0_7_1" = callPackage
    ({ mkDerivation, base, HUnit }:
     mkDerivation {
       pname = "hspec-expectations";
       version = "0.7.1";
       sha256 = "afcac6b3492a2db618e0e85e83cb106ba555fd966a3b045ee4aa30ccf199a258";
       revision = "1";
       editedCabalFile = "80e2d70b0dbb2b017d8af3ee30cc491e0b76fe7e8efb2706cda32060215a19a8";
       libraryHaskellDepends = [ base HUnit ];
       homepage = "https://github.com/sol/hspec-expectations#readme";
       description = "Catchy combinators for HUnit";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-expectations" = callPackage
    ({ mkDerivation, base, HUnit }:
     mkDerivation {
       pname = "hspec-expectations";
       version = "0.7.2";
       sha256 = "371a176b22ebdbc94b7bba55e0bda2296b44c11af01d20b23e4350ef7094a6f0";
       libraryHaskellDepends = [ base HUnit ];
       homepage = "https://github.com/sol/hspec-expectations#readme";
       description = "Catchy combinators for HUnit";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-expectations-lens" = callPackage
    ({ mkDerivation, base, hspec, hspec-expectations, HUnit, lens
     , silently
     }:
     mkDerivation {
       pname = "hspec-expectations-lens";
       version = "0.4.0";
       sha256 = "13f01bae9ff6dac00e332540d300cd0788faca601a0c5e4708afae228ac5899d";
       libraryHaskellDepends = [
         base hspec hspec-expectations HUnit lens
       ];
       testHaskellDepends = [ base hspec lens silently ];
       homepage = "http://supki.github.io/hspec-expectations-lens/";
       description = "Hspec expectations for the lens stuff";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "hspec-expectations-lifted" = callPackage
    ({ mkDerivation, base, hspec, hspec-expectations, transformers }:
     mkDerivation {
       pname = "hspec-expectations-lifted";
       version = "0.5.0";
       sha256 = "0b5511f1e4728f3b7b0eba53812319959009ab1277d14eede50f73d9f9eb6e30";
       revision = "1";
       editedCabalFile = "43e88e0e7587ba1965ba3f2416500c239ad44ba19043bb249c6f307665e85208";
       libraryHaskellDepends = [ base hspec-expectations transformers ];
       testHaskellDepends = [ base hspec ];
       description = "A version of hspec-expectations generalized to MonadIO";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-expectations-pretty" = callPackage
    ({ mkDerivation, base, deepseq, hspec-expectations
     , wl-pprint-extras, wl-pprint-terminfo
     }:
     mkDerivation {
       pname = "hspec-expectations-pretty";
       version = "0.1";
       sha256 = "c5767d10b298f74b79c66a37b649352529f9251fc4c8e338d66354b112bb1df5";
       libraryHaskellDepends = [
         base deepseq hspec-expectations wl-pprint-extras wl-pprint-terminfo
       ];
       jailbreak = true;
       homepage = "https://github.com/hspec/hspec-expectations#readme";
       description = "hspec-expectations with pretty printing on failure";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-expectations-pretty-diff" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, base, Diff, haskell-src-exts
     , hindent, hscolour, hspec, HUnit, text
     }:
     mkDerivation {
       pname = "hspec-expectations-pretty-diff";
       version = "0.7.2.3";
       sha256 = "3543bc7ecf28e8a714b255264849d82b6c513828a26a761e0f372bec1b37202f";
       libraryHaskellDepends = [
         ansi-terminal base Diff haskell-src-exts hindent hscolour HUnit
         text
       ];
       testHaskellDepends = [ aeson base hspec HUnit text ];
       homepage = "https://github.com/myfreeweb/hspec-expectations-pretty-diff#readme";
       description = "Catchy combinators for HUnit";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-experimental" = callPackage
    ({ mkDerivation, base, hspec, hspec-meta, HUnit, QuickCheck }:
     mkDerivation {
       pname = "hspec-experimental";
       version = "0.1.0";
       sha256 = "f53c0653ab2ee17b249d691e2b8f5627f61f2788107782b0aa3d905c444feca4";
       libraryHaskellDepends = [ base hspec HUnit QuickCheck ];
       testHaskellDepends = [ base hspec-meta ];
       jailbreak = true;
       description = "An experimental DSL for testing on top of Hspec";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-jenkins" = callPackage
    ({ mkDerivation, base, blaze-markup, hspec }:
     mkDerivation {
       pname = "hspec-jenkins";
       version = "0.1.1";
       sha256 = "c27f15e835ff5c1bb07096aee66f8845b691306353eb58d0378169ed1da05899";
       libraryHaskellDepends = [ base blaze-markup hspec ];
       homepage = "https://github.com/worksap-ate/hspec-jenkins";
       description = "Jenkins-friendly XML formatter for Hspec";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-laws" = callPackage
    ({ mkDerivation, base, hspec, markdown-unlit, QuickCheck }:
     mkDerivation {
       pname = "hspec-laws";
       version = "0.0.0";
       sha256 = "125025ee689e3b3a828cde1616e788a2c966ef7679472cb5ecd27e20ecd5ac96";
       libraryHaskellDepends = [ base hspec QuickCheck ];
       testHaskellDepends = [ base hspec markdown-unlit QuickCheck ];
       description = "Document and test laws for standard type classes";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-megaparsec_0_1_0" = callPackage
    ({ mkDerivation, base, hspec, hspec-expectations, megaparsec }:
     mkDerivation {
       pname = "hspec-megaparsec";
       version = "0.1.0";
       sha256 = "8fa6c28728fe8f9df354d81dccf3395160c74b28b0c9be9dcfc81f91fc331cfa";
       libraryHaskellDepends = [ base hspec-expectations megaparsec ];
       testHaskellDepends = [ base hspec hspec-expectations megaparsec ];
       homepage = "https://github.com/mrkkrp/hspec-megaparsec";
       description = "Utility functions for testing Megaparsec parsers with Hspec";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-megaparsec" = callPackage
    ({ mkDerivation, base, hspec, hspec-expectations, megaparsec }:
     mkDerivation {
       pname = "hspec-megaparsec";
       version = "0.1.1";
       sha256 = "4ff4683bdff9a3b0ba8a6ee1adfce01f30f8515f9db487b062e5e00e5a2795c5";
       libraryHaskellDepends = [ base hspec-expectations megaparsec ];
       testHaskellDepends = [ base hspec hspec-expectations megaparsec ];
       homepage = "https://github.com/mrkkrp/hspec-megaparsec";
       description = "Utility functions for testing Megaparsec parsers with Hspec";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hspec-meta_2_0_0" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, deepseq, directory
     , filepath, hspec-expectations, HUnit, QuickCheck, quickcheck-io
     , random, setenv, time, transformers
     }:
     mkDerivation {
       pname = "hspec-meta";
       version = "2.0.0";
       sha256 = "0e3189a86309c97bbc9741927be57f2ee55b55ee62444293fdf4316f49133374";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations HUnit
         QuickCheck quickcheck-io random setenv time transformers
       ];
       executableHaskellDepends = [ base directory filepath ];
       homepage = "http://hspec.github.io/";
       description = "A version of Hspec which is used to test Hspec itself";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-meta_2_1_5" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, deepseq, directory
     , filepath, hspec-expectations, HUnit, QuickCheck, quickcheck-io
     , random, setenv, time, transformers
     }:
     mkDerivation {
       pname = "hspec-meta";
       version = "2.1.5";
       sha256 = "2d4271eebd1279e3205055a18928951d93cf9de177a3b0a4dd6b91cb6051640b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations HUnit
         QuickCheck quickcheck-io random setenv time transformers
       ];
       executableHaskellDepends = [ base directory filepath ];
       homepage = "http://hspec.github.io/";
       description = "A version of Hspec which is used to test Hspec itself";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-meta_2_1_7" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, deepseq, directory
     , filepath, hspec-expectations, HUnit, QuickCheck, quickcheck-io
     , random, setenv, time, transformers
     }:
     mkDerivation {
       pname = "hspec-meta";
       version = "2.1.7";
       sha256 = "ffe41373ac24ff3e3c8d9ae5dfaf33c126c48ab16bc08c43ab91a58292f3097a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations HUnit
         QuickCheck quickcheck-io random setenv time transformers
       ];
       executableHaskellDepends = [ base directory filepath ];
       homepage = "http://hspec.github.io/";
       description = "A version of Hspec which is used to test Hspec itself";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-meta_2_2_0" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, deepseq, directory
     , filepath, hspec-expectations, HUnit, QuickCheck, quickcheck-io
     , random, setenv, time, transformers
     }:
     mkDerivation {
       pname = "hspec-meta";
       version = "2.2.0";
       sha256 = "bfa8fb7708368d063eab0c005addbb0b2f3227d76af55e61676584fbf3abb8ba";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations HUnit
         QuickCheck quickcheck-io random setenv time transformers
       ];
       executableHaskellDepends = [ base directory filepath ];
       homepage = "http://hspec.github.io/";
       description = "A version of Hspec which is used to test Hspec itself";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-meta" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, deepseq, directory
     , filepath, hspec-expectations, HUnit, QuickCheck, quickcheck-io
     , random, setenv, time, transformers
     }:
     mkDerivation {
       pname = "hspec-meta";
       version = "2.2.1";
       sha256 = "aa7b54c33cad9842783035d1a5cddbbbc3d556c8b2c8f6d0e6bfd3177b9e37d4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal async base deepseq hspec-expectations HUnit
         QuickCheck quickcheck-io random setenv time transformers
       ];
       executableHaskellDepends = [ base directory filepath ];
       homepage = "http://hspec.github.io/";
       description = "A version of Hspec which is used to test Hspec itself";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-monad-control" = callPackage
    ({ mkDerivation, base, hspec-core, monad-control, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "hspec-monad-control";
       version = "0.1.0.0";
       sha256 = "44041ea85c2629fe01bcdfbb78b46e52957c4c0d4a6caacda679c90c9f253e1f";
       libraryHaskellDepends = [
         base hspec-core monad-control transformers transformers-base
       ];
       description = "Orphan instances of MonadBase and MonadBaseControl for SpecM";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hspec-server" = callPackage
    ({ mkDerivation, base, containers, hspec, hspec-contrib, hspec-core
     , hspec-expectations, HUnit, process, regex-posix, temporary
     , transformers
     }:
     mkDerivation {
       pname = "hspec-server";
       version = "0.4.1";
       sha256 = "b838b80a5be1f347d8def2caec7124fcce23a44b3661123168ac32ecc62e769d";
       libraryHaskellDepends = [
         base containers hspec hspec-core hspec-expectations HUnit process
         regex-posix temporary transformers
       ];
       testHaskellDepends = [ base hspec hspec-contrib transformers ];
       description = "Test Framework for checking server's status";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hspec-setup" = callPackage
    ({ mkDerivation, base, directory, filepath, process, projectroot }:
     mkDerivation {
       pname = "hspec-setup";
       version = "0.1.1.0";
       sha256 = "8f1e57656595330917597a66768e752bf66c2ae7acf7c43425222a0e1ce7e12a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath process projectroot
       ];
       homepage = "https://github.com/yamadapc/haskell-hspec-setup";
       description = "Add an hspec test-suite in one command";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-shouldbe" = callPackage
    ({ mkDerivation, hspec, test-shouldbe }:
     mkDerivation {
       pname = "hspec-shouldbe";
       version = "0.0.1";
       sha256 = "2346d714fef3b7867202d4c32c224ce9376df2ef6b6990619c42748f37419e2c";
       libraryHaskellDepends = [ hspec test-shouldbe ];
       description = "Convenience wrapper and utilities for hspec";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-smallcheck_0_3_0" = callPackage
    ({ mkDerivation, base, hspec, QuickCheck, smallcheck }:
     mkDerivation {
       pname = "hspec-smallcheck";
       version = "0.3.0";
       sha256 = "bcb7e3e8f978177decafa7547da18717adf57228085ae49830db01b956f6cbfb";
       revision = "1";
       editedCabalFile = "0e173cc4f970ff00223564c44965ea1bb8c87891c2516efa4009e680d6601f03";
       libraryHaskellDepends = [ base hspec smallcheck ];
       testHaskellDepends = [ base hspec QuickCheck smallcheck ];
       jailbreak = true;
       homepage = "http://hspec.github.io/";
       description = "SmallCheck support for the Hspec testing framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-smallcheck" = callPackage
    ({ mkDerivation, base, hspec, hspec-core, QuickCheck, smallcheck }:
     mkDerivation {
       pname = "hspec-smallcheck";
       version = "0.4.1";
       sha256 = "c5ddd014ad58679554d2726a4442a124d7a3a9fad04c928c610cdc46773fc0f5";
       libraryHaskellDepends = [ base hspec-core smallcheck ];
       testHaskellDepends = [
         base hspec hspec-core QuickCheck smallcheck
       ];
       homepage = "http://hspec.github.io/";
       description = "SmallCheck support for the Hspec testing framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-snap_0_3_3_0" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , digestive-functors, directory, HandsomeSoup, hspec, hspec-core
     , hxt, lens, mtl, snap, snap-core, text, transformers
     }:
     mkDerivation {
       pname = "hspec-snap";
       version = "0.3.3.0";
       sha256 = "e465d9a2b289dd38ea4f28d01e9519573895df2a40d390702377435ffe4705b2";
       libraryHaskellDepends = [
         aeson base bytestring containers digestive-functors HandsomeSoup
         hspec hspec-core hxt lens mtl snap snap-core text transformers
       ];
       testHaskellDepends = [
         aeson base bytestring containers digestive-functors directory
         HandsomeSoup hspec hspec-core hxt lens mtl snap snap-core text
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/dbp/hspec-snap";
       description = "A library for testing with Hspec and the Snap Web Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-snap" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , digestive-functors, directory, HandsomeSoup, hspec, hspec-core
     , hxt, lens, mtl, snap, snap-core, text, transformers
     }:
     mkDerivation {
       pname = "hspec-snap";
       version = "0.4.0.0";
       sha256 = "8d18b945ce092f3848387099f2766d064d1815489a36518fe36f6f0efeab7d86";
       libraryHaskellDepends = [
         aeson base bytestring containers digestive-functors HandsomeSoup
         hspec hspec-core hxt lens mtl snap snap-core text transformers
       ];
       testHaskellDepends = [
         aeson base bytestring containers digestive-functors directory
         HandsomeSoup hspec hspec-core hxt lens mtl snap snap-core text
         transformers
       ];
       homepage = "https://github.com/dbp/hspec-snap";
       description = "A library for testing with Hspec and the Snap Web Framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hspec-structured-formatter" = callPackage
    ({ mkDerivation, base, hspec }:
     mkDerivation {
       pname = "hspec-structured-formatter";
       version = "0.1.0.3";
       sha256 = "b23e1dfc676bcc43fc9f79a076152a02a48525bdbb609d94f9e66eb831a80f01";
       libraryHaskellDepends = [ base hspec ];
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-test-framework" = callPackage
    ({ mkDerivation, base, hspec, hspec-contrib, hspec-core, HUnit
     , QuickCheck
     }:
     mkDerivation {
       pname = "hspec-test-framework";
       version = "0.1.0";
       sha256 = "bbd1425564db0ef61379e3501782ca9e8eba2b347c7f980c9152ade889f5348f";
       libraryHaskellDepends = [
         base hspec hspec-contrib hspec-core HUnit QuickCheck
       ];
       homepage = "http://hspec.github.io/";
       description = "Run test-framework tests with Hspec";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-test-framework-th" = callPackage
    ({ mkDerivation, base, hspec-test-framework, HUnit
     , language-haskell-extract, template-haskell
     }:
     mkDerivation {
       pname = "hspec-test-framework-th";
       version = "0.1.0";
       sha256 = "aa5edfeefe8bba50618e3ca75efa15f1e6f029f2a59b08a292e5ebe957deffaa";
       libraryHaskellDepends = [
         base hspec-test-framework language-haskell-extract template-haskell
       ];
       testHaskellDepends = [ base hspec-test-framework HUnit ];
       homepage = "http://hspec.github.io/";
       description = "Run test-framework tests with Hspec";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-test-sandbox" = callPackage
    ({ mkDerivation, base, hspec, hspec-core, test-sandbox }:
     mkDerivation {
       pname = "hspec-test-sandbox";
       version = "0.1.0";
       sha256 = "d72305f8611b8f0191432eb51204164d948776f7aa552819efbee818eaa5e7cd";
       libraryHaskellDepends = [ base hspec hspec-core test-sandbox ];
       testHaskellDepends = [ base hspec test-sandbox ];
       description = "Hspec convenience functions for use with test-sandbox";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hspec-wai_0_6_2" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, hspec
     , hspec-core, hspec-expectations, http-types, QuickCheck, text
     , transformers, wai, wai-extra
     }:
     mkDerivation {
       pname = "hspec-wai";
       version = "0.6.2";
       sha256 = "eb5f3c24cc83f82a3717a9fa175c831dc0966c43b268622b3182bc403e242a5a";
       libraryHaskellDepends = [
         base bytestring case-insensitive hspec-core hspec-expectations
         http-types text transformers wai wai-extra
       ];
       testHaskellDepends = [
         base bytestring case-insensitive hspec hspec-core
         hspec-expectations http-types QuickCheck text transformers wai
         wai-extra
       ];
       doHaddock = false;
       doCheck = false;
       description = "Experimental Hspec support for testing WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-wai_0_6_3" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, hspec
     , hspec-core, hspec-expectations, http-types, QuickCheck, text
     , transformers, wai, wai-extra
     }:
     mkDerivation {
       pname = "hspec-wai";
       version = "0.6.3";
       sha256 = "915ceb5efedeb7e3ff6480b9412944bf960a8f6861ae4322378d66eeee77cd6f";
       libraryHaskellDepends = [
         base bytestring case-insensitive hspec-core hspec-expectations
         http-types text transformers wai wai-extra
       ];
       testHaskellDepends = [
         base bytestring case-insensitive hspec hspec-core
         hspec-expectations http-types QuickCheck text transformers wai
         wai-extra
       ];
       description = "Experimental Hspec support for testing WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-wai" = callPackage
    ({ mkDerivation, base, base-compat, bytestring, case-insensitive
     , hspec, hspec-core, hspec-expectations, http-types, QuickCheck
     , text, transformers, wai, wai-extra
     }:
     mkDerivation {
       pname = "hspec-wai";
       version = "0.6.4";
       sha256 = "245ad277767a127ce8755c34fbc0374015250afef6f3c9af6c3aadee9f874860";
       libraryHaskellDepends = [
         base base-compat bytestring case-insensitive hspec-core
         hspec-expectations http-types QuickCheck text transformers wai
         wai-extra
       ];
       testHaskellDepends = [
         base base-compat bytestring case-insensitive hspec hspec-core
         hspec-expectations http-types QuickCheck text transformers wai
         wai-extra
       ];
       homepage = "https://github.com/hspec/hspec-wai#readme";
       description = "Experimental Hspec support for testing WAI applications";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-wai-json_0_6_0" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, bytestring, hspec
     , hspec-wai, template-haskell
     }:
     mkDerivation {
       pname = "hspec-wai-json";
       version = "0.6.0";
       sha256 = "f8ad2019c0dfec6b039b53f0d3eba8b666582860cc20abec2bdd5bcfc6463765";
       libraryHaskellDepends = [
         aeson aeson-qq base bytestring hspec-wai template-haskell
       ];
       testHaskellDepends = [ base hspec hspec-wai ];
       description = "Testing JSON APIs with hspec-wai";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-wai-json" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, bytestring
     , case-insensitive, hspec, hspec-wai, template-haskell
     }:
     mkDerivation {
       pname = "hspec-wai-json";
       version = "0.6.1";
       sha256 = "303e0e67c217ead3ef64f3ac3870b6c9b14a4135df5e8b2c79ad73df5a347c69";
       libraryHaskellDepends = [
         aeson aeson-qq base bytestring case-insensitive hspec-wai
         template-haskell
       ];
       testHaskellDepends = [ base hspec hspec-wai ];
       homepage = "https://github.com/hspec/hspec-wai#readme";
       description = "Testing JSON APIs with hspec-wai";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec-webdriver_1_0_2" = callPackage
    ({ mkDerivation, base, data-default, hashable, hspec, hspec-core
     , HUnit, lifted-base, stm, text, transformers, unordered-containers
     , webdriver
     }:
     mkDerivation {
       pname = "hspec-webdriver";
       version = "1.0.2";
       sha256 = "2c3508c9c185c08fcd27f7e2fde69e212eecf4488a0411fc72ab679544d86df2";
       libraryHaskellDepends = [
         base data-default hashable hspec hspec-core HUnit lifted-base stm
         text transformers unordered-containers webdriver
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://bitbucket.org/wuzzeb/webdriver-utils";
       description = "Write end2end web application tests using webdriver and hspec";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-webdriver_1_0_3" = callPackage
    ({ mkDerivation, base, data-default, hashable, hspec, hspec-core
     , HUnit, lifted-base, stm, text, transformers, unordered-containers
     , webdriver
     }:
     mkDerivation {
       pname = "hspec-webdriver";
       version = "1.0.3";
       sha256 = "24b736db0703acff84dfa7ed8cbccaf8b8d1884e4f609249b7461cd1b0959ff7";
       libraryHaskellDepends = [
         base data-default hashable hspec hspec-core HUnit lifted-base stm
         text transformers unordered-containers webdriver
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://bitbucket.org/wuzzeb/webdriver-utils";
       description = "Write end2end web application tests using webdriver and hspec";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspec-webdriver" = callPackage
    ({ mkDerivation, base, data-default, hashable, hspec, hspec-core
     , HUnit, lifted-base, stm, text, transformers, unordered-containers
     , webdriver
     }:
     mkDerivation {
       pname = "hspec-webdriver";
       version = "1.1.0";
       sha256 = "42c890d5f5c20f1e4eb7c21a5c33cab13adcc609e17f71495a136710186a6e69";
       libraryHaskellDepends = [
         base data-default hashable hspec hspec-core HUnit lifted-base stm
         text transformers unordered-containers webdriver
       ];
       homepage = "https://bitbucket.org/wuzzeb/webdriver-utils";
       description = "Write end2end web application tests using webdriver and hspec";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspec2" = callPackage
    ({ mkDerivation, base, hspec, hspec-discover }:
     mkDerivation {
       pname = "hspec2";
       version = "0.6.1";
       sha256 = "c4d5b728d158b764a04b458db85a55c5896e5c7635f529fa831e6143f2a99b7e";
       revision = "1";
       editedCabalFile = "d41ebaf2f80c6ae149a944cd77e31fce98c0eea45cf47a561c5c25d48e03107f";
       libraryHaskellDepends = [ base hspec hspec-discover ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://hspec.github.io/";
       description = "Alpha version of Hspec 2.0";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hspr-sh" = callPackage
    ({ mkDerivation, base, old-time }:
     mkDerivation {
       pname = "hspr-sh";
       version = "0.3";
       sha256 = "eacc267c2e0f11edf7757039b5b6a4563f54ecc16a6f6fc56d858ef49e78d8e2";
       libraryHaskellDepends = [ base old-time ];
       homepage = "http://www.cs.chalmers.se/~d00nibro/hsp/";
       description = "Session handler for HSP";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "hspread" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , extensible-exceptions, network
     }:
     mkDerivation {
       pname = "hspread";
       version = "0.3.3";
       sha256 = "6e8a9ecc1a6b1cc767aa188e2f4c04b77b321fd14000cac8f71dd6a7b82afbfc";
       libraryHaskellDepends = [
         base binary bytestring containers extensible-exceptions network
       ];
       description = "A client library for the spread toolkit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hspresent" = callPackage
    ({ mkDerivation, array, base, bytestring, vty }:
     mkDerivation {
       pname = "hspresent";
       version = "0.2.2";
       sha256 = "07c881323c0c14388e14477bb98917f8b86f13ef8e70bb5022416e44911f8e74";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base bytestring vty ];
       doHaddock = false;
       jailbreak = true;
       description = "A terminal presentation tool";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsprocess" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, easy-file
     , filepath, hint, hspec, HUnit, MonadCatchIO-mtl, process
     , QuickCheck, stringsearch, test-framework, test-framework-hunit
     , time
     }:
     mkDerivation {
       pname = "hsprocess";
       version = "0.3";
       sha256 = "bf28226f86505997b6908681fae2c9c7ba25660defdc7b9cff763e87e27887bc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring containers ];
       executableHaskellDepends = [
         base bytestring containers directory easy-file filepath hint
         MonadCatchIO-mtl process stringsearch time
       ];
       testHaskellDepends = [
         base bytestring containers hspec HUnit QuickCheck test-framework
         test-framework-hunit
       ];
       description = "The Haskell Stream Processor command line utility";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsql" = callPackage
    ({ mkDerivation, base, old-time }:
     mkDerivation {
       pname = "hsql";
       version = "1.8.2";
       sha256 = "7e2d32eb0d3a1e30ec8fe02ff41b8975298249ccf54ef2e9774260eb05b1a344";
       libraryHaskellDepends = [ base old-time ];
       description = "Database access from Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsql-mysql" = callPackage
    ({ mkDerivation, base, Cabal, hsql, mysqlclient }:
     mkDerivation {
       pname = "hsql-mysql";
       version = "1.8.3";
       sha256 = "499261d57532d01083e8a2f47edc71062490635975f391ae3a35e42c4b966420";
       revision = "1";
       editedCabalFile = "e1bbb71ecb6e310acf23a93e4a5e0121c8bd332e7a81dfa5bfe27ae94cbf14ab";
       libraryHaskellDepends = [ base Cabal hsql ];
       librarySystemDepends = [ mysqlclient ];
       description = "MySQL driver for HSQL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {mysqlclient = null;};

  "hsql-odbc" = callPackage
    ({ mkDerivation, base, hsql, old-time, unixODBC }:
     mkDerivation {
       pname = "hsql-odbc";
       version = "1.8.2";
       sha256 = "2e38527c1f29738907386231e1d161a64567f5ce0c8ab8965a52be1ebcfce953";
       libraryHaskellDepends = [ base hsql old-time ];
       librarySystemDepends = [ unixODBC ];
       description = "A Haskell Interface to ODBC";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) unixODBC;};

  "hsql-postgresql" = callPackage
    ({ mkDerivation, base, hsql, old-time, postgresql }:
     mkDerivation {
       pname = "hsql-postgresql";
       version = "1.8.2";
       sha256 = "3f3189c61daed7c4c45b37b683ee1da1ab91ec32cda7c36abf5b5e75a992407a";
       libraryHaskellDepends = [ base hsql old-time ];
       librarySystemDepends = [ postgresql ];
       description = "A Haskell Interface to PostgreSQL via the PQ library";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) postgresql;};

  "hsql-sqlite3" = callPackage
    ({ mkDerivation, base, hsql, sqlite }:
     mkDerivation {
       pname = "hsql-sqlite3";
       version = "1.8.2";
       sha256 = "94f95e93117f8bba01f4c098cd37a730a015baa7660a3eebcd4e85491c71c795";
       libraryHaskellDepends = [ base hsql ];
       librarySystemDepends = [ sqlite ];
       description = "SQLite3 driver for HSQL";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) sqlite;};

  "hsqml" = callPackage
    ({ mkDerivation, base, c2hs, containers, directory, filepath, qt5
     , QuickCheck, tagged, text, transformers
     }:
     mkDerivation {
       pname = "hsqml";
       version = "0.3.3.0";
       sha256 = "bf4eb06cbc76386158786784c4c2e29f976758c8f1cc41372b040b1484400f54";
       libraryHaskellDepends = [
         base containers filepath tagged text transformers
       ];
       libraryPkgconfigDepends = [ qt5 ];
       libraryToolDepends = [ c2hs ];
       testHaskellDepends = [
         base containers directory QuickCheck tagged text
       ];
       jailbreak = true;
       homepage = "http://www.gekkou.co.uk/software/hsqml/";
       description = "Haskell binding for Qt Quick";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {qt5 = null;};

  "hsqml-datamodel" = callPackage
    ({ mkDerivation, base, hsqml, qt5, template-haskell, text }:
     mkDerivation {
       pname = "hsqml-datamodel";
       version = "0.2.0.2";
       sha256 = "fbab7cc84a7a8938438b35d3c59f75dedf5a66b46719f044a7c869e227f7dcec";
       libraryHaskellDepends = [ base hsqml template-haskell text ];
       libraryPkgconfigDepends = [ qt5 ];
       homepage = "https://github.com/marcinmrotek/hsqml-datamodel";
       description = "HsQML (Qt5) data model";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {qt5 = null;};

  "hsqml-datamodel-vinyl" = callPackage
    ({ mkDerivation, base, exceptions, hsqml-datamodel, type-list
     , vinyl
     }:
     mkDerivation {
       pname = "hsqml-datamodel-vinyl";
       version = "0.3.0.1";
       sha256 = "b75630e22b253bcdc2760adc9e6e1e39e03ae24e2bbbebab923892f8ccd09fe0";
       libraryHaskellDepends = [
         base exceptions hsqml-datamodel type-list vinyl
       ];
       jailbreak = true;
       homepage = "https://github.com/marcinmrotek/hsqml-datamodel-vinyl";
       description = "HsQML DataModel instances for Vinyl Rec";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsqml-demo-morris" = callPackage
    ({ mkDerivation, base, containers, deepseq, directory, hsqml
     , OddWord, text
     }:
     mkDerivation {
       pname = "hsqml-demo-morris";
       version = "0.3.1.1";
       sha256 = "15d6fd3a62ccd3988eafafb0707775b6a0c7c749073644da30e0550bbd01d998";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers deepseq directory hsqml OddWord text
       ];
       homepage = "http://www.gekkou.co.uk/software/hsqml/";
       description = "HsQML-based implementation of Nine Men's Morris";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsqml-demo-notes" = callPackage
    ({ mkDerivation, base, containers, hsqml, sqlite-simple, text
     , transformers
     }:
     mkDerivation {
       pname = "hsqml-demo-notes";
       version = "0.3.3.0";
       sha256 = "23a0e790d4e91d455f1b20f1ef1992e0749142098d12b6a9d90ab2ab29d6543e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers hsqml sqlite-simple text transformers
       ];
       homepage = "http://www.gekkou.co.uk/software/hsqml/";
       description = "Sticky notes example program implemented in HsQML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "hsqml-demo-samples" = callPackage
    ({ mkDerivation, base, hsqml, OpenGL, OpenGLRaw, text }:
     mkDerivation {
       pname = "hsqml-demo-samples";
       version = "0.3.3.0";
       sha256 = "4cf95f075e9f2283e4adb0785dc25b0d45d8d33de3ea28ec17194d6ed816531c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base hsqml OpenGL OpenGLRaw text ];
       jailbreak = true;
       homepage = "http://www.gekkou.co.uk/software/hsqml/";
       description = "HsQML sample programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsqml-morris" = callPackage
    ({ mkDerivation, base, containers, deepseq, directory, hsqml
     , OddWord, tagged
     }:
     mkDerivation {
       pname = "hsqml-morris";
       version = "0.2.0.0";
       sha256 = "5d95e76968cbe2dec2b8ba79cf936d1b9d6530b6e3969d189f4f528a72883ae2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers deepseq directory hsqml OddWord tagged
       ];
       jailbreak = true;
       homepage = "http://www.gekkou.co.uk/";
       description = "HsQML-based implementation of Nine Men's Morris";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsreadability" = callPackage
    ({ mkDerivation, aeson, authenticate-oauth, base, bytestring
     , data-default, file-embed, http-conduit, http-types, HUnit
     , test-framework, test-framework-hunit, text, xsd
     }:
     mkDerivation {
       pname = "hsreadability";
       version = "1.0.0.0";
       sha256 = "5cd9ace845845d6ea76c5100fd149e0c9c60206d39fe96e9954869d94fc79a60";
       revision = "1";
       editedCabalFile = "e0b87a28497a4730024ce1459c7812d519027e8b90aa863dac85dd251558fa23";
       libraryHaskellDepends = [
         aeson authenticate-oauth base bytestring data-default http-conduit
         http-types text xsd
       ];
       testHaskellDepends = [
         aeson base file-embed HUnit test-framework test-framework-hunit
         text
       ];
       jailbreak = true;
       homepage = "http://github.com/rasendubi/hsreadability";
       description = "Access to the Readability API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hsseccomp" = callPackage
    ({ mkDerivation, base, seccomp, tasty, tasty-hunit, unix }:
     mkDerivation {
       pname = "hsseccomp";
       version = "0.1.0.2";
       sha256 = "fce6e18b1a87e1f62f3aad709d8a41fa4b34646cc32ec973ed279914c794dc0b";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ seccomp ];
       testHaskellDepends = [ base tasty tasty-hunit unix ];
       description = "Haskell bindings to libseccomp";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {seccomp = null;};

  "hsshellscript" = callPackage
    ({ mkDerivation, base, c2hs, directory, parsec, random, unix }:
     mkDerivation {
       pname = "hsshellscript";
       version = "3.3.4";
       sha256 = "3bd909d227215e0de6d6a42af736ccc21c360b677b9bff5b9c366859f582b54e";
       libraryHaskellDepends = [ base directory parsec random unix ];
       libraryToolDepends = [ c2hs ];
       homepage = "http://www.volker-wysk.de/hsshellscript/";
       description = "Haskell for Unix shell scripting tasks";
       license = "LGPL";
     }) {};

  "hssourceinfo" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, regexpr }:
     mkDerivation {
       pname = "hssourceinfo";
       version = "0.0.2";
       sha256 = "0a07297e034caa209e9fb418ad92c57a01ed3cea6e8ceac9ad3e8c40aae6e11d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath regexpr
       ];
       description = "get haskell source code info";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hssqlppp" = callPackage
    ({ mkDerivation, base, containers, groom, HUnit, mtl, parsec
     , pretty, syb, template-haskell, test-framework
     , test-framework-hunit, transformers, uniplate
     }:
     mkDerivation {
       pname = "hssqlppp";
       version = "0.4.2";
       sha256 = "f4735a94367c044eeeab7d4ee07c0c126142046a1576843c1545b1b2f0677520";
       libraryHaskellDepends = [
         base containers mtl parsec pretty syb template-haskell transformers
         uniplate
       ];
       testHaskellDepends = [
         base containers groom HUnit mtl parsec pretty syb template-haskell
         test-framework test-framework-hunit transformers uniplate
       ];
       jailbreak = true;
       homepage = "http://jakewheat.github.com/hssqlppp/";
       description = "SQL parser and type checker";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hstatistics_0_2_5_2" = callPackage
    ({ mkDerivation, array, base, hmatrix, hmatrix-gsl-stats, random
     , vector
     }:
     mkDerivation {
       pname = "hstatistics";
       version = "0.2.5.2";
       sha256 = "77bf6884977d53b30c9c78d152aa582c7006826c0fdc3f161beca036ba737321";
       libraryHaskellDepends = [
         array base hmatrix hmatrix-gsl-stats random vector
       ];
       homepage = "http://code.haskell.org/hstatistics";
       description = "Statistics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hstatistics" = callPackage
    ({ mkDerivation, array, base, hmatrix, hmatrix-gsl-stats, random
     , vector
     }:
     mkDerivation {
       pname = "hstatistics";
       version = "0.2.5.3";
       sha256 = "d8a8bf9dcf6bd25ac5ca695ec1c4fc198310411cc87ab2a23ffe1d9116812a2d";
       libraryHaskellDepends = [
         array base hmatrix hmatrix-gsl-stats random vector
       ];
       homepage = "http://code.haskell.org/hstatistics";
       description = "Statistics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hstats" = callPackage
    ({ mkDerivation, base, haskell98 }:
     mkDerivation {
       pname = "hstats";
       version = "0.3";
       sha256 = "12266f4e5212f72826281346058c1667f28af8fdb5292aab4f115ca2e01b6013";
       revision = "1";
       editedCabalFile = "0dcd5745170aeea7a6970ad9042c1043cc073f4fe40403af5795af09f9a062bf";
       libraryHaskellDepends = [ base haskell98 ];
       jailbreak = true;
       homepage = "http://github.com/unmarshal/hstats/";
       description = "Statistical Computing in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hstatsd" = callPackage
    ({ mkDerivation, base, bytestring, mtl, network, text }:
     mkDerivation {
       pname = "hstatsd";
       version = "0.1";
       sha256 = "446779594257c0fa02d5271c997ee0c22f74f7636d89e34394ad87e5bd285824";
       libraryHaskellDepends = [ base bytestring mtl network text ];
       homepage = "https://github.com/mokus0/hstatsd";
       description = "Quick and dirty statsd interface";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "hstest" = callPackage
    ({ mkDerivation, base, directory, filepath, ghc, ghc-paths, HUnit
     , mtl, QuickCheck, random
     }:
     mkDerivation {
       pname = "hstest";
       version = "0.0.1";
       sha256 = "ed99d06c79f40f74451156a58949b2341f8fc363da080a645b962a8156a1db29";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath ghc ghc-paths HUnit mtl QuickCheck random
       ];
       jailbreak = true;
       homepage = "http://bitbucket.org/dave4420/hstest/wiki/Home";
       description = "Runs tests via QuickCheck1 and HUnit; like quickCheck-script but uses GHC api";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hstidy" = callPackage
    ({ mkDerivation, base, haskell-src-exts }:
     mkDerivation {
       pname = "hstidy";
       version = "0.2";
       sha256 = "baef749c93e274212d953c9e97bcd461c891f3f682e0e866b182d80d686f5ac2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskell-src-exts ];
       homepage = "http://code.haskell.org/~morrow/code/haskell/hstidy";
       description = "Takes haskell source on stdin, parses it, then prettyprints it to stdout";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hstorchat" = callPackage
    ({ mkDerivation, attoparsec, base, containers, hsqml, HUnit
     , network, process, QuickCheck, random, safecopy, socks, tagged
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text
     }:
     mkDerivation {
       pname = "hstorchat";
       version = "0.1.1.0";
       sha256 = "6ccc80734d0b0e234e83ae8ad9a05537fdfe86b52dbef6f1d2073f6c9cd107b5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base containers hsqml network random safecopy socks
         tagged text
       ];
       executableHaskellDepends = [
         base containers hsqml network process text
       ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       jailbreak = true;
       description = "Distributed instant messaging over Tor";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hstradeking" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , case-insensitive, conduit, configurator, containers, hoauth
     , http-conduit, lifted-base, numbers, old-locale, resourcet, RSA
     , safe, text, time, transformers, vector
     }:
     mkDerivation {
       pname = "hstradeking";
       version = "0.1.0";
       sha256 = "9c98dc4c8d97951e9d62237476c3236c7c3f75e82d450491cccf6ea3a0db9e83";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring case-insensitive conduit
         configurator containers hoauth http-conduit lifted-base numbers
         old-locale resourcet RSA safe text time vector
       ];
       executableHaskellDepends = [
         base bytestring conduit resourcet transformers
       ];
       jailbreak = true;
       description = "Tradeking API bindings for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hstyle" = callPackage
    ({ mkDerivation, base, cmdargs, directory, filepath
     , haskell-src-exts, syb, text, vector
     }:
     mkDerivation {
       pname = "hstyle";
       version = "0.2.0.3";
       sha256 = "6558a2ee8cc68e1e47a966218e285b1de1a1dbfd585c12230d9aa6f64989c3a8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs directory filepath haskell-src-exts syb text vector
       ];
       jailbreak = true;
       description = "Checks Haskell source code for style compliance";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hstzaar" = callPackage
    ({ mkDerivation, base, cairo, containers, directory, filepath
     , glade, gtk, parallel, QuickCheck, random, xml
     }:
     mkDerivation {
       pname = "hstzaar";
       version = "0.9.3";
       sha256 = "55cc8f5f266c98e5d7356a1407c5de8e6da3f7154e5b9e83b42bb5528f2d4ec2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cairo containers directory filepath glade gtk parallel
         QuickCheck random xml
       ];
       jailbreak = true;
       homepage = "http://www.dcc.fc.up.pt/~pbv/stuff/hstzaar";
       description = "A two player abstract strategy game";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsubconvert" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, general-prelude, gitlib
     , hslogger, lens, mtl, parallel-io, regex-posix, stringable
     , svndump, system-fileio, system-filepath, text, text-format, time
     , transformers, unix
     }:
     mkDerivation {
       pname = "hsubconvert";
       version = "0.0.2";
       sha256 = "3c79a8425f3debb7a91bba0bf1d967d112659e2f9db61df919a91f12716f87ea";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs general-prelude gitlib hslogger lens mtl
         parallel-io regex-posix stringable svndump system-fileio
         system-filepath text text-format time transformers unix
       ];
       homepage = "https://github.com/jwiegley/hsubconvert";
       description = "One-time, faithful conversion of Subversion repositories to Git";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsverilog" = callPackage
    ({ mkDerivation, base, containers, hspec, hspec-contrib
     , hspec-expectations-lifted, shakespeare, text, transformers
     }:
     mkDerivation {
       pname = "hsverilog";
       version = "0.1.0";
       sha256 = "ea28a7bc660e00cb99681a3ee95ff56088bf237aff090e7852992414e82763e2";
       libraryHaskellDepends = [
         base containers shakespeare text transformers
       ];
       testHaskellDepends = [
         base containers hspec hspec-contrib hspec-expectations-lifted
         shakespeare text transformers
       ];
       description = "Synthesizable Verilog DSL supporting for multiple clock and reset";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hswip" = callPackage
    ({ mkDerivation, base, haskell98, mtl, ncurses, readline, swipl }:
     mkDerivation {
       pname = "hswip";
       version = "0.3";
       sha256 = "0119356ed576c3fb79d2c5dc35fe0e393679eff9b3a92baa39ff7a2b9dbdd486";
       libraryHaskellDepends = [ base haskell98 mtl ];
       librarySystemDepends = [ ncurses readline swipl ];
       description = "embedding prolog in haskell";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) ncurses; inherit (pkgs) readline; 
         swipl = null;};

  "hsx" = callPackage
    ({ mkDerivation, base, haskell-src-exts, mtl, utf8-string }:
     mkDerivation {
       pname = "hsx";
       version = "0.10.5";
       sha256 = "9b8cf0a88719607de4e11dfd2811ffe43487ed2d77624e0351df40133c12c410";
       revision = "1";
       editedCabalFile = "994fc0bb4928745f31c6c50279271b3463e2d5a8ce88cf2ede1edaf8d71e75ec";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base haskell-src-exts mtl utf8-string ];
       jailbreak = true;
       homepage = "http://patch-tag.com/r/nibro/hsx";
       description = "HSX (Haskell Source with XML) allows literal XML syntax in Haskell source code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsx-jmacro" = callPackage
    ({ mkDerivation, base, hsp, jmacro, mtl, text, wl-pprint-text }:
     mkDerivation {
       pname = "hsx-jmacro";
       version = "7.3.7";
       sha256 = "c425f16bcf578561d0e8b5e93e2e6c7a315ac05c510f88f9f675dcaca933caa9";
       libraryHaskellDepends = [
         base hsp jmacro mtl text wl-pprint-text
       ];
       homepage = "http://www.happstack.com/";
       description = "hsp+jmacro support";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsx-xhtml" = callPackage
    ({ mkDerivation, base, hsx, mtl }:
     mkDerivation {
       pname = "hsx-xhtml";
       version = "0.4.4";
       sha256 = "824e184fe16f540bc279f58d01f0f3c0187b502ed065b281e94a5be90974a180";
       libraryHaskellDepends = [ base hsx mtl ];
       homepage = "http://code.google.com/hsp";
       description = "XHTML utilities to use together with HSX";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsx2hs" = callPackage
    ({ mkDerivation, base, bytestring, haskell-src-exts
     , haskell-src-meta, mtl, template-haskell, utf8-string
     }:
     mkDerivation {
       pname = "hsx2hs";
       version = "0.13.4";
       sha256 = "9508c59b373474e7954f51be61b5e6a54f0a6241cca2a4ecf1b1ce8f5aae07df";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring haskell-src-exts haskell-src-meta mtl
         template-haskell utf8-string
       ];
       homepage = "https://github.com/seereason/hsx2hs";
       description = "HSX (Haskell Source with XML) allows literal XML syntax in Haskell source code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hsyscall" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hsyscall";
       version = "0.4";
       sha256 = "8d8ad7d8d9b6d5aa1df39b59c40985526632345a3a8c890e567a3ebe4f18517b";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/aycanirican/hsyscall";
       description = "FFI to syscalls";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hsyslog" = callPackage
    ({ mkDerivation, base, doctest }:
     mkDerivation {
       pname = "hsyslog";
       version = "2.0";
       sha256 = "f80e8cbab80388941588836e58dbb355898eb44f3f628867dc6b109b1f4a660b";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base doctest ];
       homepage = "http://github.com/peti/hsyslog";
       description = "FFI interface to syslog(3) from POSIX.1-2001";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "hszephyr" = callPackage
    ({ mkDerivation, base, bytestring, com_err, mtl, time, zephyr }:
     mkDerivation {
       pname = "hszephyr";
       version = "0.1";
       sha256 = "593b213b298bdda179bd97b013e4e7ad52ddab1ae9f18c7595710bdc58ccff51";
       libraryHaskellDepends = [ base bytestring mtl time ];
       librarySystemDepends = [ com_err zephyr ];
       description = "Simple libzephyr bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {com_err = null; zephyr = null;};

  "htaglib" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, HUnit
     , taglib, test-framework, test-framework-hunit, text
     }:
     mkDerivation {
       pname = "htaglib";
       version = "1.0.1";
       sha256 = "beade72766595be3705b9ac3d13461dffefb821b471c22a53b04b93ff86db760";
       libraryHaskellDepends = [ base bytestring text ];
       librarySystemDepends = [ taglib ];
       testHaskellDepends = [
         base directory filepath HUnit test-framework test-framework-hunit
       ];
       homepage = "https://github.com/mrkkrp/htaglib";
       description = "Bindings to TagLib, audio meta-data library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) taglib;};

  "htags" = callPackage
    ({ mkDerivation, base, directory, filepath, haskell-src, mtl }:
     mkDerivation {
       pname = "htags";
       version = "1.0.1";
       sha256 = "537e8409085a21c4dce83a2aab46d99db80764a0efbe7c61ab11ff17e96f8d18";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath haskell-src mtl
       ];
       description = "A Haskell98 parsing tags program similar to ctags";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "htar" = callPackage
    ({ mkDerivation, base, bytestring, bzlib, directory, filepath
     , old-locale, tar, time, zlib
     }:
     mkDerivation {
       pname = "htar";
       version = "0.4.0.2";
       sha256 = "7f788adcf99d32461f2a9eeb2731ab7a6c1689304cc0aa7013d33108f03ea596";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring bzlib directory filepath old-locale tar time zlib
       ];
       jailbreak = true;
       description = "Command-line tar archive utility";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "htiled" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, containers
     , filepath, hxt, split, zlib
     }:
     mkDerivation {
       pname = "htiled";
       version = "0.1.3.0";
       sha256 = "1141d497418c6f53c8e578be673073956108cf2617f8bf8af0c045a8f1f974da";
       libraryHaskellDepends = [
         base base64-bytestring bytestring containers filepath hxt split
         zlib
       ];
       jailbreak = true;
       description = "Import from the Tiled map editor";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "htime" = callPackage
    ({ mkDerivation, base, process, time }:
     mkDerivation {
       pname = "htime";
       version = "0.3.1";
       sha256 = "b92bc79630a7a7ca8d53a86a17f444ac409c21984467db55c68145c3d68dc793";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base process time ];
       description = "Timing utility for the command line";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "html" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "html";
       version = "1.0.1.2";
       sha256 = "0c35495ea33d65e69c69bc7441ec8e1af69fbb43433c2aa3406c0a13a3ab3061";
       libraryHaskellDepends = [ base ];
       description = "HTML combinator library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "html-conduit_1_1_1_1" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , containers, hspec, HUnit, resourcet, system-filepath
     , tagstream-conduit, text, transformers, xml-conduit, xml-types
     }:
     mkDerivation {
       pname = "html-conduit";
       version = "1.1.1.1";
       sha256 = "007098771875594e797a3438836ef6361c7960eb99b0734835c0cce3b50359af";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra containers resourcet
         system-filepath tagstream-conduit text transformers xml-conduit
         xml-types
       ];
       testHaskellDepends = [
         base bytestring containers hspec HUnit xml-conduit
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/xml";
       description = "Parse HTML documents using xml-conduit datatypes";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "html-conduit_1_1_1_2" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , containers, hspec, HUnit, resourcet, system-filepath
     , tagstream-conduit, text, transformers, xml-conduit, xml-types
     }:
     mkDerivation {
       pname = "html-conduit";
       version = "1.1.1.2";
       sha256 = "6474464dc21f731f2cde7a2e39a2c10d3fa95282a7080515c6398a173979da84";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra containers resourcet
         system-filepath tagstream-conduit text transformers xml-conduit
         xml-types
       ];
       testHaskellDepends = [
         base bytestring containers hspec HUnit xml-conduit
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/xml";
       description = "Parse HTML documents using xml-conduit datatypes";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "html-conduit_1_2_0" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , containers, hspec, HUnit, resourcet, tagstream-conduit, text
     , transformers, xml-conduit, xml-types
     }:
     mkDerivation {
       pname = "html-conduit";
       version = "1.2.0";
       sha256 = "751096080f961a44ac3c2d93274dfa5fd4e047d215af33734dd325158e16404a";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra containers resourcet
         tagstream-conduit text transformers xml-conduit xml-types
       ];
       testHaskellDepends = [
         base bytestring containers hspec HUnit xml-conduit
       ];
       homepage = "https://github.com/snoyberg/xml";
       description = "Parse HTML documents using xml-conduit datatypes";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "html-conduit" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , containers, hspec, HUnit, resourcet, tagstream-conduit, text
     , transformers, xml-conduit, xml-types
     }:
     mkDerivation {
       pname = "html-conduit";
       version = "1.2.1";
       sha256 = "bb1c76947268fd5661918d02de73132b50f364d92f0d4e331ee0e0c87e0cff29";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra containers resourcet
         tagstream-conduit text transformers xml-conduit xml-types
       ];
       testHaskellDepends = [
         base bytestring containers hspec HUnit xml-conduit
       ];
       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, hspec, QuickCheck
     , regex-pcre-builtin, text
     }:
     mkDerivation {
       pname = "html-email-validate";
       version = "0.2.0.0";
       sha256 = "3d2a3ec75b638cec71df57512473052d485dc118aec4662d5a8dae5e95aa6daf";
       libraryHaskellDepends = [ attoparsec base text ];
       testHaskellDepends = [
         attoparsec base hspec QuickCheck regex-pcre-builtin text
       ];
       description = "Validating an email address against HTML standard";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "html-entities" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, directory, doctest
     , filepath, text, unordered-containers
     }:
     mkDerivation {
       pname = "html-entities";
       version = "1.1.0.0";
       sha256 = "1641957d9a76e85c5bf060e3fe3fd1ecc0b2ddcff96638562d9797837cd1a07e";
       libraryHaskellDepends = [
         attoparsec base-prelude text unordered-containers
       ];
       testHaskellDepends = [
         base base-prelude directory doctest filepath
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/html-entities";
       description = "A codec library for HTML-escaped text and HTML-entities";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "html-kure" = callPackage
    ({ mkDerivation, base, hxt, kure }:
     mkDerivation {
       pname = "html-kure";
       version = "0.2.1";
       sha256 = "1428b6f5b30beb88e28925e26a498874592aa46fa51f05fc00db2b6bf270e2f4";
       libraryHaskellDepends = [ base hxt kure ];
       homepage = "www.ittc.ku.edu/csdl/fpg/software/html-kure";
       description = "HTML rewrite engine, using KURE";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "html-minimalist" = callPackage
    ({ mkDerivation, base, xml }:
     mkDerivation {
       pname = "html-minimalist";
       version = "0.15";
       sha256 = "b2f0c7fb6b0f04249b61c76ec22655c8808af15a239177ce523cf5c0d092101b";
       libraryHaskellDepends = [ base xml ];
       homepage = "http://rd.slavepianos.org/t/html-minimalist";
       description = "Minimalist haskell html library";
       license = "GPL";
     }) {};

  "html-rules" = callPackage
    ({ mkDerivation, base, lens, mtl, tagsoup, transformers }:
     mkDerivation {
       pname = "html-rules";
       version = "0.1.0.1";
       sha256 = "fcd2f2e15cdb9e77c7d2fb8db77be393c66fc376e3e7f7d03759315a43c712cc";
       libraryHaskellDepends = [ base lens mtl tagsoup transformers ];
       jailbreak = true;
       homepage = "http://github.com/kylcarte/html-rules/";
       description = "Perform traversals of HTML structures using sets of rules";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "html-tokenizer" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, case-insensitive
     , conversion, conversion-case-insensitive, conversion-text
     , directory, doctest, filepath, text
     }:
     mkDerivation {
       pname = "html-tokenizer";
       version = "0.4.0.0";
       sha256 = "8767075be6ce5efbec5cd27fdd5efa21fdf16546730789e08861429078978428";
       libraryHaskellDepends = [
         attoparsec base-prelude case-insensitive conversion
         conversion-case-insensitive conversion-text text
       ];
       testHaskellDepends = [
         base base-prelude directory doctest filepath
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/html-tokenizer";
       description = "An \"attoparsec\"-based HTML tokenizer";
       license = stdenv.lib.licenses.mit;
     }) {};

  "html-truncate" = callPackage
    ({ mkDerivation, base, tagsoup }:
     mkDerivation {
       pname = "html-truncate";
       version = "0.3.0.0";
       sha256 = "24dceeb9d4287c294b83da58022cf8aa3e4d0a9dae06ae235ae49c805e9bc6b4";
       libraryHaskellDepends = [ base tagsoup ];
       homepage = "https://github.com/mruegenberg/html-truncate";
       description = "A HTML truncator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "html2hamlet" = callPackage
    ({ mkDerivation, base, bytestring, containers, hamlet, html-conduit
     , http-conduit, mtl, optparse-declarative, regex-tdfa, text
     , wl-pprint-text, xml-conduit
     }:
     mkDerivation {
       pname = "html2hamlet";
       version = "0.3.0";
       sha256 = "bfb6c9d66fddbc38ce205d9c5133eb94336c0f762cc1d015597b529bca6f89d8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers hamlet html-conduit http-conduit mtl
         optparse-declarative regex-tdfa text wl-pprint-text xml-conduit
       ];
       homepage = "http://github.com/tanakh/html2hamlet";
       description = "HTML to Hamlet converter";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "html5-entity" = callPackage
    ({ mkDerivation, base, containers, text }:
     mkDerivation {
       pname = "html5-entity";
       version = "0.2.0.3";
       sha256 = "2e067939e2c7d1a204ee219651f6c31205eed3ff6f43e0852ffc5bd5a1feb52e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers text ];
       homepage = "https://github.com/zudov/html5-entity/";
       description = "A library for looking up and validating HTML5 entities";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "htodo" = callPackage
    ({ mkDerivation, base, HDBC, HDBC-sqlite3 }:
     mkDerivation {
       pname = "htodo";
       version = "0.0.4";
       sha256 = "555092cf22a95162b0142333583c95659505236f5262eea222f010793d27632b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base HDBC HDBC-sqlite3 ];
       homepage = "http://github.com/pirapira/htodo";
       description = "A todo application";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "htoml" = callPackage
    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
     , file-embed, old-locale, parsec, tasty, tasty-hspec, tasty-hunit
     , text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "htoml";
       version = "0.1.0.3";
       sha256 = "84890e99f5f01d38c2177f9d4f1ff1ce4e50e832a663d1c3ebe7d9750156ab16";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base containers old-locale parsec text time
         unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson base bytestring Cabal containers file-embed parsec tasty
         tasty-hspec tasty-hunit text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bytestring Cabal containers file-embed parsec tasty
         tasty-hspec tasty-hunit text time unordered-containers vector
       ];
       homepage = "https://github.com/cies/htoml";
       description = "Parser for TOML files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "htrace" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "htrace";
       version = "0.1";
       sha256 = "9dee29cd8f34466f592c50de344c26da350773f4cbf089ee164fdd6b6ee2212b";
       libraryHaskellDepends = [ base ];
       description = "Hierarchical tracing for debugging of lazy evaluation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hts" = callPackage
    ({ mkDerivation, base, hmt, xml }:
     mkDerivation {
       pname = "hts";
       version = "0.15";
       sha256 = "c21b19b50cf5d7e8da10eebdfa453d4a86d6207a3df3ccdb4c97e8a6e5d40950";
       libraryHaskellDepends = [ base hmt xml ];
       homepage = "http://rd.slavepianos.org/t/hts";
       description = "Haskell Music Typesetting";
       license = "GPL";
     }) {};

  "htsn" = callPackage
    ({ mkDerivation, base, cmdargs, configurator, directory, filepath
     , hdaemonize, hslogger, htsn-common, hxt, MissingH, network
     , process, tasty, tasty-hunit, unix
     }:
     mkDerivation {
       pname = "htsn";
       version = "0.1.1";
       sha256 = "e5de5e6bc8f2edaaf2f650a1de6c59bc64eba0a56c7f1d98755d1423441f7088";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs configurator directory filepath hdaemonize hslogger
         htsn-common hxt MissingH network tasty tasty-hunit unix
       ];
       testHaskellDepends = [
         base cmdargs configurator directory filepath hdaemonize hslogger
         htsn-common hxt MissingH network process tasty tasty-hunit unix
       ];
       description = "Parse XML files from The Sports Network feed";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "htsn-common" = callPackage
    ({ mkDerivation, ansi-terminal, base, hslogger, transformers }:
     mkDerivation {
       pname = "htsn-common";
       version = "0.0.2";
       sha256 = "25b04dafb1797eb7697d3bc2049284ffc218cb34d058aced3741d93a9001977b";
       libraryHaskellDepends = [
         ansi-terminal base hslogger transformers
       ];
       description = "Display/logging facilities used by both htsn and htsn-import";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "htsn-import" = callPackage
    ({ mkDerivation, base, cmdargs, configurator, containers, directory
     , doctest, filepath, fixed-vector-hetero, groundhog
     , groundhog-postgresql, groundhog-sqlite, groundhog-th, hslogger
     , htsn-common, hxt, MissingH, old-locale, process, split, tasty
     , tasty-hunit, time, transformers, tuple
     }:
     mkDerivation {
       pname = "htsn-import";
       version = "0.2.4";
       sha256 = "036794975f6d809c5960686e48761c1420dc4e559181a9fee7b52172144aa0d6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs configurator containers directory filepath
         fixed-vector-hetero groundhog groundhog-postgresql groundhog-sqlite
         groundhog-th hslogger htsn-common hxt MissingH old-locale split
         tasty tasty-hunit time transformers tuple
       ];
       testHaskellDepends = [
         base cmdargs configurator containers directory doctest filepath
         fixed-vector-hetero groundhog groundhog-postgresql groundhog-sqlite
         groundhog-th hslogger htsn-common hxt MissingH old-locale process
         split tasty tasty-hunit time transformers tuple
       ];
       description = "Import XML files from The Sports Network into an RDBMS";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-accept" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "http-accept";
       version = "0.2";
       sha256 = "3112c86be446d52b0b65b698ff79a95bfcdc77e1ea91dd44356e3d99329f7cc7";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "https://github.com/singpolyma/http-accept";
       description = "Functions for working with HTTP Accept headers";
       license = "unknown";
     }) {};

  "http-api-data_0_2_1" = callPackage
    ({ mkDerivation, base, bytestring, doctest, Glob, hspec, HUnit
     , QuickCheck, text, time
     }:
     mkDerivation {
       pname = "http-api-data";
       version = "0.2.1";
       sha256 = "856138d79945770cdb4b522f58893a1c45014d39238cfc5b2eceeac089c56f71";
       libraryHaskellDepends = [ base bytestring text time ];
       testHaskellDepends = [
         base doctest Glob hspec HUnit QuickCheck text time
       ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-api-data" = callPackage
    ({ mkDerivation, base, bytestring, doctest, Glob, hspec, HUnit
     , QuickCheck, text, time, time-locale-compat
     }:
     mkDerivation {
       pname = "http-api-data";
       version = "0.2.2";
       sha256 = "fba6a38c0f3a39e2ce02b42351953d9aa82f48ef83e5c921a9a1e719b8bc45dc";
       libraryHaskellDepends = [
         base bytestring text time time-locale-compat
       ];
       testHaskellDepends = [
         base doctest Glob hspec HUnit QuickCheck text time
       ];
       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-attoparsec" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, http-types }:
     mkDerivation {
       pname = "http-attoparsec";
       version = "0.1.1";
       sha256 = "43e16753f5e4126aaec41aac67562e38151fc6de9c2b10eace35841e9d48888a";
       libraryHaskellDepends = [ attoparsec base bytestring http-types ];
       jailbreak = true;
       homepage = "https://github.com/tlaitinen/http-attoparsec";
       description = "Attoparsec parsers for http-types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "http-client_0_4_6" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, exceptions, filepath, ghc-prim
     , hspec, http-types, mime-types, monad-control, network
     , network-uri, publicsuffixlist, random, streaming-commons, text
     , time, transformers, zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.6";
       sha256 = "a801a56968e67072f31638bb21e87db143479b6491ca201b9abd73a69895617f";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri publicsuffixlist random streaming-commons text time
         transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq hspec http-types monad-control
         network streaming-commons text time transformers zlib
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_6_1" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, exceptions, filepath, ghc-prim
     , hspec, http-types, mime-types, monad-control, network
     , network-uri, publicsuffixlist, random, streaming-commons, text
     , time, transformers, zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.6.1";
       sha256 = "8bafa8802a587779992da08ff80941c42331d853227a20bca35ada590a989bfc";
       revision = "1";
       editedCabalFile = "86eb1bcfc162801bdde88fbe4a3b39efa9f2eb14d56fd8e28d1a95cb3b574819";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri publicsuffixlist random streaming-commons text time
         transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq hspec http-types monad-control
         network streaming-commons text time transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_6_2" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, exceptions, filepath, ghc-prim
     , hspec, http-types, mime-types, monad-control, network
     , network-uri, publicsuffixlist, random, streaming-commons, text
     , time, transformers, zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.6.2";
       sha256 = "4c36772df657b5856f40c65ba0de0e1fc97aeff13d61d92f1f14b33a844d13ed";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri publicsuffixlist random streaming-commons text time
         transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq hspec http-types monad-control
         network streaming-commons text time transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_7" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, exceptions, filepath, ghc-prim
     , hspec, http-types, mime-types, monad-control, network
     , network-uri, publicsuffixlist, random, streaming-commons, text
     , time, transformers, zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.7";
       sha256 = "93789434091165114b9c9af749a13bc2085285c822504bb6b40b54a1cd7d00e4";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri publicsuffixlist random streaming-commons text time
         transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq hspec http-types monad-control
         network streaming-commons text time transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_7_1" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, exceptions, filepath, ghc-prim
     , hspec, http-types, mime-types, monad-control, network
     , network-uri, publicsuffixlist, random, streaming-commons, text
     , time, transformers, zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.7.1";
       sha256 = "634222f6caa6014c0f34bb858c77037e6c7417148645d62d0dfdb59f91027fee";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri publicsuffixlist random streaming-commons text time
         transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq hspec http-types monad-control
         network streaming-commons text time transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_8" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, clock, containers
     , cookie, data-default-class, deepseq, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, publicsuffixlist, random, streaming-commons, text
     , time, transformers, zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.8";
       sha256 = "e7a8c661a41a28f8bd70a88a451f53a9376cd9859aeb1f0cc2be595454a66e83";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive clock containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri publicsuffixlist random streaming-commons text time
         transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq hspec http-types monad-control
         network streaming-commons text time transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_8_1" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, clock, containers
     , cookie, data-default-class, deepseq, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, publicsuffixlist, random, streaming-commons, text
     , time, transformers, zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.8.1";
       sha256 = "3a46ee64e710d71fdbb527493a7795e28d12226868e59fe5f140961ec138ad21";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive clock containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri publicsuffixlist random streaming-commons text time
         transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq hspec http-types monad-control
         network streaming-commons text time transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_9" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, clock, containers
     , cookie, data-default-class, deepseq, directory, exceptions
     , filepath, ghc-prim, hspec, http-types, mime-types, monad-control
     , network, network-uri, publicsuffixlist, random, streaming-commons
     , text, time, transformers, zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.9";
       sha256 = "569155c371487885f2ad1982e5721af18799d827009d5212cbb004e343eb28b7";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive clock containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri publicsuffixlist random streaming-commons text time
         transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network streaming-commons text time transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_11" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, clock, containers
     , cookie, data-default-class, deepseq, directory, exceptions
     , filepath, ghc-prim, hspec, http-types, mime-types, monad-control
     , network, network-uri, publicsuffixlist, random, streaming-commons
     , text, time, transformers, zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.11";
       sha256 = "0b5e802c58439b964c0b20e8de9700553ed4dd91f6f548b2d142d9a1e4dcf953";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive clock containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri publicsuffixlist random streaming-commons text time
         transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network streaming-commons text time transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_11_1" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, clock, containers
     , cookie, data-default-class, deepseq, directory, exceptions
     , filepath, ghc-prim, hspec, http-types, mime-types, monad-control
     , network, network-uri, publicsuffixlist, random, streaming-commons
     , text, time, transformers, zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.11.1";
       sha256 = "642500bd7e7a26a80dae54ca2d830e42b0e55e39d172cc73e7f68469cd4b5088";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive clock containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri publicsuffixlist random streaming-commons text time
         transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network streaming-commons text time transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_11_2" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.11.2";
       sha256 = "6275d2a1012fa159b2a68fe54c1f6ff9967d772a973189503598c4213d80981c";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network streaming-commons text time transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_11_3" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.11.3";
       sha256 = "3867cbde9a7b7715c4bc3340592de89acb6d908a5a514b42d529960fc3eac911";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network streaming-commons text time transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_12" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.12";
       sha256 = "8f3ada7a0626bea36430e0feec603a318d304c49b093f93aeab7fa359dc3b5be";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network streaming-commons text time transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_13" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.13";
       sha256 = "b11640ec850dfe17db59e81cfaf7222a064c67ef35884b4546365d4cf966b2ef";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network network-uri streaming-commons text time
         transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_15" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.15";
       sha256 = "2e673dd139db1c6a76b7ec705f55a1f7afacd7d5f92aa7a06f499ba3e2786a4c";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network network-uri streaming-commons text time
         transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_16" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.16";
       sha256 = "02ddc0a6679c5caf2c8cb080028a99d11b8ada4f70be3e1d0f16b00151221fbe";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network network-uri streaming-commons text time
         transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_18_1" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.18.1";
       sha256 = "69bba520e4719b5f2b1f2ce5bebea441d082691b76bef37c9fff410497ae156c";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network network-uri streaming-commons text time
         transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_19" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.19";
       sha256 = "5e5db3a8dfb309c8dc99ba154e0176013f7c50547b60b758725a5f5927b5e3f8";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network network-uri streaming-commons text time
         transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_20" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.20";
       sha256 = "8d79157a2887b67d90926a267eaf21b24e914c0975e371ac079167894e308a24";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network network-uri streaming-commons text time
         transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_21" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.21";
       sha256 = "f6465cfec946c7acfeb210daa97e65e67c3924867072ed47193a83cf1226dc30";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network network-uri streaming-commons text time
         transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_22" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.22";
       sha256 = "769c99eaa9aea041ac7cb8bede9397737a1235cd6c83b3c8e98366f868ea5b33";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network network-uri streaming-commons text time
         transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_23" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.23";
       sha256 = "161519afbc9c9e51fd4429250b9bb1e475f5da4b550d0daf2a93a8e685660369";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network network-uri streaming-commons text time
         transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_24" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.24";
       sha256 = "93e4182ef9d3e8b45b75cca0f63b20457823e5aeaba46f6a16de47d7e618e177";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network network-uri streaming-commons text time
         transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_25" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.25";
       sha256 = "2aaefe7d75a0052b32a14cd3749c2a94602a64d87195722cebe75ebde014ec6d";
       revision = "1";
       editedCabalFile = "18bfde86302131a8378a0289610f8f860a0f2d1b3f58d8d450e62a79a0410c98";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network network-uri streaming-commons text time
         transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_26_1" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.26.1";
       sha256 = "38c264cdc0ad0dcc1f0fbd11a2fa638b55f65476ebcee0bdd9309c38fb5f1047";
       revision = "1";
       editedCabalFile = "8b6aa0fc4dba313afe69bc926a29a98638402f82b54fee6a9798b9bf90e83a62";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network network-uri streaming-commons text time
         transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client_0_4_26_2" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.26.2";
       sha256 = "5c06c7944da2489d0abb91f8807418e013e77610d2fd3245641f1235371e8c6d";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network network-uri streaming-commons text time
         transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client" = callPackage
    ({ mkDerivation, array, async, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, exceptions, filepath
     , ghc-prim, hspec, http-types, mime-types, monad-control, network
     , network-uri, random, streaming-commons, text, time, transformers
     , zlib
     }:
     mkDerivation {
       pname = "http-client";
       version = "0.4.27";
       sha256 = "3700731ca44470847b9a6429c61b7501318443ded995c33c7f52c9a7fd23a88b";
       libraryHaskellDepends = [
         array base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         exceptions filepath ghc-prim http-types mime-types network
         network-uri random streaming-commons text time transformers
       ];
       testHaskellDepends = [
         async base base64-bytestring blaze-builder bytestring
         case-insensitive containers deepseq directory hspec http-types
         monad-control network network-uri streaming-commons text time
         transformers zlib
       ];
       doCheck = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "An HTTP client engine, intended as a base layer for more user-friendly packages";
       license = stdenv.lib.licenses.mit;
     }) {};

  "http-client-auth" = callPackage
    ({ mkDerivation, base, base64-string, blaze-builder, bytestring
     , case-insensitive, conduit, crypto-conduit, http-client
     , http-conduit, pureMD5, resourcet, transformers, utf8-string
     }:
     mkDerivation {
       pname = "http-client-auth";
       version = "0.1.0.1";
       sha256 = "441a92ab423615e740fd39784c3dfc0cd4c66b5fddd3c21f730ea3113e574c1f";
       libraryHaskellDepends = [
         base base64-string blaze-builder bytestring case-insensitive
         conduit crypto-conduit http-client http-conduit pureMD5 resourcet
         transformers utf8-string
       ];
       description = "HTTP authorization (both basic and digest) done right";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "http-client-conduit" = callPackage
    ({ mkDerivation, base, http-client }:
     mkDerivation {
       pname = "http-client-conduit";
       version = "0.3.0";
       sha256 = "2934dd952999bdb87a0c1ccabfdaf985db82a12227cbaf358373b9797cc25b4c";
       libraryHaskellDepends = [ base http-client ];
       doHaddock = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "Frontend support for using http-client with conduit (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "http-client-lens" = callPackage
    ({ mkDerivation, base, bytestring, http-client, http-types, lens
     , network
     }:
     mkDerivation {
       pname = "http-client-lens";
       version = "0.1.0";
       sha256 = "37cab1344deaf1b54c9e63f76cd21f37cda4023560072b30e7135d982f1fb8d8";
       libraryHaskellDepends = [
         base bytestring http-client http-types lens network
       ];
       jailbreak = true;
       homepage = "http://github.com/reinh/http-client-lens";
       description = "Optics for http-client";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "http-client-multipart" = callPackage
    ({ mkDerivation, base, http-client }:
     mkDerivation {
       pname = "http-client-multipart";
       version = "0.3.0.0";
       sha256 = "2fb33407176843b1495835aa3fed618398057e86eff99c4baa0fa2628636eaa3";
       libraryHaskellDepends = [ base http-client ];
       doHaddock = false;
       homepage = "https://github.com/snoyberg/http-client";
       description = "Generate multipart uploads for http-client. (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "http-client-openssl" = callPackage
    ({ mkDerivation, base, HsOpenSSL, hspec, http-client, http-types
     , network
     }:
     mkDerivation {
       pname = "http-client-openssl";
       version = "0.2.0.1";
       sha256 = "a37a5c6695c3771594e6202062e433f80843249bc6d48a1a4766f5188a7de2d5";
       libraryHaskellDepends = [ base HsOpenSSL http-client network ];
       testHaskellDepends = [
         base HsOpenSSL hspec http-client http-types
       ];
       homepage = "https://github.com/snoyberg/http-client";
       description = "http-client backend using the OpenSSL library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "http-client-request-modifiers" = callPackage
    ({ mkDerivation, base, bytestring, exceptions, http-client
     , http-media, http-types, network, network-uri
     }:
     mkDerivation {
       pname = "http-client-request-modifiers";
       version = "0.1";
       sha256 = "b944faca62c140e1e478b4f110f3c46d5e8b6d1a7d60408074dd02f888c8a6ad";
       libraryHaskellDepends = [
         base bytestring exceptions http-client http-media http-types
         network network-uri
       ];
       jailbreak = true;
       homepage = "https://github.com/spl/http-client-request-modifiers";
       description = "Convenient monadic HTTP request modifiers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-client-streams" = callPackage
    ({ mkDerivation, base, bytestring, HsOpenSSL, http-client
     , http-client-openssl, io-streams, mtl, transformers
     }:
     mkDerivation {
       pname = "http-client-streams";
       version = "0.3.1.0";
       sha256 = "1fb9a61ef1b4af41dd3c1dfc9b683c8f56ed4d0963cd5212a129159510053ce1";
       libraryHaskellDepends = [
         base bytestring HsOpenSSL http-client http-client-openssl
         io-streams mtl transformers
       ];
       jailbreak = true;
       description = "http-client for io-streams supporting openssl";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "http-client-tls" = callPackage
    ({ mkDerivation, base, bytestring, connection, data-default-class
     , hspec, http-client, http-types, network, tls
     }:
     mkDerivation {
       pname = "http-client-tls";
       version = "0.2.2";
       sha256 = "451e5833a1f07fdc162fde4371ac92986932d5c38f9969ace7babb020bc80128";
       libraryHaskellDepends = [
         base bytestring connection data-default-class http-client network
         tls
       ];
       testHaskellDepends = [ base hspec http-client http-types ];
       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, 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
       ];
       homepage = "http://research.operationaldynamics.com/projects/http-streams/";
       description = "Common types for HTTP clients and servers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "http-conduit_2_1_5" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , conduit, conduit-extra, connection, cookie, data-default-class
     , hspec, http-client, http-client-tls, http-types, HUnit
     , lifted-base, monad-control, mtl, network, resourcet
     , streaming-commons, text, time, transformers, utf8-string, wai
     , wai-conduit, warp, warp-tls
     }:
     mkDerivation {
       pname = "http-conduit";
       version = "2.1.5";
       sha256 = "0300ec74e16799b2eec9d9a3402aaead9beaae1a2ef734e92ceac0018d55626e";
       revision = "1";
       editedCabalFile = "0f535cbb34d4a3614910c50c148e7ff93ebfa2b51976844e43e7c039b9cced65";
       libraryHaskellDepends = [
         base bytestring conduit http-client http-client-tls http-types
         lifted-base monad-control mtl resourcet transformers
       ];
       testHaskellDepends = [
         base blaze-builder bytestring case-insensitive conduit
         conduit-extra connection cookie data-default-class hspec
         http-client http-types HUnit lifted-base network streaming-commons
         text time transformers utf8-string wai wai-conduit warp warp-tls
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-conduit_2_1_5_1" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , conduit, conduit-extra, connection, cookie, data-default-class
     , hspec, http-client, http-client-tls, http-types, HUnit
     , lifted-base, monad-control, mtl, network, resourcet
     , streaming-commons, text, time, transformers, utf8-string, wai
     , wai-conduit, warp, warp-tls
     }:
     mkDerivation {
       pname = "http-conduit";
       version = "2.1.5.1";
       sha256 = "821b4891d236c190ee8853f4aa273e46a521a04402bee0bec218a630c040f7e6";
       revision = "1";
       editedCabalFile = "cdb1774981302f416fe1c9fc31e1a66e0ee888bbd3ea714911380650e8820810";
       libraryHaskellDepends = [
         base bytestring conduit http-client http-client-tls http-types
         lifted-base monad-control mtl resourcet transformers
       ];
       testHaskellDepends = [
         base blaze-builder bytestring case-insensitive conduit
         conduit-extra connection cookie data-default-class hspec
         http-client http-types HUnit lifted-base network streaming-commons
         text time transformers utf8-string wai wai-conduit warp warp-tls
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-conduit_2_1_7_1" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , conduit, conduit-extra, connection, cookie, data-default-class
     , hspec, http-client, http-client-tls, http-types, HUnit
     , lifted-base, monad-control, mtl, network, resourcet
     , streaming-commons, text, time, transformers, utf8-string, wai
     , wai-conduit, warp, warp-tls
     }:
     mkDerivation {
       pname = "http-conduit";
       version = "2.1.7.1";
       sha256 = "a674bcdede3336bf7cd85ba58763d9267d67adcfa3e95ef987288a131ad78a95";
       revision = "1";
       editedCabalFile = "ac4bbb931c8c5349bb56954062e4b12b51e769784deb49d91e75e8cda0b97d09";
       libraryHaskellDepends = [
         base bytestring conduit http-client http-client-tls http-types
         lifted-base monad-control mtl resourcet transformers
       ];
       testHaskellDepends = [
         base blaze-builder bytestring case-insensitive conduit
         conduit-extra connection cookie data-default-class hspec
         http-client http-types HUnit lifted-base network streaming-commons
         text time transformers utf8-string wai wai-conduit warp warp-tls
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-conduit_2_1_7_2" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , conduit, conduit-extra, connection, cookie, data-default-class
     , hspec, http-client, http-client-tls, http-types, HUnit
     , lifted-base, monad-control, mtl, network, resourcet
     , streaming-commons, text, time, transformers, utf8-string, wai
     , wai-conduit, warp, warp-tls
     }:
     mkDerivation {
       pname = "http-conduit";
       version = "2.1.7.2";
       sha256 = "ccd5d034d9c1f185ccf600e7f6d6153df793218233683ba073bab62d5449dc46";
       revision = "1";
       editedCabalFile = "c8c8877562dbf78bd7329907b9e9bb594778ecf0bbd8eb50fda80d82205503ce";
       libraryHaskellDepends = [
         base bytestring conduit http-client http-client-tls http-types
         lifted-base monad-control mtl resourcet transformers
       ];
       testHaskellDepends = [
         base blaze-builder bytestring case-insensitive conduit
         conduit-extra connection cookie data-default-class hspec
         http-client http-types HUnit lifted-base network streaming-commons
         text time transformers utf8-string wai wai-conduit warp warp-tls
       ];
       jailbreak = true;
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-conduit" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , conduit, conduit-extra, connection, cookie, data-default-class
     , hspec, http-client, http-client-tls, http-types, HUnit
     , lifted-base, monad-control, mtl, network, resourcet
     , streaming-commons, text, time, transformers, utf8-string, wai
     , wai-conduit, warp, warp-tls
     }:
     mkDerivation {
       pname = "http-conduit";
       version = "2.1.8";
       sha256 = "550d86ea9ee6dd90994a460c5c85ddc861fb5c0f007304dc4a2e2035f980ea3d";
       revision = "2";
       editedCabalFile = "970d73310cb9628d120eaa029aac6b9dd8b79ce63e91959cce8ca26afa952c7f";
       libraryHaskellDepends = [
         base bytestring conduit http-client http-client-tls http-types
         lifted-base monad-control mtl resourcet transformers
       ];
       testHaskellDepends = [
         base blaze-builder bytestring case-insensitive conduit
         conduit-extra connection cookie data-default-class hspec
         http-client http-types HUnit lifted-base network streaming-commons
         text time transformers utf8-string wai wai-conduit warp warp-tls
       ];
       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-conduit-browser" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring
     , case-insensitive, conduit, containers, cookie, data-default
     , exceptions, hspec, http-client, http-conduit, http-types, HUnit
     , lifted-base, monad-control, network, network-uri, resourcet, text
     , time, transformers, transformers-base, wai, warp
     }:
     mkDerivation {
       pname = "http-conduit-browser";
       version = "2.0.0.0";
       sha256 = "3885fe04cd87526c082e906a1d29ce9088ca456cfe3dc121cf4ef34ac2d28feb";
       libraryHaskellDepends = [
         base bytestring conduit containers cookie data-default exceptions
         http-client http-conduit http-types lifted-base monad-control
         network-uri resourcet time transformers transformers-base
       ];
       testHaskellDepends = [
         base base64-bytestring blaze-builder bytestring case-insensitive
         conduit containers cookie data-default hspec http-client
         http-conduit http-types HUnit lifted-base monad-control network
         resourcet text time transformers wai warp
       ];
       jailbreak = true;
       homepage = "https://github.com/exbb2/http-conduit-browser";
       description = "Browser interface to the http-conduit package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-conduit-downloader" = callPackage
    ({ mkDerivation, base, bytestring, conduit, connection
     , data-default, HsOpenSSL, http-client, http-conduit, http-types
     , lifted-base, mtl, network, network-uri, old-locale, resourcet
     , time, zlib
     }:
     mkDerivation {
       pname = "http-conduit-downloader";
       version = "1.0.25";
       sha256 = "6ae6f5a6ac130225d2fae5f123ff89c547de3b549efe016c0464dd352b1b693c";
       libraryHaskellDepends = [
         base bytestring conduit connection data-default HsOpenSSL
         http-client http-conduit http-types lifted-base mtl network
         network-uri old-locale resourcet time zlib
       ];
       homepage = "https://github.com/bazqux/http-conduit-downloader";
       description = "HTTP downloader tailored for web-crawler needs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-date_0_0_4" = callPackage
    ({ mkDerivation, array, attoparsec, base, bytestring, doctest
     , hspec, old-locale, time
     }:
     mkDerivation {
       pname = "http-date";
       version = "0.0.4";
       sha256 = "25228b2456b319c7c777ea3673f441ddf68881da176b37c51feab2108d0175dd";
       libraryHaskellDepends = [ array attoparsec base bytestring ];
       testHaskellDepends = [
         base bytestring doctest hspec old-locale time
       ];
       description = "HTTP Date parser/formatter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-date_0_0_5" = callPackage
    ({ mkDerivation, array, attoparsec, base, bytestring, doctest
     , hspec, old-locale, time
     }:
     mkDerivation {
       pname = "http-date";
       version = "0.0.5";
       sha256 = "6f245dd8f13a0d676b3b3291a3ed3b6bcd8dc91747f75973d5af2e2e77d97b8b";
       libraryHaskellDepends = [ array attoparsec base bytestring ];
       testHaskellDepends = [
         base bytestring doctest hspec old-locale time
       ];
       description = "HTTP Date parser/formatter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-date_0_0_6" = callPackage
    ({ mkDerivation, array, attoparsec, base, bytestring, doctest
     , hspec, old-locale, time
     }:
     mkDerivation {
       pname = "http-date";
       version = "0.0.6";
       sha256 = "898d56c1b5736b3f866c7abf9ab2bdc6811d6bcddf8a784d0074b2afdc223a38";
       libraryHaskellDepends = [ array attoparsec base bytestring ];
       testHaskellDepends = [
         base bytestring doctest hspec old-locale time
       ];
       description = "HTTP Date parser/formatter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-date" = callPackage
    ({ mkDerivation, array, attoparsec, base, bytestring, doctest
     , hspec, old-locale, time
     }:
     mkDerivation {
       pname = "http-date";
       version = "0.0.6.1";
       sha256 = "f2e106603e2b3f710f1189e478f6c20067d9a9d21a20a633fe362b3f91807636";
       libraryHaskellDepends = [ array attoparsec base bytestring ];
       testHaskellDepends = [
         base bytestring doctest hspec old-locale time
       ];
       description = "HTTP Date parser/formatter";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "http-encodings" = callPackage
    ({ mkDerivation, base, bytestring, HTTP, iconv, mime, mtl, parsec
     , text, utf8-string, zlib
     }:
     mkDerivation {
       pname = "http-encodings";
       version = "0.9.3";
       sha256 = "76dbd6c38d885cc6d260b59945cc0cd6c6087bb078a01be5384a2e2f14fe492c";
       revision = "3";
       editedCabalFile = "5d6088d3d3691cec6febb92f81d5034a69bcf6d319230d5a478d79cb79b0e6f9";
       libraryHaskellDepends = [
         base bytestring HTTP iconv mime mtl parsec text utf8-string zlib
       ];
       homepage = "http://github.com/achudnov/http-encodings";
       description = "A library for encoding and decoding bodies of HTTP messages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "http-enumerator" = callPackage
    ({ mkDerivation, asn1-data, attoparsec, attoparsec-enumerator, base
     , base64-bytestring, blaze-builder, blaze-builder-enumerator
     , bytestring, case-insensitive, certificate, containers, cprng-aes
     , data-default, enumerator, failure, http-types, monad-control
     , network, tls, tls-extra, transformers, utf8-string, zlib-enum
     }:
     mkDerivation {
       pname = "http-enumerator";
       version = "0.7.3.3";
       sha256 = "463f4a7086ee9226ad882ddeb51d5086b237204ef2e0780e1c544eb2debd8283";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         asn1-data attoparsec attoparsec-enumerator base base64-bytestring
         blaze-builder blaze-builder-enumerator bytestring case-insensitive
         certificate containers cprng-aes data-default enumerator failure
         http-types monad-control network tls tls-extra transformers
         utf8-string zlib-enum
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/http-enumerator";
       description = "HTTP client package with enumerator interface and HTTPS support. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-kit" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, hspec
     , http-types, QuickCheck, quickcheck-instances
     }:
     mkDerivation {
       pname = "http-kit";
       version = "0.5.1";
       sha256 = "487cd630f7ec3c1d50e22d9566bfa56ab7b7409e0927edaf21692ea596de96eb";
       libraryHaskellDepends = [
         base bytestring case-insensitive http-types
       ];
       testHaskellDepends = [
         base bytestring hspec http-types QuickCheck quickcheck-instances
       ];
       description = "A low-level HTTP library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "http-link-header" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring
     , bytestring-conversion, errors, hspec, hspec-attoparsec
     , network-uri, QuickCheck, text
     }:
     mkDerivation {
       pname = "http-link-header";
       version = "1.0.1";
       sha256 = "908bb3356d3fe24615f5498c6dca1075f76f01e034838538a3c4b0ccc342e9b7";
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-conversion errors network-uri
         text
       ];
       testHaskellDepends = [
         base hspec hspec-attoparsec QuickCheck text
       ];
       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-listen" = callPackage
    ({ mkDerivation, base, bytestring, exceptions, HTTP, network
     , transformers
     }:
     mkDerivation {
       pname = "http-listen";
       version = "0.1.0.0";
       sha256 = "e0eb0bb8898084fe07ddead700e42de294f70b6a62ee4c2e3c9c3d4b3f2595b1";
       revision = "2";
       editedCabalFile = "968de91e5c6c468a62f8f5bff6b465dea5fcd0d33b024dc81df1a9cea9beb2ef";
       libraryHaskellDepends = [
         base bytestring exceptions HTTP network transformers
       ];
       homepage = "http://rel4tion.org/projects/http-listen/";
       description = "Listen to HTTP requests and handle them in arbitrary ways";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "http-media_0_6_1" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, cabal-test-quickcheck
     , case-insensitive, containers, QuickCheck
     }:
     mkDerivation {
       pname = "http-media";
       version = "0.6.1";
       sha256 = "b8affebcb75e508ecb14fe22213d8c54e190e7b144f2a6c2a09418cdd8ac5a74";
       libraryHaskellDepends = [
         base bytestring case-insensitive containers
       ];
       testHaskellDepends = [
         base bytestring Cabal cabal-test-quickcheck case-insensitive
         containers QuickCheck
       ];
       doCheck = false;
       homepage = "https://github.com/zmthy/http-media";
       description = "Processing HTTP Content-Type and Accept headers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-media_0_6_2" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, containers
     , QuickCheck, test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "http-media";
       version = "0.6.2";
       sha256 = "a7ce64b69d1dbb4e7480976e80c451f9773ab02ed44846d743ec720b3b7c7d64";
       libraryHaskellDepends = [
         base bytestring case-insensitive containers
       ];
       testHaskellDepends = [
         base bytestring case-insensitive containers QuickCheck
         test-framework test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "https://github.com/zmthy/http-media";
       description = "Processing HTTP Content-Type and Accept headers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-media" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, containers
     , QuickCheck, test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "http-media";
       version = "0.6.3";
       sha256 = "38ac24e33a2ef0fdeb9f1c3311aa1efb4902701888fd4a590c1912aaa9b1dad6";
       libraryHaskellDepends = [
         base bytestring case-insensitive containers
       ];
       testHaskellDepends = [
         base bytestring case-insensitive containers QuickCheck
         test-framework test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "https://github.com/zmthy/http-media";
       description = "Processing HTTP Content-Type and Accept headers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "http-monad" = callPackage
    ({ mkDerivation, base, bytestring, containers, explicit-exception
     , HTTP, lazyio, network, parsec, transformers, utility-ht
     }:
     mkDerivation {
       pname = "http-monad";
       version = "0.1.1";
       sha256 = "e75643a34100c171050f4f9011b2120c87269ebf49f372a7005aa63a49f1ee88";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers explicit-exception HTTP lazyio network
         parsec transformers utility-ht
       ];
       jailbreak = true;
       description = "Monad abstraction for HTTP allowing lazy transfer and non-I/O simulation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-proxy" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder
     , blaze-builder-conduit, bytestring, bytestring-lexing
     , case-insensitive, conduit, ghc-prim, http-conduit, http-types
     , lifted-base, network, resourcet, tls, transformers, wai
     }:
     mkDerivation {
       pname = "http-proxy";
       version = "0.0.12";
       sha256 = "2fb6fbcd49babf663fe2d52f3ebb8bddc5b712fb5b0a1741e2c1cfdc47aed84c";
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder blaze-builder-conduit
         bytestring bytestring-lexing case-insensitive conduit ghc-prim
         http-conduit http-types lifted-base network resourcet tls
         transformers wai
       ];
       jailbreak = true;
       homepage = "https://github.com/erikd/http-proxy";
       description = "A library for writing HTTP and HTTPS proxies";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-querystring" = callPackage
    ({ mkDerivation, base, bytestring, containers, doctest, hspec
     , http-types, QuickCheck
     }:
     mkDerivation {
       pname = "http-querystring";
       version = "1.0";
       sha256 = "a69e29840dbbe6fd924ec660cdcab0660283ce0387f3b768b9febd9b38ea4158";
       libraryHaskellDepends = [ base bytestring containers http-types ];
       testHaskellDepends = [
         base bytestring containers doctest hspec http-types QuickCheck
       ];
       homepage = "https://github.com/worksap-ate/http-querystring";
       description = "The HTTP query builder";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "http-reverse-proxy_0_4_1_2" = callPackage
    ({ mkDerivation, async, base, blaze-builder, bytestring
     , case-insensitive, conduit, conduit-extra, containers
     , data-default-class, hspec, http-client, http-conduit, http-types
     , lifted-base, monad-control, network, resourcet, streaming-commons
     , text, transformers, wai, wai-logger, warp, word8
     }:
     mkDerivation {
       pname = "http-reverse-proxy";
       version = "0.4.1.2";
       sha256 = "9ea3ef753447c7cd4d74258d14eae26af8830c47f040a0e6eaf53c0468b1efbd";
       libraryHaskellDepends = [
         async base blaze-builder bytestring case-insensitive conduit
         conduit-extra containers data-default-class http-client http-types
         lifted-base monad-control network resourcet streaming-commons text
         transformers wai wai-logger word8
       ];
       testHaskellDepends = [
         base blaze-builder bytestring conduit conduit-extra hspec
         http-conduit http-types lifted-base network resourcet
         streaming-commons transformers wai warp
       ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-reverse-proxy_0_4_1_3" = callPackage
    ({ mkDerivation, async, base, blaze-builder, bytestring
     , case-insensitive, conduit, conduit-extra, containers
     , data-default-class, hspec, http-client, http-conduit, http-types
     , lifted-base, monad-control, network, resourcet, streaming-commons
     , text, transformers, wai, wai-logger, warp, word8
     }:
     mkDerivation {
       pname = "http-reverse-proxy";
       version = "0.4.1.3";
       sha256 = "d089c4cf26f9bebac8469dc26ec6b40868744f4b629683e254fc54204752a1c8";
       libraryHaskellDepends = [
         async base blaze-builder bytestring case-insensitive conduit
         conduit-extra containers data-default-class http-client http-types
         lifted-base monad-control network resourcet streaming-commons text
         transformers wai wai-logger word8
       ];
       testHaskellDepends = [
         base blaze-builder bytestring conduit conduit-extra hspec
         http-conduit http-types lifted-base network resourcet
         streaming-commons transformers wai warp
       ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-reverse-proxy_0_4_2" = callPackage
    ({ mkDerivation, async, base, blaze-builder, bytestring
     , case-insensitive, conduit, conduit-extra, containers
     , data-default-class, hspec, http-client, http-conduit, http-types
     , lifted-base, monad-control, network, resourcet, streaming-commons
     , text, transformers, wai, wai-logger, warp, word8
     }:
     mkDerivation {
       pname = "http-reverse-proxy";
       version = "0.4.2";
       sha256 = "3118eae07425ee5e44fb309f6a99f09d6a4fccb4965cc6af2ce5ba6003348d81";
       revision = "1";
       editedCabalFile = "3b7a6c0b55cd7eb98d3f020ac08cec7ca052b8ec716f76cfabdcbaef27645db7";
       libraryHaskellDepends = [
         async base blaze-builder bytestring case-insensitive conduit
         conduit-extra containers data-default-class http-client http-types
         lifted-base monad-control network resourcet streaming-commons text
         transformers wai wai-logger word8
       ];
       testHaskellDepends = [
         base blaze-builder bytestring conduit conduit-extra hspec
         http-conduit http-types lifted-base network resourcet
         streaming-commons transformers wai warp
       ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-reverse-proxy" = callPackage
    ({ mkDerivation, async, base, blaze-builder, bytestring
     , case-insensitive, conduit, conduit-extra, containers
     , data-default-class, hspec, http-client, http-conduit, http-types
     , lifted-base, monad-control, network, resourcet, streaming-commons
     , text, transformers, wai, wai-logger, warp, word8
     }:
     mkDerivation {
       pname = "http-reverse-proxy";
       version = "0.4.3";
       sha256 = "4776b8bc59dfc889ce932223f07f236be89840c3c47cb91b7fd3fb47d1cddf45";
       libraryHaskellDepends = [
         async base blaze-builder bytestring case-insensitive conduit
         conduit-extra containers data-default-class http-client http-types
         lifted-base monad-control network resourcet streaming-commons text
         transformers wai wai-logger word8
       ];
       testHaskellDepends = [
         base blaze-builder bytestring conduit conduit-extra hspec
         http-conduit http-types lifted-base network resourcet
         streaming-commons transformers wai warp
       ];
       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-server" = callPackage
    ({ mkDerivation, base, HTTP, mime, network, network-uri, text, unix
     , url, utf8-string
     }:
     mkDerivation {
       pname = "http-server";
       version = "1.0.6";
       sha256 = "5cd44741053aef8ba7bd6b6d8d0a8048a171db42e2b7cb5013a99fcd754143b5";
       libraryHaskellDepends = [
         base HTTP mime network network-uri text unix url utf8-string
       ];
       homepage = "https://github.com/GaloisInc/http-server";
       description = "A library for writing Haskell web servers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "http-shed" = callPackage
    ({ mkDerivation, base, network }:
     mkDerivation {
       pname = "http-shed";
       version = "0.1";
       sha256 = "bb31968733cbe9d369c651b166f1ecbac9d325c371a9b2fd9723f79953224b2b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base network ];
       description = "A simple websever with an interact style API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-streams" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base
     , base64-bytestring, blaze-builder, bytestring, case-insensitive
     , directory, ghc-prim, HsOpenSSL, hspec, hspec-expectations
     , http-common, HUnit, io-streams, MonadCatchIO-transformers, mtl
     , network, network-uri, openssl-streams, snap-core, snap-server
     , system-fileio, system-filepath, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "http-streams";
       version = "0.8.3.3";
       sha256 = "3f4597936490ab1ca12af71578a7c6fe6c4aa9f3d0936de88c7f83475593e232";
       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
       ];
       testHaskellDepends = [
         aeson aeson-pretty attoparsec base base64-bytestring blaze-builder
         bytestring case-insensitive directory ghc-prim HsOpenSSL hspec
         hspec-expectations http-common HUnit io-streams
         MonadCatchIO-transformers mtl network network-uri openssl-streams
         snap-core snap-server system-fileio system-filepath text
         transformers unordered-containers
       ];
       homepage = "http://research.operationaldynamics.com/projects/http-streams/";
       description = "An HTTP client using io-streams";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "http-test" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-client, lens
     , lens-aeson, mtl, tasty, tasty-hunit, text, time, wreq
     }:
     mkDerivation {
       pname = "http-test";
       version = "0.2.4";
       sha256 = "03e5ea74bc05ce46b2cfabae00c307db86fdc31dc6636d33cb32655f67b4c71b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring http-client lens lens-aeson mtl tasty
         tasty-hunit text time wreq
       ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/openbrainsrc/http-test";
       description = "Test framework for HTTP APIs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-types_0_8_5" = callPackage
    ({ mkDerivation, array, base, blaze-builder, bytestring
     , case-insensitive, doctest, hspec, QuickCheck
     , quickcheck-instances, text
     }:
     mkDerivation {
       pname = "http-types";
       version = "0.8.5";
       sha256 = "3cb243486053f2e80af255ab79009c2ef057d314d5710ba7aa65fa3e9c164834";
       libraryHaskellDepends = [
         array base blaze-builder bytestring case-insensitive text
       ];
       testHaskellDepends = [
         base blaze-builder bytestring doctest hspec QuickCheck
         quickcheck-instances text
       ];
       jailbreak = true;
       homepage = "https://github.com/aristidb/http-types";
       description = "Generic HTTP types for Haskell (for both client and server code)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-types_0_8_6" = callPackage
    ({ mkDerivation, array, base, blaze-builder, bytestring
     , case-insensitive, doctest, hspec, QuickCheck
     , quickcheck-instances, text
     }:
     mkDerivation {
       pname = "http-types";
       version = "0.8.6";
       sha256 = "b03b1893e0148169087f64ef0b1dedcf2382865352f4306d4fa7219d118a36e0";
       libraryHaskellDepends = [
         array base blaze-builder bytestring case-insensitive text
       ];
       testHaskellDepends = [
         base blaze-builder bytestring doctest hspec QuickCheck
         quickcheck-instances text
       ];
       homepage = "https://github.com/aristidb/http-types";
       description = "Generic HTTP types for Haskell (for both client and server code)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http-types" = callPackage
    ({ mkDerivation, array, base, blaze-builder, bytestring
     , case-insensitive, doctest, hspec, QuickCheck
     , quickcheck-instances, text
     }:
     mkDerivation {
       pname = "http-types";
       version = "0.9";
       sha256 = "8ca1cf90c21cad08abbef979f7248729709be908d96ad3bdd070ea529f2cc15b";
       libraryHaskellDepends = [
         array base blaze-builder bytestring case-insensitive text
       ];
       testHaskellDepends = [
         base blaze-builder bytestring doctest hspec QuickCheck
         quickcheck-instances text
       ];
       homepage = "https://github.com/aristidb/http-types";
       description = "Generic HTTP types for Haskell (for both client and server code)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "http-wget" = callPackage
    ({ mkDerivation, base, failure, process, transformers }:
     mkDerivation {
       pname = "http-wget";
       version = "0.6.2.3";
       sha256 = "dd9da1c130553752be306aaf03a413234f2bad3b953a5ec2ea6a46d4ef236fe9";
       libraryHaskellDepends = [ base failure process transformers ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/http-wget/tree/master";
       description = "Provide a simple HTTP client interface by wrapping the wget command line tool. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "http2_1_0_4" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring
     , bytestring-builder, containers, directory, doctest, filepath
     , Glob, hex, hspec, mwc-random, stm, text, unordered-containers
     , vector, word8
     }:
     mkDerivation {
       pname = "http2";
       version = "1.0.4";
       sha256 = "727fc0d39a62b02b677189f9ef745e3c8fd574334736594139767940dc4647b7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring bytestring-builder containers mwc-random stm
         unordered-containers
       ];
       executableHaskellDepends = [
         aeson aeson-pretty array base bytestring bytestring-builder
         containers directory filepath hex text unordered-containers vector
         word8
       ];
       testHaskellDepends = [
         aeson aeson-pretty array base bytestring bytestring-builder
         containers directory doctest filepath Glob hex hspec mwc-random stm
         text unordered-containers vector word8
       ];
       doCheck = false;
       description = "HTTP/2.0 library including frames and HPACK";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http2_1_3_1" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring
     , bytestring-builder, containers, directory, doctest, filepath
     , Glob, hex, hspec, mwc-random, psqueues, stm, text
     , unordered-containers, vector, word8
     }:
     mkDerivation {
       pname = "http2";
       version = "1.3.1";
       sha256 = "547aa0826373711e4ec8d271f767cd8db74ac3cb822cdf58d305c18babd22f96";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring bytestring-builder containers psqueues stm
         unordered-containers
       ];
       executableHaskellDepends = [
         aeson aeson-pretty array base bytestring bytestring-builder
         containers directory filepath hex text unordered-containers vector
         word8
       ];
       testHaskellDepends = [
         aeson aeson-pretty array base bytestring bytestring-builder
         containers directory doctest filepath Glob hex hspec mwc-random
         psqueues stm text unordered-containers vector word8
       ];
       doCheck = false;
       description = "HTTP/2.0 library including frames and HPACK";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http2_1_4_4" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring
     , bytestring-builder, containers, directory, doctest, filepath
     , Glob, hex, hspec, psqueues, stm, text, unordered-containers
     , vector, word8
     }:
     mkDerivation {
       pname = "http2";
       version = "1.4.4";
       sha256 = "d6ff4d5578749082d3a319bf97a9e830e320be0b2f8701c2ef39ad896cf977c4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring bytestring-builder containers psqueues stm
         unordered-containers
       ];
       executableHaskellDepends = [
         aeson aeson-pretty array base bytestring bytestring-builder
         containers directory filepath hex text unordered-containers vector
         word8
       ];
       testHaskellDepends = [
         aeson aeson-pretty array base bytestring bytestring-builder
         containers directory doctest filepath Glob hex hspec psqueues stm
         text unordered-containers vector word8
       ];
       description = "HTTP/2.0 library including frames and HPACK";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "http2" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, array, base, bytestring
     , bytestring-builder, containers, directory, doctest, filepath
     , Glob, hex, hspec, psqueues, stm, text, unordered-containers
     , vector, word8
     }:
     mkDerivation {
       pname = "http2";
       version = "1.4.5";
       sha256 = "34c6e481b2ce00180ce86370af3d06b01afe762360289fa945abbf8a55c5dba5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring bytestring-builder containers psqueues stm
         unordered-containers
       ];
       executableHaskellDepends = [
         aeson aeson-pretty array base bytestring bytestring-builder
         containers directory filepath hex text unordered-containers vector
         word8
       ];
       testHaskellDepends = [
         aeson aeson-pretty array base bytestring bytestring-builder
         containers directory doctest filepath Glob hex hspec psqueues stm
         text unordered-containers vector word8
       ];
       description = "HTTP/2.0 library including frames and HPACK";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "httpd-shed" = callPackage
    ({ mkDerivation, base, network, network-uri }:
     mkDerivation {
       pname = "httpd-shed";
       version = "0.4.0.3";
       sha256 = "b0ff87d81e61f788d3920d952e4469d984742ba49c006df086c159886bf09218";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base network network-uri ];
       description = "A simple web-server with an interact style API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "https-everywhere-rules" = callPackage
    ({ mkDerivation, attoparsec, base, errors, functor-infix, hspec
     , http-client, https-everywhere-rules-raw, lens, network, pipes
     , string-conversions, taggy-lens, text, text-icu
     }:
     mkDerivation {
       pname = "https-everywhere-rules";
       version = "0.1.0";
       sha256 = "d74e41d6fb34499918d55f955e252570ecc92768241aa17310e237b4e5b21e9c";
       libraryHaskellDepends = [
         attoparsec base errors functor-infix http-client
         https-everywhere-rules-raw lens network pipes string-conversions
         taggy-lens text text-icu
       ];
       testHaskellDepends = [
         attoparsec base errors functor-infix hspec http-client
         https-everywhere-rules-raw lens network pipes string-conversions
         taggy-lens text text-icu
       ];
       jailbreak = true;
       homepage = "https://github.com/fmap/https-everywhere-rules";
       description = "High-level access to HTTPS Everywhere rulesets";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "https-everywhere-rules-raw" = callPackage
    ({ mkDerivation, base, directory, filepath, functor-infix, text }:
     mkDerivation {
       pname = "https-everywhere-rules-raw";
       version = "4.0";
       sha256 = "c6b7a6c928d8ed10e3b366e742ff034b67f4b545c34a79694bf05b41acfda37e";
       libraryHaskellDepends = [
         base directory filepath functor-infix text
       ];
       jailbreak = true;
       homepage = "https://github.com/fmap/https-everywhere-rules-raw";
       description = "Low-level (i.e. XML) access to HTTPS Everywhere rulesets.";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "httpspec" = callPackage
    ({ mkDerivation, base, bidispec, bytestring, cgi, containers
     , encoding, filepath, HTTP, hxt, hxthelper, MissingH, mtl, network
     , pretty, safe
     }:
     mkDerivation {
       pname = "httpspec";
       version = "0.3.0.1";
       sha256 = "bbb4163981210083aca4ff403e34320edda6a135106a4c454f4a3271749ef0ed";
       libraryHaskellDepends = [
         base bidispec bytestring cgi containers encoding filepath HTTP hxt
         hxthelper MissingH mtl network pretty safe
       ];
       description = "Specification of HTTP request/response generators and parsers";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "htune" = callPackage
    ({ mkDerivation, alsa-pcm, base, carray, fft, gloss }:
     mkDerivation {
       pname = "htune";
       version = "0.2";
       sha256 = "026663c771180a31767d19b6ac21c3412304fd3f63d4d88f4b65fb7e166a81c6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ alsa-pcm base carray fft gloss ];
       jailbreak = true;
       description = "harmonic analyser and tuner for musical instruments";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "htzaar" = callPackage
    ({ mkDerivation, base, OpenGL, random, SDL }:
     mkDerivation {
       pname = "htzaar";
       version = "0.0.2";
       sha256 = "ab5d4bd286a00a2038aedb28f0cca761a2b23cbed2a445b51d04fa20100ee489";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base OpenGL random SDL ];
       jailbreak = true;
       homepage = "http://tomahawkins.org";
       description = "A two player abstract strategy game";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "hub" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , fgl, filepath, hexpat, process, regex-compat, unix, utf8-string
     }:
     mkDerivation {
       pname = "hub";
       version = "1.9.0.1";
       sha256 = "61f71c22ea76cd3a192aa12431884a8f061230fe5bffea02f51fd7305b530c82";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring containers directory fgl filepath hexpat
         process regex-compat unix utf8-string
       ];
       homepage = "http://justhub.org";
       description = "For multiplexing GHC installations and providing development sandboxes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hubigraph" = callPackage
    ({ mkDerivation, base, containers, haxr, mtl }:
     mkDerivation {
       pname = "hubigraph";
       version = "0.3.2";
       sha256 = "24a06ec63e1c574d4687588306e4972dc2a46e9da41771668690ade1315dbda6";
       libraryHaskellDepends = [ base containers haxr mtl ];
       homepage = "http://ooxo.org/hubigraph/";
       description = "A haskell wrap for Ubigraph";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hubris" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers, ghc
     , ghc-paths, haskell98, hint, mtl, old-time, process, ruby
     }:
     mkDerivation {
       pname = "hubris";
       version = "0.0.3";
       sha256 = "341dbe825a8e52d340b67db87364e12a31cbe90bf7f4bb489f8b59c8be1db88c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring Cabal containers ghc ghc-paths haskell98 hint
         mtl old-time
       ];
       librarySystemDepends = [ ruby ];
       executableHaskellDepends = [
         array base bytestring Cabal containers ghc ghc-paths haskell98 hint
         mtl old-time process
       ];
       executableSystemDepends = [ ruby ];
       jailbreak = true;
       description = "Support library for Hubris, the Ruby <=> Haskell bridge";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) ruby;};

  "huckleberry" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, mtl, serialport }:
     mkDerivation {
       pname = "huckleberry";
       version = "0.9.0.2";
       sha256 = "70fd7cbe9e41d28f2d8882364646007745ce6b2a64d6369b25fd5a3222eda32d";
       libraryHaskellDepends = [ base bytestring mtl serialport ];
       testHaskellDepends = [ base HUnit ];
       description = "IchigoJam BASIC expressed in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "huffman" = callPackage
    ({ mkDerivation, base, containers, fingertree }:
     mkDerivation {
       pname = "huffman";
       version = "1.0.1";
       sha256 = "43933e2b7f2256420bc9ae28c9e22d6d2b40ce2f79105519825912a3c9a634a4";
       libraryHaskellDepends = [ base containers fingertree ];
       description = "Pure Haskell implementation of the Huffman encoding algorithm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hugs2yc" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, mtl, parsec
     , uniplate, ycextra, yhccore
     }:
     mkDerivation {
       pname = "hugs2yc";
       version = "0.1.1";
       sha256 = "ea90c2d2ba2b17dc2a9540dee21ee700630ebecaaec1d36524082300b96cacae";
       libraryHaskellDepends = [
         base containers directory filepath mtl parsec uniplate ycextra
         yhccore
       ];
       homepage = "http://www.haskell.org/haskellwiki/Yhc";
       description = "Hugs Front-end to Yhc Core";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hulk" = callPackage
    ({ mkDerivation, aeson, base, bytestring, case-insensitive, cmdargs
     , ConfigFile, containers, Crypto, directory, fastirc, filepath
     , ghc-prim, monad-extras, mtl, network, split, strict, text, time
     , unix, utf8-string
     }:
     mkDerivation {
       pname = "hulk";
       version = "0.2.0";
       sha256 = "624e9ef6c3fa0b436afee182e35e364e23c959803a16b88ef139c619c2d2006f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring case-insensitive cmdargs ConfigFile
         containers Crypto directory fastirc filepath ghc-prim monad-extras
         mtl network split strict text time unix utf8-string
       ];
       executableHaskellDepends = [
         aeson base bytestring case-insensitive cmdargs ConfigFile
         containers Crypto directory fastirc filepath ghc-prim monad-extras
         mtl network split strict text time unix utf8-string
       ];
       jailbreak = true;
       description = "IRC server written in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "human-readable-duration_0_1_0_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "human-readable-duration";
       version = "0.1.0.0";
       sha256 = "75c5f9f83fe3204b5da47cfd6da82465185dcfd926ed0cec51ac91406684f7de";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/yogsototh/human-readable-duration#readme";
       description = "Provide duration helper";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "human-readable-duration_0_1_1_0" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "human-readable-duration";
       version = "0.1.1.0";
       sha256 = "dfd07e9a6077834c65a5f7989eb9e77e207e446acfa261cec1d4c9d0f7424fb8";
       libraryHaskellDepends = [ base time ];
       homepage = "http://github.com/yogsototh/human-readable-duration#readme";
       description = "Provide duration helper";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "human-readable-duration" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "human-readable-duration";
       version = "0.2.0.0";
       sha256 = "4c1959b3014c2e7dcdc754814129e4a3e5f4b5d7eb317f0f315f1d01025d097d";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/yogsototh/human-readable-duration#readme";
       description = "Provide duration helper";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hums" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , ConfigFile, containers, directory, filepath, HaXml, http-types
     , hxt, MissingH, mtl, network, system-fileio, system-filepath
     , system-uuid, text, transformers, unix, unordered-containers, wai
     , warp
     }:
     mkDerivation {
       pname = "hums";
       version = "0.7.0";
       sha256 = "19f64c73fd7f88561ba932e28f22ea94a70ac83eecce07ee65c6663a905d69f1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-builder bytestring case-insensitive ConfigFile
         containers directory filepath HaXml http-types hxt MissingH mtl
         network system-fileio system-filepath system-uuid text transformers
         unix unordered-containers wai warp
       ];
       jailbreak = true;
       description = "Haskell UPnP Media Server";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hunch" = callPackage
    ({ mkDerivation, base, containers, directory, filepath
     , optparse-applicative, parsec, QuickCheck, split
     }:
     mkDerivation {
       pname = "hunch";
       version = "0.2.0";
       sha256 = "52e214b7b9af8fed9735ab65d1c241f2f11204909b4b29345054557dfd236331";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath optparse-applicative parsec
         split
       ];
       testHaskellDepends = [
         base containers directory filepath optparse-applicative parsec
         QuickCheck split
       ];
       homepage = "https://github.com/loganbraga/hunch";
       description = "CSS-like syntax for file system manipulation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hunit-dejafu" = callPackage
    ({ mkDerivation, base, dejafu, HUnit }:
     mkDerivation {
       pname = "hunit-dejafu";
       version = "0.2.0.0";
       sha256 = "c81eb0cd3e6c53509c056b0f37dcdb5f7fac6e7766abf36fb68c44e3dd997db0";
       libraryHaskellDepends = [ base dejafu HUnit ];
       homepage = "https://github.com/barrucadu/dejafu";
       description = "Deja Fu support for the HUnit test framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hunit-gui" = callPackage
    ({ mkDerivation, base, cairo, gtk, haskell98, HUnit }:
     mkDerivation {
       pname = "hunit-gui";
       version = "0.1.4";
       sha256 = "c0f0c4da19cfc04bf2bf3f50ccd21fbba1ca588f0851eb989020e3dbe513fe73";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base cairo gtk haskell98 HUnit ];
       executableHaskellDepends = [ base cairo gtk haskell98 HUnit ];
       jailbreak = true;
       homepage = "http://patch-tag.com/r/kwallmar/hunit_gui/home";
       description = "A GUI testrunner for HUnit";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hunit-parsec" = callPackage
    ({ mkDerivation, base, HUnit, parsec }:
     mkDerivation {
       pname = "hunit-parsec";
       version = "0.3";
       sha256 = "80e46f5d7a31de3445052dccd68b52985d2e1bb8289b93afd7c631e983453421";
       libraryHaskellDepends = [ base HUnit parsec ];
       description = "An HUnit Testable instance for Parsec parser unit tests";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hunit-rematch" = callPackage
    ({ mkDerivation, base, hspec, HUnit, rematch }:
     mkDerivation {
       pname = "hunit-rematch";
       version = "0.1.0.1";
       sha256 = "fa1512a6caa2f7fb70bf48a57835808517a2ac9082f2d6815b56398ba87145f6";
       libraryHaskellDepends = [ base HUnit rematch ];
       testHaskellDepends = [ base hspec HUnit rematch ];
       jailbreak = true;
       homepage = "github.com/tcrayford/rematch";
       description = "HUnit support for rematch";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hunp" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, monads-fd
     , parsec, pcre-light, process, split
     }:
     mkDerivation {
       pname = "hunp";
       version = "0.1";
       sha256 = "91e9f6936380fbfc2b1099ae790a6570905f8c61af88e9891a0f5a9af16a074c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory filepath monads-fd parsec pcre-light
         process split
       ];
       homepage = "http://github.com/skorpan/hunp/tree/master";
       description = "Unpacker tool with DWIM";
       license = "GPL";
     }) {};

  "hunt-searchengine" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, binary, bytestring
     , containers, data-default, data-r-tree, data-stringmap, deepseq
     , directory, dlist, filepath, hslogger, HUnit, hxt-regex-xmlschema
     , monad-parallel, mtl, murmur-hash, old-locale, parsec, QuickCheck
     , random, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "hunt-searchengine";
       version = "0.3.0.1";
       sha256 = "8653aa01b4894f664c13a97148030a1f5d18bf7ead0357f01fb471894ac017f9";
       libraryHaskellDepends = [
         aeson aeson-pretty base binary bytestring containers data-default
         data-r-tree data-stringmap deepseq dlist filepath hslogger
         hxt-regex-xmlschema monad-parallel mtl murmur-hash parsec text time
         transformers unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base binary containers data-default data-r-tree directory
         HUnit monad-parallel mtl old-locale QuickCheck random
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time
       ];
       jailbreak = true;
       homepage = "http://github.com/hunt-framework/";
       description = "A search and indexing engine";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hunt-server" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, binary, blaze-html
     , blaze-markup, bytestring, cmdargs, containers, data-default
     , deepseq, ekg-core, hamlet, hslogger, http-types
     , hunt-searchengine, mtl, scotty, shakespeare-js, text, wai
     , wai-extra, wai-middleware-static, warp
     }:
     mkDerivation {
       pname = "hunt-server";
       version = "0.3.0.2";
       sha256 = "e66d294e034bb1f87224922751ad5ddef5cf231408be29175e3a00794fb26ba5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson aeson-pretty base binary blaze-html blaze-markup bytestring
         cmdargs containers data-default deepseq ekg-core hamlet hslogger
         http-types hunt-searchengine mtl scotty shakespeare-js text wai
         wai-extra wai-middleware-static warp
       ];
       jailbreak = true;
       homepage = "http://github.com/hunt-framework";
       description = "A search and indexing engine server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hunt-server-cli" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, binary, bytestring
     , conduit, conduit-extra, containers, csv-conduit, data-default
     , docopt, hslogger, http-types, hunt-client, hunt-searchengine, mtl
     , resourcet, string-conversions, text, time, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "hunt-server-cli";
       version = "0.2.0.0";
       sha256 = "7f251f579616ce244e77259552b26a96c035fac1e25376764aacde280d78b4de";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson aeson-pretty base binary bytestring conduit conduit-extra
         containers csv-conduit data-default docopt hslogger http-types
         hunt-client hunt-searchengine mtl resourcet string-conversions text
         time transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/hunt-framework";
       description = "A Command line Interface for the Hunt server";
       license = stdenv.lib.licenses.mit;
       broken = true;
     }) {hunt-client = null;};

  "hurdle" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, kangaroo }:
     mkDerivation {
       pname = "hurdle";
       version = "0.4.0";
       sha256 = "8ee3bd3ba360ad3b85a9b5bca14c71bba0aae770a17288818f5e9cb9cf360f8e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring containers kangaroo
       ];
       jailbreak = true;
       homepage = "http://code.google.com/p/copperbox/";
       description = "Extract function names from Windows DLLs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "husk-scheme" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , filepath, ghc-paths, haskeline, knob, mtl, parsec, process, time
     , transformers, utf8-string
     }:
     mkDerivation {
       pname = "husk-scheme";
       version = "3.19.1";
       sha256 = "6441ed37323177d8f1c3855d4f7e1b11ad3cb998afd31f2571b4a0ac483c6b2c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers directory haskeline knob mtl
         parsec process time transformers utf8-string
       ];
       executableHaskellDepends = [
         array base containers directory filepath ghc-paths haskeline mtl
         parsec process transformers
       ];
       homepage = "http://justinethier.github.com/husk-scheme";
       description = "R5RS Scheme interpreter, compiler, and library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "husk-scheme-libs" = callPackage
    ({ mkDerivation, array, base, containers, husk-scheme, json, mtl
     , transformers
     }:
     mkDerivation {
       pname = "husk-scheme-libs";
       version = "0.0.1";
       sha256 = "92bd9dbac5dc4264123e512650f43f56be6ec6ba993d35065cfdade304e788a1";
       libraryHaskellDepends = [
         array base containers husk-scheme json mtl transformers
       ];
       homepage = "http://justinethier.github.com/husk-scheme";
       description = "Extra libraries for the husk Scheme platform";
       license = stdenv.lib.licenses.mit;
     }) {};

  "husky" = callPackage
    ({ mkDerivation, base, containers, mtl, old-locale, parsec
     , readline, time
     }:
     mkDerivation {
       pname = "husky";
       version = "0.4";
       sha256 = "6fb5394d663c1944b9b86318d7d7117b92fd0f109efa571bd6dc9235e5d4da8c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers mtl old-locale parsec readline time
       ];
       jailbreak = true;
       homepage = "http://github.com/markusle/husky/tree/master";
       description = "A simple command line calculator";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hutton" = callPackage
    ({ mkDerivation, aeson, base, bytestring, connection, flow
     , http-client, http-conduit, http-types, network, rainbow
     , regex-compat, text, time, transformers, websockets, wuss
     }:
     mkDerivation {
       pname = "hutton";
       version = "1.0.0";
       sha256 = "11ead4c07258ba73d8129cb1a7ac4f9a9ab042ebd15b5e40372459d09ea23b8b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring connection flow http-client http-conduit
         http-types network rainbow regex-compat text time transformers
         websockets wuss
       ];
       jailbreak = true;
       description = "A program for the button on Reddit";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "huttons-razor" = callPackage
    ({ mkDerivation, base, parsec, parsec-numbers }:
     mkDerivation {
       pname = "huttons-razor";
       version = "0.1.1.0";
       sha256 = "5a9cf6f8ac793e507ae0d591aa0e1b4b7987eec1441d7d6c7f6454279e8797f3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base parsec parsec-numbers ];
       homepage = "https://github.com/steshaw/huttons-razor";
       description = "Quick implemention of Hutton's Razor";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "huzzy" = callPackage
    ({ mkDerivation, base, easyplot }:
     mkDerivation {
       pname = "huzzy";
       version = "0.1.5.5";
       sha256 = "b751430f716caa7ff53ba78a484329224c1333e8f850d3cf84a77d6d011a1045";
       libraryHaskellDepends = [ base easyplot ];
       jailbreak = true;
       description = "Fuzzy logic library with support for T1, IT2, GT2";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hvect_0_2_0_0" = callPackage
    ({ mkDerivation, base, HTF }:
     mkDerivation {
       pname = "hvect";
       version = "0.2.0.0";
       sha256 = "310fa7a975673fa99eaace924c0ec3b600d6d21d4f94625c855e97caadcc2a06";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base HTF ];
       homepage = "https://github.com/agrafix/hvect";
       description = "Simple strict heterogeneous lists";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hvect" = callPackage
    ({ mkDerivation, base, HTF }:
     mkDerivation {
       pname = "hvect";
       version = "0.3.0.0";
       sha256 = "b2931f7c3bca66b7b6fbfa46bacaf0fc6f8a6c75dc29c0567c3f682764407ebc";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base HTF ];
       homepage = "https://github.com/agrafix/hvect";
       description = "Simple strict heterogeneous lists";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hwall-auth-iitk" = callPackage
    ({ mkDerivation, base, bytestring, haskeline, http-conduit
     , http-types, mtl, regex-compat, unix
     }:
     mkDerivation {
       pname = "hwall-auth-iitk";
       version = "0.1.0.1";
       sha256 = "823a2278ff213e3581854a09a81a5ff72d2ddb7668c1af116bc3969c9e6f7d45";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring haskeline http-conduit http-types mtl regex-compat
         unix
       ];
       description = "Initial version of firewall Authentication for IITK network";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hweblib" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, HUnit
     , mtl, text, transformers
     }:
     mkDerivation {
       pname = "hweblib";
       version = "0.6.3";
       sha256 = "1e8ee12baac496d56831935a60e78f54eb43d2b7268bf7d31acb6b9a63e9b50d";
       libraryHaskellDepends = [
         attoparsec base bytestring containers mtl text transformers
       ];
       testHaskellDepends = [
         attoparsec base bytestring containers HUnit mtl transformers
       ];
       homepage = "http://github.com/aycanirican/hweblib";
       description = "Haskell Web Library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hworker" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, hedis, hspec
     , hspec-contrib, HUnit, text, time, uuid
     }:
     mkDerivation {
       pname = "hworker";
       version = "0.1.0.1";
       sha256 = "34cbcc4db8f190ab0dc02a072adcf1fc75b7beab7e545982872bf265a1223f1d";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring hedis text time uuid
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring hedis hspec hspec-contrib HUnit
         text time uuid
       ];
       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;
     }) {};

  "hworker-ses" = callPackage
    ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-ses, base
     , hworker, lens, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "hworker-ses";
       version = "0.1.1.0";
       sha256 = "dd5330691585b39ff0ddba8eb7edd2129a5610bae8a0493c2855f2786a3581c7";
       libraryHaskellDepends = [
         aeson amazonka amazonka-core amazonka-ses base hworker lens text
         time unordered-containers
       ];
       doCheck = false;
       homepage = "http://github.com/dbp/hworker-ses";
       description = "Library for sending email with Amazon's SES and hworker";
       license = stdenv.lib.licenses.isc;
     }) {};

  "hws" = callPackage
    ({ mkDerivation, array, base, containers, directory, haskell98
     , html, mtl, network, old-time, regex-compat, text, unix
     }:
     mkDerivation {
       pname = "hws";
       version = "1.1.0.1";
       sha256 = "f968d7937299fa022589a14c30cb6f4a34257bc72055d365a8ab32b7f8020e34";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory haskell98 html mtl network old-time
         regex-compat text unix
       ];
       jailbreak = true;
       description = "Simple Haskell Web Server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hwsl2" = callPackage
    ({ mkDerivation, base, bytestring, quickcheck-properties, tasty
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "hwsl2";
       version = "0.4.0.0";
       sha256 = "2000137fd0c5374e582d963f2c352390fb55be91f91a1d9f433a42c1050c0838";
       libraryHaskellDepends = [ base bytestring ];
       testHaskellDepends = [
         base bytestring quickcheck-properties tasty tasty-quickcheck
       ];
       homepage = "https://github.com/srijs/hwsl2";
       description = "Hashing with SL2";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hwsl2-bytevector" = callPackage
    ({ mkDerivation, base, bytestring, fingertree, hwsl2 }:
     mkDerivation {
       pname = "hwsl2-bytevector";
       version = "0.1.0.0";
       sha256 = "e98a476d3f7503044b62d4e38f31df6afd2fefcb00f1ecf35ced6d320b62da4d";
       libraryHaskellDepends = [ base bytestring fingertree hwsl2 ];
       homepage = "https://github.com/srijs/hwsl2-haskell-bytevector";
       description = "A hashed byte-vector based on algebraic hashes and finger trees";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hwsl2-reducers" = callPackage
    ({ mkDerivation, base, bytestring, hwsl2, reducers, semigroups }:
     mkDerivation {
       pname = "hwsl2-reducers";
       version = "0.1.0.0";
       sha256 = "fdbcfc5e05628adae70497a5c65552efb077aace12385037e5ee85b0c582f7e0";
       libraryHaskellDepends = [
         base bytestring hwsl2 reducers semigroups
       ];
       homepage = "https://github.com/srijs/hwsl2-reducers";
       description = "Semigroup and Reducer instances for Data.Hash.SL2";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hx" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hx";
       version = "0.4";
       sha256 = "2b0776d8982494344940f1633f1fafbb845574e4aac8996ea52fe967287e9313";
       libraryHaskellDepends = [ base ];
       description = "Haskell extras (missing utility functions)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hxmppc" = callPackage
    ({ mkDerivation, base, fclabels, network, network-protocol-xmpp
     , text, transformers, xml-types
     }:
     mkDerivation {
       pname = "hxmppc";
       version = "0.2.3";
       sha256 = "4972e692bad4327f63f607a87c4e877d4f34415433c370889bd697a4590f31bb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base fclabels network network-protocol-xmpp text transformers
         xml-types
       ];
       jailbreak = true;
       description = "Haskell XMPP (Jabber Client) Command Line Interface (CLI)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxournal" = callPackage
    ({ mkDerivation, base, bytestring, cairo, cmdargs, configurator
     , containers, Diff, directory, double-conversion, dyre, fclabels
     , filepath, gtk, monad-coroutine, mtl, poppler, strict
     , template-haskell, time, transformers, TypeCompose
     , xournal-builder, xournal-parser, xournal-render, xournal-types
     }:
     mkDerivation {
       pname = "hxournal";
       version = "0.6.6.1";
       sha256 = "982ea5c9cf72fc6bd42486b31c64678e2e95c8e2d32a88e6d9c5314be66364ba";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cairo cmdargs configurator containers Diff
         directory double-conversion dyre fclabels filepath gtk
         monad-coroutine mtl poppler strict template-haskell time
         transformers TypeCompose xournal-builder xournal-parser
         xournal-render xournal-types
       ];
       executableHaskellDepends = [ base cmdargs ];
       jailbreak = true;
       homepage = "http://ianwookim.org/hxournal";
       description = "A pen notetaking program written in haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxt_9_3_1_7" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , directory, filepath, HUnit, hxt-charproperties
     , hxt-regex-xmlschema, hxt-unicode, mtl, network-uri, parsec
     }:
     mkDerivation {
       pname = "hxt";
       version = "9.3.1.7";
       sha256 = "516c509f669afd0495b609606af64bae94b46b95bdcf0a553463a399a8c0edb5";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq directory filepath HUnit
         hxt-charproperties hxt-regex-xmlschema hxt-unicode mtl network-uri
         parsec
       ];
       homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";
       description = "A collection of tools for processing XML with Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxt_9_3_1_10" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , directory, filepath, HUnit, hxt-charproperties
     , hxt-regex-xmlschema, hxt-unicode, mtl, network-uri, parsec
     }:
     mkDerivation {
       pname = "hxt";
       version = "9.3.1.10";
       sha256 = "8ec991ecbcab223e21b8055e8511bb24970288cd55fccd11cd272601f908ad4a";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq directory filepath HUnit
         hxt-charproperties hxt-regex-xmlschema hxt-unicode mtl network-uri
         parsec
       ];
       homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";
       description = "A collection of tools for processing XML with Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxt_9_3_1_12" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , directory, filepath, HUnit, hxt-charproperties
     , hxt-regex-xmlschema, hxt-unicode, mtl, network-uri, parsec
     }:
     mkDerivation {
       pname = "hxt";
       version = "9.3.1.12";
       sha256 = "af2d7edb8bbed49c0d97bd5875dbb07a6395a62d5a84e477a21bb19d9a405e8c";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq directory filepath HUnit
         hxt-charproperties hxt-regex-xmlschema hxt-unicode mtl network-uri
         parsec
       ];
       homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";
       description = "A collection of tools for processing XML with Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxt" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , directory, filepath, HUnit, hxt-charproperties
     , hxt-regex-xmlschema, hxt-unicode, mtl, network-uri, parsec
     }:
     mkDerivation {
       pname = "hxt";
       version = "9.3.1.15";
       sha256 = "723e7b3c22f58771087e7763d11702b3ae3aa910158a2beee70e973722966560";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq directory filepath HUnit
         hxt-charproperties hxt-regex-xmlschema hxt-unicode mtl network-uri
         parsec
       ];
       homepage = "https://github.com/UweSchmidt/hxt";
       description = "A collection of tools for processing XML with Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hxt-binary" = callPackage
    ({ mkDerivation, base, binary, bytestring, bzlib, deepseq
     , haskell98, hxt
     }:
     mkDerivation {
       pname = "hxt-binary";
       version = "0.0.2";
       sha256 = "5cab3cf4694082e8120ec97db4b7cf1c07a5a37fb938fd0bd071a6c528f06bc1";
       libraryHaskellDepends = [
         base binary bytestring bzlib deepseq haskell98 hxt
       ];
       jailbreak = true;
       homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";
       description = "Serialisation and deserialisation of HXT XmlTrees";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxt-cache" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , directory, filepath, hxt, SHA, time, unix
     }:
     mkDerivation {
       pname = "hxt-cache";
       version = "9.1.0.1";
       sha256 = "f470012bcde9fe0a534b540abddd3434b61814c89f596858b88619147a8223ce";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq directory filepath hxt
         SHA time unix
       ];
       homepage = "https://github.com/UweSchmidt/hxt";
       description = "Cache for HXT XML Documents and other binary data";
       license = "unknown";
     }) {};

  "hxt-charproperties_9_2_0_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hxt-charproperties";
       version = "9.2.0.0";
       sha256 = "f13ef018513b0ba54b27287f9928c928618c052a1a69e2230a77def418906307";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/UweSchmidt/hxt";
       description = "Character properties and classes for XML and Unicode";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxt-charproperties" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hxt-charproperties";
       version = "9.2.0.1";
       sha256 = "e46614d6bf0390b2a6a1aeeb0771e6d366944da40fb21c12c2f8a94d1f47b4d6";
       libraryHaskellDepends = [ base ];
       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 }:
     mkDerivation {
       pname = "hxt-css";
       version = "0.1.0.1";
       sha256 = "bc04f9b17694ad33206a283db99bcf3d3a04cd3ae8ba2a6c3169823e3dd7187d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base hxt parsec split ];
       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 }:
     mkDerivation {
       pname = "hxt-curl";
       version = "9.1.1.1";
       sha256 = "cdc1cc8bf9b8699cabdee965c9737d497c199b5cf82eabc66a5fe3f2ffb3c5ea";
       libraryHaskellDepends = [ base bytestring curl hxt parsec ];
       homepage = "https://github.com/UweSchmidt/hxt";
       description = "LibCurl interface for HXT";
       license = "unknown";
     }) {};

  "hxt-expat" = callPackage
    ({ mkDerivation, base, bytestring, hexpat, hxt }:
     mkDerivation {
       pname = "hxt-expat";
       version = "9.1.1";
       sha256 = "10d9c43c20c82e879fbc06944fcfed373f8b43bd3e0a44f9c712db30a27022d6";
       libraryHaskellDepends = [ base bytestring hexpat hxt ];
       homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";
       description = "Expat parser for HXT";
       license = "unknown";
     }) {};

  "hxt-extras" = callPackage
    ({ mkDerivation, base, hxt }:
     mkDerivation {
       pname = "hxt-extras";
       version = "0.4.1";
       sha256 = "617d8b0e220843609ab517ab1ebb58f140b95ca69f7930cf5df26da1329b68af";
       libraryHaskellDepends = [ base hxt ];
       homepage = "http://code.google.com/p/hxt-extras/";
       description = "Extra functions for HXT";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hxt-filter" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, haskell98
     , HTTP, HUnit, hxt, network, parsec, process
     }:
     mkDerivation {
       pname = "hxt-filter";
       version = "8.4.2";
       sha256 = "4065fba5fb10c829378780a1f58b46b032da438ccf0b56bc13aca5c20ebcb14b";
       libraryHaskellDepends = [
         base containers directory filepath haskell98 HTTP HUnit hxt network
         parsec process
       ];
       jailbreak = true;
       homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";
       description = "A collection of tools for processing XML with Haskell (Filter variant)";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxt-http_9_1_5" = callPackage
    ({ mkDerivation, base, bytestring, HTTP, hxt, network, network-uri
     , parsec
     }:
     mkDerivation {
       pname = "hxt-http";
       version = "9.1.5";
       sha256 = "69c5a8bf3e5c595f9da171189389d0129b0b154e0fa67962db98e0d43f025e9c";
       libraryHaskellDepends = [
         base bytestring HTTP hxt network network-uri parsec
       ];
       homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";
       description = "Interface to native Haskell HTTP package HTTP";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxt-http" = callPackage
    ({ mkDerivation, base, bytestring, HTTP, hxt, network, network-uri
     , parsec
     }:
     mkDerivation {
       pname = "hxt-http";
       version = "9.1.5.2";
       sha256 = "6fa19d03991d53c34f4525a4fdfaafde56dd48459093b4502832a1fdd9dfdd0b";
       libraryHaskellDepends = [
         base bytestring HTTP hxt network network-uri parsec
       ];
       homepage = "https://github.com/UweSchmidt/hxt";
       description = "Interface to native Haskell HTTP package HTTP";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hxt-pickle-utils_0_1_0_2" = callPackage
    ({ mkDerivation, base, hxt, mtl }:
     mkDerivation {
       pname = "hxt-pickle-utils";
       version = "0.1.0.2";
       sha256 = "e237c6ed5d31363349ca3f6bf814129b7c375a241feca248f79e494acb48641b";
       revision = "1";
       editedCabalFile = "89173b402c57c3ee7ee0eb2814e58d81e46cce5742a4f01684980b841359d2fb";
       libraryHaskellDepends = [ base hxt mtl ];
       homepage = "https://github.com/silkapp/hxt-pickle-utils";
       description = "Utility functions for using HXT picklers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxt-pickle-utils" = callPackage
    ({ mkDerivation, base, hxt, mtl }:
     mkDerivation {
       pname = "hxt-pickle-utils";
       version = "0.1.0.3";
       sha256 = "9ddba19f27d9d8c155012da4dd9598fb318cab862da10f14ee4bc3eb5321a9c5";
       libraryHaskellDepends = [ base hxt mtl ];
       homepage = "https://github.com/silkapp/hxt-pickle-utils";
       description = "Utility functions for using HXT picklers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hxt-regex-xmlschema_9_2_0" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, hxt-charproperties
     , parsec, text
     }:
     mkDerivation {
       pname = "hxt-regex-xmlschema";
       version = "9.2.0";
       sha256 = "e3110265247533be78e14a4a192e99f95949bdbfedbef94153e38470d8f68b5d";
       libraryHaskellDepends = [
         base bytestring hxt-charproperties parsec text
       ];
       testHaskellDepends = [ base bytestring HUnit parsec text ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxt-regex-xmlschema_9_2_0_1" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, hxt-charproperties
     , parsec, text
     }:
     mkDerivation {
       pname = "hxt-regex-xmlschema";
       version = "9.2.0.1";
       sha256 = "81f521bc6729f328849cc179120d0e8da4c53bd1138939f8b148b4995ac55cb6";
       libraryHaskellDepends = [
         base bytestring hxt-charproperties parsec text
       ];
       testHaskellDepends = [ base bytestring HUnit parsec text ];
       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;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxt-regex-xmlschema" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, hxt-charproperties
     , parsec, text
     }:
     mkDerivation {
       pname = "hxt-regex-xmlschema";
       version = "9.2.0.2";
       sha256 = "4744676dde2b29c4bb75a579345145225a1f1b7ba15d46b7f868c37c6e696cc2";
       libraryHaskellDepends = [
         base bytestring hxt-charproperties parsec text
       ];
       testHaskellDepends = [ base bytestring HUnit parsec text ];
       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-relaxng_9_1_5_1" = callPackage
    ({ mkDerivation, base, containers, hxt, hxt-charproperties
     , hxt-regex-xmlschema, network-uri, parsec
     }:
     mkDerivation {
       pname = "hxt-relaxng";
       version = "9.1.5.1";
       sha256 = "8687288236bd9c54ab113ad28f463a386eb20c07d5161b5ac016e7f9d2d45f9a";
       libraryHaskellDepends = [
         base containers hxt hxt-charproperties hxt-regex-xmlschema
         network-uri parsec
       ];
       homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";
       description = "The HXT RelaxNG validator";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxt-relaxng_9_1_5_3" = callPackage
    ({ mkDerivation, base, containers, hxt, hxt-charproperties
     , hxt-regex-xmlschema, network-uri, parsec
     }:
     mkDerivation {
       pname = "hxt-relaxng";
       version = "9.1.5.3";
       sha256 = "34ce02afed789526407bd8b446a33a1f0458fe04ac783765d9295fd2fb7de084";
       libraryHaskellDepends = [
         base containers hxt hxt-charproperties hxt-regex-xmlschema
         network-uri parsec
       ];
       homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";
       description = "The HXT RelaxNG validator";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxt-relaxng" = callPackage
    ({ mkDerivation, base, containers, hxt, hxt-charproperties
     , hxt-regex-xmlschema, network-uri, parsec
     }:
     mkDerivation {
       pname = "hxt-relaxng";
       version = "9.1.5.5";
       sha256 = "0efe2de0abc71f9cef655e52543528c4ab8ed1793be58afe6f1734d8cb3f441f";
       libraryHaskellDepends = [
         base containers hxt hxt-charproperties hxt-regex-xmlschema
         network-uri parsec
       ];
       homepage = "https://github.com/UweSchmidt/hxt";
       description = "The HXT RelaxNG validator";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hxt-tagsoup" = callPackage
    ({ mkDerivation, base, hxt, hxt-charproperties, hxt-unicode
     , tagsoup
     }:
     mkDerivation {
       pname = "hxt-tagsoup";
       version = "9.1.3";
       sha256 = "e7601d375af58c5a806002a61c1e077f60e70ab04e708fbbeb090e6e644ae4e6";
       libraryHaskellDepends = [
         base hxt hxt-charproperties hxt-unicode tagsoup
       ];
       homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";
       description = "TagSoup parser for HXT";
       license = "unknown";
     }) {};

  "hxt-unicode_9_0_2_2" = callPackage
    ({ mkDerivation, base, hxt-charproperties }:
     mkDerivation {
       pname = "hxt-unicode";
       version = "9.0.2.2";
       sha256 = "193dbe7bb829ef3c9b8d2f5ad71bd603990310dfe02e910a9d9cb4e3ce5c92c6";
       libraryHaskellDepends = [ base hxt-charproperties ];
       homepage = "http://www.fh-wedel.de/~si/HXmlToolbox/index.html";
       description = "Unicode en-/decoding functions for utf8, iso-latin-* and other encodings";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxt-unicode" = callPackage
    ({ mkDerivation, base, hxt-charproperties }:
     mkDerivation {
       pname = "hxt-unicode";
       version = "9.0.2.4";
       sha256 = "7b5823f3bd94b57022d9d84ab3555303653c5121eaaef2ee1fd4918f3c434466";
       libraryHaskellDepends = [ base hxt-charproperties ];
       homepage = "https://github.com/UweSchmidt/hxt";
       description = "Unicode en-/decoding functions for utf8, iso-latin-* and other encodings";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hxt-xpath" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, hxt, parsec
     }:
     mkDerivation {
       pname = "hxt-xpath";
       version = "9.1.2.2";
       sha256 = "50377cb5fc17a31091ef41d648cb26ce8d8bd52f9dc639e5b654b118804e9872";
       libraryHaskellDepends = [
         base containers directory filepath hxt parsec
       ];
       homepage = "https://github.com/UweSchmidt/hxt";
       description = "The XPath modules for HXT";
       license = "unknown";
     }) {};

  "hxt-xslt" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, hxt
     , hxt-xpath, parsec
     }:
     mkDerivation {
       pname = "hxt-xslt";
       version = "9.1.1.1";
       sha256 = "32f9501cb020941b4eac9c511965d1fc3d5a1cba8f01b6be90a5a9c5e53f1308";
       libraryHaskellDepends = [
         base containers directory filepath hxt hxt-xpath parsec
       ];
       homepage = "https://github.com/UweSchmidt/hxt";
       description = "The XSLT modules for HXT";
       license = "unknown";
     }) {};

  "hxthelper" = callPackage
    ({ mkDerivation, base, bytestring, encoding, hxt, mtl }:
     mkDerivation {
       pname = "hxthelper";
       version = "0.2.2";
       sha256 = "619ae58bdb9bfed588dca6310671df4b41cc83ecd15b3d8bb7cded5d710d82c6";
       libraryHaskellDepends = [ base bytestring encoding hxt mtl ];
       jailbreak = true;
       description = "Helper functions for HXT";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hxweb" = callPackage
    ({ mkDerivation, base, cgi, fastcgi, libxml, mtl, xslt }:
     mkDerivation {
       pname = "hxweb";
       version = "0.1";
       sha256 = "e88b115f42892ae77a264fc3fe693231c9d9537d1888a417f0c256e8a9f35139";
       libraryHaskellDepends = [ base cgi fastcgi libxml mtl xslt ];
       description = "Minimal webframework using fastcgi, libxml2 and libxslt";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hyahtzee" = callPackage
    ({ mkDerivation, base, containers, HUnit, random }:
     mkDerivation {
       pname = "hyahtzee";
       version = "0.2";
       sha256 = "bb326e105267a1a2f8f694fcae70ae4f7a99a7a9046883702a31eae41ef3697f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers HUnit random ];
       homepage = "http://github.com/DamienCassou/HYahtzee";
       description = "A Yahtzee game implementation in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hyakko" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, bytestring, cmdargs
     , directory, filepath, highlighting-kate, mtl, pandoc
     , regex-pcre-builtin, text, unordered-containers
     }:
     mkDerivation {
       pname = "hyakko";
       version = "0.6.7";
       sha256 = "93637316f8dab220e15d5b9f953d48aae32e2831abbe34964cb716e015e401cd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base blaze-html bytestring cmdargs directory filepath
         highlighting-kate mtl pandoc regex-pcre-builtin text
         unordered-containers
       ];
       jailbreak = true;
       homepage = "http://sourrust.github.io/hyakko/";
       description = "Literate-style Documentation Generator";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hybrid" = callPackage
    ({ mkDerivation, base, containers, haskell98, mtl, parsec }:
     mkDerivation {
       pname = "hybrid";
       version = "2.0";
       sha256 = "3c2dda5af2d5ccd7daaf68af4bc8d22e53de2096bf665bfd8ce99d6f354b6617";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers haskell98 mtl parsec
       ];
       homepage = "http://repos.mine.nu/davve/darcs/hybrid";
       description = "A implementation of a type-checker for Lambda-H";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hybrid-vectors_0_1_2" = callPackage
    ({ mkDerivation, base, deepseq, primitive, vector }:
     mkDerivation {
       pname = "hybrid-vectors";
       version = "0.1.2";
       sha256 = "0e8ff6eebe9a8b326ea076e40e919135341a3872ef173903ebb7e19c720f9de9";
       revision = "1";
       editedCabalFile = "52e01325244b1d6864e0841bc76618203b2c908248d2ecbe8b953c0a559139e7";
       libraryHaskellDepends = [ base deepseq primitive vector ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/hybrid-vectors";
       description = "Hybrid vectors e.g. Mixed Boxed/Unboxed vectors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hybrid-vectors_0_1_2_1" = callPackage
    ({ mkDerivation, base, deepseq, primitive, vector }:
     mkDerivation {
       pname = "hybrid-vectors";
       version = "0.1.2.1";
       sha256 = "a96cce16973664cf5c59b1abdd7f053ba04d6d7823301871fe507979f6f60676";
       revision = "2";
       editedCabalFile = "bd0d08875f3daa5a9e546b2ed20234f8118fe59854a742b957b53b5002c5a447";
       libraryHaskellDepends = [ base deepseq primitive vector ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/hybrid-vectors";
       description = "Hybrid vectors e.g. Mixed Boxed/Unboxed vectors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hybrid-vectors" = callPackage
    ({ mkDerivation, base, deepseq, primitive, vector }:
     mkDerivation {
       pname = "hybrid-vectors";
       version = "0.2.1";
       sha256 = "2edcd8fcfedc76a944ac690bfc257f2974100df6484c6c20883d27773836cca2";
       libraryHaskellDepends = [ base deepseq primitive vector ];
       homepage = "http://github.com/ekmett/hybrid-vectors";
       description = "Hybrid vectors e.g. Mixed Boxed/Unboxed vectors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hydra-hs" = callPackage
    ({ mkDerivation, base, hmatrix, sixense_x64 }:
     mkDerivation {
       pname = "hydra-hs";
       version = "1.0.0.2";
       sha256 = "1af52ef504d1b1712d1e640bcdffe1464a5dbd19e0e976ce5a6f50fbacc25da3";
       libraryHaskellDepends = [ base hmatrix ];
       librarySystemDepends = [ sixense_x64 ];
       testHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/mruegenberg/hydra-hs";
       description = "Haskell binding to the Sixense SDK for the Razer Hydra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {sixense_x64 = null;};

  "hydra-print" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, directory
     , filepath, HUnit, io-streams, mtl, ncurses, process, QuickCheck
     , random, semigroups, test-framework, test-framework-hunit
     , test-framework-quickcheck2, test-framework-th, text, time
     , transformers, unix
     }:
     mkDerivation {
       pname = "hydra-print";
       version = "0.1.0.3";
       sha256 = "3199332c8853117fe6f41a9874cd2388bd3d371bdb6dad3ef0ff9643d4b88f99";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base bytestring containers directory io-streams mtl ncurses
         process random semigroups text time transformers unix
       ];
       executableHaskellDepends = [
         async base bytestring containers directory filepath io-streams mtl
         ncurses process random semigroups text time transformers unix
       ];
       testHaskellDepends = [
         async base bytestring containers directory HUnit io-streams mtl
         ncurses process QuickCheck random semigroups test-framework
         test-framework-hunit test-framework-quickcheck2 test-framework-th
         text time transformers unix
       ];
       jailbreak = true;
       homepage = "https://github.com/rrnewton/hydra-print";
       description = "NCurses interface to view multiple ByteString streams in parallel";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hydrogen" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, mtl, pretty
     , QuickCheck, text
     }:
     mkDerivation {
       pname = "hydrogen";
       version = "0.3.0.0";
       sha256 = "916c372aaab01b9389649e92f4a4adc61161ae27ff8b137635407bc6f7d6042b";
       libraryHaskellDepends = [
         base bytestring containers mtl pretty text
       ];
       testHaskellDepends = [ base Cabal containers mtl QuickCheck ];
       homepage = "https://www.github.com/ktvoelker/hydrogen";
       description = "An alternate Prelude";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "hydrogen-cli" = callPackage
    ({ mkDerivation, base, hydrogen-cli-args, hydrogen-data
     , hydrogen-multimap, hydrogen-parsing, hydrogen-prelude
     , hydrogen-syntax
     }:
     mkDerivation {
       pname = "hydrogen-cli";
       version = "0.14";
       sha256 = "2b01d1b8e94bf1f518c7cb5a83734040eb5143cbd573ff6d59e17d62d2271f0e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base hydrogen-cli-args hydrogen-data hydrogen-multimap
         hydrogen-parsing hydrogen-prelude hydrogen-syntax
       ];
       jailbreak = true;
       homepage = "https://scravy.de/hydrogen-cli/";
       description = "Hydrogen Data";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hydrogen-cli-args" = callPackage
    ({ mkDerivation, base, containers, hydrogen-multimap
     , hydrogen-prelude
     }:
     mkDerivation {
       pname = "hydrogen-cli-args";
       version = "0.17";
       sha256 = "84f6f223f1fb049ad35403ffb873bc2aa275bb8af01f9ba84ea06eef68c157f1";
       libraryHaskellDepends = [
         base containers hydrogen-multimap hydrogen-prelude
       ];
       jailbreak = true;
       homepage = "https://scravy.de/hydrogen-cli-args/";
       description = "Hydrogen Command Line Arguments Parser";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hydrogen-data" = callPackage
    ({ mkDerivation, base, hydrogen-parsing, hydrogen-prelude }:
     mkDerivation {
       pname = "hydrogen-data";
       version = "0.14";
       sha256 = "08410a47248787a5dee10ebea1415da2c7f0c2745f862b6af825c6acf4292435";
       libraryHaskellDepends = [ base hydrogen-parsing hydrogen-prelude ];
       jailbreak = true;
       homepage = "https://scravy.de/hydrogen-data/";
       description = "Hydrogen Data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hydrogen-multimap" = callPackage
    ({ mkDerivation, base, containers, ghc-prim }:
     mkDerivation {
       pname = "hydrogen-multimap";
       version = "0.3";
       sha256 = "23c58559d7b25b252abd6f09ba1f4e75c3f9d43a115ff7b408bf755f90426646";
       libraryHaskellDepends = [ base containers ghc-prim ];
       homepage = "https://scravy.de/hydrogen-multimap/";
       description = "Hydrogen Multimap";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hydrogen-parsing" = callPackage
    ({ mkDerivation, base, containers, hydrogen-prelude, parsec }:
     mkDerivation {
       pname = "hydrogen-parsing";
       version = "0.17";
       sha256 = "49c0035739668fa0bb6fd22e7d6d661f219155956b7662d7c9340ce073a43955";
       libraryHaskellDepends = [
         base containers hydrogen-prelude parsec
       ];
       jailbreak = true;
       homepage = "https://scravy.de/hydrogen-parsing/";
       description = "Hydrogen Parsing Utilities";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hydrogen-prelude" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, cereal
     , containers, directory, filepath, hashable, hydrogen-multimap
     , hydrogen-version, network, process, random, regex-base
     , regex-tdfa, strict, text, time, transformers, uuid
     }:
     mkDerivation {
       pname = "hydrogen-prelude";
       version = "0.20";
       sha256 = "2799201f435bc6d9f7236cbf3e463bfb5ea0eb196178fbf12f683cad4bcae3a1";
       libraryHaskellDepends = [
         array base binary bytestring cereal containers directory filepath
         hashable hydrogen-multimap hydrogen-version network process random
         regex-base regex-tdfa strict text time transformers uuid
       ];
       homepage = "http://scravy.de/hydrogen-prelude/";
       description = "Hydrogen Prelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hydrogen-prelude-parsec" = callPackage
    ({ mkDerivation, base, hydrogen-prelude, parsec }:
     mkDerivation {
       pname = "hydrogen-prelude-parsec";
       version = "0.17";
       sha256 = "b08a86bfad3219398abe4065b7750c421bc6cfc532b3df97f1c6b03ec7ddbb41";
       libraryHaskellDepends = [ base hydrogen-prelude parsec ];
       jailbreak = true;
       homepage = "http://scravy.de/hydrogen-prelude-parsec/";
       description = "Hydrogen Prelude /w Parsec";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hydrogen-syntax" = callPackage
    ({ mkDerivation, base, containers, hydrogen-parsing
     , hydrogen-prelude, nicify, parsec, uuid
     }:
     mkDerivation {
       pname = "hydrogen-syntax";
       version = "0.17";
       sha256 = "bb2140dbb66482245a11e4b946649d3fcca50c3a5a96f627df4307e8048e469e";
       libraryHaskellDepends = [
         base containers hydrogen-parsing hydrogen-prelude nicify parsec
         uuid
       ];
       jailbreak = true;
       homepage = "https://scravy.de/hydrogen-syntax/";
       description = "Hydrogen Syntax";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hydrogen-util" = callPackage
    ({ mkDerivation, base, containers, hydrogen-prelude, parsec, time
     }:
     mkDerivation {
       pname = "hydrogen-util";
       version = "0.8";
       sha256 = "4885259b31365ae9210d9fb0c6d482c0625184652493aa45c6cd03a784b3e293";
       libraryHaskellDepends = [
         base containers hydrogen-prelude parsec time
       ];
       jailbreak = true;
       homepage = "https://scravy.de/hydrogen-util/";
       description = "Hydrogen Tools";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hydrogen-version" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "hydrogen-version";
       version = "1.4";
       sha256 = "68b8ea8a188fd861ae7f0629bdda35723ca59563f67cfda279117c00374d6313";
       libraryHaskellDepends = [ base ];
       homepage = "https://scravy.de/hydrogen-version/";
       description = "Hydrogen Version Type";
       license = stdenv.lib.licenses.mit;
     }) {};

  "hyena" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory
     , extensible-exceptions, filepath, mtl, network, network-bytestring
     , unix
     }:
     mkDerivation {
       pname = "hyena";
       version = "0.1.0.1";
       sha256 = "5102c802d080ba230f1ac9ba9ecc625640a67a3ee17002ef009c6dbf01a72921";
       libraryHaskellDepends = [
         base bytestring containers directory extensible-exceptions filepath
         mtl network network-bytestring unix
       ];
       jailbreak = true;
       homepage = "http://github.com/tibbe/hyena";
       description = "Simple web application server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hylolib" = callPackage
    ({ mkDerivation, array, base, containers, mtl, pretty, QuickCheck
     , random, uniplate
     }:
     mkDerivation {
       pname = "hylolib";
       version = "1.4.0";
       sha256 = "426ee0b316bcb38569691c5299cb6ab3fbd27451ba8e8f8f7c2b8b6c2e451398";
       libraryHaskellDepends = [
         array base containers mtl pretty QuickCheck random uniplate
       ];
       jailbreak = true;
       description = "Tools for hybrid logics related programs";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hylotab" = callPackage
    ({ mkDerivation, base, hylolib, mtl }:
     mkDerivation {
       pname = "hylotab";
       version = "1.2.1";
       sha256 = "3c1c3b3276639a954892a93d5ce673cc0fc91f00f869fb527804addbc5e9d677";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base hylolib mtl ];
       homepage = "http://www.glyc.dc.uba.ar/intohylo/hylotab.php";
       description = "Tableau based theorem prover for hybrid logics";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hyloutils" = callPackage
    ({ mkDerivation, base, containers, hylolib, mtl, uniplate }:
     mkDerivation {
       pname = "hyloutils";
       version = "1.0";
       sha256 = "d03ee75ef3def52a0ffa8872b7873bdaed55718ee25dc0f92aaa33098723c1de";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers hylolib mtl uniplate
       ];
       description = "Very small programs for hybrid logics";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hyperdrive" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-lexing
     , extensible-exceptions, mtl, network, pipes, pretty
     }:
     mkDerivation {
       pname = "hyperdrive";
       version = "0.1";
       sha256 = "e9336664adca49057b9b94d56dd2417692d30e9a99067e122b9aab80b3ee6f43";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring bytestring-lexing extensible-exceptions mtl network
         pipes pretty
       ];
       jailbreak = true;
       description = "a fast, trustworthy HTTP(s) server built";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hyperfunctions" = callPackage
    ({ mkDerivation, adjunctions, base, distributive, profunctors
     , transformers
     }:
     mkDerivation {
       pname = "hyperfunctions";
       version = "0";
       sha256 = "757ebcac2afdab089b9c1bb5e7b6ea7642d450e430b6c97f3089d38fc5138560";
       libraryHaskellDepends = [
         adjunctions base distributive profunctors transformers
       ];
       homepage = "http://github.com/ekmett/hyperfunctions";
       description = "Hyperfunctions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hyperloglog_0_3_4" = callPackage
    ({ mkDerivation, approximate, base, binary, bits, bytes, cereal
     , cereal-vector, comonad, deepseq, directory, distributive, doctest
     , filepath, generic-deriving, hashable, hashable-extras, lens
     , reflection, safecopy, semigroupoids, semigroups, simple-reflect
     , siphash, tagged, vector
     }:
     mkDerivation {
       pname = "hyperloglog";
       version = "0.3.4";
       sha256 = "4f5d4a3be879651a88c3713c010218311d6938ba35fe42695fd0f31ede6c5888";
       revision = "1";
       editedCabalFile = "2d152b42ce20e23f1ea60febb92e9600cde19932884c4418e65739d3e8ff27cf";
       libraryHaskellDepends = [
         approximate base binary bits bytes cereal cereal-vector comonad
         deepseq distributive hashable hashable-extras lens reflection
         safecopy semigroupoids semigroups siphash tagged vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       jailbreak = true;
       homepage = "http://github.com/analytics/hyperloglog";
       description = "An approximate streaming (constant space) unique object counter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hyperloglog" = callPackage
    ({ mkDerivation, approximate, base, binary, bits, bytes, cereal
     , cereal-vector, comonad, deepseq, directory, distributive, doctest
     , filepath, generic-deriving, hashable, hashable-extras, lens
     , reflection, safecopy, semigroupoids, semigroups, simple-reflect
     , siphash, tagged, vector
     }:
     mkDerivation {
       pname = "hyperloglog";
       version = "0.4.0.4";
       sha256 = "34d7a2db30d680bc38ab7fa3488e9182adacee65a751b75cc5e99eb9f39b9847";
       libraryHaskellDepends = [
         approximate base binary bits bytes cereal cereal-vector comonad
         deepseq distributive hashable hashable-extras lens reflection
         safecopy semigroupoids semigroups siphash tagged vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       homepage = "http://github.com/analytics/hyperloglog";
       description = "An approximate streaming (constant space) unique object counter";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hyperpublic" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , http-enumerator, http-types
     }:
     mkDerivation {
       pname = "hyperpublic";
       version = "0.1.1";
       sha256 = "ed576a468e9e55ebb442db8b3b75fbb5583e57ce573256672efaaa067a425f1e";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring http-enumerator http-types
       ];
       jailbreak = true;
       homepage = "https://github.com/mkscrg/hyperpublic-haskell";
       description = "A thin wrapper for the Hyperpublic API";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hyphenate" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "hyphenate";
       version = "0.1";
       sha256 = "a4cfd81d3dc1a2d5904d0b9baff712380cd49ef7279a8daa349643a0422bd75e";
       libraryHaskellDepends = [ base containers ];
       homepage = "http://www.alpheccar.org";
       description = "Text hyphenation algorithm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hyphenation_0_4" = callPackage
    ({ mkDerivation, base, containers, directory, doctest, filepath
     , unordered-containers
     }:
     mkDerivation {
       pname = "hyphenation";
       version = "0.4";
       sha256 = "abfbe5949a1b80b1a5742910aa1c7320eccc82ca15b3b7bda6776c648a27ca1a";
       libraryHaskellDepends = [ base containers unordered-containers ];
       testHaskellDepends = [
         base containers directory doctest filepath unordered-containers
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/ekmett/hyphenation";
       description = "Configurable Knuth-Liang hyphenation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hyphenation_0_4_1" = callPackage
    ({ mkDerivation, base, containers, directory, doctest, filepath
     , unordered-containers
     }:
     mkDerivation {
       pname = "hyphenation";
       version = "0.4.1";
       sha256 = "dbecf7c48a3dbc7a9ffd7cc648a47be3c3eda6bec6bd2ec89b429d16bd9497c1";
       libraryHaskellDepends = [ base containers unordered-containers ];
       testHaskellDepends = [
         base containers directory doctest filepath unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/hyphenation";
       description = "Configurable Knuth-Liang hyphenation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hyphenation_0_4_2" = callPackage
    ({ mkDerivation, base, containers, directory, doctest, filepath
     , unordered-containers
     }:
     mkDerivation {
       pname = "hyphenation";
       version = "0.4.2";
       sha256 = "4840a2c64405acb7941e13ddb1f4a9b51241d370f9ef28d39edf1aa7ddd5d016";
       libraryHaskellDepends = [ base containers unordered-containers ];
       testHaskellDepends = [
         base containers directory doctest filepath unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/hyphenation";
       description = "Configurable Knuth-Liang hyphenation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hyphenation_0_4_2_1" = callPackage
    ({ mkDerivation, base, containers, directory, doctest, filepath
     , unordered-containers
     }:
     mkDerivation {
       pname = "hyphenation";
       version = "0.4.2.1";
       sha256 = "b1b31d95679f8ef36b389396c989f114ae025a80132f94bba766482a5b5f3519";
       libraryHaskellDepends = [ base containers unordered-containers ];
       testHaskellDepends = [
         base containers directory doctest filepath unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/hyphenation";
       description = "Configurable Knuth-Liang hyphenation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hyphenation" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, doctest
     , filepath, unordered-containers, zlib
     }:
     mkDerivation {
       pname = "hyphenation";
       version = "0.6";
       sha256 = "2f673666c18f63581422f7c6389b78b0ff754406671296a3d680d417942512f7";
       libraryHaskellDepends = [
         base bytestring containers unordered-containers zlib
       ];
       testHaskellDepends = [
         base containers directory doctest filepath unordered-containers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/ekmett/hyphenation";
       description = "Configurable Knuth-Liang hyphenation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hypher" = callPackage
    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
     , data-default, hashable, HTTP, http-conduit, http-types, HUnit
     , lifted-base, monad-control, mtl, QuickCheck, resourcet
     , scientific, test-framework, test-framework-hunit
     , test-framework-quickcheck2, test-framework-th, text, transformers
     , transformers-base, unordered-containers, vector
     }:
     mkDerivation {
       pname = "hypher";
       version = "0.1.5";
       sha256 = "133a1cc83a68cf77bf3614b48ea69833c9d15a9eb3f3100b6a58116ad4bfb460";
       libraryHaskellDepends = [
         aeson base bytestring containers data-default hashable HTTP
         http-conduit http-types lifted-base monad-control mtl resourcet
         scientific text transformers transformers-base unordered-containers
         vector
       ];
       testHaskellDepends = [
         aeson base bytestring Cabal data-default hashable HTTP http-conduit
         http-types HUnit lifted-base monad-control mtl QuickCheck resourcet
         scientific test-framework test-framework-hunit
         test-framework-quickcheck2 test-framework-th text transformers
         transformers-base unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/zoetic-community/hypher";
       description = "A Haskell neo4j client";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hzaif" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-conduit, text }:
     mkDerivation {
       pname = "hzaif";
       version = "0.1.0.0";
       sha256 = "1d600bf4940412059c0d3916573fd2042c3695d627993fb1277b38e241fa9a55";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring http-conduit text
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/i-amd3/hzaif";
       description = "This package is Zaif Exchange Api wrapper";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "hzk" = callPackage
    ({ mkDerivation, base, bytestring, resource-pool, tasty
     , tasty-hunit, time, zookeeper_mt
     }:
     mkDerivation {
       pname = "hzk";
       version = "2.1.0";
       sha256 = "4c4d3e60a2e763099dcf155ca2c32e884a4464785bd7fb839adcb8cf87829bc9";
       libraryHaskellDepends = [ base bytestring resource-pool time ];
       librarySystemDepends = [ zookeeper_mt ];
       testHaskellDepends = [
         base bytestring resource-pool tasty tasty-hunit time
       ];
       testSystemDepends = [ zookeeper_mt ];
       homepage = "http://github.com/dgvncsz0f/hzk";
       description = "Haskell client library for Apache Zookeeper";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) zookeeper_mt;};

  "hzulip_1_1_1_2" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, conduit
     , exceptions, hspec, http-client, http-client-tls, http-types, lens
     , lens-aeson, mtl, raw-strings-qq, scotty, stm, stm-conduit, text
     , transformers
     }:
     mkDerivation {
       pname = "hzulip";
       version = "1.1.1.2";
       sha256 = "62402ce2010bf6d9c07ee266ac30c9506383b3a5dcbbd0fba54b30d191ac02d8";
       libraryHaskellDepends = [
         aeson base bytestring conduit exceptions http-client
         http-client-tls http-types lens lens-aeson mtl stm stm-conduit text
         transformers
       ];
       testHaskellDepends = [
         aeson async base bytestring conduit exceptions hspec http-client
         http-client-tls http-types lens lens-aeson mtl raw-strings-qq
         scotty stm stm-conduit text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/yamadapc/hzulip";
       description = "A haskell wrapper for the Zulip API";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "hzulip" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, conduit
     , exceptions, hspec, http-client, http-client-tls, http-types, lens
     , lens-aeson, mtl, raw-strings-qq, scotty, stm, stm-conduit, text
     , transformers
     }:
     mkDerivation {
       pname = "hzulip";
       version = "1.1.1.3";
       sha256 = "a49c129e665984ebfc013bffdf7f997b76e7362fb66d622e5f43a35ba1468661";
       libraryHaskellDepends = [
         aeson base bytestring conduit exceptions http-client
         http-client-tls http-types lens lens-aeson mtl stm stm-conduit text
         transformers
       ];
       testHaskellDepends = [
         aeson async base bytestring conduit exceptions hspec http-client
         http-client-tls http-types lens lens-aeson mtl raw-strings-qq
         scotty stm stm-conduit text transformers
       ];
       homepage = "https://github.com/yamadapc/hzulip";
       description = "A haskell wrapper for the Zulip API";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "i18n" = callPackage
    ({ mkDerivation, array, base, containers, directory, filepath, mtl
     , old-locale, old-time, parsec, utf8-string
     }:
     mkDerivation {
       pname = "i18n";
       version = "0.3";
       sha256 = "37e012104ab07255ae4f45490af8795d743e24857e83c38dd1dddaf0984a3f50";
       libraryHaskellDepends = [
         array base containers directory filepath mtl old-locale old-time
         parsec utf8-string
       ];
       description = "Internationalization for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "iCalendar" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring
     , case-insensitive, containers, data-default, mime, mtl, network
     , network-uri, old-locale, parsec, text, time
     }:
     mkDerivation {
       pname = "iCalendar";
       version = "0.4.0.3";
       sha256 = "bc06a08165e2c135a2c98d0ca08cfd2b0862134337342b9f3da65f878c4e7a35";
       libraryHaskellDepends = [
         base base64-bytestring bytestring case-insensitive containers
         data-default mime mtl network network-uri old-locale parsec text
         time
       ];
       homepage = "http://github.com/chrra/iCalendar";
       description = "iCalendar data types, parser, and printer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "iException" = callPackage
    ({ mkDerivation, base, interleavableIO, mtl }:
     mkDerivation {
       pname = "iException";
       version = "0.0.1";
       sha256 = "f7c8ed3664c44f8fce891addc48051d181c0a4d47f1796a4e724855af681303d";
       libraryHaskellDepends = [ base interleavableIO mtl ];
       description = "Version of Control.Exception using InterleavableIO.";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "iap-verifier" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , conduit, http-conduit, monads-tf, text, transformers
     }:
     mkDerivation {
       pname = "iap-verifier";
       version = "0.1.0.1";
       sha256 = "0a6a27ead1a4f82e30c1dc9e2a9fedb6983272010833fc1ac508172ffa2cc555";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring conduit http-conduit
         monads-tf text transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/tattsun/iap-verifier";
       description = "A simple wrapper of In-App-Purchase receipt validate APIs";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ib-api" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, network, unix }:
     mkDerivation {
       pname = "ib-api";
       version = "0.1.0.1";
       sha256 = "336bb043a50a68001635ffb03d2c175e92b7a7d05393b098ffa8ae5dcfd25c7f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ attoparsec base bytestring network ];
       executableHaskellDepends = [
         attoparsec base bytestring network unix
       ];
       jailbreak = true;
       homepage = "https://github.com/rbermani/ib-api";
       description = "An API for the Interactive Brokers Trading Workstation written in pure Haskell";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "iban" = callPackage
    ({ mkDerivation, base, containers, HUnit, iso3166-country-codes
     , tasty, tasty-hunit, text, unordered-containers
     }:
     mkDerivation {
       pname = "iban";
       version = "0.1.1.1";
       sha256 = "e9e2ef69259edb58988ab147fbd71d75f7c1a1015220e40cca4e1c68d5fc9c91";
       libraryHaskellDepends = [
         base containers iso3166-country-codes text unordered-containers
       ];
       testHaskellDepends = [ base HUnit tasty tasty-hunit text ];
       homepage = "https://github.com/ibotty/iban";
       description = "Validate and generate IBANs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ibus-hs" = callPackage
    ({ mkDerivation, base, dbus, directory, unix, xdg-basedir }:
     mkDerivation {
       pname = "ibus-hs";
       version = "0.0.0.1";
       sha256 = "4166d8e641a88eb71b10d0d6717384518bf7c1f426af5c29788d6a0d3c812d7b";
       libraryHaskellDepends = [ base dbus directory unix xdg-basedir ];
       homepage = "https://github.com/Ongy/ibus-hs";
       description = "A simple uncomplete ibus api";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "ical" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, containers, either, mtl
     , text, time, transformers
     }:
     mkDerivation {
       pname = "ical";
       version = "0.0.1";
       sha256 = "f5e45df4249aa90a87080ef6714d77d8e961c5ba50e6813062379fcdaea7d882";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base containers either mtl text time transformers
       ];
       executableHaskellDepends = [ base time ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/chrisdone/ical#readme";
       description = "iCalendar format parser and org-mode converter";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "iconv_0_4_1_2" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "iconv";
       version = "0.4.1.2";
       sha256 = "8204268e688c1ffef80ab7b4b9df6e7ff14ee4d039b0569119dcb2168f5fa769";
       revision = "1";
       editedCabalFile = "dec449ecde9679a092fc8513cec0bfe72031aa309b9b9795db572a726a976451";
       libraryHaskellDepends = [ base bytestring ];
       jailbreak = true;
       description = "String encoding conversion";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "iconv" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "iconv";
       version = "0.4.1.3";
       sha256 = "36425168e3314bc83ba5ee95152872d52e94ee0f9503f3591f84d458e005b554";
       libraryHaskellDepends = [ base bytestring ];
       description = "String encoding conversion";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ide-backend_0_9_0_4" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , bytestring-trie, Cabal-ide-backend, containers, crypto-api
     , data-accessor, data-accessor-mtl, deepseq, directory
     , executable-path, filemanip, filepath, fingertree, ghc-prim, HUnit
     , ide-backend-common, mtl, pretty-show, process, pureMD5, random
     , regex-compat, stm, tagged, tasty, template-haskell, temporary
     , test-framework, test-framework-hunit, text, time, transformers
     , unix, unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "ide-backend";
       version = "0.9.0.4";
       sha256 = "db6d41f26ae6a139029cd26aca46f092474ba2b9842a356b86b5d418e61d5601";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async attoparsec base binary bytestring Cabal-ide-backend
         containers data-accessor data-accessor-mtl directory filemanip
         filepath ghc-prim ide-backend-common mtl pretty-show process
         pureMD5 template-haskell temporary text time transformers unix
         utf8-string
       ];
       executableHaskellDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         Cabal-ide-backend containers crypto-api data-accessor
         data-accessor-mtl directory executable-path filemanip filepath
         fingertree ghc-prim ide-backend-common mtl pretty-show process
         pureMD5 random tagged template-haskell temporary text time
         transformers unix unordered-containers
       ];
       testHaskellDepends = [
         aeson async base binary bytestring Cabal-ide-backend containers
         deepseq directory executable-path filemanip filepath HUnit
         ide-backend-common process random regex-compat stm tagged tasty
         template-haskell temporary test-framework test-framework-hunit text
         unix utf8-string
       ];
       jailbreak = true;
       description = "An IDE backend library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend_0_9_0_6" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , bytestring-trie, Cabal-ide-backend, containers, crypto-api
     , data-accessor, data-accessor-mtl, deepseq, directory
     , executable-path, filemanip, filepath, fingertree, ghc-prim, HUnit
     , ide-backend-common, mtl, pretty-show, process, pureMD5, random
     , regex-compat, stm, tagged, tasty, template-haskell, temporary
     , test-framework, test-framework-hunit, text, time, transformers
     , unix, unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "ide-backend";
       version = "0.9.0.6";
       sha256 = "f863395089fa92587aa692c4f890cbb4a3631d5b64adf52ac1fb50d819865337";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async attoparsec base binary bytestring Cabal-ide-backend
         containers data-accessor data-accessor-mtl directory filemanip
         filepath ghc-prim ide-backend-common mtl pretty-show process
         pureMD5 template-haskell temporary text time transformers unix
         utf8-string
       ];
       executableHaskellDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         Cabal-ide-backend containers crypto-api data-accessor
         data-accessor-mtl directory executable-path filemanip filepath
         fingertree ghc-prim ide-backend-common mtl pretty-show process
         pureMD5 random tagged template-haskell temporary text time
         transformers unix unordered-containers
       ];
       testHaskellDepends = [
         aeson async base binary bytestring Cabal-ide-backend containers
         deepseq directory executable-path filemanip filepath HUnit
         ide-backend-common process random regex-compat stm tagged tasty
         template-haskell temporary test-framework test-framework-hunit text
         unix utf8-string
       ];
       jailbreak = true;
       description = "An IDE backend library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend_0_9_0_7" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , bytestring-trie, Cabal-ide-backend, containers, crypto-api
     , data-accessor, data-accessor-mtl, deepseq, directory
     , executable-path, filemanip, filepath, fingertree, ghc-prim, HUnit
     , ide-backend-common, mtl, pretty-show, process, pureMD5, random
     , regex-compat, stm, tagged, tasty, template-haskell, temporary
     , test-framework, test-framework-hunit, text, time, transformers
     , unix, unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "ide-backend";
       version = "0.9.0.7";
       sha256 = "43836b80811981e6fc28a1ccb11ec475d3d3a5ee990f4fce586056485cbf057d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async attoparsec base binary bytestring Cabal-ide-backend
         containers data-accessor data-accessor-mtl directory filemanip
         filepath ghc-prim ide-backend-common mtl pretty-show process
         pureMD5 template-haskell temporary text time transformers unix
         utf8-string
       ];
       executableHaskellDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         Cabal-ide-backend containers crypto-api data-accessor
         data-accessor-mtl directory executable-path filemanip filepath
         fingertree ghc-prim ide-backend-common mtl pretty-show process
         pureMD5 random tagged template-haskell temporary text time
         transformers unix unordered-containers
       ];
       testHaskellDepends = [
         aeson async base binary bytestring Cabal-ide-backend containers
         deepseq directory executable-path filemanip filepath HUnit
         ide-backend-common process random regex-compat stm tagged tasty
         template-haskell temporary test-framework test-framework-hunit text
         unix utf8-string
       ];
       jailbreak = true;
       description = "An IDE backend library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend_0_9_0_8" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , bytestring-trie, Cabal-ide-backend, containers, crypto-api
     , data-accessor, data-accessor-mtl, deepseq, directory
     , executable-path, filemanip, filepath, fingertree, ghc-prim, HUnit
     , ide-backend-common, mtl, pretty-show, process, pureMD5, random
     , regex-compat, stm, tagged, tasty, template-haskell, temporary
     , test-framework, test-framework-hunit, text, time, transformers
     , unix, unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "ide-backend";
       version = "0.9.0.8";
       sha256 = "18fd661f418793a9c43a00ce4a9ae6074b5d56178091b87ba409973e4fbf324b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async attoparsec base binary bytestring Cabal-ide-backend
         containers data-accessor data-accessor-mtl directory filemanip
         filepath ghc-prim ide-backend-common mtl pretty-show process
         pureMD5 template-haskell temporary text time transformers unix
         utf8-string
       ];
       executableHaskellDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         Cabal-ide-backend containers crypto-api data-accessor
         data-accessor-mtl directory executable-path filemanip filepath
         fingertree ghc-prim ide-backend-common mtl pretty-show process
         pureMD5 random tagged template-haskell temporary text time
         transformers unix unordered-containers
       ];
       testHaskellDepends = [
         aeson async base binary bytestring Cabal-ide-backend containers
         deepseq directory executable-path filemanip filepath HUnit
         ide-backend-common process random regex-compat stm tagged tasty
         template-haskell temporary test-framework test-framework-hunit text
         unix utf8-string
       ];
       jailbreak = true;
       description = "An IDE backend library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend_0_9_0_9" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , bytestring-trie, Cabal-ide-backend, containers, crypto-api
     , data-accessor, data-accessor-mtl, deepseq, directory
     , executable-path, filemanip, filepath, fingertree, ghc-prim, HUnit
     , ide-backend-common, mtl, pretty-show, process, pureMD5, random
     , regex-compat, stm, tagged, tasty, template-haskell, temporary
     , test-framework, test-framework-hunit, text, time, transformers
     , unix, unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "ide-backend";
       version = "0.9.0.9";
       sha256 = "55a4906b4f19c2ff7ca32f2607c06ebf19b85c879af0f3a5ad088283c7ddea7e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async attoparsec base binary bytestring Cabal-ide-backend
         containers data-accessor data-accessor-mtl directory filemanip
         filepath ghc-prim ide-backend-common mtl pretty-show process
         pureMD5 template-haskell temporary text time transformers unix
         utf8-string
       ];
       executableHaskellDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         Cabal-ide-backend containers crypto-api data-accessor
         data-accessor-mtl directory executable-path filemanip filepath
         fingertree ghc-prim ide-backend-common mtl pretty-show process
         pureMD5 random tagged template-haskell temporary text time
         transformers unix unordered-containers
       ];
       testHaskellDepends = [
         aeson async base binary bytestring Cabal-ide-backend containers
         deepseq directory executable-path filemanip filepath HUnit
         ide-backend-common process random regex-compat stm tagged tasty
         template-haskell temporary test-framework test-framework-hunit text
         unix utf8-string
       ];
       jailbreak = true;
       description = "An IDE backend library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend_0_9_0_11" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , bytestring-trie, Cabal-ide-backend, containers, crypto-api
     , data-accessor, data-accessor-mtl, deepseq, directory
     , executable-path, filemanip, filepath, fingertree, ghc-prim, HUnit
     , ide-backend-common, mtl, pretty-show, process, pureMD5, random
     , regex-compat, stm, tagged, tasty, template-haskell, temporary
     , test-framework, test-framework-hunit, text, time, transformers
     , unix, unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "ide-backend";
       version = "0.9.0.11";
       sha256 = "f7769735e53bc9abf795f51142478fa6765f8326ff50f1190611ad8db007371a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async attoparsec base binary bytestring Cabal-ide-backend
         containers data-accessor data-accessor-mtl directory filemanip
         filepath ghc-prim ide-backend-common mtl pretty-show process
         pureMD5 template-haskell temporary text time transformers unix
         utf8-string
       ];
       executableHaskellDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         Cabal-ide-backend containers crypto-api data-accessor
         data-accessor-mtl directory executable-path filemanip filepath
         fingertree ghc-prim ide-backend-common mtl pretty-show process
         pureMD5 random tagged template-haskell temporary text time
         transformers unix unordered-containers
       ];
       testHaskellDepends = [
         aeson async base binary bytestring Cabal-ide-backend containers
         deepseq directory executable-path filemanip filepath HUnit
         ide-backend-common process random regex-compat stm tagged tasty
         template-haskell temporary test-framework test-framework-hunit text
         unix utf8-string
       ];
       jailbreak = true;
       description = "An IDE backend library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend_0_10_0" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , bytestring-trie, Cabal-ide-backend, containers, crypto-api
     , data-accessor, data-accessor-mtl, deepseq, directory
     , executable-path, filemanip, filepath, fingertree, ghc-prim, HUnit
     , ide-backend-common, monads-tf, mtl, parallel, pretty-show
     , process, pureMD5, random, regex-compat, stm, tagged, tasty
     , template-haskell, temporary, test-framework, test-framework-hunit
     , text, time, transformers, unix, unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "ide-backend";
       version = "0.10.0";
       sha256 = "26a35f82533d8361824e04468176cab7c14d3fa4d0a1ebe1aa243a986a3ae0a2";
       revision = "1";
       editedCabalFile = "96888cccc65f025e63931b466ac392e6caa581f6e902a428fd203cdf3c22f5ef";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async attoparsec base binary bytestring Cabal-ide-backend
         containers data-accessor data-accessor-mtl directory filemanip
         filepath ghc-prim ide-backend-common mtl pretty-show process
         pureMD5 template-haskell temporary text time transformers unix
         utf8-string
       ];
       executableHaskellDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         Cabal-ide-backend containers crypto-api data-accessor
         data-accessor-mtl directory executable-path filemanip filepath
         fingertree ghc-prim ide-backend-common mtl pretty-show process
         pureMD5 random tagged template-haskell temporary text time
         transformers unix unordered-containers
       ];
       testHaskellDepends = [
         aeson async base binary bytestring Cabal-ide-backend containers
         deepseq directory executable-path filemanip filepath HUnit
         ide-backend-common monads-tf parallel process random regex-compat
         stm tagged tasty template-haskell temporary test-framework
         test-framework-hunit text unix utf8-string
       ];
       jailbreak = true;
       doCheck = false;
       description = "An IDE backend library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , bytestring-trie, Cabal-ide-backend, containers, crypto-api
     , data-accessor, data-accessor-mtl, deepseq, directory
     , executable-path, filemanip, filepath, fingertree, ghc-prim, HUnit
     , ide-backend-common, monads-tf, mtl, network, parallel
     , pretty-show, process, pureMD5, random, regex-compat, stm, tagged
     , tasty, template-haskell, temporary, test-framework
     , test-framework-hunit, text, time, transformers, unix, unix-compat
     , unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "ide-backend";
       version = "0.10.0.1";
       sha256 = "07186ec1d8135e94fac39c16fc10145c3a6cee957b96fa739f240afd0ae5faf0";
       revision = "1";
       editedCabalFile = "cf76e099362742622e03b1463e55eb77e4488755afbc768fe2aca9e8c163662d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async attoparsec base binary bytestring Cabal-ide-backend
         containers data-accessor data-accessor-mtl directory filemanip
         filepath ghc-prim ide-backend-common mtl network pretty-show
         process pureMD5 template-haskell temporary text time transformers
         unix utf8-string
       ];
       executableHaskellDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         Cabal-ide-backend containers crypto-api data-accessor
         data-accessor-mtl directory executable-path filemanip filepath
         fingertree ghc-prim ide-backend-common mtl network pretty-show
         process pureMD5 random tagged template-haskell temporary text time
         transformers unix unix-compat unordered-containers
       ];
       testHaskellDepends = [
         aeson async base binary bytestring Cabal-ide-backend containers
         deepseq directory executable-path filemanip filepath HUnit
         ide-backend-common monads-tf network parallel process random
         regex-compat stm tagged tasty template-haskell temporary
         test-framework test-framework-hunit text unix utf8-string
       ];
       jailbreak = true;
       doCheck = false;
       description = "An IDE backend library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ide-backend-common_0_9_0" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , bytestring-trie, containers, crypto-api, data-accessor, directory
     , filepath, fingertree, mtl, pretty-show, pureMD5, tagged
     , template-haskell, temporary, text, transformers, unix
     }:
     mkDerivation {
       pname = "ide-backend-common";
       version = "0.9.0";
       sha256 = "8218847779d81ace563266216dc12230e539112889163b0a1f7b439f1c291706";
       revision = "1";
       editedCabalFile = "d106249c8347af8eebe2318e0ee3e5cd0b2a8422bf270c9bbee4fa969c17d30c";
       libraryHaskellDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         containers crypto-api data-accessor directory filepath fingertree
         mtl pretty-show pureMD5 tagged template-haskell temporary text
         transformers unix
       ];
       jailbreak = true;
       description = "Shared library used be ide-backend and ide-backend-server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend-common_0_9_1" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , bytestring-trie, containers, crypto-api, data-accessor, directory
     , filepath, fingertree, mtl, pretty-show, pureMD5, tagged
     , template-haskell, temporary, text, transformers, unix
     }:
     mkDerivation {
       pname = "ide-backend-common";
       version = "0.9.1";
       sha256 = "22b0b9ad46d3dc56bf974ab113839b2890ee209ad5b73661e88c25b69e393dbe";
       revision = "1";
       editedCabalFile = "1b9ea6bdd1442d5381f89c3cf9daea66158c4e0d02161de4c0a4ae6a97472f6c";
       libraryHaskellDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         containers crypto-api data-accessor directory filepath fingertree
         mtl pretty-show pureMD5 tagged template-haskell temporary text
         transformers unix
       ];
       jailbreak = true;
       description = "Shared library used be ide-backend and ide-backend-server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend-common_0_9_1_1" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , bytestring-trie, containers, crypto-api, data-accessor, directory
     , filepath, fingertree, mtl, pretty-show, pureMD5, tagged
     , template-haskell, temporary, text, transformers, unix
     }:
     mkDerivation {
       pname = "ide-backend-common";
       version = "0.9.1.1";
       sha256 = "d20178e587530e44a09a0a91ee58b8ad0c33199d56a29028401356ec57ba7acc";
       revision = "1";
       editedCabalFile = "d97b8e6548343012a92aa2c0d3d5392d7640e5e13953b8a604a4b3ff666789a4";
       libraryHaskellDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         containers crypto-api data-accessor directory filepath fingertree
         mtl pretty-show pureMD5 tagged template-haskell temporary text
         transformers unix
       ];
       jailbreak = true;
       description = "Shared library used be ide-backend and ide-backend-server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend-common_0_9_1_2" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , bytestring-trie, containers, crypto-api, data-accessor, directory
     , filepath, fingertree, mtl, pretty-show, pureMD5, tagged
     , template-haskell, temporary, text, transformers, unix
     }:
     mkDerivation {
       pname = "ide-backend-common";
       version = "0.9.1.2";
       sha256 = "07974e9b5afae67d1b9776eab5524ab665a6e8ad496abe6b82077580374945b2";
       revision = "1";
       editedCabalFile = "cdbec9d6422b6888b23622286333a5119e9913f82e49f85676bb56d6ca850b38";
       libraryHaskellDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         containers crypto-api data-accessor directory filepath fingertree
         mtl pretty-show pureMD5 tagged template-haskell temporary text
         transformers unix
       ];
       jailbreak = true;
       description = "Shared library used be ide-backend and ide-backend-server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend-common_0_9_1_3" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , bytestring-trie, containers, crypto-api, data-accessor, directory
     , filepath, fingertree, mtl, pretty-show, pureMD5, tagged
     , template-haskell, temporary, text, transformers, unix
     }:
     mkDerivation {
       pname = "ide-backend-common";
       version = "0.9.1.3";
       sha256 = "2635d687af1121f59fa95041964b5e625d2b08a109fe17fb9479c5b762a8b685";
       libraryHaskellDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         containers crypto-api data-accessor directory filepath fingertree
         mtl pretty-show pureMD5 tagged template-haskell temporary text
         transformers unix
       ];
       jailbreak = true;
       description = "Shared library used be ide-backend and ide-backend-server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend-common_0_10_0" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , bytestring-trie, containers, crypto-api, data-accessor, directory
     , filepath, fingertree, monad-logger, mtl, pretty-show, pureMD5
     , tagged, template-haskell, temporary, text, transformers, unix
     }:
     mkDerivation {
       pname = "ide-backend-common";
       version = "0.10.0";
       sha256 = "947717b22aa207ee1406ed55a577c287dc4c95cfb2b1840968c896dc370443f4";
       libraryHaskellDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         containers crypto-api data-accessor directory filepath fingertree
         monad-logger mtl pretty-show pureMD5 tagged template-haskell
         temporary text transformers unix
       ];
       jailbreak = true;
       description = "Shared library used be ide-backend and ide-backend-server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend-common_0_10_1_1" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , bytestring-trie, containers, crypto-api, data-accessor, directory
     , filepath, fingertree, monad-logger, mtl, pretty-show, pureMD5
     , tagged, template-haskell, temporary, text, transformers, unix
     }:
     mkDerivation {
       pname = "ide-backend-common";
       version = "0.10.1.1";
       sha256 = "858cc32d6c73ca0d55e1fc7dc25831e437a3cca483438a74bbc236f8f93cfcb3";
       revision = "1";
       editedCabalFile = "ed08fca4f17984a5ef06a632b23bc604d5e93a3040fde4cde9721a8ef4991975";
       libraryHaskellDepends = [
         aeson async attoparsec base binary bytestring bytestring-trie
         containers crypto-api data-accessor directory filepath fingertree
         monad-logger mtl pretty-show pureMD5 tagged template-haskell
         temporary text transformers unix
       ];
       jailbreak = true;
       description = "Shared library used be ide-backend and ide-backend-server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend-common" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, base64-bytestring
     , binary, bytestring, bytestring-trie, containers, crypto-api
     , data-accessor, directory, filepath, fingertree, monad-logger, mtl
     , network, pretty-show, process, pureMD5, tagged, template-haskell
     , temporary, text, transformers, unix, unix-compat
     }:
     mkDerivation {
       pname = "ide-backend-common";
       version = "0.10.1.2";
       sha256 = "031028f38e1a6174a58665cecd882356c6ca7579c6c21a9e2461f13d81a5915b";
       revision = "1";
       editedCabalFile = "c4caa9457f4890700a79c91a9c71d11785bc43bb4bb7564e01e6b787736b9dd9";
       libraryHaskellDepends = [
         aeson async attoparsec base base64-bytestring binary bytestring
         bytestring-trie containers crypto-api data-accessor directory
         filepath fingertree monad-logger mtl network pretty-show process
         pureMD5 tagged template-haskell temporary text transformers unix
         unix-compat
       ];
       description = "Shared library used be ide-backend and ide-backend-server";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ide-backend-rts" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ide-backend-rts";
       version = "0.1.3.1";
       sha256 = "407e6c80dedc129f22e9564f447314f4053d1cc6ca244b7c9ff755e82f7d41fe";
       libraryHaskellDepends = [ base ];
       description = "RTS for the IDE backend";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ide-backend-server_0_10_0" = callPackage
    ({ mkDerivation, array, async, base, bytestring, Cabal, containers
     , data-accessor, data-accessor-mtl, directory, file-embed
     , filemanip, filepath, ghc, haddock-api, ide-backend-common, mtl
     , process, tar, temporary, text, time, transformers, unix
     , unordered-containers, zlib
     }:
     mkDerivation {
       pname = "ide-backend-server";
       version = "0.10.0";
       sha256 = "3e3f6930c78431e7573f0b4d2307f4fcaae1cd5cf4c39b0c3a3fcbe24e6150cd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array async base bytestring Cabal containers data-accessor
         data-accessor-mtl directory file-embed filemanip filepath ghc
         haddock-api ide-backend-common mtl process tar temporary text time
         transformers unix unordered-containers zlib
       ];
       jailbreak = true;
       description = "An IDE backend server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend-server_0_10_0_1" = callPackage
    ({ mkDerivation, array, async, base, bytestring, Cabal, containers
     , data-accessor, data-accessor-mtl, directory, file-embed
     , filemanip, filepath, ghc, haddock-api, ide-backend-common, mtl
     , network, process, tar, temporary, text, time, transformers, unix
     , unordered-containers, zlib
     }:
     mkDerivation {
       pname = "ide-backend-server";
       version = "0.10.0.1";
       sha256 = "e9adc5133af1025d0f011184f2beb6189927620f7557410b6e0043f126be49a0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array async base bytestring Cabal containers data-accessor
         data-accessor-mtl directory file-embed filemanip filepath ghc
         haddock-api ide-backend-common mtl network process tar temporary
         text time transformers unix unordered-containers zlib
       ];
       jailbreak = true;
       description = "An IDE backend server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ide-backend-server" = callPackage
    ({ mkDerivation, array, async, base, bytestring, Cabal, containers
     , data-accessor, data-accessor-mtl, directory, file-embed
     , filemanip, filepath, ghc, haddock-api, ide-backend-common, mtl
     , network, process, tar, temporary, text, time, transformers, unix
     , unordered-containers, zlib
     }:
     mkDerivation {
       pname = "ide-backend-server";
       version = "0.10.0.2";
       sha256 = "e5290e08247cc77b7736016342d743c01d850b01e38193bfa2b897d19accfe5f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array async base bytestring Cabal containers data-accessor
         data-accessor-mtl directory file-embed filemanip filepath ghc
         haddock-api ide-backend-common mtl network process tar temporary
         text time transformers unix unordered-containers zlib
       ];
       description = "An IDE backend server";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ideas" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, Diff
     , directory, exceptions, filepath, mtl, multipart, network
     , network-uri, old-locale, old-time, parsec, QuickCheck, random
     , time, uniplate, wl-pprint, xhtml
     }:
     mkDerivation {
       pname = "ideas";
       version = "1.4";
       sha256 = "3467d64e0e4f956f0769f3ecb9407726af8b931ebf6d5d14ebceb5a06b65d279";
       libraryHaskellDepends = [
         array base bytestring containers Diff directory exceptions filepath
         mtl multipart network network-uri old-locale old-time parsec
         QuickCheck random time uniplate wl-pprint xhtml
       ];
       jailbreak = true;
       homepage = "http://ideas.cs.uu.nl/www/";
       description = "Feedback services for intelligent tutoring systems";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ideas-math" = callPackage
    ({ mkDerivation, base, containers, ideas, parsec, QuickCheck
     , random
     }:
     mkDerivation {
       pname = "ideas-math";
       version = "1.2";
       sha256 = "22e7c39305e12987142080a8c792f0a21c1978784afbec9aabb31df6a5cf77e8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers ideas parsec QuickCheck random
       ];
       jailbreak = true;
       homepage = "http://ideas.cs.uu.nl/www/";
       description = "Interactive domain reasoner for logic and mathematics";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "idempotent" = callPackage
    ({ mkDerivation, base, containers, hspec, QuickCheck }:
     mkDerivation {
       pname = "idempotent";
       version = "0.1.2";
       sha256 = "402e120c269e1dccdbfef77f95672bf674a11462a4dfd497c514945a8b995ca2";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [ base containers hspec QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/prophile/idempotent";
       description = "Idempotent monoids";
       license = stdenv.lib.licenses.mit;
     }) {};

  "identifiers" = callPackage
    ({ mkDerivation, base, binary, cereal, containers, deepseq
     , hashable, ListLike, QuickCheck, test-framework
     , test-framework-quickcheck2, text, unordered-containers
     }:
     mkDerivation {
       pname = "identifiers";
       version = "0.4.0.0";
       sha256 = "0e9504c56888e35664840027b8fa38f9cd16ef6b19adf0a1aee7a86208436552";
       libraryHaskellDepends = [
         base binary cereal containers deepseq hashable ListLike text
         unordered-containers
       ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       description = "Numeric identifiers for values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "idiii" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-accessor
     , directory, filepath, HUnit, MissingH, polyparse, process, text
     , utf8-string
     }:
     mkDerivation {
       pname = "idiii";
       version = "0.1.3.3";
       sha256 = "10f1b88fdc02f11e1d7d5d309d637ed3b032976ed4c0fc90985c6a53a42aa984";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers data-accessor MissingH polyparse text
         utf8-string
       ];
       executableHaskellDepends = [ base containers ];
       testHaskellDepends = [
         base bytestring containers data-accessor directory filepath HUnit
         MissingH polyparse process text utf8-string
       ];
       description = "ID3v2 (tagging standard for MP3 files) library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "idna" = callPackage
    ({ mkDerivation, base, punycode, stringprep, text }:
     mkDerivation {
       pname = "idna";
       version = "0.3.0";
       sha256 = "97ffb01fea8e905e37e2cc900500f04845191090877469c96fbf12c5d3ad8213";
       libraryHaskellDepends = [ base punycode stringprep text ];
       description = "Implements IDNA (RFC 3490)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "idna2008" = callPackage
    ({ mkDerivation, base, punycode, split }:
     mkDerivation {
       pname = "idna2008";
       version = "0.0.1.0";
       sha256 = "9f7e4a3605827fcb8cf28552ccb85fa8e8ea3b2dae04d66b31657a18f215a6dd";
       libraryHaskellDepends = [ base punycode split ];
       jailbreak = true;
       description = "Converts Unicode hostnames into ASCII";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "idris" = callPackage
    ({ mkDerivation, annotated-wl-pprint, ansi-terminal, ansi-wl-pprint
     , async, base, base64-bytestring, binary, blaze-html, blaze-markup
     , bytestring, cheapskate, containers, deepseq, directory, filepath
     , fingertree, fsnotify, gmp, haskeline, hscurses, libffi, mtl
     , network, optparse-applicative, parsers, pretty, process, safe
     , split, text, time, transformers, transformers-compat, trifecta
     , uniplate, unix, unordered-containers, utf8-string, vector
     , vector-binary-instances, zip-archive
     }:
     mkDerivation {
       pname = "idris";
       version = "0.10";
       sha256 = "5593feca2cdd00ff819f37135da496111b3af06b664f4cd1f4aecba6ac6e6a10";
       configureFlags = [ "-fcurses" "-fffi" "-fgmp" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         annotated-wl-pprint ansi-terminal ansi-wl-pprint async base
         base64-bytestring binary blaze-html blaze-markup bytestring
         cheapskate containers deepseq directory filepath fingertree
         fsnotify haskeline hscurses libffi mtl network optparse-applicative
         parsers pretty process safe split text time transformers
         transformers-compat trifecta uniplate unix unordered-containers
         utf8-string vector vector-binary-instances zip-archive
       ];
       librarySystemDepends = [ gmp ];
       executableHaskellDepends = [
         base directory filepath haskeline transformers
       ];
       jailbreak = true;
       homepage = "http://www.idris-lang.org/";
       description = "Functional Programming Language with Dependent Types";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) gmp;};

  "ieee" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ieee";
       version = "0.7";
       sha256 = "758ede0080500e365eb211e5213307321a24f3f31486b74a866c120a82af7032";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/patperry/hs-ieee";
       description = "Utilities for dealing with IEEE floating point numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ieee-utils" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ieee-utils";
       version = "0.4.0";
       sha256 = "f3391c158a7f8cc772e9abd5beaf6bbf20589cc812573ae72cc6fd2d7ba88814";
       libraryHaskellDepends = [ base ];
       description = "ieee-utils";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ieee-utils-tempfix" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ieee-utils-tempfix";
       version = "0.4.0.1";
       sha256 = "831543e027e9a3aefc7f3df9eff52914f847cc301b9eb80e749ee0e1ec9e1574";
       libraryHaskellDepends = [ base ];
       description = "ieee-utils";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ieee754_0_7_4" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ieee754";
       version = "0.7.4";
       sha256 = "30bc11aa71a8d1df28b5c84cab57eb363298443ed6a26093416cd720949babdf";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/patperry/hs-ieee754";
       description = "Utilities for dealing with IEEE floating point numbers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ieee754_0_7_5" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ieee754";
       version = "0.7.5";
       sha256 = "2313ca7585ea17ffdc6e23e14b1b6593c9beefd4e35b7b975eb69b333dac0904";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/patperry/hs-ieee754";
       description = "Utilities for dealing with IEEE floating point numbers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ieee754_0_7_6" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ieee754";
       version = "0.7.6";
       sha256 = "5840644e8adbb243adc63d112c8bec3c3996af21a6c1262ce30c1e2b1034450f";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/patperry/hs-ieee754";
       description = "Utilities for dealing with IEEE floating point numbers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ieee754" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ieee754";
       version = "0.7.8";
       sha256 = "de4aefce42d903a3016cba4c7ebfc70d4fa0a76f8c04014c7eb3545b9ab56eff";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/patperry/hs-ieee754";
       description = "Utilities for dealing with IEEE floating point numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ieee754-parser" = callPackage
    ({ mkDerivation, base, binary, bytestring }:
     mkDerivation {
       pname = "ieee754-parser";
       version = "0.1";
       sha256 = "3b064492031e7cf7647dde86e92a4b6b526a08e68d40c09ccb96d5989afcfe1a";
       libraryHaskellDepends = [ base binary bytestring ];
       license = "GPL";
     }) {};

  "ifcxt" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "ifcxt";
       version = "0.1.0.0";
       sha256 = "7c09ff72dc72b288bb2020970adabc87ef1e5913175a745dd1573faf3422169d";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/mikeizbicki/ifcxt";
       description = "put if statements within type constraints";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "iff" = callPackage
    ({ mkDerivation, base, binary, bytestring }:
     mkDerivation {
       pname = "iff";
       version = "0.0.5";
       sha256 = "26ec287bfa3039429d21af00f98b9a7723922dab71d721c54fc7cd9f464bc1e3";
       libraryHaskellDepends = [ base binary bytestring ];
       homepage = "http://code.haskell.org/~thielema/iff/";
       description = "Constructing and dissecting IFF files";
       license = "GPL";
     }) {};

  "ifscs" = callPackage
    ({ mkDerivation, base, containers, failure, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "ifscs";
       version = "0.2.0.0";
       sha256 = "3854b5c8ddf09967ffd45f5d88feb6760fed24e95671f050e3ccd13a8d91e598";
       libraryHaskellDepends = [ base containers failure ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       description = "An inductive-form set constraint solver";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ig" = callPackage
    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
     , conduit, conduit-extra, crypto-api, cryptohash
     , cryptohash-cryptoapi, data-default, http-conduit, http-types
     , lifted-base, monad-control, resourcet, text, time, transformers
     , transformers-base, unordered-containers
     }:
     mkDerivation {
       pname = "ig";
       version = "0.6.1";
       sha256 = "ae2e0da4ebd3be77aac665b822191f0e4704d70cb9a73f2044494ea7f76065fe";
       libraryHaskellDepends = [
         aeson base base16-bytestring bytestring conduit conduit-extra
         crypto-api cryptohash cryptohash-cryptoapi data-default
         http-conduit http-types lifted-base monad-control resourcet text
         time transformers transformers-base unordered-containers
       ];
       homepage = "https://github.com/prowdsponsor/ig";
       description = "Bindings to Instagram's API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ige-mac-integration" = callPackage
    ({ mkDerivation, array, base, containers, glib, gtk
     , gtk2hs-buildtools, haskell98, ige-mac-integration, mtl
     }:
     mkDerivation {
       pname = "ige-mac-integration";
       version = "0.1.0.1";
       sha256 = "c66239bcafaa90d8e8bc532340897fb43f15d3615cb55619a7fd9430766189a4";
       libraryHaskellDepends = [
         array base containers glib gtk haskell98 mtl
       ];
       libraryPkgconfigDepends = [ ige-mac-integration ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       jailbreak = true;
       homepage = "http://www.haskell.org/gtk2hs/";
       description = "Bindings for the Gtk/OS X integration library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {ige-mac-integration = null;};

  "ignore" = callPackage
    ({ mkDerivation, base, directory, Glob, HTF, mtl, path, pcre-heavy
     , text
     }:
     mkDerivation {
       pname = "ignore";
       version = "0.1.1.0";
       sha256 = "aaf481fdab8bdc5a506e4726eadf56697726f82086a3cd0439526b9442c73575";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory Glob mtl path pcre-heavy text
       ];
       executableHaskellDepends = [ base directory path ];
       testHaskellDepends = [ base HTF text ];
       homepage = "http://github.com/agrafix/ignore";
       description = "Handle ignore files of different VCSes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "igraph" = callPackage
    ({ mkDerivation, base, c2hs, containers, hashable, igraph
     , unordered-containers
     }:
     mkDerivation {
       pname = "igraph";
       version = "0.1.1";
       sha256 = "4d4303f6a3c4188352965ac3f7fcee6b01cd046a8ce0abe78897561e830f0b25";
       libraryHaskellDepends = [
         base containers hashable unordered-containers
       ];
       librarySystemDepends = [ igraph ];
       libraryToolDepends = [ c2hs ];
       homepage = "http://giorgidze.github.com/igraph/";
       description = "Bindings to the igraph C library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {igraph = null;};

  "igrf" = callPackage
    ({ mkDerivation, ad, base, polynomial }:
     mkDerivation {
       pname = "igrf";
       version = "0.2.0.0";
       sha256 = "a1dea6b576654e8fdbbe0ad9639e99a05f43ae4e0a434dddbc6cece0335c3712";
       revision = "1";
       editedCabalFile = "7d616cb461fb1406310675937e1e761f2d09757824dce8a92d235b7ef6ce1e4f";
       libraryHaskellDepends = [ ad base polynomial ];
       jailbreak = true;
       homepage = "https://github.com/dmcclean/igrf";
       description = "International Geomagnetic Reference Field";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ihaskell_0_6_4_1" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bin-package-db
     , bytestring, cereal, cmdargs, containers, directory, filepath, ghc
     , ghc-parser, ghc-paths, haskeline, haskell-src-exts, here, hlint
     , hspec, http-client, http-client-tls, HUnit, ipython-kernel, mtl
     , parsec, process, random, setenv, shelly, split, stm, strict
     , system-argv0, text, transformers, unix, unordered-containers
     , utf8-string, uuid, vector
     }:
     mkDerivation {
       pname = "ihaskell";
       version = "0.6.4.1";
       sha256 = "524cf3836857ba1762f895379b533352cf25a532ad8825f93f9842d9f235adbe";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base64-bytestring bin-package-db bytestring cereal
         cmdargs containers directory filepath ghc ghc-parser ghc-paths
         haskeline haskell-src-exts here 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 bin-package-db bytestring containers directory ghc here
         ipython-kernel strict text transformers unix
       ];
       testHaskellDepends = [
         aeson base base64-bytestring bin-package-db bytestring cereal
         cmdargs containers directory filepath ghc ghc-parser ghc-paths
         haskeline haskell-src-exts here hlint hspec http-client
         http-client-tls HUnit ipython-kernel mtl parsec process random
         setenv shelly split stm strict system-argv0 text transformers unix
         unordered-containers utf8-string uuid vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://gibiansky.github.io/IHaskell/";
       description = "A Haskell backend kernel for the IPython project";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ihaskell_0_6_5_0" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bin-package-db
     , bytestring, cereal, cmdargs, containers, directory, filepath, ghc
     , ghc-parser, ghc-paths, haskeline, haskell-src-exts, here, hlint
     , hspec, http-client, http-client-tls, HUnit, ipython-kernel, mtl
     , parsec, process, random, setenv, shelly, split, stm, strict
     , system-argv0, text, transformers, unix, unordered-containers
     , utf8-string, uuid, vector
     }:
     mkDerivation {
       pname = "ihaskell";
       version = "0.6.5.0";
       sha256 = "e634513efa47aa3e369c3d7fb0ad038b1cba308186d4c50268641a97a727ddbb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base64-bytestring bin-package-db bytestring cereal
         cmdargs containers directory filepath ghc ghc-parser ghc-paths
         haskeline haskell-src-exts here 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 bin-package-db bytestring containers directory ghc here
         ipython-kernel strict text transformers unix
       ];
       testHaskellDepends = [
         aeson base base64-bytestring bin-package-db bytestring cereal
         cmdargs containers directory filepath ghc ghc-parser ghc-paths
         haskeline haskell-src-exts here hlint hspec http-client
         http-client-tls HUnit ipython-kernel mtl parsec process random
         setenv shelly split stm strict system-argv0 text transformers unix
         unordered-containers utf8-string uuid vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/gibiansky/IHaskell";
       description = "A Haskell backend kernel for the IPython project";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ihaskell" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bin-package-db
     , bytestring, cereal, cmdargs, containers, directory, filepath, ghc
     , ghc-parser, ghc-paths, haskeline, haskell-src-exts, hlint, hspec
     , http-client, http-client-tls, HUnit, ipython-kernel, mtl, parsec
     , process, random, setenv, shelly, split, stm, strict, system-argv0
     , text, transformers, unix, unordered-containers, utf8-string, uuid
     , vector
     }:
     mkDerivation {
       pname = "ihaskell";
       version = "0.8.3.0";
       sha256 = "c486e0b6342fa6261c671ad6a891f5763f7979bc225781329fe9f913a3833107";
       revision = "1";
       editedCabalFile = "4079263fe3b633e589775753fe7e3bbab21c800fd7d54c2aa6761478c5019654";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base64-bytestring bin-package-db bytestring cereal
         cmdargs containers directory filepath ghc 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 bin-package-db bytestring containers directory ghc
         ipython-kernel process strict text transformers unix
       ];
       testHaskellDepends = [
         aeson base base64-bytestring bin-package-db bytestring cereal
         cmdargs containers directory filepath ghc ghc-parser ghc-paths
         haskeline haskell-src-exts hlint hspec http-client http-client-tls
         HUnit ipython-kernel mtl parsec process random setenv shelly split
         stm strict system-argv0 text transformers unix unordered-containers
         utf8-string uuid vector
       ];
       doCheck = false;
       homepage = "http://github.com/gibiansky/IHaskell";
       description = "A Haskell backend kernel for the IPython project";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ihaskell-aeson" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, here
     , ihaskell, text
     }:
     mkDerivation {
       pname = "ihaskell-aeson";
       version = "0.3.0.0";
       sha256 = "a716703680e95ecd6c1e9bd93819c2aeeeec248397024b84f5ad22caf15c4b40";
       libraryHaskellDepends = [
         aeson aeson-pretty base bytestring here ihaskell text
       ];
       homepage = "http://www.github.com/gibiansky/ihaskell";
       description = "IHaskell display instances for Aeson";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ihaskell-basic" = callPackage
    ({ mkDerivation, base, ihaskell }:
     mkDerivation {
       pname = "ihaskell-basic";
       version = "0.3.0.0";
       sha256 = "1c1ee80276e7950370b8b3fe61fc6764e60fb41d1adab5028e74e865a0e964ed";
       libraryHaskellDepends = [ base ihaskell ];
       homepage = "http://www.github.com/gibiansky/IHaskell";
       description = "IHaskell display instances for basic types";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ihaskell-blaze" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, ihaskell }:
     mkDerivation {
       pname = "ihaskell-blaze";
       version = "0.3.0.0";
       sha256 = "eba41d50a7d9af9fd9e1a9e0d1346ec77dd564866c673dcad905ea69c38f83c6";
       libraryHaskellDepends = [ base blaze-html blaze-markup ihaskell ];
       homepage = "http://www.github.com/gibiansky/ihaskell";
       description = "IHaskell display instances for blaze-html types";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ihaskell-charts" = callPackage
    ({ mkDerivation, base, bytestring, Chart, Chart-cairo
     , data-default-class, directory, ihaskell
     }:
     mkDerivation {
       pname = "ihaskell-charts";
       version = "0.3.0.0";
       sha256 = "c3919848c37f067299e9e24daa725b81af140f4a69b5ff3ad1618f92baaf915a";
       libraryHaskellDepends = [
         base bytestring Chart Chart-cairo data-default-class directory
         ihaskell
       ];
       homepage = "http://www.github.com/gibiansky/ihaskell";
       description = "IHaskell display instances for charts types";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ihaskell-diagrams_0_3_0_0" = callPackage
    ({ mkDerivation, active, base, bytestring, diagrams, diagrams-cairo
     , diagrams-lib, directory, ihaskell, text
     }:
     mkDerivation {
       pname = "ihaskell-diagrams";
       version = "0.3.0.0";
       sha256 = "8afdad1e343b77e0627fc75417c42e78b5b9f13c5ef39017cfefd264b3fe3270";
       libraryHaskellDepends = [
         active base bytestring diagrams diagrams-cairo diagrams-lib
         directory ihaskell text
       ];
       homepage = "http://www.github.com/gibiansky/ihaskell";
       description = "IHaskell display instances for diagram types";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ihaskell-diagrams" = callPackage
    ({ mkDerivation, active, base, bytestring, diagrams, diagrams-cairo
     , diagrams-lib, directory, ihaskell, text
     }:
     mkDerivation {
       pname = "ihaskell-diagrams";
       version = "0.3.1.0";
       sha256 = "1f137977fde3cc9f3efbd2b5c1a21e06cbfdee6eab1c096c8fc1429dbba907a3";
       libraryHaskellDepends = [
         active base bytestring diagrams diagrams-cairo diagrams-lib
         directory ihaskell text
       ];
       homepage = "http://www.github.com/gibiansky/ihaskell";
       description = "IHaskell display instances for diagram types";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ihaskell-display" = callPackage
    ({ mkDerivation, base, classy-prelude, ihaskell }:
     mkDerivation {
       pname = "ihaskell-display";
       version = "0.1.0.0";
       sha256 = "800e5324e52abaa01e31f0123e4596e9df614684b01a5b91906d8c37d3866eb1";
       libraryHaskellDepends = [ base classy-prelude ihaskell ];
       jailbreak = true;
       homepage = "http://www.github.com/gibiansky/IHaskell";
       description = "IHaskell display instances for basic types";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ihaskell-hatex" = callPackage
    ({ mkDerivation, base, HaTeX, ihaskell, text }:
     mkDerivation {
       pname = "ihaskell-hatex";
       version = "0.2.1.0";
       sha256 = "11999ba26d5d09a1f51f88907ca52dcbff9b7714e3f8b66d2bb150cd975a1525";
       libraryHaskellDepends = [ base HaTeX ihaskell text ];
       homepage = "http://www.github.com/gibiansky/IHaskell";
       description = "IHaskell display instances for hatex";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ihaskell-inline-r" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring
     , filepath, ihaskell, ihaskell-blaze, inline-r, template-haskell
     , temporary
     }:
     mkDerivation {
       pname = "ihaskell-inline-r";
       version = "0.1.1.0";
       sha256 = "e6584ad3c1140ebbcf26c37ae668b00c8b033574f380b11f486c69f1eb58665a";
       libraryHaskellDepends = [
         base base64-bytestring blaze-html bytestring filepath ihaskell
         ihaskell-blaze inline-r template-haskell temporary
       ];
       homepage = "https://tweag.github.io/HaskellR/";
       description = "Embed R quasiquotes and plots in IHaskell notebooks";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ihaskell-juicypixels" = callPackage
    ({ mkDerivation, base, bytestring, directory, ihaskell, JuicyPixels
     }:
     mkDerivation {
       pname = "ihaskell-juicypixels";
       version = "0.3.0.0";
       sha256 = "1e4ce2bcede2d2a3a808078f83aecc24dba6220913af34f4ff907c400aa5fa2a";
       libraryHaskellDepends = [
         base bytestring directory ihaskell JuicyPixels
       ];
       homepage = "http://www.github.com/gibiansky/ihaskell";
       description = "IHaskell - IHaskellDisplay instances of the image types of the JuicyPixels package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ihaskell-magic" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, ihaskell
     , ipython-kernel, magic, text, utf8-string
     }:
     mkDerivation {
       pname = "ihaskell-magic";
       version = "0.3.0.0";
       sha256 = "b45999a7fec36b642e05d739af16999b80677998d09d756bc6aa0d1314f35b16";
       libraryHaskellDepends = [
         base base64-bytestring bytestring ihaskell ipython-kernel magic
         text utf8-string
       ];
       homepage = "http://www.github.com/gibiansky/IHaskell";
       description = "IHaskell display instances for bytestrings";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ihaskell-parsec" = callPackage
    ({ mkDerivation, aeson, base, here, ihaskell, parsec, random, text
     , unordered-containers
     }:
     mkDerivation {
       pname = "ihaskell-parsec";
       version = "0.3.0.0";
       sha256 = "c422accbff5cf785799c3596eb5712d4fd90eef13b071c2263488880ece62a58";
       libraryHaskellDepends = [
         aeson base here ihaskell parsec random text unordered-containers
       ];
       jailbreak = true;
       homepage = "http://www.github.com/gibiansky/ihaskell";
       description = "IHaskell display instances for Parsec";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ihaskell-plot" = callPackage
    ({ mkDerivation, base, bytestring, ihaskell, plot }:
     mkDerivation {
       pname = "ihaskell-plot";
       version = "0.3.0.0";
       sha256 = "0106697f8f81ea5fac13c1e8572aef3362cd00f6affbb8464c5b939d2c15179f";
       libraryHaskellDepends = [ base bytestring ihaskell plot ];
       homepage = "http://www.github.com/gibiansky/ihaskell";
       description = "IHaskell display instance for Plot (from plot package)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ihaskell-rlangqq" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-html, bytestring
     , directory, filepath, ihaskell, ihaskell-blaze, Rlang-QQ, split
     , stm, template-haskell, xformat
     }:
     mkDerivation {
       pname = "ihaskell-rlangqq";
       version = "0.3.0.0";
       sha256 = "52c59fed843f2451c4d888d9e1a5f00370799ba114dab799294d885007e55ef0";
       libraryHaskellDepends = [
         base base64-bytestring blaze-html bytestring directory filepath
         ihaskell ihaskell-blaze Rlang-QQ split stm template-haskell xformat
       ];
       description = "a rDisp quasiquote to show plots from Rlang-QQ in IHaskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ihaskell-widgets" = callPackage
    ({ mkDerivation, aeson, base, containers, ihaskell, ipython-kernel
     , nats, scientific, singletons, text, unix, unordered-containers
     , vector, vinyl
     }:
     mkDerivation {
       pname = "ihaskell-widgets";
       version = "0.2.2.1";
       sha256 = "c085e47379547e61009d9ffc2c48f2b038a7bbd55d537e328d0e2cb064cf12d9";
       libraryHaskellDepends = [
         aeson base containers ihaskell ipython-kernel nats scientific
         singletons text unix unordered-containers vector vinyl
       ];
       jailbreak = true;
       homepage = "http://www.github.com/gibiansky/IHaskell";
       description = "IPython standard widgets for IHaskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ihttp" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , contstuff, enumerator, netlines, network
     }:
     mkDerivation {
       pname = "ihttp";
       version = "0.3.0";
       sha256 = "f5974c244f47ca05aaaf40f963539aa71106a494fb8ffcf0d8e90ddf98489be5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring containers contstuff enumerator netlines
       ];
       executableHaskellDepends = [ base network ];
       description = "Incremental HTTP iteratee";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "illuminate" = callPackage
    ({ mkDerivation, alex, array, base, containers, filemanip, filepath
     , hscolour, html, utf8-string, xhtml
     }:
     mkDerivation {
       pname = "illuminate";
       version = "0.1";
       sha256 = "65c2cb06a676d17114fab562884bd91ed2d88fc1f2a9d8e8805eada6b480329a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers filemanip filepath hscolour html utf8-string xhtml
       ];
       libraryToolDepends = [ alex ];
       executableHaskellDepends = [ array base containers html xhtml ];
       executableToolDepends = [ alex ];
       homepage = "http://github.com/jgm/illuminate";
       description = "A fast syntax highlighting library built with alex";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "image-type" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "image-type";
       version = "0.1.0.0";
       sha256 = "7af29056bd7e8f841a4d963eca12dfe3e4c47951781d8f07f2c14af20a2b2577";
       revision = "1";
       editedCabalFile = "47033c893690f2cea85ba867343f277a8e2594f9010a5466a39dc7f3c4d682f2";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "https://github.com/Icelandjack/Image-type";
       description = "Determine the type of an image by reading the first bytes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "imagefilters" = callPackage
    ({ mkDerivation, base, gd }:
     mkDerivation {
       pname = "imagefilters";
       version = "0.1";
       sha256 = "7e500386a3010b4114917223903f27c10e40ae1e314b52ae06df54cd51e7ead8";
       libraryHaskellDepends = [ base gd ];
       homepage = "https://github.com/tchannel/imagefilters";
       description = "Image Filters (contrast, brightness, gaussian blur, etc)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "imagemagick" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, imagemagick
     , lifted-base, MonadCatchIO-transformers, QuickCheck, resourcet
     , tasty, tasty-hunit, text, transformers, vector
     }:
     mkDerivation {
       pname = "imagemagick";
       version = "0.0.4.1";
       sha256 = "a395fa54e4aa3edca9961f062345247e925e841206c1826e58b31e255062c6ea";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring filepath MonadCatchIO-transformers resourcet text
         transformers vector
       ];
       libraryPkgconfigDepends = [ imagemagick ];
       executablePkgconfigDepends = [ imagemagick ];
       testHaskellDepends = [
         base bytestring directory filepath lifted-base QuickCheck resourcet
         tasty tasty-hunit text transformers vector
       ];
       testPkgconfigDepends = [ imagemagick ];
       description = "bindings to imagemagick library";
       license = "unknown";
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {inherit (pkgs) imagemagick;};

  "imagepaste" = callPackage
    ({ mkDerivation, base, containers, HTTP, json, mtl, network
     , regex-posix, tagsoup, template-haskell, transformers
     , vcs-revision
     }:
     mkDerivation {
       pname = "imagepaste";
       version = "0.2.0.1";
       sha256 = "fbee1a3964b4f290e90c930a45643dcb1d376b06c06af1bf35150a457815a1cc";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers HTTP json mtl network regex-posix tagsoup
         template-haskell transformers vcs-revision
       ];
       homepage = "https://bitbucket.org/balta2ar/imagepaste";
       description = "Command-line image paste utility";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "imagesize-conduit_1_0_0_4" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra, hspec
     , resourcet
     }:
     mkDerivation {
       pname = "imagesize-conduit";
       version = "1.0.0.4";
       sha256 = "8733f22e0dec8e401c3d91dd2d13ea49f5370deee2dd0fe7f04ed286db921542";
       revision = "1";
       editedCabalFile = "9a9a6ea6572ae1cdf6f1df1bbd35c96ae2aac9f61f7eabbcc1a60ed792d14a3d";
       libraryHaskellDepends = [ base bytestring conduit conduit-extra ];
       testHaskellDepends = [
         base bytestring conduit conduit-extra hspec resourcet
       ];
       homepage = "http://github.com/silkapp/imagesize-conduit";
       description = "Determine the size of some common image formats";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "imagesize-conduit" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , exceptions, hspec, resourcet
     }:
     mkDerivation {
       pname = "imagesize-conduit";
       version = "1.1";
       sha256 = "31c5784578b305921b89f7ab6fca35747e5a35f12884770b78c31e3a0a01ac19";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra exceptions
       ];
       testHaskellDepends = [
         base bytestring conduit conduit-extra hspec resourcet
       ];
       homepage = "http://github.com/silkapp/imagesize-conduit";
       description = "Determine the size of some common image formats";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "imap" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, connection
     , data-default, derive, either, exceptions, hslogger, HUnit, list-t
     , monadIO, mtl, QuickCheck, random, rolling-queue, stm, stm-delay
     , tasty, tasty-hunit, tasty-quickcheck, text, transformers, word8
     }:
     mkDerivation {
       pname = "imap";
       version = "0.2.0.3";
       sha256 = "912e050ba15043cbc05782bd5a6069d249402f86a41d17e0761fd6153a5a5f88";
       libraryHaskellDepends = [
         attoparsec base bytestring connection data-default derive either
         exceptions hslogger list-t monadIO random rolling-queue stm
         stm-delay text transformers word8
       ];
       testHaskellDepends = [
         attoparsec base bytestring connection data-default derive either
         exceptions hslogger HUnit list-t monadIO mtl QuickCheck random
         rolling-queue stm stm-delay tasty tasty-hunit tasty-quickcheck text
         transformers word8
       ];
       description = "An efficient IMAP client library, with SSL and streaming";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "imapget" = callPackage
    ({ mkDerivation, base, bytestring, directory, HaskellNet, HsOpenSSL
     , network, text
     }:
     mkDerivation {
       pname = "imapget";
       version = "0.0.3";
       sha256 = "bb60d130f9a166f5735a40eba7d23ecdcec2e4fc677b78650eb5a3f3075cd340";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory HaskellNet HsOpenSSL network text
       ];
       jailbreak = true;
       description = "Downloads email from imap SSL servers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "imbib" = callPackage
    ({ mkDerivation, base, bibtex, bytestring, ConfigFile, containers
     , curl, directory, download-curl, filepath, glib, gnomevfs, gtk
     , mtl, parsec, process, split, utf8-string
     }:
     mkDerivation {
       pname = "imbib";
       version = "1.0.0";
       sha256 = "7f1f3326f2534ba3427d1dadea50b853170de055cfaa9547ee11ab6a9ae46174";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bibtex bytestring ConfigFile containers curl directory
         download-curl filepath glib gnomevfs gtk mtl parsec process split
         utf8-string
       ];
       jailbreak = true;
       description = "Minimalistic reference manager";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "imgurder" = callPackage
    ({ mkDerivation, base, curl, directory, haskell98, hxt, hxt-xpath
     , url
     }:
     mkDerivation {
       pname = "imgurder";
       version = "1.2";
       sha256 = "5d667e0960a3af9574f8a2c71fc79599e50779be1153a38614219023b01bca94";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base curl directory haskell98 hxt hxt-xpath url
       ];
       executableHaskellDepends = [
         base curl directory haskell98 hxt hxt-xpath url
       ];
       description = "Uploader for Imgur";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "imm" = callPackage
    ({ mkDerivation, async, base, bytestring, case-insensitive, cond
     , data-default, directory, dyre, feed, filepath, hslogger
     , http-conduit, http-types, lens, mime-mail, monad-control, mtl
     , network, network-uri, old-locale, opml, random, resourcet, text
     , text-icu, time, timerep, tls, transformers, transformers-base
     , utf8-string, xdg-basedir, xml
     }:
     mkDerivation {
       pname = "imm";
       version = "0.6.0.3";
       sha256 = "b488b4a0011abf516b4d71eeea0c5cdbd2a4ebb561c2ec200cb90bd9cd58183a";
       revision = "1";
       editedCabalFile = "c14d5caa0066c05d15589dfbb663c5397bcb6d12ab4477de1d7572e3a16b132d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base bytestring case-insensitive cond data-default directory
         dyre feed filepath hslogger http-conduit http-types lens mime-mail
         monad-control mtl network network-uri old-locale opml random
         resourcet text text-icu time timerep tls transformers
         transformers-base utf8-string xdg-basedir xml
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       description = "Retrieve RSS/Atom feeds and write one mail per new item in a maildir";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "immortal" = callPackage
    ({ mkDerivation, base, lifted-base, monad-control, stm, tasty
     , tasty-hunit, transformers, transformers-base
     }:
     mkDerivation {
       pname = "immortal";
       version = "0.2";
       sha256 = "e29810c17ec07ecadb09f2d2d484923a4b1d39d460c1d9334e02f60406fc29ea";
       libraryHaskellDepends = [
         base lifted-base monad-control transformers-base
       ];
       testHaskellDepends = [
         base lifted-base stm tasty tasty-hunit transformers
       ];
       homepage = "https://github.com/feuerbach/immortal";
       description = "Spawn threads that never die (unless told to do so)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "imparse" = callPackage
    ({ mkDerivation, ascetic, base, compilation, containers, directory
     , indents, MissingH, parsec, richreports, split, staticanalysis
     , text, uxadt
     }:
     mkDerivation {
       pname = "imparse";
       version = "0.0.0.3";
       sha256 = "cf259d1141910ced182db15bb647d43b1e1a19370d222b4bf82a8d5650fa7795";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ascetic base compilation containers directory indents MissingH
         parsec richreports split staticanalysis text uxadt
       ];
       executableHaskellDepends = [
         ascetic base compilation containers directory indents MissingH
         parsec richreports split staticanalysis text uxadt
       ];
       jailbreak = true;
       description = "Multi-platform parser analyzer and generator";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "imperative-edsl" = callPackage
    ({ mkDerivation, array, base, BoundedChan, constraints, containers
     , directory, exception-transformers, language-c-quote
     , mainland-pretty, microlens, microlens-mtl, microlens-th, mtl
     , open-typerep, operational-alacarte, process, srcloc, syntactic
     , tagged
     }:
     mkDerivation {
       pname = "imperative-edsl";
       version = "0.4.1";
       sha256 = "5b78994b208351b4fdd8465146559d7198c6969dfaaa3767ed667d9df29bfad4";
       libraryHaskellDepends = [
         array base BoundedChan constraints containers
         exception-transformers language-c-quote mainland-pretty microlens
         microlens-mtl microlens-th mtl open-typerep operational-alacarte
         srcloc syntactic tagged
       ];
       testHaskellDepends = [ base directory mainland-pretty process ];
       homepage = "https://github.com/emilaxelsson/imperative-edsl";
       description = "Deep embedding of imperative programs with code generation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "imperative-edsl-vhdl" = callPackage
    ({ mkDerivation, base, bytestring, constraints, containers
     , language-vhdl, mtl, operational-alacarte, pretty, syntactic
     }:
     mkDerivation {
       pname = "imperative-edsl-vhdl";
       version = "0.3.2";
       sha256 = "2bc6771e4dad56aba06441139c4649232cd876ec56d87bc96e57430096843098";
       libraryHaskellDepends = [
         base bytestring constraints containers language-vhdl mtl
         operational-alacarte pretty syntactic
       ];
       description = "Deep embedding of VHDL programs with code generation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "implicit" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-markup, blaze-svg
     , bytestring, containers, deepseq, directory, filepath, JuicyPixels
     , mtl, NumInstances, optparse-applicative, parallel, parsec
     , storable-endian, text, unordered-containers, vector-space
     }:
     mkDerivation {
       pname = "implicit";
       version = "0.0.5";
       sha256 = "aa5a5de53ad25517a9ce044c21572f42262e537c848a81fd2be5b32c88d2fc9e";
       revision = "1";
       editedCabalFile = "9f5c887aaa0c834171243bf2acdc5e6234e124c3ee3f55c8c10ce37a7690500a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder blaze-markup blaze-svg bytestring containers
         deepseq directory filepath JuicyPixels mtl NumInstances
         optparse-applicative parallel parsec storable-endian text
         unordered-containers vector-space
       ];
       homepage = "https://github.com/colah/ImplicitCAD";
       description = "Math-inspired programmatic 2&3D CAD: CSG, bevels, and shells; gcode export..";
       license = "GPL";
     }) {};

  "implicit-params" = callPackage
    ({ mkDerivation, base, data-default-class }:
     mkDerivation {
       pname = "implicit-params";
       version = "0.2.1";
       sha256 = "11d98bcb69c30abe29d229f2807e16381de2302a7473c53d2823b8cead0b40b5";
       libraryHaskellDepends = [ base data-default-class ];
       homepage = "http://github.com/duairc/implicit-params";
       description = "Named and unnamed implicit parameters with defaults";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "imports" = callPackage
    ({ mkDerivation, base, directory, filepath, mtl }:
     mkDerivation {
       pname = "imports";
       version = "0.2.0.0";
       sha256 = "8a423866bce4862f65926a67519f23c3262ea2f85f01104a5a2e03ee63f2dc61";
       libraryHaskellDepends = [ base directory filepath mtl ];
       testHaskellDepends = [ base directory filepath mtl ];
       homepage = "https://github.com/CindyLinz/Haskell-imports";
       description = "Generate code for importing directories automatically";
       license = stdenv.lib.licenses.mit;
     }) {};

  "impossible" = callPackage
    ({ mkDerivation, base, lens }:
     mkDerivation {
       pname = "impossible";
       version = "1.0.0";
       sha256 = "7f4f8d20bea5ee0c125218276d6e252d85c748808fc7f8ec5d6990aa84e277e2";
       libraryHaskellDepends = [ base lens ];
       homepage = "https://github.com/wdanilo/impossible";
       description = "Set of data and type definitions of impossible types. Impossible types are useful when declaring type classes / type families instances that should not be expanded by GHC until a specific type is provided in order to keep the types nice and readable.";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "improve" = callPackage
    ({ mkDerivation, base, mtl, yices }:
     mkDerivation {
       pname = "improve";
       version = "0.4.0";
       sha256 = "ea98772782c4faa11001ccf018d74203cb15fc86520d4ad6647118311f3d1c7d";
       libraryHaskellDepends = [ base mtl yices ];
       jailbreak = true;
       homepage = "http://github.com/tomahawkins/improve/wiki/ImProve";
       description = "An imperative, verifiable programming language for high assurance applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "inc-ref" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "inc-ref";
       version = "0.3.0.0";
       sha256 = "b403f23ba47896e5a7aa04829f47e8d87959d2da0d2d4e8eac4109ccdb2a2243";
       libraryHaskellDepends = [ base stm ];
       homepage = "https://github.com/jfischoff/inc-ref";
       description = "A STM reference useful for incremental computing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "inch" = callPackage
    ({ mkDerivation, base, containers, directory, filepath
     , IndentParser, mtl, parsec, presburger, pretty
     }:
     mkDerivation {
       pname = "inch";
       version = "0.2.0";
       sha256 = "b1d9a71a676026e88d4d32e482ea2cd7633b568635ba3b6d072b16a0be2fc215";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers filepath IndentParser mtl parsec presburger pretty
       ];
       testHaskellDepends = [
         base containers directory filepath IndentParser mtl parsec
         presburger pretty
       ];
       jailbreak = true;
       homepage = "https://github.com/adamgundry/inch/";
       description = "A type-checker for Haskell with integer constraints";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "include-file_0_1_0_2" = callPackage
    ({ mkDerivation, base, bytestring, random, template-haskell }:
     mkDerivation {
       pname = "include-file";
       version = "0.1.0.2";
       sha256 = "6aa1fd4ff8b561c3a21e19fd72609fda9392088ffedbb98f4c5cf2336edb387b";
       libraryHaskellDepends = [
         base bytestring random template-haskell
       ];
       testHaskellDepends = [ base bytestring ];
       description = "Inclusion of files in executables at compile-time";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "include-file" = callPackage
    ({ mkDerivation, base, bytestring, random, template-haskell }:
     mkDerivation {
       pname = "include-file";
       version = "0.1.0.3";
       sha256 = "208f1f3bdc717f5f953cb7c9935c84d6a6291b7cd5ed8a22fa8567184be33d29";
       libraryHaskellDepends = [
         base bytestring random template-haskell
       ];
       testHaskellDepends = [ base bytestring ];
       description = "Inclusion of files in executables at compile-time";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "incremental-computing" = callPackage
    ({ mkDerivation, base, Cabal, cabal-test-quickcheck, containers
     , dlist, fingertree, order-maintenance, QuickCheck, transformers
     }:
     mkDerivation {
       pname = "incremental-computing";
       version = "0.0.0.0";
       sha256 = "03efed30f17d3a2eafc72a549298368ebaf6303d3af6b65f44015b508508b87d";
       libraryHaskellDepends = [
         base containers dlist fingertree order-maintenance transformers
       ];
       testHaskellDepends = [
         base Cabal cabal-test-quickcheck containers QuickCheck
       ];
       jailbreak = true;
       homepage = "http://darcs.wolfgang.jeltsch.info/haskell/incremental-computing";
       description = "Incremental computing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "incremental-parser_0_2_3_3" = callPackage
    ({ mkDerivation, base, checkers, monoid-subclasses, QuickCheck
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "incremental-parser";
       version = "0.2.3.3";
       sha256 = "d61eff855366beb82d7a42bfecaf36497c7163b8d3eb0bcec1f40de07a012d34";
       libraryHaskellDepends = [ base monoid-subclasses ];
       testHaskellDepends = [
         base checkers monoid-subclasses QuickCheck test-framework
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://patch-tag.com/r/blamario/incremental-parser/wiki/";
       description = "Generic parser library capable of providing partial results from partial input";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "incremental-parser_0_2_3_4" = callPackage
    ({ mkDerivation, base, checkers, monoid-subclasses, QuickCheck
     , tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "incremental-parser";
       version = "0.2.3.4";
       sha256 = "e329c982a03cdbb1c050985b01b80089e55497631c20cd7ad2ecfd46220a4358";
       libraryHaskellDepends = [ base monoid-subclasses ];
       testHaskellDepends = [
         base checkers monoid-subclasses QuickCheck tasty tasty-quickcheck
       ];
       homepage = "http://patch-tag.com/r/blamario/incremental-parser/wiki/";
       description = "Generic parser library capable of providing partial results from partial input";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "incremental-parser_0_2_4" = callPackage
    ({ mkDerivation, base, checkers, monoid-subclasses, QuickCheck
     , tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "incremental-parser";
       version = "0.2.4";
       sha256 = "e6068d005c9c70bbc11a329c7cfa19753842f668d62e9bb37f67f5567475fc70";
       libraryHaskellDepends = [ base monoid-subclasses ];
       testHaskellDepends = [
         base checkers monoid-subclasses QuickCheck tasty tasty-quickcheck
       ];
       homepage = "http://patch-tag.com/r/blamario/incremental-parser/wiki/";
       description = "Generic parser library capable of providing partial results from partial input";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "incremental-parser" = callPackage
    ({ mkDerivation, base, checkers, monoid-subclasses, QuickCheck
     , tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "incremental-parser";
       version = "0.2.4.1";
       sha256 = "1630a763db0808cfa4c1439365e21a53a378b38c2c02957539a9f75bb482b054";
       libraryHaskellDepends = [ base monoid-subclasses ];
       testHaskellDepends = [
         base checkers monoid-subclasses QuickCheck tasty tasty-quickcheck
       ];
       homepage = "https://github.com/blamario/incremental-parser";
       description = "Generic parser library capable of providing partial results from partial input";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "incremental-sat-solver" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "incremental-sat-solver";
       version = "0.1.7";
       sha256 = "5b30d2e18cb17e22bc3aa9987908e3a044acdd7d367f8d44f328529a021e2cce";
       libraryHaskellDepends = [ base containers mtl ];
       homepage = "http://github.com/sebfisch/incremental-sat-solver";
       description = "Simple, Incremental SAT Solving as a Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "increments" = callPackage
    ({ mkDerivation, base, beamable, bytestring, containers, ghc-prim
     , QuickCheck, test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "increments";
       version = "0.1.0.4";
       sha256 = "317592eb290638a51e70464d55d0befde7fe033022f319b52b41b8e443b34a37";
       libraryHaskellDepends = [
         base beamable bytestring containers ghc-prim
       ];
       testHaskellDepends = [
         base beamable bytestring containers ghc-prim QuickCheck
         test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       description = "type classes for incremental updates to data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "indentation" = callPackage
    ({ mkDerivation, base, mtl, parsec, parsers, tasty, tasty-hunit
     , trifecta
     }:
     mkDerivation {
       pname = "indentation";
       version = "0.2.1.1";
       sha256 = "72134a7c01812ccadacf1c5db86e40892136e7bf583b85c083b088cec19e65f1";
       revision = "1";
       editedCabalFile = "642875a7d7d3b8bd626f1671ff1dad1a8584bfa0fab236e5e404d8b26345317e";
       libraryHaskellDepends = [ base mtl parsec parsers trifecta ];
       testHaskellDepends = [ base parsec tasty tasty-hunit trifecta ];
       homepage = "https://bitbucket.org/adamsmd/indentation";
       description = "Indentation sensitive parsing combinators for Parsec and Trifecta";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "indentparser" = callPackage
    ({ mkDerivation, base, mtl, parsec }:
     mkDerivation {
       pname = "indentparser";
       version = "0.1";
       sha256 = "5c1dd6eeeb8fb5e136528df6ffb7c0041e708b63f0bcd4e55fa297d960fd2b90";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl parsec ];
       homepage = "http://www.cse.iitk.ac.in/users/ppk/code/HASKELL/indentparser";
       description = "A parser for indentation based structures";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "indents" = callPackage
    ({ mkDerivation, base, concatenative, mtl, parsec }:
     mkDerivation {
       pname = "indents";
       version = "0.3.3";
       sha256 = "b61f51ac894609cb5571cc3ded12db5de97185a8de236c69ec24c87457109f9a";
       libraryHaskellDepends = [ base concatenative mtl parsec ];
       homepage = "http://patch-tag.com/r/salazar/indents";
       description = "indentation sensitive parser-combinators for parsec";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "index-core" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "index-core";
       version = "1.0.2";
       sha256 = "bc51abd8393a83ab472adb545ae60366e55d6c72ea40484fd0816f55534e466a";
       revision = "1";
       editedCabalFile = "97808339bd2ac8a5c79ed99e716e2e8e941234421fde3930b370e0bbc734b063";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Indexed Types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "indexed" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "indexed";
       version = "0.1";
       sha256 = "2274650021b803c6e55828f18b27a08d7b7b95767c306804154dea5ba2bfa5b7";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/reinerp/indexed";
       description = "Haskell98 indexed functors, monads, comonads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "indexed-do-notation" = callPackage
    ({ mkDerivation, base, haskell-src-meta, indexed, template-haskell
     }:
     mkDerivation {
       pname = "indexed-do-notation";
       version = "0.1";
       sha256 = "c9e958fb47ce04d214e015164f3b2453e8ea5990c25a9fb8a729bc2f255cdb83";
       libraryHaskellDepends = [
         base haskell-src-meta indexed template-haskell
       ];
       homepage = "https://github.com/fumieval/indexed-do-notation";
       description = "Do notation for indexed monads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "indexed-extras" = callPackage
    ({ mkDerivation, base, bifunctors, indexed, mtl, pointed }:
     mkDerivation {
       pname = "indexed-extras";
       version = "0.1.1";
       sha256 = "3901759ad35d8b2333ae18142d88f3b92954b05db733f8ccac255256b5981f56";
       libraryHaskellDepends = [ base bifunctors indexed mtl pointed ];
       jailbreak = true;
       homepage = "https://github.com/reinerp/indexed-extras";
       description = "Indexed functors, monads and comonads that require extensions to Haskell98";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "indexed-free" = callPackage
    ({ mkDerivation, base, indexed }:
     mkDerivation {
       pname = "indexed-free";
       version = "0.3.1";
       sha256 = "bd363584d8370af21b440d47d8a11e5332bf6db30d2d6a6b30c0f9ef61dfe284";
       libraryHaskellDepends = [ base indexed ];
       homepage = "https://github.com/fumieval/indexed-free";
       description = "indexed monads for free";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "indian-language-font-converter" = callPackage
    ({ mkDerivation, base, gtk, HDBC, HDBC-sqlite3 }:
     mkDerivation {
       pname = "indian-language-font-converter";
       version = "0.2";
       sha256 = "c85e1aa01dba45ae2943080ef23c07976c8404134e8533b8a2db41b1877780b7";
       libraryHaskellDepends = [ base gtk HDBC HDBC-sqlite3 ];
       description = "Indian Language Font Converter";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "indices" = callPackage
    ({ mkDerivation, base, QuickCheck, tagged, template-haskell }:
     mkDerivation {
       pname = "indices";
       version = "1.7.1";
       sha256 = "8505d262f5ae056e83be32084d93bb1472194c4c4d2b8e442fb3c5845f02c6eb";
       libraryHaskellDepends = [ base tagged template-haskell ];
       testHaskellDepends = [ base QuickCheck ];
       description = "Multi-dimensional statically bounded indices";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "indieweb-algorithms" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, bytestring, containers
     , data-default, either, hspec, hspec-expectations-pretty-diff
     , http-link-header, lens, lens-aeson, microformats2-parser, mtl
     , network-uri, raw-strings-qq, safe, template-haskell, text, time
     , transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "indieweb-algorithms";
       version = "0.1.0";
       sha256 = "3417c4dc270ca59b7731319e7e4009a0f5f464d038814a2db2ceac079dcc80b2";
       libraryHaskellDepends = [
         aeson base bytestring containers data-default either
         http-link-header lens lens-aeson microformats2-parser network-uri
         safe text time transformers unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-qq base bytestring data-default hspec
         hspec-expectations-pretty-diff microformats2-parser mtl network-uri
         raw-strings-qq template-haskell text time
       ];
       homepage = "https://github.com/myfreeweb/indieweb-algorithms";
       description = "A collection of implementations of IndieWeb algorithms";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "inf-interval" = callPackage
    ({ mkDerivation, array, base, deepseq, QuickCheck, text, vector }:
     mkDerivation {
       pname = "inf-interval";
       version = "0.1.0.1";
       sha256 = "7a636cd2a8ba6394fa104f24215b0dc59da0377b47d2d1296b477737e34cb59c";
       libraryHaskellDepends = [ array base deepseq vector ];
       testHaskellDepends = [ array base deepseq QuickCheck text vector ];
       jailbreak = true;
       homepage = "https://github.com/RaminHAL9001/inf-interval";
       description = "Non-contiguous interval data types with potentially infinite ranges";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "infer-upstream" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, github, optparse-applicative
     , parsec, process, text
     }:
     mkDerivation {
       pname = "infer-upstream";
       version = "0.1.1.0";
       sha256 = "ca81b05583e7a8feadc3457676bcf970c4f94206f23d5894c31f4b1ba5b46887";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-wl-pprint base github optparse-applicative parsec process text
       ];
       jailbreak = true;
       homepage = "https://github.com/silky/infer-upstream";
       description = "Find the repository from where a given repo was forked";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "infernu" = callPackage
    ({ mkDerivation, base, containers, digits, either, fgl
     , language-ecmascript, mtl, optparse-applicative, parsec
     , transformers
     }:
     mkDerivation {
       pname = "infernu";
       version = "0.0.0.1";
       sha256 = "1697a74440cbd7209317393fae5be1993bcae70b8ec79cf070f6fa7e0bfd8a54";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers digits either fgl language-ecmascript mtl
         optparse-applicative parsec transformers
       ];
       executableHaskellDepends = [ base optparse-applicative parsec ];
       homepage = "https://github.com/sinelaw/infernu";
       description = "Type inference and checker for JavaScript (experimental)";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "infinite-search" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "infinite-search";
       version = "0.12";
       sha256 = "813c347230aa7b73da97f7d699a65727a73091e1349c1e7b2941598bd2494ea3";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/luqui/infinite-search";
       description = "Exhaustively searchable infinite sets";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "infinity" = callPackage
    ({ mkDerivation, base, binary, Cabal, filepath, ghc, irc, plugins
     }:
     mkDerivation {
       pname = "infinity";
       version = "0.3";
       sha256 = "4b7d057669014a4f084e43dbb7768491ff01730aad73f7f03f95ab67893254b4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary Cabal filepath ghc irc plugins
       ];
       jailbreak = true;
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "infix" = callPackage
    ({ mkDerivation, base, containers, haskell-src }:
     mkDerivation {
       pname = "infix";
       version = "0.1.1";
       sha256 = "d8b42c13db9af14e75bc1c20144655f706f2099ad2bdb703e169abbd0867d494";
       libraryHaskellDepends = [ base containers haskell-src ];
       homepage = "http://www.cs.mu.oz.au/~bjpop/code.html";
       description = "Infix expression re-parsing (for HsParser library)";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "inflections" = callPackage
    ({ mkDerivation, base, containers, HUnit, parsec, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "inflections";
       version = "0.2.0.0";
       sha256 = "8374014c210820be9576a0aca76b71a040779c0f451efb6983159f4084d4429b";
       libraryHaskellDepends = [ base containers parsec ];
       testHaskellDepends = [
         base containers HUnit parsec QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/stackbuilders/inflections-hs";
       description = "Inflections library for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "inflist" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "inflist";
       version = "0.0.1";
       sha256 = "9c59ec33093f7da92b46fe04ffeeddff798d3504d23aa1a5062cc2a35b393c6b";
       libraryHaskellDepends = [ base QuickCheck ];
       testHaskellDepends = [ base QuickCheck ];
       homepage = "https://bitbucket.org/eegg/inflist";
       description = "An infinite list type and operations thereon";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "influxdb" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , data-default-class, dlist, exceptions, http-client, HUnit, mtl
     , mwc-random, network-uri, retry, scientific, tagged, tasty
     , tasty-hunit, tasty-quickcheck, tasty-th, template-haskell, text
     , time, vector
     }:
     mkDerivation {
       pname = "influxdb";
       version = "0.9.1.3";
       sha256 = "9daff640a386d2b94818b50d0b82546f497c4139856d405d18b648914a14096c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers data-default-class
         dlist exceptions http-client mtl network-uri retry scientific
         tagged template-haskell text vector
       ];
       executableHaskellDepends = [
         base bytestring http-client mtl mwc-random text time
       ];
       testHaskellDepends = [
         base http-client HUnit mtl tasty tasty-hunit tasty-quickcheck
         tasty-th text vector
       ];
       jailbreak = true;
       homepage = "https://github.com/maoe/influxdb-haskell";
       description = "Haskell client library for InfluxDB";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "informative" = callPackage
    ({ mkDerivation, base, containers, csv, highlighting-kate
     , http-conduit, monad-logger, pandoc, persistent
     , persistent-postgresql, shakespeare, text, time
     , time-locale-compat, yesod, yesod-auth, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "informative";
       version = "0.1.0.20";
       sha256 = "f6503d7b794fd938a29c8e9ae5fafe349697d835fce0ab15ce872d9239bef4f5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers csv highlighting-kate http-conduit monad-logger
         pandoc persistent persistent-postgresql shakespeare text time
         time-locale-compat yesod yesod-auth yesod-core yesod-form
       ];
       executableHaskellDepends = [
         base containers csv highlighting-kate http-conduit monad-logger
         pandoc persistent persistent-postgresql shakespeare text time
         time-locale-compat yesod yesod-auth yesod-core yesod-form
       ];
       jailbreak = true;
       homepage = "http://doomanddarkness.eu/pub/informative";
       description = "A yesod subsite serving a wiki";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ini_0_2_2" = callPackage
    ({ mkDerivation, attoparsec, base, text, unordered-containers }:
     mkDerivation {
       pname = "ini";
       version = "0.2.2";
       sha256 = "2fa206a766760c75148fbd03fbbf14271be90f77d687dd3028c780c546bf4dbc";
       libraryHaskellDepends = [
         attoparsec base text unordered-containers
       ];
       description = "Quick and easy configuration files in the INI format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ini_0_3_0" = callPackage
    ({ mkDerivation, attoparsec, base, text, unordered-containers }:
     mkDerivation {
       pname = "ini";
       version = "0.3.0";
       sha256 = "a2f982bff9c8fd79280292fed4be9a2cd6d3d29be29d09e276be7f18192b8dd3";
       libraryHaskellDepends = [
         attoparsec base text unordered-containers
       ];
       description = "Quick and easy configuration files in the INI format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ini_0_3_1" = callPackage
    ({ mkDerivation, attoparsec, base, text, unordered-containers }:
     mkDerivation {
       pname = "ini";
       version = "0.3.1";
       sha256 = "0bfb1860a37cbd5652da1914b114ecb242726366442e9f03cf75f4e622713c06";
       libraryHaskellDepends = [
         attoparsec base text unordered-containers
       ];
       description = "Quick and easy configuration files in the INI format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ini_0_3_2" = callPackage
    ({ mkDerivation, attoparsec, base, text, unordered-containers }:
     mkDerivation {
       pname = "ini";
       version = "0.3.2";
       sha256 = "63e7860208999ec7142b227964bf12cd0c9ff69aa99a6e651746332307aa7d30";
       libraryHaskellDepends = [
         attoparsec base text unordered-containers
       ];
       homepage = "http://github.com/chrisdone/ini";
       description = "Quick and easy configuration files in the INI format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ini_0_3_3" = callPackage
    ({ mkDerivation, attoparsec, base, text, unordered-containers }:
     mkDerivation {
       pname = "ini";
       version = "0.3.3";
       sha256 = "2a995405f80e6827db214e3d6ff0ca0cca6a468d1363007ce220b8e327409284";
       libraryHaskellDepends = [
         attoparsec base text unordered-containers
       ];
       homepage = "http://github.com/chrisdone/ini";
       description = "Quick and easy configuration files in the INI format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ini" = callPackage
    ({ mkDerivation, attoparsec, base, text, unordered-containers }:
     mkDerivation {
       pname = "ini";
       version = "0.3.4";
       sha256 = "98427ece1d1f361df76e59f2d22863b53756327d8c7f6229f2dbee4e05a570dc";
       libraryHaskellDepends = [
         attoparsec base text unordered-containers
       ];
       homepage = "http://github.com/chrisdone/ini";
       description = "Quick and easy configuration files in the INI format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "inilist" = callPackage
    ({ mkDerivation, base, bifunctors, containers, deepseq, HUnit, safe
     , tasty, tasty-hunit, testpack, trifecta
     }:
     mkDerivation {
       pname = "inilist";
       version = "0.2.0.0";
       sha256 = "6a789313821150d1cf9e5c4fd4038f6647aeecaa48d987758b401a26950f27e7";
       libraryHaskellDepends = [
         base bifunctors containers safe trifecta
       ];
       testHaskellDepends = [
         base bifunctors containers deepseq HUnit safe tasty tasty-hunit
         testpack trifecta
       ];
       homepage = "https://chiselapp.com/user/mwm/repository/inilist";
       description = "Processing for .ini files with duplicate sections and options";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "inject" = callPackage
    ({ mkDerivation, attoparsec, base, hspec, hspec-expectations
     , process, text
     }:
     mkDerivation {
       pname = "inject";
       version = "0.1.0";
       sha256 = "18cbee154485ac3368f988a6a26a1f504d9c68805672c63d4a7571d7670fa866";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ attoparsec base process text ];
       executableHaskellDepends = [ base text ];
       testHaskellDepends = [
         attoparsec base hspec hspec-expectations process text
       ];
       description = "A minimalistic template engine";
       license = stdenv.lib.licenses.mit;
     }) {};

  "inject-function" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "inject-function";
       version = "0.2.1.0";
       sha256 = "b4b5722b50fb138d84b89bb183f447ba9579d4ed75fc663f207e70c17f1688c7";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/skypers/inject-function";
       description = "Monadic functions with injected parameters";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "inline-c_0_5_5_1" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, binary, bytestring
     , containers, cryptohash, directory, filepath, gsl, gslcblas
     , hashable, hspec, mtl, parsec, parsers, QuickCheck, raw-strings-qq
     , regex-posix, template-haskell, transformers, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "inline-c";
       version = "0.5.5.1";
       sha256 = "1d43e051cb97cb016b373bf0dd2285fcdeaa8f03cd9449921454826e011a62eb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-wl-pprint base binary bytestring containers cryptohash
         directory filepath hashable mtl parsec parsers QuickCheck
         template-haskell transformers unordered-containers vector
       ];
       executableSystemDepends = [ gsl gslcblas ];
       testHaskellDepends = [
         ansi-wl-pprint base containers hashable hspec parsers QuickCheck
         raw-strings-qq regex-posix template-haskell transformers
         unordered-containers vector
       ];
       description = "Write Haskell source files including C code inline. No FFI required.";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gsl; gslcblas = null;};

  "inline-c" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, binary, bytestring
     , containers, cryptohash, directory, filepath, gsl, gslcblas
     , hashable, hspec, mtl, parsec, parsers, QuickCheck, raw-strings-qq
     , regex-posix, template-haskell, transformers, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "inline-c";
       version = "0.5.5.2";
       sha256 = "b1265ed095cc1b832d20e3c30de574817f906534f46660ed2ff55b85b15677d6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-wl-pprint base binary bytestring containers cryptohash
         directory filepath hashable mtl parsec parsers QuickCheck
         template-haskell transformers unordered-containers vector
       ];
       executableSystemDepends = [ gsl gslcblas ];
       testHaskellDepends = [
         ansi-wl-pprint base containers hashable hspec parsers QuickCheck
         raw-strings-qq regex-posix template-haskell transformers
         unordered-containers vector
       ];
       description = "Write Haskell source files including C code inline. No FFI required.";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) gsl; gslcblas = null;};

  "inline-c-cpp" = callPackage
    ({ mkDerivation, base, inline-c, template-haskell }:
     mkDerivation {
       pname = "inline-c-cpp";
       version = "0.1.0.0";
       sha256 = "2e179756d13191e7c75522e7fda1b4ed9bfbe870484fb27479ab332bee396a45";
       libraryHaskellDepends = [ base inline-c template-haskell ];
       testHaskellDepends = [ base ];
       description = "Lets you embed C++ code into Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "inline-c-win32" = callPackage
    ({ mkDerivation, base, containers, inline-c, template-haskell
     , Win32
     }:
     mkDerivation {
       pname = "inline-c-win32";
       version = "0.1";
       sha256 = "75c6780424cbd3b58480aa10399c65965525ec3bd645696f0eb5567d6c2b4590";
       libraryHaskellDepends = [
         base containers inline-c template-haskell Win32
       ];
       homepage = "https://github.com/anton-dessiatov/inline-c-win32";
       description = "Win32 API Context for the inline-c library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "inline-r" = callPackage
    ({ mkDerivation, aeson, base, bytestring, c2hs, containers
     , data-default-class, deepseq, directory, exceptions, filepath
     , ieee754, mtl, pretty, primitive, process, quickcheck-assertions
     , R, reflection, setenv, silently, singletons, strict, tasty
     , tasty-expected-failure, tasty-golden, tasty-hunit
     , tasty-quickcheck, template-haskell, temporary, text, th-lift
     , th-orphans, transformers, unix, vector
     }:
     mkDerivation {
       pname = "inline-r";
       version = "0.8.0.1";
       sha256 = "4ce2363046cb3173e00e1f60fe666e539d88ab61a4a3d5eb06d550dba0f41e61";
       libraryHaskellDepends = [
         aeson base bytestring containers data-default-class deepseq
         exceptions mtl pretty primitive process reflection setenv
         singletons template-haskell text th-lift th-orphans transformers
         unix vector
       ];
       libraryPkgconfigDepends = [ R ];
       libraryToolDepends = [ c2hs ];
       testHaskellDepends = [
         base bytestring directory filepath ieee754 mtl process
         quickcheck-assertions silently singletons strict tasty
         tasty-expected-failure tasty-golden tasty-hunit tasty-quickcheck
         template-haskell temporary text unix vector
       ];
       description = "Seamlessly call R from Haskell and vice versa. No FFI required.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) R;};

  "inquire" = callPackage
    ({ mkDerivation, aether, base, text }:
     mkDerivation {
       pname = "inquire";
       version = "0.1";
       sha256 = "88f2c4383615c53c0bc6a66c59d6b620c6bf02d4065a6c5ba6411dfb78930ca3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ aether base text ];
       jailbreak = true;
       description = "Console client for encyclopedias";
       license = stdenv.lib.licenses.gpl3;
       broken = true;
     }) {aether = null;};

  "inserts" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, dlist }:
     mkDerivation {
       pname = "inserts";
       version = "0.1.2";
       sha256 = "e710388992f7cb45f4262a0f2c315242deddddfa07c2c8f6d7523cd19cf6e2d4";
       libraryHaskellDepends = [ attoparsec base bytestring dlist ];
       jailbreak = true;
       homepage = "http://github.com/tel/inserts";
       description = "Stupid simple bytestring templates";
       license = stdenv.lib.licenses.mit;
     }) {};

  "inspection-proxy" = callPackage
    ({ mkDerivation, async, base, bytestring, cmdargs, pipes
     , pipes-network
     }:
     mkDerivation {
       pname = "inspection-proxy";
       version = "0.1.0.3";
       sha256 = "3ee20645dc7a11df5c05ef80596e06998c33a954e3a30e3efc61e8451a17b326";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async base bytestring cmdargs pipes pipes-network
       ];
       description = "A simple proxy for debugging plaintext protocols communication";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "instant-aeson" = callPackage
    ({ mkDerivation, aeson, base, instant-generics, tasty
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "instant-aeson";
       version = "0.2";
       sha256 = "98d43d18aec3de9bd52c9c162eabbc736d4a50ad27fd5a9ade54888b5f6ba222";
       libraryHaskellDepends = [ aeson base instant-generics ];
       testHaskellDepends = [
         aeson base instant-generics tasty tasty-quickcheck
       ];
       homepage = "https://github.com/k0001/instant-aeson";
       description = "Generic Aeson instances through instant-generics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "instant-bytes" = callPackage
    ({ mkDerivation, base, bytes, instant-generics, tasty
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "instant-bytes";
       version = "0.2";
       sha256 = "e70cc805ca399ac0e413a30de053c5abbce7f4d2698f49976d299fdd2074f9f5";
       libraryHaskellDepends = [ base bytes instant-generics ];
       testHaskellDepends = [
         base bytes instant-generics tasty tasty-quickcheck
       ];
       homepage = "https://github.com/k0001/instant-bytes";
       description = "Generic Serial instances through instant-generics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "instant-deepseq" = callPackage
    ({ mkDerivation, base, deepseq, instant-generics }:
     mkDerivation {
       pname = "instant-deepseq";
       version = "0.2";
       sha256 = "606ffaffb09ad1bb1d766499a589b16531e9a4c7978734a349975248a4e60e21";
       libraryHaskellDepends = [ base deepseq instant-generics ];
       homepage = "https://github.com/k0001/instant-deepseq";
       description = "Generic NFData instances through instant-generics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "instant-generics" = callPackage
    ({ mkDerivation, base, containers, syb, template-haskell }:
     mkDerivation {
       pname = "instant-generics";
       version = "0.5";
       sha256 = "79d7cccead455f00637a182e0639cd7b8e6ef67e054d53098064772981dd8a9c";
       revision = "1";
       editedCabalFile = "c69a74fef28272e5e46a0e37711bb980ac07d2f3feeed3513da1cc572a1ab6bc";
       libraryHaskellDepends = [ base containers syb template-haskell ];
       homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/InstantGenerics";
       description = "Generic programming library with a sum of products view";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "instant-hashable" = callPackage
    ({ mkDerivation, base, hashable, instant-generics }:
     mkDerivation {
       pname = "instant-hashable";
       version = "0.2";
       sha256 = "8bf851b902126e91845e28cf6443d119ce675724c2e664562f8dd76664403a77";
       libraryHaskellDepends = [ base hashable instant-generics ];
       homepage = "https://github.com/k0001/instant-hashable";
       description = "Generic Hashable instances through instant-generics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "instant-zipper" = callPackage
    ({ mkDerivation, base, instant-generics, mtl }:
     mkDerivation {
       pname = "instant-zipper";
       version = "0.0.0";
       sha256 = "8c10863c481e49b17636a381b184b5e1ee100e5567d026d4fa95e652e987a53d";
       revision = "1";
       editedCabalFile = "a0e15510d3e3eefaa18d20fbfce7a1840519e160e2a8a8b36c498a3664b9c037";
       libraryHaskellDepends = [ base instant-generics mtl ];
       jailbreak = true;
       description = "Heterogenous Zipper in Instant Generics";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "instinct" = callPackage
    ({ mkDerivation, base, containers, mersenne-random, vector }:
     mkDerivation {
       pname = "instinct";
       version = "0.1.0";
       sha256 = "885e1b10c9ed900b4ef41b6f1feb4ecbe241b642408ac7d8b041a6dde42f0972";
       libraryHaskellDepends = [ base containers mersenne-random vector ];
       description = "Fast artifical neural networks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "instrument-chord" = callPackage
    ({ mkDerivation, array, base, containers, music-diatonic }:
     mkDerivation {
       pname = "instrument-chord";
       version = "0.1.0.9";
       sha256 = "cb0a629a88db8f0baaad638d2a9c61cb4e00d112f93a866adf7e5d5c434c073f";
       libraryHaskellDepends = [ array base containers music-diatonic ];
       homepage = "https://github.com/xpika/chord";
       description = "Render Instrument Chords";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "int-cast" = callPackage
    ({ mkDerivation, base, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "int-cast";
       version = "0.1.2.0";
       sha256 = "6bfa10f7296fb0bf63d9078e2c7520112a22988f04202c3eb25e060bde1ddd3d";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/hvr/int-cast";
       description = "Checked conversions between integral types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "integer-gmp_1_0_0_0" = callPackage
    ({ mkDerivation, ghc-prim }:
     mkDerivation {
       pname = "integer-gmp";
       version = "1.0.0.0";
       sha256 = "ae1489ea4361138f668aee76c5ac47bfc1818ac1ef2832525fe09f15970e006a";
       revision = "1";
       editedCabalFile = "5d63fab9a7c94b4e713d151bdc0c361228efbac2b7583dfa8e6c5370ecae5663";
       libraryHaskellDepends = [ ghc-prim ];
       description = "Integer library based on GMP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "integer-pure" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "integer-pure";
       version = "1.0";
       sha256 = "aad7e53d99e6d04a38f4d062829db45d58f18e1dbbfb0507bc6e81c4ab713053";
       homepage = "http://projects.haskell.org/~malcolm/integer-pure";
       description = "A pure-Haskell implementation of arbitrary-precision Integers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "integration_0_2_0_1" = callPackage
    ({ mkDerivation, base, parallel }:
     mkDerivation {
       pname = "integration";
       version = "0.2.0.1";
       sha256 = "b32e3b13111055de4e891da445eb54cf1fb8c4bff590e36c3c2d78294f9b9edf";
       libraryHaskellDepends = [ base parallel ];
       homepage = "https://github.com/ekmett/integration";
       description = "Fast robust numeric integration via tanh-sinh quadrature";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "integration" = callPackage
    ({ mkDerivation, base, parallel }:
     mkDerivation {
       pname = "integration";
       version = "0.2.1";
       sha256 = "0c27385eadc10a580e78f7b7d4bc919c346b2c9b1e73aea7e7804d824d53582f";
       libraryHaskellDepends = [ base parallel ];
       homepage = "https://github.com/ekmett/integration";
       description = "Fast robust numeric integration via tanh-sinh quadrature";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "intel-aes" = callPackage
    ({ mkDerivation, base, bytestring, cereal, crypto-api, DRBG
     , intel_aes, largeword, process, random, rdtsc, split, tagged, time
     , unix
     }:
     mkDerivation {
       pname = "intel-aes";
       version = "0.2.1.1";
       sha256 = "a9b231a7c0286a3082786f50e9e86c05f49696749d70a2d7abe953eb694b9e85";
       libraryHaskellDepends = [
         base bytestring cereal crypto-api DRBG largeword process random
         rdtsc split tagged time unix
       ];
       librarySystemDepends = [ intel_aes ];
       homepage = "https://github.com/rrnewton/intel-aes/wiki";
       description = "Hardware accelerated AES encryption and Random Number Generation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {intel_aes = null;};

  "interchangeable" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "interchangeable";
       version = "0.2.0.0";
       sha256 = "b059fa9b5b5e74fdd271d012abc2b4082304425eaa2e2a4f4e914c4117ef0fe4";
       libraryHaskellDepends = [ base containers ];
       homepage = "https://github.com/arowM/interchangeable";
       description = "A type class for interchangeable data";
       license = stdenv.lib.licenses.mit;
     }) {};

  "interleavableGen" = callPackage
    ({ mkDerivation, base, directory, haskell-src, hint, mtl }:
     mkDerivation {
       pname = "interleavableGen";
       version = "0.0.1";
       sha256 = "e25e6cf754dc86511c36698c71eecbf7f738495c1f0a0971641dbdcb98539481";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory haskell-src hint mtl ];
       description = "Generates a version of a module using InterleavableIO";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "interleavableIO" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "interleavableIO";
       version = "0.0.1";
       sha256 = "48e10af5ffdb8205ff62f8c76b745e737e334786f0641483dcdf1b6bb2cb4da6";
       libraryHaskellDepends = [ base mtl ];
       description = "Use other Monads in functions that asks for an IO Monad";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "interleave" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "interleave";
       version = "1.0";
       sha256 = "0ca9f428b006d8445f985dd7cb433ce396e13b73771be9c6e655d59c17ee5118";
       libraryHaskellDepends = [ base ];
       description = "Combinators for supporting interleaving of different behaviours";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "interlude" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "interlude";
       version = "0.1.2";
       sha256 = "fa4c020618645e47a6b9fe3795becc6b4cc621a5b2999bea5d5fba0a2c113bfa";
       libraryHaskellDepends = [ base ];
       homepage = "http://malde.org/~ketil/";
       description = "Replaces some Prelude functions for enhanced error reporting";
       license = "GPL";
     }) {};

  "intern" = callPackage
    ({ mkDerivation, array, base, bytestring, hashable, text
     , unordered-containers
     }:
     mkDerivation {
       pname = "intern";
       version = "0.9.1.4";
       sha256 = "60fe200de0a1906fe22105e5c284c19b89172e5223d01abcd73fd1584b56d26a";
       libraryHaskellDepends = [
         array base bytestring hashable text unordered-containers
       ];
       homepage = "http://github.com/ekmett/intern/";
       description = "Efficient hash-consing for arbitrary data types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "internetmarke" = callPackage
    ({ mkDerivation, base, explicit-exception, HPDF, parsec, process
     , transformers, utility-ht
     }:
     mkDerivation {
       pname = "internetmarke";
       version = "0.0.3";
       sha256 = "fff4b7fe9d027075430a7201a096953bef07c46b2f22fd6172693268f3dec6be";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base explicit-exception HPDF parsec process transformers utility-ht
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/internetmarke/";
       description = "Shell command for constructing custom stamps for German Post";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "interpol" = callPackage
    ({ mkDerivation, base, haskell-src-exts, HUnit, regex-posix, syb
     , test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "interpol";
       version = "0.2.3";
       sha256 = "83fcd5945a52428d3e088e6198a6ec07316288b6c7598609f563f8970d9d5c85";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [
         base haskell-src-exts regex-posix syb
       ];
       testHaskellDepends = [
         base haskell-src-exts HUnit regex-posix syb test-framework
         test-framework-hunit
       ];
       homepage = "https://github.com/scvalex/interpol";
       description = "GHC preprocessor and library to enable variable interpolation in strings";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "interpolate" = callPackage
    ({ mkDerivation, base, bytestring, haskell-src-meta, hspec
     , QuickCheck, quickcheck-instances, template-haskell, text
     }:
     mkDerivation {
       pname = "interpolate";
       version = "0.1.0";
       sha256 = "2d1a6d5d19fe19d2fa4c7552ef7fd26a26ddfe13d80f458cec03afd030088c72";
       libraryHaskellDepends = [ base haskell-src-meta template-haskell ];
       testHaskellDepends = [
         base bytestring haskell-src-meta hspec QuickCheck
         quickcheck-instances template-haskell text
       ];
       description = "String interpolation done right";
       license = stdenv.lib.licenses.mit;
     }) {};

  "interpolatedstring-perl6_0_9_0" = callPackage
    ({ mkDerivation, base, bytestring, haskell-src-meta
     , template-haskell, text
     }:
     mkDerivation {
       pname = "interpolatedstring-perl6";
       version = "0.9.0";
       sha256 = "36e135bbd70b69f1273ffaa0ae1a4f49ad601a65b54cbf0195af393ea2ad1f96";
       libraryHaskellDepends = [
         base bytestring haskell-src-meta template-haskell text
       ];
       description = "QuasiQuoter for Perl6-style multi-line interpolated strings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "interpolatedstring-perl6" = callPackage
    ({ mkDerivation, base, bytestring, haskell-src-meta
     , template-haskell, text
     }:
     mkDerivation {
       pname = "interpolatedstring-perl6";
       version = "1.0.0";
       sha256 = "65e0b2ad2d7482755570637212417b84d1db3bcc3cd1aa348b6b37f57911a1d3";
       libraryHaskellDepends = [
         base bytestring haskell-src-meta template-haskell text
       ];
       description = "QuasiQuoter for Perl6-style multi-line interpolated strings";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "interpolatedstring-qq" = callPackage
    ({ mkDerivation, base, haskell-src-meta-mwotton, template-haskell
     }:
     mkDerivation {
       pname = "interpolatedstring-qq";
       version = "0.2";
       sha256 = "385f9944e72257d72e9c52f04bf720cde3a8b742bd8ce9212a210fc2f04b16af";
       libraryHaskellDepends = [
         base haskell-src-meta-mwotton template-haskell
       ];
       description = "QuasiQuoter for Ruby-style multi-line interpolated strings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "interpolatedstring-qq-mwotton" = callPackage
    ({ mkDerivation, base, haskell-src-meta-mwotton, template-haskell
     }:
     mkDerivation {
       pname = "interpolatedstring-qq-mwotton";
       version = "0.1.1";
       sha256 = "7341ed85e824f47c0dc01cf0a9711be3e53c72ab8e03eee8b3a0d0c525f190b3";
       libraryHaskellDepends = [
         base haskell-src-meta-mwotton template-haskell
       ];
       jailbreak = true;
       description = "DO NOT USE THIS. interpolatedstring-qq works now.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "interpolation" = callPackage
    ({ mkDerivation, array, base, containers, QuickCheck, utility-ht }:
     mkDerivation {
       pname = "interpolation";
       version = "0.1";
       sha256 = "cad3e655c9893007058dfd8b128195a15434f0759e447c78722fb50aa50337fa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base utility-ht ];
       testHaskellDepends = [
         array base containers QuickCheck utility-ht
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/interpolation/";
       description = "piecewise linear and cubic Hermite interpolation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "intervals_0_7_0_1" = callPackage
    ({ mkDerivation, array, base, directory, distributive, doctest
     , filepath, ghc-prim
     }:
     mkDerivation {
       pname = "intervals";
       version = "0.7.0.1";
       sha256 = "e92a527f8f23b7262f58102b9d3975220f926e73c3f7e866f5da79a11e210b0b";
       revision = "1";
       editedCabalFile = "ff335c7921df2f341b02893cf5aa3118ca96d3b3650d39f20467838a5931d44b";
       libraryHaskellDepends = [ array base distributive ghc-prim ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/intervals";
       description = "Interval Arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "intervals_0_7_1" = callPackage
    ({ mkDerivation, array, base, directory, distributive, doctest
     , filepath, ghc-prim
     }:
     mkDerivation {
       pname = "intervals";
       version = "0.7.1";
       sha256 = "226d75e179fa66dc85c0d5295effe95986222d17d01aac3323dd08c8a61c2a0f";
       libraryHaskellDepends = [ array base distributive ghc-prim ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/ekmett/intervals";
       description = "Interval Arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "intervals" = callPackage
    ({ mkDerivation, array, base, directory, distributive, doctest
     , filepath, ghc-prim, QuickCheck, template-haskell
     }:
     mkDerivation {
       pname = "intervals";
       version = "0.7.2";
       sha256 = "0dd04a7dfd0ac6b364c66b78dafa48739c5116253078d4023e104f5e99d5fe28";
       libraryHaskellDepends = [ array base distributive ghc-prim ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck template-haskell
       ];
       homepage = "http://github.com/ekmett/intervals";
       description = "Interval Arithmetic";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "intricacy" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , cryptohash, directory, filepath, hscurses, mtl, network-fancy
     , random, safe, SDL, SDL-gfx, SDL-mixer, SDL-ttf, stm, time
     , transformers, vector
     }:
     mkDerivation {
       pname = "intricacy";
       version = "0.5.7.2";
       sha256 = "50482ec337ab24992a46e92df1263da65b7f1b2eb84f563de5f41d56f96a952a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base binary bytestring containers cryptohash directory
         filepath hscurses mtl network-fancy random safe SDL SDL-gfx
         SDL-mixer SDL-ttf stm time transformers vector
       ];
       homepage = "http://mbays.freeshell.org/intricacy";
       description = "A game of competitive puzzle-design";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "intset" = callPackage
    ({ mkDerivation, base, bits-extras, bytestring, deepseq, QuickCheck
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "intset";
       version = "0.1.1.0";
       sha256 = "60d2c3923889cc99ede3544cd0576cc4927098dec4e49ba8aa86a8273ee29610";
       libraryHaskellDepends = [ base bits-extras bytestring deepseq ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       homepage = "https://github.com/pxqr/intset";
       description = "Pure, mergeable, succinct Int sets";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "invariant_0_2" = callPackage
    ({ mkDerivation, array, base, bifunctors, containers, contravariant
     , ghc-prim, hspec, profunctors, QuickCheck, semigroups, stm, tagged
     , template-haskell, transformers, transformers-compat
     , unordered-containers
     }:
     mkDerivation {
       pname = "invariant";
       version = "0.2";
       sha256 = "411aba2fbb5480007cce8356247668ea1c32bb94ea2d5dfb109ffca1e0babf7f";
       revision = "1";
       editedCabalFile = "c984b47d7adfb3945e96b9ce36216b51e24d4b61b4b4b4292a91421611fdce26";
       libraryHaskellDepends = [
         array base bifunctors containers contravariant ghc-prim profunctors
         semigroups stm tagged template-haskell transformers
         transformers-compat unordered-containers
       ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "https://github.com/nfrisby/invariant-functors";
       description = "Haskell 98 invariant functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "invariant_0_2_2" = callPackage
    ({ mkDerivation, array, base, bifunctors, containers, contravariant
     , ghc-prim, hspec, profunctors, QuickCheck, semigroups, stm, tagged
     , template-haskell, transformers, transformers-compat
     , unordered-containers
     }:
     mkDerivation {
       pname = "invariant";
       version = "0.2.2";
       sha256 = "269cfd73bb7064459791b03461c9a73ce182e9d0a6f929f7cd46c0566d747975";
       revision = "1";
       editedCabalFile = "ec713862cc5b8f03e58eeca3596d53cfdfc28a9957afffcff2680a855322f0ee";
       libraryHaskellDepends = [
         array base bifunctors containers contravariant ghc-prim profunctors
         semigroups stm tagged template-haskell transformers
         transformers-compat unordered-containers
       ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "https://github.com/nfrisby/invariant-functors";
       description = "Haskell 98 invariant functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "invariant_0_3" = callPackage
    ({ mkDerivation, array, base, bifunctors, containers, contravariant
     , ghc-prim, hspec, profunctors, QuickCheck, semigroups, StateVar
     , stm, tagged, template-haskell, transformers, transformers-compat
     , unordered-containers
     }:
     mkDerivation {
       pname = "invariant";
       version = "0.3";
       sha256 = "c45b9a150b3b48b22ec41964481bbe85567b3eab0ae15b784dd75b9a666a7a00";
       revision = "1";
       editedCabalFile = "560be9fd410c36d98bd6d1203a9916bf321d26d1b7c2b5ba259b30215245cd6f";
       libraryHaskellDepends = [
         array base bifunctors containers contravariant ghc-prim profunctors
         semigroups StateVar stm tagged template-haskell transformers
         transformers-compat unordered-containers
       ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "https://github.com/nfrisby/invariant-functors";
       description = "Haskell 98 invariant functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "invariant" = callPackage
    ({ mkDerivation, array, base, bifunctors, containers, contravariant
     , ghc-prim, hspec, profunctors, QuickCheck, semigroups, StateVar
     , stm, tagged, template-haskell, transformers, transformers-compat
     , unordered-containers
     }:
     mkDerivation {
       pname = "invariant";
       version = "0.3.1";
       sha256 = "db88ce3955ba99cec99dd1da2d917ce26c204837a6779712dd55f79cc873fdff";
       libraryHaskellDepends = [
         array base bifunctors containers contravariant ghc-prim profunctors
         semigroups StateVar stm tagged template-haskell transformers
         transformers-compat unordered-containers
       ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "https://github.com/nfrisby/invariant-functors";
       description = "Haskell 98 invariant functors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "invertible-syntax" = callPackage
    ({ mkDerivation, base, partial-isomorphisms }:
     mkDerivation {
       pname = "invertible-syntax";
       version = "0.2.1";
       sha256 = "774147d1c65a1e0259bf8b0e26d97966f2bf4d8908dfca29d9221d05f03bd14f";
       libraryHaskellDepends = [ base partial-isomorphisms ];
       homepage = "http://www.informatik.uni-marburg.de/~rendel/unparse";
       description = "Invertible syntax descriptions for both parsing and pretty printing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "io-capture" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "io-capture";
       version = "0.3";
       sha256 = "ce809d6ff9c22bceb67c9bcd55477a209141da9fbb265c9fe5718718be96720e";
       libraryHaskellDepends = [ base unix ];
       description = "capture IO action's stdout and stderr";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "io-choice" = callPackage
    ({ mkDerivation, base, hspec, lifted-base, monad-control
     , template-haskell, transformers, transformers-base
     }:
     mkDerivation {
       pname = "io-choice";
       version = "0.0.5";
       sha256 = "f096bee7c7fcbeffa979d867b21dfa3e45d47462c4ca87190805a5c7fa44d9a6";
       libraryHaskellDepends = [
         base lifted-base monad-control template-haskell transformers
         transformers-base
       ];
       testHaskellDepends = [
         base hspec lifted-base monad-control transformers
       ];
       description = "Choice for IO and lifted IO";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "io-manager" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "io-manager";
       version = "0.1.0.2";
       sha256 = "bf0aa7740a8aaf31fc4f2570a47957365ae7d9248edd309e694053f1cd804138";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [ base containers ];
       description = "Skeleton library around the IO monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "io-memoize" = callPackage
    ({ mkDerivation, async, base }:
     mkDerivation {
       pname = "io-memoize";
       version = "1.1.1.0";
       sha256 = "c753a1b1a2fb286bf608d6467e6e7599cde8e641c619885197f298bf1b2f483d";
       libraryHaskellDepends = [ async base ];
       homepage = "https://github.com/DanBurton/io-memoize";
       description = "Memoize IO actions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "io-reactive" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "io-reactive";
       version = "0.1.1";
       sha256 = "76bfcb26687d42669acf8f26ff4136d61a85dba502c5e3daaf10506c10433826";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       description = "An API for generating TIMBER style reactive objects";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "io-region" = callPackage
    ({ mkDerivation, base, hspec, stm, transformers }:
     mkDerivation {
       pname = "io-region";
       version = "0.1.1";
       sha256 = "ee303f66c2b3d33fae877b0dbb7c64624109fc759dffa669ca182e387f1015f1";
       libraryHaskellDepends = [ base stm ];
       testHaskellDepends = [ base hspec transformers ];
       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 }:
     mkDerivation {
       pname = "io-storage";
       version = "0.3";
       sha256 = "9a0df5cc7ff2eeef11e29e1362fea284f535bc2fe67469bba6dbc41c4f5b49bd";
       libraryHaskellDepends = [ base containers ];
       homepage = "http://github.com/willdonnelly/io-storage";
       description = "A key-value store in the IO monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "io-streams_1_3_2_0" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, bytestring-builder
     , deepseq, directory, filepath, HUnit, mtl, network, primitive
     , process, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time, transformers, vector
     , zlib, zlib-bindings
     }:
     mkDerivation {
       pname = "io-streams";
       version = "1.3.2.0";
       sha256 = "1e30da4bb0f61c4540cb60f5543f9970c39849471e0dcf03fa9cfec19a12123f";
       configureFlags = [ "-fnointeractivetests" ];
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-builder network primitive
         process text time transformers vector zlib-bindings
       ];
       testHaskellDepends = [
         attoparsec base bytestring bytestring-builder deepseq directory
         filepath HUnit mtl network primitive process QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time transformers vector zlib zlib-bindings
       ];
       description = "Simple, composable, and easy-to-use stream I/O";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "io-streams_1_3_3_1" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, bytestring-builder
     , deepseq, directory, filepath, HUnit, mtl, network, primitive
     , process, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time, transformers, vector
     , zlib, zlib-bindings
     }:
     mkDerivation {
       pname = "io-streams";
       version = "1.3.3.1";
       sha256 = "9a0849eb2efaf72312bbba672c2a589763c15dde50e93a53c64d2b594b80f544";
       configureFlags = [ "-fnointeractivetests" ];
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-builder network primitive
         process text time transformers vector zlib-bindings
       ];
       testHaskellDepends = [
         attoparsec base bytestring bytestring-builder deepseq directory
         filepath HUnit mtl network primitive process QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time transformers vector zlib zlib-bindings
       ];
       description = "Simple, composable, and easy-to-use stream I/O";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "io-streams_1_3_4_0" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, bytestring-builder
     , deepseq, directory, filepath, HUnit, mtl, network, primitive
     , process, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time, transformers, vector
     , zlib, zlib-bindings
     }:
     mkDerivation {
       pname = "io-streams";
       version = "1.3.4.0";
       sha256 = "dbf96287305efed2ba20bed46b82e70a6ea757ddb7cc66dc184fefd7ce05b431";
       configureFlags = [ "-fnointeractivetests" ];
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-builder network primitive
         process text time transformers vector zlib-bindings
       ];
       testHaskellDepends = [
         attoparsec base bytestring bytestring-builder deepseq directory
         filepath HUnit mtl network primitive process QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time transformers vector zlib zlib-bindings
       ];
       description = "Simple, composable, and easy-to-use stream I/O";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "io-streams" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, bytestring-builder
     , deepseq, directory, filepath, HUnit, mtl, network, primitive
     , process, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time, transformers, vector
     , zlib, zlib-bindings
     }:
     mkDerivation {
       pname = "io-streams";
       version = "1.3.5.0";
       sha256 = "6c27d7ef3c5e06f4dd3aac33d5f2354b9778455473ab314a0b58dec4794ecae0";
       configureFlags = [ "-fnointeractivetests" ];
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-builder network primitive
         process text time transformers vector zlib-bindings
       ];
       testHaskellDepends = [
         attoparsec base bytestring bytestring-builder deepseq directory
         filepath HUnit mtl network primitive process QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
         time transformers vector zlib zlib-bindings
       ];
       description = "Simple, composable, and easy-to-use stream I/O";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "io-streams-http" = callPackage
    ({ mkDerivation, base, bytestring, http-client, http-client-tls
     , io-streams, mtl, transformers
     }:
     mkDerivation {
       pname = "io-streams-http";
       version = "0.2.1.2";
       sha256 = "63d6bc557bf0950386e3b35e21c33c6a945fd4ed9f748ab7e0ab926686f84365";
       libraryHaskellDepends = [
         base bytestring http-client http-client-tls io-streams mtl
         transformers
       ];
       description = "http-client for io-streams";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "io-throttle" = callPackage
    ({ mkDerivation, base, SafeSemaphore, threads }:
     mkDerivation {
       pname = "io-throttle";
       version = "0.1.0";
       sha256 = "49b27cb7f0d57fe2679c6c18e0f3d1ff3b11de4cf3b526db9ad00063d3a27710";
       revision = "1";
       editedCabalFile = "c3903532515f76e374229ea572d11f7ab02a560062425f33649399c5ac61a16e";
       libraryHaskellDepends = [ base SafeSemaphore threads ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/rodrigosetti/io-throttle";
       description = "Limit number of IO actions started per second";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ioctl" = callPackage
    ({ mkDerivation, base, network, unix }:
     mkDerivation {
       pname = "ioctl";
       version = "0.0.1";
       sha256 = "1a9f21bc8f03d4729ef936d543d463e9ab5656699b2cf27fb344b4c6693d9067";
       libraryHaskellDepends = [ base network unix ];
       description = "Type-safe I/O control package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ioref-stable" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ioref-stable";
       version = "0.1.0.0";
       sha256 = "9044897340c044e44d3a9c33b350523147a6a95a2f1c8fb410caee880ceba314";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/cocreature/ioref-stable#readme";
       description = "iorefs with a unique stable index";
       license = stdenv.lib.licenses.mit;
     }) {};

  "iothread" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "iothread";
       version = "0.1.0.0";
       sha256 = "a03b253219cb41b8e28c11d007295bab9e5cf5fa36814c23c082f46ac1d27edb";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/tattsun/iothread";
       description = "run IOs in a single thread";
       license = stdenv.lib.licenses.mit;
     }) {};

  "iotransaction" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "iotransaction";
       version = "0.1";
       sha256 = "8c857bbe3676b4c038baba534e4a487ccde478041b35af07d8a33b2e6acc9c7a";
       libraryHaskellDepends = [ base ];
       homepage = "https://bitbucket.org/dshearer/iotransaction/";
       description = "Supports the automatic undoing of IO operations when an exception is thrown";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ip-quoter" = callPackage
    ({ mkDerivation, base, cpu, network, tasty, tasty-hunit
     , template-haskell
     }:
     mkDerivation {
       pname = "ip-quoter";
       version = "1.0.1.1";
       sha256 = "94c4369d0a83ed5f8a0bb8057d297935f19e7a51a568f4c5348936e9053929a0";
       libraryHaskellDepends = [ base cpu network template-haskell ];
       testHaskellDepends = [ base cpu network tasty tasty-hunit ];
       homepage = "https://github.com/shlevy/ip-quoter";
       description = "Quasiquoter for IP addresses";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ip6addr" = callPackage
    ({ mkDerivation, base, cmdargs, IPv6Addr, text }:
     mkDerivation {
       pname = "ip6addr";
       version = "0.5.0.1";
       sha256 = "24b6420c3ca8ca7c28ae1863af2b6da5aace2baf6db046213b648d5cb4fadc22";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base cmdargs IPv6Addr text ];
       homepage = "https://github.com/MichelBoucey/ip6addr";
       description = "Commandline tool to generate IPv6 address text representations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ipatch" = callPackage
    ({ mkDerivation, base, bytestring, darcs, directory, filepath
     , hashed-storage, process, unix
     }:
     mkDerivation {
       pname = "ipatch";
       version = "0.1.1";
       sha256 = "b8d1a4f99effe3ef05930935aa7aafbfa2a11da568b8588092f4ba28d002cea7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring darcs directory filepath hashed-storage process
         unix
       ];
       homepage = "http://darcs.nomeata.de/ipatch";
       description = "interactive patch editor";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ipc" = callPackage
    ({ mkDerivation, base, binary, bytestring, dlist, mtl, network
     , network-bytestring, stm
     }:
     mkDerivation {
       pname = "ipc";
       version = "0.0.5";
       sha256 = "0d196e3ea379567f529dd06a0dc1cb6192e99a1c1191328c9e41e88082303c34";
       libraryHaskellDepends = [
         base binary bytestring dlist mtl network network-bytestring stm
       ];
       jailbreak = true;
       description = "High level inter-process communication library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ipcvar" = callPackage
    ({ mkDerivation, base, binary, bytestring, directory, hspec, unix
     }:
     mkDerivation {
       pname = "ipcvar";
       version = "0.0.1";
       sha256 = "7664f9a64d91a9a0f20ec8fb74a15fe97ce1e6dff242edfc00932731fb00b720";
       libraryHaskellDepends = [ base binary bytestring directory unix ];
       testHaskellDepends = [ base hspec unix ];
       description = "Simple inter-process communication through IPCVars";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ipopt-hs" = callPackage
    ({ mkDerivation, ad, ansi-wl-pprint, base, c2hs, containers, ipopt
     , lens, mtl, nlopt, template-haskell, uu-parsinglib, vector
     , vector-space
     }:
     mkDerivation {
       pname = "ipopt-hs";
       version = "0.5.1.0";
       sha256 = "aaf193c06daed43998d4d37f7916d8c1bb73b61e01815755eff61bd2c472344a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ad ansi-wl-pprint base containers lens mtl template-haskell
         uu-parsinglib vector vector-space
       ];
       libraryPkgconfigDepends = [ ipopt nlopt ];
       libraryToolDepends = [ c2hs ];
       jailbreak = true;
       description = "haskell binding to ipopt and nlopt including automatic differentiation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) ipopt; nlopt = null;};

  "ipprint" = callPackage
    ({ mkDerivation, base, haskell-src, sr-extra }:
     mkDerivation {
       pname = "ipprint";
       version = "0.6";
       sha256 = "1a241f79219fe0daac1b4c61d4fa14f2c8fd8a8bf5b9cd8e4f80d206bca3a823";
       libraryHaskellDepends = [ base haskell-src sr-extra ];
       description = "Tiny helper for pretty-printing values in ghci console";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "iproute_1_3_1" = callPackage
    ({ mkDerivation, appar, base, byteorder, containers, doctest, hspec
     , network, QuickCheck, safe
     }:
     mkDerivation {
       pname = "iproute";
       version = "1.3.1";
       sha256 = "b73104d337f14e63e1ca84dd37405df28e7a7f7e714e83efd63cca80d1d66ad0";
       libraryHaskellDepends = [
         appar base byteorder containers network
       ];
       testHaskellDepends = [
         appar base byteorder containers doctest hspec network QuickCheck
         safe
       ];
       homepage = "http://www.mew.org/~kazu/proj/iproute/";
       description = "IP Routing Table";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "iproute_1_3_2" = callPackage
    ({ mkDerivation, appar, base, byteorder, containers, doctest, hspec
     , network, QuickCheck, safe
     }:
     mkDerivation {
       pname = "iproute";
       version = "1.3.2";
       sha256 = "b5240bf6f9f098cb95b1471fc183aedf83a360006202f8daea4c05eb7bbdac7d";
       libraryHaskellDepends = [
         appar base byteorder containers network
       ];
       testHaskellDepends = [
         appar base byteorder containers doctest hspec network QuickCheck
         safe
       ];
       homepage = "http://www.mew.org/~kazu/proj/iproute/";
       description = "IP Routing Table";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "iproute_1_5_0" = callPackage
    ({ mkDerivation, appar, base, byteorder, containers, doctest, hspec
     , network, QuickCheck, safe
     }:
     mkDerivation {
       pname = "iproute";
       version = "1.5.0";
       sha256 = "e33b233c681be367162c342ebf3843ec2d858db49716ef52d96546bd3f6f2557";
       revision = "1";
       editedCabalFile = "f601b3319004e7b4a4636c89996ea78fd084e9b10d15d679d7ae58e822fe19b8";
       libraryHaskellDepends = [
         appar base byteorder containers network
       ];
       testHaskellDepends = [
         appar base byteorder containers doctest hspec network QuickCheck
         safe
       ];
       homepage = "http://www.mew.org/~kazu/proj/iproute/";
       description = "IP Routing Table";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "iproute" = callPackage
    ({ mkDerivation, appar, base, byteorder, containers, doctest, hspec
     , network, QuickCheck, safe
     }:
     mkDerivation {
       pname = "iproute";
       version = "1.7.0";
       sha256 = "65dd0033101702cd3ba291ff52d5d2563a89087fda7bb7e4bd5a301042049ede";
       libraryHaskellDepends = [
         appar base byteorder containers network
       ];
       testHaskellDepends = [
         appar base byteorder containers doctest hspec network QuickCheck
         safe
       ];
       homepage = "http://www.mew.org/~kazu/proj/iproute/";
       description = "IP Routing Table";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "iptables-helpers" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec, QuickCheck, safe
     , syb, utf8-string
     }:
     mkDerivation {
       pname = "iptables-helpers";
       version = "0.5.0";
       sha256 = "f214ba973c439c64683106276ecf06f789e2e039183dc0d25f4feb44c63bbb8f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl parsec safe utf8-string
       ];
       executableHaskellDepends = [ base QuickCheck syb ];
       jailbreak = true;
       description = "iptables rules parser/printer library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "iptadmin" = callPackage
    ({ mkDerivation, augeas, base, blaze-html, blaze-markup, bytestring
     , ConfigFile, containers, file-embed, filepath, happstack-server
     , happstack-server-tls, hdaemonize, hsyslog, iptables-helpers, mtl
     , network, old-time, pam, parsec, process, random, safe
     , template-haskell, time, unix, utf8-string
     }:
     mkDerivation {
       pname = "iptadmin";
       version = "1.3.4";
       sha256 = "95243bf80e2cb51a8c1ae8635607136c5004f35215ee3d965e5ef592f0f556cf";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         augeas base blaze-html blaze-markup bytestring ConfigFile
         containers file-embed filepath happstack-server
         happstack-server-tls hdaemonize hsyslog iptables-helpers mtl
         network old-time pam parsec process random safe template-haskell
         time unix utf8-string
       ];
       jailbreak = true;
       homepage = "http://iptadmin.117.su";
       description = "web-interface for iptables";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ipython-kernel_0_6_1_2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cereal, containers
     , directory, filepath, mtl, parsec, SHA, tar, text, transformers
     , uuid, zeromq4-haskell
     }:
     mkDerivation {
       pname = "ipython-kernel";
       version = "0.6.1.2";
       sha256 = "1431c7442b9081dd9169348b36f0befafeedca8a773b8d5349518b39fde1e4e2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring cereal containers directory filepath mtl SHA
         tar text transformers uuid zeromq4-haskell
       ];
       executableHaskellDepends = [
         base filepath mtl parsec text transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/gibiansky/IHaskell";
       description = "A library for creating kernels for IPython frontends";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ipython-kernel_0_6_1_3" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cereal, containers
     , directory, filepath, mtl, parsec, SHA, tar, text, transformers
     , uuid, zeromq4-haskell
     }:
     mkDerivation {
       pname = "ipython-kernel";
       version = "0.6.1.3";
       sha256 = "d254f8d372bc5e8c5693897573106eae5514838c5e804ea7a973659e2d27e451";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring cereal containers directory filepath mtl SHA
         tar text transformers uuid zeromq4-haskell
       ];
       executableHaskellDepends = [
         base filepath mtl parsec text transformers
       ];
       homepage = "http://github.com/gibiansky/IHaskell";
       description = "A library for creating kernels for IPython frontends";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ipython-kernel" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cereal, containers
     , directory, filepath, mtl, parsec, process, SHA, temporary, text
     , transformers, unordered-containers, uuid, zeromq4-haskell
     }:
     mkDerivation {
       pname = "ipython-kernel";
       version = "0.8.3.0";
       sha256 = "e865322381ddc4271fc2b0650aeee70d04036e2114e1a77921878c150af5a60c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring cereal containers directory filepath mtl
         process SHA temporary text transformers unordered-containers uuid
         zeromq4-haskell
       ];
       executableHaskellDepends = [
         base filepath mtl parsec text transformers
       ];
       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, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "irc";
       version = "0.6.1.0";
       sha256 = "3816ead4dfb32d61c03265e3a2a45053508cb27ca3132595773a27ef381637e1";
       libraryHaskellDepends = [ attoparsec base bytestring ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       description = "A small library for parsing IRC messages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "irc-bytestring" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring }:
     mkDerivation {
       pname = "irc-bytestring";
       version = "0.1";
       sha256 = "a7c559cacb6aeb8288385f2d2099389173abeae730e884fea28b93d347f2c426";
       libraryHaskellDepends = [ attoparsec base bytestring ];
       homepage = "https://github.com/kallisti-dev/irc-bytestring";
       description = "serialization and parsing of IRC messages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "irc-client_0_2_5_0" = callPackage
    ({ mkDerivation, base, bytestring, conduit, data-default-class
     , irc-conduit, irc-ctcp, old-locale, stm, stm-conduit, text, time
     , transformers
     }:
     mkDerivation {
       pname = "irc-client";
       version = "0.2.5.0";
       sha256 = "4a2a10eafd82e3c1e049068bb1d37ae09db7832ac5941765935ab763ea51bd0c";
       libraryHaskellDepends = [
         base bytestring conduit data-default-class irc-conduit irc-ctcp
         old-locale stm stm-conduit text time transformers
       ];
       homepage = "https://github.com/barrucadu/irc-client";
       description = "An IRC client library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "irc-client" = callPackage
    ({ mkDerivation, base, bytestring, conduit, data-default-class
     , irc-conduit, irc-ctcp, old-locale, stm, stm-conduit, text, time
     , transformers
     }:
     mkDerivation {
       pname = "irc-client";
       version = "0.2.6.0";
       sha256 = "8d14293adb106f1755358bd7c2e9f1193537ef87333e0492d54fa8b8611b795d";
       libraryHaskellDepends = [
         base bytestring conduit data-default-class irc-conduit irc-ctcp
         old-locale stm stm-conduit text time transformers
       ];
       homepage = "https://github.com/barrucadu/irc-client";
       description = "An IRC client library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "irc-colors" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "irc-colors";
       version = "0.1";
       sha256 = "00ce2cda8c9bbf76c96838c4e2f51a667a6a0e242a670730fa879b15f04283f6";
       libraryHaskellDepends = [ base text ];
       description = "Colourize your IRC strings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "irc-conduit" = callPackage
    ({ mkDerivation, async, base, bytestring, conduit, conduit-extra
     , connection, irc, irc-ctcp, network-conduit-tls, text, time, tls
     , transformers, x509-validation
     }:
     mkDerivation {
       pname = "irc-conduit";
       version = "0.1.2.0";
       sha256 = "77aea49a8efdbd8dc405d8a9ed4afddb11c906136bd3c8ec3bd32e981d0a84d7";
       libraryHaskellDepends = [
         async base bytestring conduit conduit-extra connection irc irc-ctcp
         network-conduit-tls text time tls transformers x509-validation
       ];
       homepage = "https://github.com/barrucadu/irc-conduit";
       description = "Streaming IRC message library using conduits";
       license = stdenv.lib.licenses.mit;
     }) {};

  "irc-core" = callPackage
    ({ mkDerivation, array, attoparsec, base, base64-bytestring
     , bytestring, config-value, connection, containers
     , data-default-class, deepseq, directory, filepath, free
     , haskell-lexer, lens, network, old-locale, regex-tdfa, split, stm
     , text, time, tls, transformers, vty, x509, x509-store, x509-system
     , x509-validation
     }:
     mkDerivation {
       pname = "irc-core";
       version = "1.1.3";
       sha256 = "62385b4372ea61aeb41b7e7bb808a89adf1bbbf4d9c7127a6eb019a8b75e7142";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array attoparsec base base64-bytestring bytestring containers free
         lens regex-tdfa text time transformers
       ];
       executableHaskellDepends = [
         array base bytestring config-value connection containers
         data-default-class deepseq directory filepath haskell-lexer lens
         network old-locale regex-tdfa split stm text time tls transformers
         vty x509 x509-store x509-system x509-validation
       ];
       homepage = "https://github.com/glguy/irc-core";
       description = "An IRC client library and text client";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "irc-ctcp" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "irc-ctcp";
       version = "0.1.3.0";
       sha256 = "d67cd91a5521173565033777cea76636e4d2be6e6224f681392d9e726f4bb79a";
       libraryHaskellDepends = [ base bytestring text ];
       homepage = "https://github.com/barrucadu/irc-ctcp";
       description = "A CTCP encoding and decoding library for IRC clients";
       license = stdenv.lib.licenses.mit;
     }) {};

  "irc-fun-bot" = callPackage
    ({ mkDerivation, aeson, auto-update, base, case-insensitive, clock
     , containers, data-default-class, fast-logger, formatting
     , irc-fun-client, irc-fun-types, json-state, text, time
     , time-interval, time-units, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "irc-fun-bot";
       version = "0.6.0.0";
       sha256 = "1284142d5957d8b30975fb9178908cec8414d60cebd5b5e6d04af6c41809cd82";
       libraryHaskellDepends = [
         aeson auto-update base case-insensitive clock containers
         data-default-class fast-logger formatting irc-fun-client
         irc-fun-types json-state text time time-interval time-units
         transformers unordered-containers
       ];
       homepage = "http://rel4tion.org/projects/irc-fun-bot/";
       description = "Library for writing fun IRC bots";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "irc-fun-client" = callPackage
    ({ mkDerivation, auto-update, base, bytestring, connection
     , data-default-class, fast-logger, hashable, irc-fun-messages
     , irc-fun-types, text, time, time-units, unordered-containers
     }:
     mkDerivation {
       pname = "irc-fun-client";
       version = "0.5.0.0";
       sha256 = "a8a6bb0835fd2ff4b0697306d76d639802ced44dba23b8e661ed8e4aea31525a";
       libraryHaskellDepends = [
         auto-update base bytestring connection data-default-class
         fast-logger hashable irc-fun-messages irc-fun-types text time
         time-units unordered-containers
       ];
       homepage = "http://rel4tion.org/projects/irc-fun-client/";
       description = "Another library for writing IRC clients";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "irc-fun-color" = callPackage
    ({ mkDerivation, base, dlist, formatting, irc-fun-types, text
     , text-show
     }:
     mkDerivation {
       pname = "irc-fun-color";
       version = "0.2.0.0";
       sha256 = "d08930a2d5b39411515cd1477804416a0d1882cb4af716cfdddffc0bf3e20780";
       libraryHaskellDepends = [
         base dlist formatting irc-fun-types text text-show
       ];
       testHaskellDepends = [ base text ];
       homepage = "http://rel4tion.org/projects/irc-fun-color/";
       description = "Add color and style decorations to IRC messages";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "irc-fun-messages" = callPackage
    ({ mkDerivation, base, irc-fun-types, regex-applicative, text }:
     mkDerivation {
       pname = "irc-fun-messages";
       version = "0.3.0.0";
       sha256 = "bfabe5cd9eff9d2e41c7adf0b7729fee4713a133a1f9da6b2b410753c0ecd04f";
       libraryHaskellDepends = [
         base irc-fun-types regex-applicative text
       ];
       homepage = "http://rel4tion.org/projects/irc-fun-messages/";
       description = "Types and functions for working with the IRC protocol";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "irc-fun-types" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "irc-fun-types";
       version = "0.1.0.0";
       sha256 = "818255949173d1c4fb982f8bef99d9261b1b7ee77ad3183872d4a0fcbfe5341f";
       libraryHaskellDepends = [ base text ];
       homepage = "http://hub.darcs.net/fr33domlover/irc-fun-types";
       description = "Common types for IRC related packages";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "ircbot" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , irc, mtl, network, parsec, random, SafeSemaphore, stm, time, unix
     }:
     mkDerivation {
       pname = "ircbot";
       version = "0.6.4";
       sha256 = "ad3a34a57abe03f2b56f459a92e40cd3500cc605545eeab24bd16604eeac9c08";
       libraryHaskellDepends = [
         base bytestring containers directory filepath irc mtl network
         parsec random SafeSemaphore stm time unix
       ];
       homepage = "http://hub.darcs.net/stepcut/ircbot";
       description = "A library for writing irc bots";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ircbouncer" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "ircbouncer";
       version = "0.2.0";
       sha256 = "f5a75465ad5af3decac2d88d6b3f24fd1a6e744cf321fbd0b713df847aaac0ae";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ireal" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "ireal";
       version = "0.2.3";
       sha256 = "928294da41708e1036283aee492be120e478c0994998df50af533898c9c9bc73";
       libraryHaskellDepends = [ base QuickCheck ];
       description = "Real numbers and intervals with relatively efficient exact arithmetic";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "iron-mq" = callPackage
    ({ mkDerivation, aeson, base, http-client, lens, text, wreq }:
     mkDerivation {
       pname = "iron-mq";
       version = "0.1.1.0";
       sha256 = "9936b04b59c48f5e197c17b8a5f35a4637d0233b6483dbec09af9b18898a21fa";
       libraryHaskellDepends = [ aeson base http-client lens text wreq ];
       jailbreak = true;
       homepage = "https://github.com/arnoblalam/iron_mq_haskell";
       description = "Iron.IO message queueing client library";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "ironforge" = callPackage
    ({ mkDerivation, antisplice, base, chatty, chatty-utils, mtl
     , transformers
     }:
     mkDerivation {
       pname = "ironforge";
       version = "0.1.0.35";
       sha256 = "f490eba48cfbbaa2fb997d20c8a453cbe74aea0ea4ef26735a1b51eab6a4a0b7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         antisplice base chatty chatty-utils mtl transformers
       ];
       executableHaskellDepends = [
         antisplice base chatty chatty-utils mtl transformers
       ];
       homepage = "http://doomanddarkness.eu/pub/antisplice";
       description = "A technical demo for Antisplice";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "is" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "is";
       version = "0.2";
       sha256 = "502c962d45859050455057be9886e8944e300ef690a56605c91aca76fdcd19c6";
       libraryHaskellDepends = [ base template-haskell ];
       testHaskellDepends = [ base template-haskell ];
       description = "Pattern predicates using TH";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "isdicom" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, QuickCheck
     , template-haskell
     }:
     mkDerivation {
       pname = "isdicom";
       version = "0.0.2";
       sha256 = "37f074017c3aa1f5dd5bc3cca6e332fa0c322ad7350d1f3ad054354fb64dc915";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory filepath ];
       executableHaskellDepends = [ base directory filepath ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck template-haskell
       ];
       homepage = "https://github.com/tonymorris/isdicom";
       description = "An executable and library to determine if a file is a DICOM file";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "isevaluated" = callPackage
    ({ mkDerivation, base, vacuum }:
     mkDerivation {
       pname = "isevaluated";
       version = "0.3.0.2";
       sha256 = "a51da5092ea7cae41a16fa840609c19cc6c2a8b56e129168a3c5f731f24ac081";
       libraryHaskellDepends = [ base vacuum ];
       jailbreak = true;
       description = "Check whether a value has been evaluated";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "isiz" = callPackage
    ({ mkDerivation, base, gtk3 }:
     mkDerivation {
       pname = "isiz";
       version = "0.0.1";
       sha256 = "1a20826305c276fc277040b73f527f2dcc618a7b91ee92bcdaf4a0cf62f4164c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base gtk3 ];
       description = "A program to show the size of image and whether suitable for wallpaper";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "islink" = callPackage
    ({ mkDerivation, base, unordered-containers }:
     mkDerivation {
       pname = "islink";
       version = "0.1.0.0";
       sha256 = "cfbf9c1a6dc46327b7ed7bf9336e245a255626c9d04aeba3d887d90f26d2aed7";
       libraryHaskellDepends = [ base unordered-containers ];
       homepage = "https://github.com/redneb/islink";
       description = "Check if an HTML element is a link";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ismtp" = callPackage
    ({ mkDerivation, base, bytestring, containers, contstuff, dnscache
     , enumerator, lifted-base, monad-control, netlines, network, vector
     }:
     mkDerivation {
       pname = "ismtp";
       version = "4.0.2";
       sha256 = "15ceeef4bbca3ea7a602e2e0e9b79bdefd75a13acf069906740fdc93c8cd7e6a";
       libraryHaskellDepends = [
         base bytestring containers contstuff dnscache enumerator
         lifted-base monad-control netlines network vector
       ];
       description = "Advanced ESMTP library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "iso3166-country-codes" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "iso3166-country-codes";
       version = "0.20140203.7";
       sha256 = "3a9d48b3ccb6d0df6df9e41e3a58bfb1afa2c0ae702a9e33caacf1d2f3ccd5b1";
       libraryHaskellDepends = [ base ];
       description = "A datatype for ISO 3166 country codes";
       license = "LGPL";
     }) {};

  "iso639" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "iso639";
       version = "0.1.0.3";
       sha256 = "124b8322fabaedb4de3dbc39880b36d0eab0e28d5775954aadb6630bc0da25e8";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/HugoDaniel/iso639";
       description = "ISO-639-1 language codes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "iso8583-bitmaps" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, parsec, syb
     , template-haskell, th-lift
     }:
     mkDerivation {
       pname = "iso8583-bitmaps";
       version = "0.1.0.0";
       sha256 = "0dff97867871024dd86f0cae1211918dc09e052009ff55f72fe9057f9f47d570";
       libraryHaskellDepends = [
         base binary bytestring containers parsec syb template-haskell
         th-lift
       ];
       description = "Parse and merge ISO 8583-style bitmaps";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "iso8601-time" = callPackage
    ({ mkDerivation, base, hspec, HUnit, time }:
     mkDerivation {
       pname = "iso8601-time";
       version = "0.1.4";
       sha256 = "761d737ea0841ee8fd3660cfe20041e9458be8ab424de8b3b661bb249b930126";
       libraryHaskellDepends = [ base time ];
       testHaskellDepends = [ base hspec HUnit time ];
       homepage = "https://github.com/nh2/iso8601-time";
       description = "Convert to/from the ISO 8601 time format";
       license = stdenv.lib.licenses.mit;
     }) {};

  "isohunt" = callPackage
    ({ mkDerivation, aeson, base, bytestring, data-default, ghc-prim
     , http-conduit, text, unordered-containers, uri, vector
     }:
     mkDerivation {
       pname = "isohunt";
       version = "0.1.3";
       sha256 = "fc1ac52fa488271661019a1decbd503f9adea7b93e7e4008c413e4fa59af2da1";
       libraryHaskellDepends = [
         aeson base bytestring data-default ghc-prim http-conduit text
         unordered-containers uri vector
       ];
       jailbreak = true;
       homepage = "https://github.com/reinerp/isohunt";
       description = "Bindings to the isoHunt torrent search API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "itanium-abi" = callPackage
    ({ mkDerivation, base, boomerang, HUnit, process, test-framework
     , test-framework-hunit, text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "itanium-abi";
       version = "0.1.0.0";
       sha256 = "937395ed097f0dcc6b7c958a4b115f819e4b244a783f759c90774a896a8cdca7";
       libraryHaskellDepends = [
         base boomerang text transformers unordered-containers
       ];
       testHaskellDepends = [
         base HUnit process test-framework test-framework-hunit
       ];
       description = "An implementation of name mangling/demangling for the Itanium ABI";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "iter-stats" = callPackage
    ({ mkDerivation, base, heap, HUnit, iteratee, ListLike, mtl
     , statistics, test-framework, test-framework-hunit
     , test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "iter-stats";
       version = "0.1.0.4";
       sha256 = "e1600f0cea9d7e288fe01e7fecb2a024def5cef4713eacaeb33e85a16fefdbdd";
       libraryHaskellDepends = [ base heap iteratee ListLike mtl ];
       testHaskellDepends = [
         base heap HUnit iteratee ListLike mtl statistics test-framework
         test-framework-hunit test-framework-quickcheck2 vector
       ];
       jailbreak = true;
       homepage = "https://github.com/JohnLato/iter-stats";
       description = "iteratees for statistical processing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "iterIO" = callPackage
    ({ mkDerivation, array, attoparsec, base, bytestring, containers
     , filepath, HsOpenSSL, ListLike, mtl, network, old-locale, process
     , stringsearch, time, unix, zlib
     }:
     mkDerivation {
       pname = "iterIO";
       version = "0.2.2";
       sha256 = "f593ffddc77eff88026a4b0f0c1bc1496c9113d11f02fdfe4c3511413f570033";
       libraryHaskellDepends = [
         array attoparsec base bytestring containers filepath HsOpenSSL
         ListLike mtl network old-locale process stringsearch time unix
       ];
       librarySystemDepends = [ zlib ];
       jailbreak = true;
       homepage = "http://www.scs.stanford.edu/~dm/iterIO";
       description = "Iteratee-based IO with pipe operators";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) zlib;};

  "iterable" = callPackage
    ({ mkDerivation, base, mtl, tagged, template-haskell, vector }:
     mkDerivation {
       pname = "iterable";
       version = "3.0";
       sha256 = "6cd13d621144e937cc88acfed1663bd2e208dcbe54be4bad1f7b7279250a87a4";
       libraryHaskellDepends = [
         base mtl tagged template-haskell vector
       ];
       homepage = "https://github.com/BioHaskell/iterable";
       description = "API for hierarchical multilevel collections";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "iteratee" = callPackage
    ({ mkDerivation, base, bytestring, containers, exceptions, HUnit
     , ListLike, monad-control, mtl, parallel, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , transformers, transformers-base, unix
     }:
     mkDerivation {
       pname = "iteratee";
       version = "0.8.9.6";
       sha256 = "3760121c55677da5fef1b2d8e876f3b272d18e9ad5b3d1e8db5971b4307685f9";
       libraryHaskellDepends = [
         base bytestring containers exceptions ListLike monad-control
         parallel transformers transformers-base unix
       ];
       testHaskellDepends = [
         base bytestring exceptions HUnit ListLike monad-control mtl
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 transformers transformers-base unix
       ];
       jailbreak = true;
       homepage = "http://www.tiresiaspress.us/haskell/iteratee";
       description = "Iteratee-based I/O";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "iteratee-compress" = callPackage
    ({ mkDerivation, base, bytestring, bzip2, iteratee, mtl, zlib }:
     mkDerivation {
       pname = "iteratee-compress";
       version = "0.3.3.1";
       sha256 = "84aa9b9992e17def07fc647109f8d5e83ac66491993bf31c47a85714dd1dbcc8";
       libraryHaskellDepends = [ base bytestring iteratee mtl ];
       librarySystemDepends = [ bzip2 zlib ];
       description = "Enumeratees for compressing and decompressing streams";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) bzip2; inherit (pkgs) zlib;};

  "iteratee-mtl" = callPackage
    ({ mkDerivation, base, bytestring, containers, ListLike
     , MonadCatchIO-mtl, mtl, unix
     }:
     mkDerivation {
       pname = "iteratee-mtl";
       version = "0.5.0.0";
       sha256 = "008a7dfc38986daf8b164472dd739b8185b5564246858450d093b04753056e28";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers ListLike MonadCatchIO-mtl mtl unix
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://inmachina.net/~jwlato/haskell/iteratee";
       description = "Iteratee-based I/O";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "iteratee-parsec" = callPackage
    ({ mkDerivation, base, iteratee, ListLike, parsec, reference
     , transformers
     }:
     mkDerivation {
       pname = "iteratee-parsec";
       version = "0.0.6";
       sha256 = "4898ffe9ca9a33233b1eeb0d14c4e21d2bf7daf746eb260dbc0e087a07764ee9";
       libraryHaskellDepends = [
         base iteratee ListLike parsec reference transformers
       ];
       jailbreak = true;
       description = "Package allowing parsec parser initeratee";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "iteratee-stm" = callPackage
    ({ mkDerivation, base, iteratee, stm, stm-chans, transformers }:
     mkDerivation {
       pname = "iteratee-stm";
       version = "0.1.2";
       sha256 = "1d5c127f686f832ce9dff0f55981a242fc9132e6faea1c4ea97bb20332bc26a4";
       libraryHaskellDepends = [
         base iteratee stm stm-chans transformers
       ];
       jailbreak = true;
       homepage = "http://www.tiresiaspress.us/~jwlato/haskell/iteratee-stm";
       description = "Concurrent iteratees using STM";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "iterio-server" = callPackage
    ({ mkDerivation, base, bytestring, filepath, iterIO, ListLike
     , monadIO, mtl, network, split, transformers, unix
     }:
     mkDerivation {
       pname = "iterio-server";
       version = "0.3";
       sha256 = "1630137d7c0902045fc32e686a6234653a7669ca10566d57cbd10c108d2fe0fb";
       libraryHaskellDepends = [
         base bytestring filepath iterIO ListLike monadIO mtl network split
         transformers unix
       ];
       jailbreak = true;
       homepage = "https://github.com/alevy/iterio-server";
       description = "Library for building servers with IterIO";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ivar-simple" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ivar-simple";
       version = "0.3.2";
       sha256 = "1cc082416e63598212cba91aa14199732e70a05a9c3d512230119ac866b3a752";
       libraryHaskellDepends = [ base ];
       description = "Write once concurrency primitives";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ivor" = callPackage
    ({ mkDerivation, base, binary, containers, directory, haskell98
     , mtl, parsec
     }:
     mkDerivation {
       pname = "ivor";
       version = "0.1.14.1";
       sha256 = "90f91a08095f7bd37615bec3108a3f2a1d7783193924b3b78659f3dba79b3e65";
       revision = "1";
       editedCabalFile = "32900700e14c90c9c9aad7d7790c36540bad4c7a4af16cfdc1c16c6289902635";
       libraryHaskellDepends = [
         base binary containers directory haskell98 mtl parsec
       ];
       jailbreak = true;
       homepage = "http://www.dcs.st-and.ac.uk/~eb/Ivor/";
       description = "Theorem proving library based on dependent type theory";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ivory" = callPackage
    ({ mkDerivation, base, containers, monadLib, parsec, pretty
     , template-haskell, th-lift
     }:
     mkDerivation {
       pname = "ivory";
       version = "0.1.0.0";
       sha256 = "4c1739e32f72d694b3ad45d1b4771e1ed436edef377e32972d1344a6f354c1e6";
       libraryHaskellDepends = [
         base containers monadLib parsec pretty template-haskell th-lift
       ];
       jailbreak = true;
       homepage = "http://smaccmpilot.org/languages/ivory-introduction.html";
       description = "Safe embedded C programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ivory-backend-c" = callPackage
    ({ mkDerivation, base, bytestring, cmdlib, containers, directory
     , filepath, ivory, ivory-opts, language-c-quote, mainland-pretty
     , monadLib, process, srcloc, template-haskell
     }:
     mkDerivation {
       pname = "ivory-backend-c";
       version = "0.1.0.1";
       sha256 = "244630c41baf5c96a69b4333727eb05f8124dd9ded855e80b2dc20daad522c8b";
       libraryHaskellDepends = [
         base bytestring cmdlib containers directory filepath ivory
         ivory-opts language-c-quote mainland-pretty monadLib process srcloc
         template-haskell
       ];
       jailbreak = true;
       homepage = "http://smaccmpilot.org/languages/ivory-introduction.html";
       description = "Ivory C backend";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ivory-bitdata" = callPackage
    ({ mkDerivation, base, ivory, ivory-backend-c, monadLib, parsec
     , template-haskell
     }:
     mkDerivation {
       pname = "ivory-bitdata";
       version = "0.2.0.0";
       sha256 = "a386f786f49c444beaa033ca82850eaa2e0a8e0b2886c35af458648c5257180f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base ivory ivory-backend-c monadLib parsec template-haskell
       ];
       executableHaskellDepends = [ base ivory ivory-backend-c ];
       jailbreak = true;
       homepage = "http://smaccmpilot.org/languages/ivory-introduction.html";
       description = "Ivory bit-data support";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ivory-examples" = callPackage
    ({ mkDerivation, base, ivory, ivory-backend-c, ivory-opts
     , ivory-quickcheck, ivory-stdlib, mainland-pretty, monadLib, pretty
     , QuickCheck, template-haskell, wl-pprint
     }:
     mkDerivation {
       pname = "ivory-examples";
       version = "0.1.0.2";
       sha256 = "35d7f04e613887e691d0ad3ac10cd899eb700d28df2124c843de04a3c5c94c4a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base ivory ivory-backend-c ivory-opts ivory-quickcheck ivory-stdlib
         mainland-pretty monadLib pretty QuickCheck template-haskell
         wl-pprint
       ];
       jailbreak = true;
       homepage = "http://smaccmpilot.org/languages/ivory-introduction.html";
       description = "Ivory examples";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ivory-hw" = callPackage
    ({ mkDerivation, base, filepath, ivory, ivory-backend-c
     , ivory-bitdata
     }:
     mkDerivation {
       pname = "ivory-hw";
       version = "0.1.0.0";
       sha256 = "5eafbcb226d11e65127c55b32e324bfe628cc24dc59a32e2c1e5d953bd5740e9";
       libraryHaskellDepends = [
         base filepath ivory ivory-backend-c ivory-bitdata
       ];
       jailbreak = true;
       homepage = "http://smaccmpilot.org/languages/ivory-introduction.html";
       description = "Ivory hardware model (STM32F4)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ivory-opts" = callPackage
    ({ mkDerivation, base, containers, dlist, fgl, filepath, ivory
     , monadLib
     }:
     mkDerivation {
       pname = "ivory-opts";
       version = "0.1.0.1";
       sha256 = "bf68324fbd65da2221c942c313d523498b03cd50269732a069b49dd12697dc23";
       libraryHaskellDepends = [
         base containers dlist fgl filepath ivory monadLib
       ];
       jailbreak = true;
       homepage = "http://smaccmpilot.org/languages/ivory-introduction.html";
       description = "Ivory compiler optimizations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ivory-quickcheck" = callPackage
    ({ mkDerivation, base, ivory, monadLib, QuickCheck, random }:
     mkDerivation {
       pname = "ivory-quickcheck";
       version = "0.1.0.0";
       sha256 = "4d6a0b49f276091617a9a4949cc59e68c3dfd825a4d2f25e82004ff4abbe6e49";
       libraryHaskellDepends = [ base ivory monadLib QuickCheck random ];
       jailbreak = true;
       homepage = "http://smaccmpilot.org/languages/ivory-introduction.html";
       description = "QuickCheck driver for Ivory";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ivory-stdlib" = callPackage
    ({ mkDerivation, base, filepath, ivory }:
     mkDerivation {
       pname = "ivory-stdlib";
       version = "0.1.0.0";
       sha256 = "b88b962382e82e9e768ec8e61950ebddbc8e428a339dc84ab63fbf6c424a6da8";
       libraryHaskellDepends = [ base filepath ivory ];
       jailbreak = true;
       homepage = "http://smaccmpilot.org/languages/ivory-introduction.html";
       description = "Ivory standard library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ivy-web" = callPackage
    ({ mkDerivation, base, invertible-syntax, partial-isomorphisms
     , snap, snap-core
     }:
     mkDerivation {
       pname = "ivy-web";
       version = "0.2";
       sha256 = "386c6babe87ee8fcaa2f1258b28e9ccb9d400d6d347119a3f4d80a01296a5c54";
       libraryHaskellDepends = [
         base invertible-syntax partial-isomorphisms snap snap-core
       ];
       homepage = "https://github.com/lilac/ivy-web/";
       description = "A lightweight web framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ix-shapable" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "ix-shapable";
       version = "0.1.0";
       sha256 = "5007ffb6a8a7bb490f962cedceed5ceb7c435126d09bc565441070cbfda79222";
       libraryHaskellDepends = [ array base ];
       description = "Reshape multi-dimensional arrays";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ixdopp" = callPackage
    ({ mkDerivation, base, preprocessor-tools, syb }:
     mkDerivation {
       pname = "ixdopp";
       version = "0.1.3";
       sha256 = "a4114a212e5110fc688435575dd9703e98f38030dfc07a091e630932ede776ee";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base preprocessor-tools syb ];
       jailbreak = true;
       homepage = "http://www.eecs.harvard.edu/~tov/pubs/haskell-session-types/";
       description = "A preprocessor for expanding \"ixdo\" notation for indexed monads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ixmonad" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "ixmonad";
       version = "0.57";
       sha256 = "f354ef7938e3e5d91dd0af3d422081ca78c396f0063f2dc97a864b73537718cd";
       libraryHaskellDepends = [ base ghc-prim ];
       description = "Embeds effect systems into Haskell using parameteric effect monads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ixset_1_0_6" = callPackage
    ({ mkDerivation, base, containers, safecopy, syb, syb-with-class
     , template-haskell
     }:
     mkDerivation {
       pname = "ixset";
       version = "1.0.6";
       sha256 = "dbdf754a802d6c7bec402c6daf0244b63175b680293ff5d73156a854a74bee24";
       libraryHaskellDepends = [
         base containers safecopy syb syb-with-class template-haskell
       ];
       homepage = "http://happstack.com";
       description = "Efficient relational queries on Haskell sets";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ixset" = callPackage
    ({ mkDerivation, base, containers, safecopy, syb, syb-with-class
     , template-haskell
     }:
     mkDerivation {
       pname = "ixset";
       version = "1.0.6.1";
       sha256 = "729a9601ef889f2178a9e857c39efb89c6defcb7e074f9bf9156086bc51327e1";
       libraryHaskellDepends = [
         base containers safecopy syb syb-with-class template-haskell
       ];
       homepage = "http://happstack.com";
       description = "Efficient relational queries on Haskell sets";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ixset-typed" = callPackage
    ({ mkDerivation, base, containers, deepseq, HUnit, QuickCheck
     , safecopy, syb, tasty, tasty-hunit, tasty-quickcheck
     , template-haskell
     }:
     mkDerivation {
       pname = "ixset-typed";
       version = "0.3";
       sha256 = "b3caa97470aa5c0e940a8916519b33fad29d54b82b97965fe8d3dd528e2dd354";
       libraryHaskellDepends = [
         base containers deepseq safecopy syb template-haskell
       ];
       testHaskellDepends = [
         base containers HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       doCheck = false;
       description = "Efficient relational queries on Haskell sets";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "iyql" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , filepath, haskeline, haskell98, hoauth, mtl, old-locale, parsec
     , time, utf8-string, xml
     }:
     mkDerivation {
       pname = "iyql";
       version = "0.0.7";
       sha256 = "040327633b0159de9abc2fb065fc2aa92a95db1c992daebd441ff154bf3c69c9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring containers directory filepath haskeline
         haskell98 hoauth mtl old-locale parsec time utf8-string xml
       ];
       description = "CLI (command line interface) to YQL";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "j2hs" = callPackage
    ({ mkDerivation, base, bimap, containers, directory, filepath, hx
     , java-bridge, java-bridge-extras, java-reflect, mtl, named-records
     , split, strict, strings, syb, transformers
     }:
     mkDerivation {
       pname = "j2hs";
       version = "0.99.1";
       sha256 = "62cdf7f209a2ddaaadf1a09e6dd68285c419f5f49eac52ce3b0cd0d4f32c9a3a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bimap containers directory filepath hx java-bridge
         java-bridge-extras java-reflect mtl named-records split strict
         strings syb transformers
       ];
       jailbreak = true;
       description = "j2hs";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ja-base-extra" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ja-base-extra";
       version = "0.2.1.0";
       sha256 = "5575e318795d0c95c0cad7e291c50ea0bfccc06b4fe698eec0cad6a7be84a498";
       libraryHaskellDepends = [ base ];
       description = "Extra functions I require in base";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "jack" = callPackage
    ({ mkDerivation, array, base, bytestring, enumset, event-list
     , explicit-exception, libjack2, midi, non-negative, transformers
     , unix
     }:
     mkDerivation {
       pname = "jack";
       version = "0.7.0.3";
       sha256 = "33d3c0fa183e590b2bc9323edb4f0d22d202e9ed4ff3892bffe5d6ff583f5789";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring enumset event-list explicit-exception midi
         non-negative transformers unix
       ];
       libraryPkgconfigDepends = [ libjack2 ];
       homepage = "http://www.haskell.org/haskellwiki/JACK";
       description = "Bindings for the JACK Audio Connection Kit";
       license = "GPL";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) libjack2;};

  "jack-bindings" = callPackage
    ({ mkDerivation, base, c2hs, libjack2, mtl }:
     mkDerivation {
       pname = "jack-bindings";
       version = "0.1.1";
       sha256 = "75d5c41c64a876fc7da68126a1ef626d7d1039748b6b98816cfef3f32316bfbe";
       libraryHaskellDepends = [ base mtl ];
       libraryPkgconfigDepends = [ libjack2 ];
       libraryToolDepends = [ c2hs ];
       description = "DEPRECATED Bindings to the JACK Audio Connection Kit";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libjack2;};

  "jackminimix" = callPackage
    ({ mkDerivation, base, hosc }:
     mkDerivation {
       pname = "jackminimix";
       version = "0.1";
       sha256 = "cdd9c064a88ec6a081ab7082f6827be4c9b2b3bdbb703c758dba0d57deabda0f";
       libraryHaskellDepends = [ base hosc ];
       jailbreak = true;
       homepage = "http://www.renickbell.net/doku.php?id=jackminimix";
       description = "control JackMiniMix";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jacobi-roots" = callPackage
    ({ mkDerivation, base, binary, bytestring, doctest, vector }:
     mkDerivation {
       pname = "jacobi-roots";
       version = "0.2.0.4";
       sha256 = "4cc6e6b6b4b644e21907c5563616873bd3d1ce98aed87418f514bc52a5e077ea";
       libraryHaskellDepends = [ base binary bytestring vector ];
       testHaskellDepends = [ base doctest ];
       homepage = "http://github.com/ghorn/jacobi-roots";
       description = "Roots of two shifted Jacobi polynomials (Legendre and Radau) to double precision";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jail" = callPackage
    ({ mkDerivation, base, containers, directory, monads-fd
     , transformers
     }:
     mkDerivation {
       pname = "jail";
       version = "0.0.1.1";
       sha256 = "7fef11e3918e90a797be20e4cbb9532da875c4e45363bf623885fd900b1fbf73";
       libraryHaskellDepends = [
         base containers directory monads-fd transformers
       ];
       jailbreak = true;
       description = "Jailed IO monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "jailbreak-cabal" = callPackage
    ({ mkDerivation, base, Cabal }:
     mkDerivation {
       pname = "jailbreak-cabal";
       version = "1.3.1";
       sha256 = "610d8dbd04281eee3d5da05c9eef45bfd1a1ddca20dfe54f283e15ddf6d5c235";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base Cabal ];
       homepage = "http://github.com/peti/jailbreak-cabal";
       description = "Strip version restrictions from build dependencies in Cabal files";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "jalaali" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "jalaali";
       version = "0.2.0";
       sha256 = "a01e8ade25f87e0c20c946b77be3a446e7ffa2870b601b001931ae837ef6b908";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/jalaali/jalaali-hs";
       description = "Convert Jalaali and Gregorian calendar systems to each other";
       license = stdenv.lib.licenses.mit;
     }) {};

  "jalla" = callPackage
    ({ mkDerivation, base, base-orphans, blas, c2hs, cblas, convertible
     , HUnit, lapacke, mtl, QuickCheck, random, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "jalla";
       version = "0.2.0.1";
       sha256 = "8050dd412323a369e57e7269f55e80862053f051673768e4f701699864705488";
       libraryHaskellDepends = [
         base base-orphans convertible mtl QuickCheck random
       ];
       librarySystemDepends = [ blas cblas lapacke ];
       libraryToolDepends = [ c2hs ];
       testHaskellDepends = [
         base HUnit QuickCheck random test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       homepage = "https://github.com/cgo/jalla";
       description = "Higher level functions for linear algebra. Wraps BLAS and LAPACKE.";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) blas; cblas = null; lapacke = null;};

  "jammittools" = callPackage
    ({ mkDerivation, base, boxes, bytestring, conduit, conduit-audio
     , containers, directory, filepath, HPDF, JuicyPixels, process
     , resourcet, temporary, text, transformers, vector, xml
     }:
     mkDerivation {
       pname = "jammittools";
       version = "0.5.0.2";
       sha256 = "2d633a0410423ad12840449bb809f3bc3ffbc9aae7db6b365379b02ebeb3829c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring conduit conduit-audio containers directory filepath
         HPDF JuicyPixels process resourcet temporary text transformers
         vector xml
       ];
       executableHaskellDepends = [ base boxes directory filepath ];
       jailbreak = true;
       homepage = "https://github.com/mtolly/jammittools";
       description = "Export sheet music and audio from Windows/Mac app Jammit";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jarfind" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, regex-tdfa
     , zip-archive
     }:
     mkDerivation {
       pname = "jarfind";
       version = "0.1.0.3";
       sha256 = "1c4c7301832195ff81ba2b255499a889958e333aebfaa889e323a30926c2dd31";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring regex-tdfa zip-archive
       ];
       executableHaskellDepends = [
         array base binary bytestring regex-tdfa zip-archive
       ];
       description = "Tool for searching java classes, members and fields in classfiles and JAR archives";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "java-bridge" = callPackage
    ({ mkDerivation, base, bimap, containers, cpphs, directory
     , filepath, hinduce-missingh, hint, mtl, multimap, named-records
     , names, split, strings, syb, transformers, unix
     }:
     mkDerivation {
       pname = "java-bridge";
       version = "0.20130606.3";
       sha256 = "a790433ec3b76103a9af94decac64923f08e3bb28f8852c31b3a0f5fac2cd59a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers cpphs directory filepath hinduce-missingh mtl
         multimap strings syb transformers unix
       ];
       executableHaskellDepends = [
         base bimap containers directory filepath hint multimap
         named-records names split strings syb
       ];
       description = "Bindings to the JNI and a high level interface generator";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "java-bridge-extras" = callPackage
    ({ mkDerivation, base, java-bridge, transformers }:
     mkDerivation {
       pname = "java-bridge-extras";
       version = "0.99";
       sha256 = "fbc357580cb8ff22a98d0294e5e1f15dbec38c594b3178e3594ad35e20a85d72";
       libraryHaskellDepends = [ base java-bridge transformers ];
       jailbreak = true;
       description = "Utilities for working with the java-bridge package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "java-character" = callPackage
    ({ mkDerivation, base, diet }:
     mkDerivation {
       pname = "java-character";
       version = "0.0.4";
       sha256 = "c81c2044a1b3ad7ea14c2be8652f927fe02595b012bd86cfbd4365554baa48d7";
       libraryHaskellDepends = [ base diet ];
       homepage = "https://github.com/tonymorris/java-character";
       description = "Functions to simulate Java's Character class";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "java-poker" = callPackage
    ({ mkDerivation, base, random-shuffle }:
     mkDerivation {
       pname = "java-poker";
       version = "0.1.2.0";
       sha256 = "031e0b69cb30ac98acfc59b067ccc73fdda6b2abe446f3fc501c56593e83c213";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base random-shuffle ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/tobynet/java-poker#readme";
       description = "The etude of the Haskell programming";
       license = stdenv.lib.licenses.mit;
     }) {};

  "java-reflect" = callPackage
    ({ mkDerivation, base, containers, hx, java-bridge }:
     mkDerivation {
       pname = "java-reflect";
       version = "0.99";
       sha256 = "8c0f0b24318054a73317aef3262791b11652b34f23f8288dd6104386d8c0aeed";
       libraryHaskellDepends = [ base containers hx java-bridge ];
       jailbreak = true;
       description = "Tools for reflecting on Java classes";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "javasf" = callPackage
    ({ mkDerivation, base, binary, bytestring, directory, doctest
     , filepath, language-java-classfile, QuickCheck
     }:
     mkDerivation {
       pname = "javasf";
       version = "0.1.0";
       sha256 = "fca40ac4eb55211840d8d059e571000420e9e2a4f9605fae838e5ed8328a1a4d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring language-java-classfile
       ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck
       ];
       homepage = "https://github.com/tonymorris/javasf";
       description = "A utility to print the SourceFile attribute of one or more Java class files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "javav" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, QuickCheck }:
     mkDerivation {
       pname = "javav";
       version = "0.1.1";
       sha256 = "ad143ee98872c2856fe8af2a7909a8e6c7c8fadfa93ec4253a54a61a5fbaf0cf";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck
       ];
       homepage = "https://github.com/tonymorris/javav";
       description = "A utility to print the target version of Java class files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jcdecaux-vls" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-conduit, text
     , transformers
     }:
     mkDerivation {
       pname = "jcdecaux-vls";
       version = "0.1.0";
       sha256 = "1ac9e98c45802d28f680a79703ae668e40b97e71dd8aa1696cb5a7708daf5985";
       libraryHaskellDepends = [
         aeson base bytestring http-conduit text transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/Herzult/jcdecaux-vls";
       description = "JCDecaux self-service bicycles API client";
       license = stdenv.lib.licenses.mit;
     }) {};

  "jdi" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, mtl, network
     , transformers
     }:
     mkDerivation {
       pname = "jdi";
       version = "0.0.3";
       sha256 = "cbb26b34123df1018e12120603fe568a61bd1a4158971272a4673c6fd78ff6cb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers mtl network transformers
       ];
       executableHaskellDepends = [ base mtl network ];
       jailbreak = true;
       homepage = "https://github.com/VictorDenisov/jdi";
       description = "Implementation of Java Debug Interface";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "jespresso" = callPackage
    ({ mkDerivation, arrows, base, bytestring, cmdargs
     , data-default-class, data-default-instances-base, Diff, directory
     , filepath, HTTP, http-encodings, hxt, hxt-tagsoup
     , language-ecmascript, network, network-uri, random, tasty
     , tasty-golden, transformers
     }:
     mkDerivation {
       pname = "jespresso";
       version = "1.0.2";
       sha256 = "cd5e20c7c41ae3fb72552c0416256a509fdb10a3998f9437fcdbf48430176a72";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         arrows base bytestring data-default-class
         data-default-instances-base HTTP http-encodings hxt hxt-tagsoup
         language-ecmascript network network-uri random
       ];
       executableHaskellDepends = [
         base cmdargs HTTP network network-uri
       ];
       testHaskellDepends = [
         arrows base Diff directory filepath hxt tasty tasty-golden
         transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/achudnov/jespresso";
       description = "Extract all JavaScript from an HTML page and consolidate it in one script";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jmacro_0_6_11" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , haskell-src-exts, haskell-src-meta, mtl, parseargs, parsec
     , regex-posix, safe, syb, template-haskell, text
     , unordered-containers, vector, wl-pprint-text
     }:
     mkDerivation {
       pname = "jmacro";
       version = "0.6.11";
       sha256 = "ba134edbbe19b6fa2d41be1d28dae9fddcf488be4aebe05453d582a7547e85ac";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers haskell-src-exts haskell-src-meta
         mtl parsec regex-posix safe syb template-haskell text
         unordered-containers vector wl-pprint-text
       ];
       executableHaskellDepends = [ parseargs ];
       description = "QuasiQuotation library for programmatic generation of Javascript code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jmacro_0_6_12" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , haskell-src-exts, haskell-src-meta, mtl, parseargs, parsec
     , regex-posix, safe, syb, template-haskell, text
     , unordered-containers, vector, wl-pprint-text
     }:
     mkDerivation {
       pname = "jmacro";
       version = "0.6.12";
       sha256 = "f9b69c592c37ac3f746bdc8c855a15239da90366ac1af8eed026f7e86a05c022";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers haskell-src-exts haskell-src-meta
         mtl parsec regex-posix safe syb template-haskell text
         unordered-containers vector wl-pprint-text
       ];
       executableHaskellDepends = [ parseargs ];
       description = "QuasiQuotation library for programmatic generation of Javascript code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jmacro" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , haskell-src-exts, haskell-src-meta, mtl, parseargs, parsec
     , regex-posix, safe, syb, template-haskell, text
     , unordered-containers, vector, wl-pprint-text
     }:
     mkDerivation {
       pname = "jmacro";
       version = "0.6.13";
       sha256 = "c4428aae69a7d80e84eb466f5fd71e850a48ddad7e3c9e0c0f44ceab0624f42c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers haskell-src-exts haskell-src-meta
         mtl parsec regex-posix safe syb template-haskell text
         unordered-containers vector wl-pprint-text
       ];
       executableHaskellDepends = [ parseargs ];
       description = "QuasiQuotation library for programmatic generation of Javascript code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "jmacro-rpc_0_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-html, bytestring
     , containers, contravariant, jmacro, mtl, scientific, split, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "jmacro-rpc";
       version = "0.3";
       sha256 = "fca391b655326ac99cb4c84162c6b5b58a097dbfddf2b55827e684e2849f6cba";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-html bytestring containers
         contravariant jmacro mtl scientific split text unordered-containers
         vector
       ];
       homepage = "http://hub.darcs.net/gershomb/jmacro";
       description = "JSON-RPC clients and servers using JMacro, and evented client-server Reactive Programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jmacro-rpc" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-html, bytestring
     , containers, contravariant, jmacro, mtl, scientific, split, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "jmacro-rpc";
       version = "0.3.2";
       sha256 = "a32f53b97bc84e79834df4c4630745c6b07ae46b45bc2ca2d43d91a38571c5d9";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-html bytestring containers
         contravariant jmacro mtl scientific split text unordered-containers
         vector
       ];
       homepage = "http://hub.darcs.net/gershomb/jmacro";
       description = "JSON-RPC clients and servers using JMacro, and evented client-server Reactive Programming";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "jmacro-rpc-happstack_0_3_1" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, bytestring, containers
     , happstack-server, jmacro, jmacro-rpc, mtl
     }:
     mkDerivation {
       pname = "jmacro-rpc-happstack";
       version = "0.3.1";
       sha256 = "caa84220ae60c43b8b5b7f1e4a8ca19e3a43df84204ad9ccd59f079877b6e72c";
       libraryHaskellDepends = [
         aeson base blaze-html bytestring containers happstack-server jmacro
         jmacro-rpc mtl
       ];
       homepage = "http://hub.darcs.net/gershomb/jmacro-rpc";
       description = "Happstack backend for jmacro-rpc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jmacro-rpc-happstack" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, bytestring, containers
     , happstack-server, jmacro, jmacro-rpc, mtl
     }:
     mkDerivation {
       pname = "jmacro-rpc-happstack";
       version = "0.3.2";
       sha256 = "99cdee3c1a5bd4499acf8decb2e76af48e7da7ccba01d51b86f65ea92944b064";
       libraryHaskellDepends = [
         aeson base blaze-html bytestring containers happstack-server jmacro
         jmacro-rpc mtl
       ];
       homepage = "http://hub.darcs.net/gershomb/jmacro-rpc";
       description = "Happstack backend for jmacro-rpc";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "jmacro-rpc-snap" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, jmacro
     , jmacro-rpc, mtl, snap-core
     }:
     mkDerivation {
       pname = "jmacro-rpc-snap";
       version = "0.3";
       sha256 = "48aea4a4ba90532ca105b6b274060a47a1c509b8346e0db1b61365c2a9e8dfeb";
       libraryHaskellDepends = [
         aeson base bytestring containers jmacro jmacro-rpc mtl snap-core
       ];
       homepage = "http://hub.darcs.net/gershomb/jmacro-rpc";
       description = "Snap backend for jmacro-rpc";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "jobqueue" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, bytestring
     , containers, data-default, directory, fast-logger, HDBC
     , HDBC-sqlite3, hslogger, hspec, hzk, lifted-base, monad-control
     , monad-logger, mtl, network, QuickCheck, regex-posix, split, stm
     , template-haskell, text, text-format, time, transformers-base
     }:
     mkDerivation {
       pname = "jobqueue";
       version = "0.1.6";
       sha256 = "e960c4f3320336d998ada5df27f356a93e89ac5402a5fe75d0c56ef8355dd595";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers data-default
         fast-logger HDBC HDBC-sqlite3 hslogger hzk lifted-base
         monad-control monad-logger mtl network regex-posix split stm
         template-haskell text text-format time transformers-base
       ];
       testHaskellDepends = [
         async base bytestring data-default directory hspec network
         QuickCheck stm
       ];
       homepage = "https://github.com/gree/haskell-jobqueue";
       description = "A job queue library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "join" = callPackage
    ({ mkDerivation, base, haskell98, multisetrewrite, stm }:
     mkDerivation {
       pname = "join";
       version = "0.4";
       sha256 = "1d2379c651afbcddf93a5ed8e8fbe91a853f8404f4f2fe3018ff7008db66a92f";
       libraryHaskellDepends = [ base haskell98 multisetrewrite stm ];
       homepage = "http://sulzmann.blogspot.com/2008/12/parallel-join-patterns-with-guards-and.html";
       description = "Parallel Join Patterns with Guards and Propagation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "joinlist" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "joinlist";
       version = "0.3.0";
       sha256 = "656cfe066805002043d6e82435c3758fb453279361a56d920987c045bdf75442";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.google.com/p/copperbox/";
       description = "Join list - symmetric list type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jonathanscard" = callPackage
    ({ mkDerivation, base, bytestring, containers, HTTP, json, mtl
     , network, old-locale, time
     }:
     mkDerivation {
       pname = "jonathanscard";
       version = "0.1.1";
       sha256 = "e8955d5c093ffd98e16889ecfd5ecfce9799eef64042ea6837d457c55b2d8d7f";
       libraryHaskellDepends = [
         base bytestring containers HTTP json mtl network old-locale time
       ];
       jailbreak = true;
       homepage = "http://rawr.mschade.me/jonathanscard/";
       description = "An implementation of the Jonathan's Card API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jort" = callPackage
    ({ mkDerivation, array, base, gtk }:
     mkDerivation {
       pname = "jort";
       version = "1.0.0";
       sha256 = "a389558e0b2d93b1752ed6fe5c457e5890aa03ae4257ec7725d66f822fca36b0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base gtk ];
       jailbreak = true;
       description = "JP's own ray tracer";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jose" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bifunctors, byteable, bytestring, crypto-pubkey
     , crypto-pubkey-types, crypto-random, cryptohash
     , data-default-class, ghc-prim, hspec, integer-gmp, lens
     , network-uri, safe, semigroups, template-haskell, text, time
     , unordered-containers, vector, x509
     }:
     mkDerivation {
       pname = "jose";
       version = "0.3.41.2";
       sha256 = "8593c745330b58426075bb2ff8077551777bfcd7ba6ebd2cbfbfa03b7978555d";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring bifunctors byteable
         bytestring crypto-pubkey crypto-pubkey-types crypto-random
         cryptohash data-default-class ghc-prim integer-gmp lens network-uri
         safe semigroups template-haskell text time unordered-containers
         vector x509
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring bifunctors byteable
         bytestring crypto-pubkey crypto-pubkey-types crypto-random
         cryptohash data-default-class hspec lens network-uri safe
         semigroups template-haskell text time unordered-containers vector
         x509
       ];
       jailbreak = true;
       homepage = "https://github.com/frasertweedale/hs-jose";
       description = "Javascript Object Signing and Encryption and JSON Web Token library";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "jose-jwt_0_4_2" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, base64-bytestring, byteable
     , bytestring, cereal, cipher-aes, containers, cprng-aes
     , crypto-cipher-types, crypto-numbers, crypto-pubkey
     , crypto-pubkey-types, crypto-random, cryptohash, doctest, either
     , errors, hspec, HUnit, mtl, QuickCheck, text, time
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "jose-jwt";
       version = "0.4.2";
       sha256 = "f9df06c9f44ec3481c9729f44661728c7f8687772c36cdf898ce97e60917e3ef";
       libraryHaskellDepends = [
         aeson base base64-bytestring byteable bytestring cereal cipher-aes
         containers crypto-cipher-types crypto-numbers crypto-pubkey
         crypto-pubkey-types crypto-random cryptohash errors mtl text time
         unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-qq base base64-bytestring bytestring cipher-aes
         cprng-aes crypto-cipher-types crypto-pubkey crypto-pubkey-types
         crypto-random cryptohash doctest either hspec HUnit mtl QuickCheck
         text
       ];
       homepage = "http://github.com/tekul/jose-jwt";
       description = "JSON Object Signing and Encryption Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jose-jwt_0_6_2" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, base64-bytestring, byteable
     , bytestring, cereal, cipher-aes, containers, cprng-aes
     , crypto-cipher-types, crypto-numbers, crypto-pubkey
     , crypto-pubkey-types, crypto-random, cryptohash, doctest, either
     , hspec, HUnit, mtl, QuickCheck, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "jose-jwt";
       version = "0.6.2";
       sha256 = "f8bbfcf64af6547f687b54d587b60f923594a72131581a4da9575ef8c858833b";
       revision = "1";
       editedCabalFile = "5aa6637a051160937328c7ff477615ff8424212374f46e41386c705e4db425c0";
       libraryHaskellDepends = [
         aeson base base64-bytestring byteable bytestring cereal cipher-aes
         containers crypto-cipher-types crypto-numbers crypto-pubkey
         crypto-pubkey-types crypto-random cryptohash either mtl text time
         unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-qq base base64-bytestring bytestring cipher-aes
         cprng-aes crypto-cipher-types crypto-pubkey crypto-pubkey-types
         crypto-random cryptohash doctest either hspec HUnit mtl QuickCheck
         text
       ];
       homepage = "http://github.com/tekul/jose-jwt";
       description = "JSON Object Signing and Encryption Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jose-jwt" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, bytestring, cereal
     , containers, cryptonite, doctest, either, hspec, HUnit, memory
     , mtl, QuickCheck, text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "jose-jwt";
       version = "0.7";
       sha256 = "60d5bf047e6ba6081b4ca7a86fe78a371594aa9ed1fec808a8c3628b5b0eca62";
       libraryHaskellDepends = [
         aeson base bytestring cereal containers cryptonite either memory
         mtl text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-qq base bytestring cryptonite doctest either hspec
         HUnit memory mtl QuickCheck text unordered-containers vector
       ];
       doCheck = false;
       homepage = "http://github.com/tekul/jose-jwt";
       description = "JSON Object Signing and Encryption Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "jpeg" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "jpeg";
       version = "0.0.1.1";
       sha256 = "1d27b81dc995ddbd579e4a55dbc6795fa25014afff13c57df4eefe20f255cec2";
       libraryHaskellDepends = [ base mtl ];
       description = "A library for decoding JPEG files written in pure Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "js-flot" = callPackage
    ({ mkDerivation, base, HTTP }:
     mkDerivation {
       pname = "js-flot";
       version = "0.8.3";
       sha256 = "1ba2f2a6b8d85da76c41f526c98903cbb107f8642e506c072c1e7e3c20fe5e7a";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base HTTP ];
       homepage = "https://github.com/ndmitchell/js-flot#readme";
       description = "Obtain minified flot code";
       license = stdenv.lib.licenses.mit;
     }) {};

  "js-good-parts" = callPackage
    ({ mkDerivation, base, wl-pprint }:
     mkDerivation {
       pname = "js-good-parts";
       version = "0.0.7";
       sha256 = "e54cf3774b5f91bf47f84ce6162fc1739112dddae7c80c4d1b4a4488681f7944";
       libraryHaskellDepends = [ base wl-pprint ];
       homepage = "https://github.com/sseefried/js-good-parts.git";
       description = "Javascript: The Good Parts -- AST & Pretty Printer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "js-jquery_1_11_1" = callPackage
    ({ mkDerivation, base, HTTP }:
     mkDerivation {
       pname = "js-jquery";
       version = "1.11.1";
       sha256 = "0da1183c74326d8c3f2ced74e6a1a659e91c7364d2f02fb2551611a6fbcd904c";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base HTTP ];
       doCheck = false;
       homepage = "https://github.com/ndmitchell/js-jquery#readme";
       description = "Obtain minified jQuery code";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "js-jquery_1_11_2" = callPackage
    ({ mkDerivation, base, HTTP }:
     mkDerivation {
       pname = "js-jquery";
       version = "1.11.2";
       sha256 = "2204d8830f4cae60110a596e53516c1e7e86e9d7a24d338c898045f7c67fbf69";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base HTTP ];
       doCheck = false;
       homepage = "https://github.com/ndmitchell/js-jquery#readme";
       description = "Obtain minified jQuery code";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "js-jquery_1_11_3" = callPackage
    ({ mkDerivation, base, HTTP }:
     mkDerivation {
       pname = "js-jquery";
       version = "1.11.3";
       sha256 = "3d7b19d0b5ae59339b705026bed66e72fe5392a792f08859876d6e4131b3c257";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base HTTP ];
       doCheck = false;
       homepage = "https://github.com/ndmitchell/js-jquery#readme";
       description = "Obtain minified jQuery code";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "js-jquery" = callPackage
    ({ mkDerivation, base, HTTP }:
     mkDerivation {
       pname = "js-jquery";
       version = "1.12.0";
       sha256 = "23535bdcd96bc45f96ac0bdd67ee83b761816612a5dff7d2c13b081fecca59a6";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base HTTP ];
       doCheck = false;
       homepage = "https://github.com/ndmitchell/js-jquery#readme";
       description = "Obtain minified jQuery code";
       license = stdenv.lib.licenses.mit;
     }) {};

  "jsaddle" = callPackage
    ({ mkDerivation, base, doctest, glib, gtk3, lens, QuickCheck
     , template-haskell, text, transformers, vector, webkitgtk3
     , webkitgtk3-javascriptcore
     }:
     mkDerivation {
       pname = "jsaddle";
       version = "0.3.0.1";
       sha256 = "91511d9b4df73285f0f060418697028bc5384022da93d6dd9b5573214020aaaf";
       libraryHaskellDepends = [
         base glib gtk3 lens template-haskell text transformers webkitgtk3
         webkitgtk3-javascriptcore
       ];
       testHaskellDepends = [
         base doctest glib gtk3 QuickCheck text vector webkitgtk3
         webkitgtk3-javascriptcore
       ];
       description = "High level interface for webkit-javascriptcore";
       license = stdenv.lib.licenses.mit;
     }) {};

  "jsaddle-hello" = callPackage
    ({ mkDerivation, base, ghcjs-dom, jsaddle, lens }:
     mkDerivation {
       pname = "jsaddle-hello";
       version = "1.0.0.0";
       sha256 = "b78158a85e4b8006c1b2fe738dec2ba011b9f67289c4f43d9494af5dc6956f1e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ghcjs-dom jsaddle lens ];
       jailbreak = true;
       homepage = "https://github.com/ghcjs/jsaddle-hello";
       description = "JSaddle Hello World, an example package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "jsc" = callPackage
    ({ mkDerivation, base, glib, gtk3, hslogger, jmacro, lens
     , template-haskell, text, transformers, webkitgtk3
     , webkitgtk3-javascriptcore
     }:
     mkDerivation {
       pname = "jsc";
       version = "0.1.1.1";
       sha256 = "ec23fb15e81a8a5d48974a753a3db81f56d9a3420f804ecf7e643bbd99bdbba2";
       libraryHaskellDepends = [
         base jmacro lens template-haskell text transformers webkitgtk3
         webkitgtk3-javascriptcore
       ];
       testHaskellDepends = [
         base glib gtk3 hslogger jmacro lens template-haskell text
         transformers webkitgtk3 webkitgtk3-javascriptcore
       ];
       jailbreak = true;
       description = "High level interface for webkit-javascriptcore";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jsmw" = callPackage
    ({ mkDerivation, base, DOM, mtl, WebBits }:
     mkDerivation {
       pname = "jsmw";
       version = "0.1";
       sha256 = "f87901fc858e38c5c13f4870196cf511b365f869dedb678aa5f80050a0e066e4";
       libraryHaskellDepends = [ base DOM mtl WebBits ];
       jailbreak = true;
       description = "Javascript Monadic Writer base package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, mtl, parsec
     , pretty, syb, text
     }:
     mkDerivation {
       pname = "json";
       version = "0.9.1";
       sha256 = "96b57e4d167e45dc80aeff872a922ae9cdb953a1ded29ebbb51019b68f0085a2";
       libraryHaskellDepends = [
         array base bytestring containers mtl parsec pretty syb text
       ];
       description = "Support for serialising Haskell to and from JSON";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "json-assertions" = callPackage
    ({ mkDerivation, aeson, base, indexed, indexed-free, lens
     , lens-aeson, text
     }:
     mkDerivation {
       pname = "json-assertions";
       version = "1.0.7";
       sha256 = "0a2b071178b27b8ab295040c22b712c17278986b6829b2a085819b85fdd7e3f4";
       libraryHaskellDepends = [
         aeson base indexed indexed-free lens lens-aeson text
       ];
       jailbreak = true;
       homepage = "http://github.com/ocharles/json-assertions.git";
       description = "Test that your (Aeson) JSON encoding matches your expectations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "json-ast" = callPackage
    ({ mkDerivation, base, scientific, text, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "json-ast";
       version = "0.2";
       sha256 = "595ed692fa82dc6e178d368a6a247eb19f96f643ce030b8c178ec7d54b0a4b5c";
       libraryHaskellDepends = [
         base scientific text unordered-containers vector
       ];
       homepage = "https://github.com/nikita-volkov/json-ast";
       description = "Universal JSON AST datastructure";
       license = stdenv.lib.licenses.mit;
     }) {};

  "json-ast-quickcheck" = callPackage
    ({ mkDerivation, base, json-ast, QuickCheck, quickcheck-instances
     }:
     mkDerivation {
       pname = "json-ast-quickcheck";
       version = "0.2";
       sha256 = "41a6cab47756614727427311c08326ae960d7b88c21a5c9c5910f29a66e6cd04";
       libraryHaskellDepends = [
         base json-ast QuickCheck quickcheck-instances
       ];
       homepage = "https://github.com/nikita-volkov/json-ast-quickcheck";
       description = "Compatibility layer for \"json-ast\" and \"QuickCheck\"";
       license = stdenv.lib.licenses.mit;
     }) {};

  "json-autotype_0_2_5_4" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, filepath
     , GenericPretty, hashable, hflags, lens, mtl, pretty, process
     , scientific, text, uniplate, unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-autotype";
       version = "0.2.5.4";
       sha256 = "c7159b8449a5a369c4d7e1bd46a6704fee31e81ddb72c8b9a0d811f6b7270580";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers filepath GenericPretty hashable
         hflags lens mtl pretty process scientific text uniplate
         unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson base bytestring containers filepath GenericPretty hashable
         hflags lens mtl pretty process scientific text uniplate
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/mgajda/json-autotype";
       description = "Automatic type declaration for JSON input data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-autotype_0_2_5_8" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, filepath
     , GenericPretty, hashable, hflags, hint, lens, mtl, pretty, process
     , scientific, text, uniplate, unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-autotype";
       version = "0.2.5.8";
       sha256 = "2002e656b606d016bc87dac1eed580e1d7272ad2fbe2d92861012950229cd7dc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers filepath GenericPretty hashable
         hflags hint lens mtl pretty process scientific text uniplate
         unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson base bytestring containers filepath GenericPretty hashable
         hflags lens mtl pretty process scientific text uniplate
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/mgajda/json-autotype";
       description = "Automatic type declaration for JSON input data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-autotype_0_2_5_9" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, filepath
     , GenericPretty, hashable, hflags, hint, lens, mtl, pretty, process
     , scientific, text, uniplate, unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-autotype";
       version = "0.2.5.9";
       sha256 = "c2e5fe1ebc06c900277dde2e36bdd9db5d495e7d8992f42a5e049112caeb5a2a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers filepath GenericPretty hashable
         hflags hint lens mtl pretty process scientific text uniplate
         unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson base bytestring containers filepath GenericPretty hashable
         hflags lens mtl pretty process scientific text uniplate
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/mgajda/json-autotype";
       description = "Automatic type declaration for JSON input data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-autotype_0_2_5_11" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, filepath
     , GenericPretty, hashable, hflags, hint, lens, mtl, pretty, process
     , scientific, text, uniplate, unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-autotype";
       version = "0.2.5.11";
       sha256 = "1e50296c68d26291be6f33d2b1c47d2bbbe6149a4f60daa07078c7651d8aa902";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers filepath GenericPretty hashable
         hflags hint lens mtl pretty process scientific text uniplate
         unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson base bytestring containers filepath GenericPretty hashable
         hflags lens mtl pretty process scientific text uniplate
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/mgajda/json-autotype";
       description = "Automatic type declaration for JSON input data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-autotype_0_2_5_13" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, directory
     , filepath, GenericPretty, hashable, hflags, hint, lens, mtl
     , pretty, process, QuickCheck, scientific, text, uniplate
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-autotype";
       version = "0.2.5.13";
       sha256 = "b3205fa29f5fdd5d7eae33da6b1f59362e699068712886007f1070ff92f47206";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers filepath GenericPretty hashable
         hflags hint lens mtl pretty process scientific text uniplate
         unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson base bytestring containers directory filepath GenericPretty
         hashable hflags lens mtl pretty process QuickCheck scientific text
         uniplate unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/mgajda/json-autotype";
       description = "Automatic type declaration for JSON input data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-autotype_1_0_7" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, directory
     , filepath, GenericPretty, hashable, hflags, hint, lens, mtl
     , pretty, process, QuickCheck, scientific, smallcheck, text
     , uniplate, unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-autotype";
       version = "1.0.7";
       sha256 = "86e05f28da564f8a1661117d3288bcabcc5b2810f30a501b880a7e0c4755a687";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers filepath GenericPretty hashable
         hflags hint lens mtl pretty process scientific text uniplate
         unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson base bytestring containers filepath GenericPretty hashable
         hflags hint lens mtl pretty process scientific text uniplate
         unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bytestring containers directory filepath GenericPretty
         hashable hflags lens mtl pretty process QuickCheck scientific
         smallcheck text uniplate unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/mgajda/json-autotype";
       description = "Automatic type declaration for JSON input data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-autotype" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, directory
     , filepath, GenericPretty, hashable, hflags, hint, lens, mtl
     , pretty, process, QuickCheck, scientific, smallcheck, text
     , uniplate, unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-autotype";
       version = "1.0.10";
       sha256 = "38201e4322d1bc98c05cab499704a52e1725c3547edd58d3e45e97a3929c70ea";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers filepath GenericPretty hashable
         hflags hint lens mtl pretty process scientific text uniplate
         unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson base bytestring containers filepath GenericPretty hashable
         hflags hint lens mtl pretty process scientific text uniplate
         unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bytestring containers directory filepath GenericPretty
         hashable hflags lens mtl pretty process QuickCheck scientific
         smallcheck text uniplate unordered-containers vector
       ];
       homepage = "https://github.com/mgajda/json-autotype";
       description = "Automatic type declaration for JSON input data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "json-b" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-nums, bytestring-trie
     , bytestringparser-temporary, containers, utf8-string
     }:
     mkDerivation {
       pname = "json-b";
       version = "0.0.4";
       sha256 = "faa938a92e9bf15d6ec717cfbe96525275d8cded98967db083fb3bf7b8569b71";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring bytestring-nums bytestring-trie
         bytestringparser-temporary containers utf8-string
       ];
       executableHaskellDepends = [
         base bytestring bytestring-nums bytestring-trie
         bytestringparser-temporary containers utf8-string
       ];
       jailbreak = true;
       homepage = "http://github.com/jsnx/JSONb/";
       description = "JSON parser that uses byte strings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-builder" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-textual, bytestring
     , containers, text, unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "json-builder";
       version = "0.3";
       sha256 = "b5ef217d5432e8e962fac45f5a266993a0ea26d29c2580b93d0c9988d7480b4d";
       libraryHaskellDepends = [
         base blaze-builder blaze-textual bytestring containers text
         unordered-containers utf8-string vector
       ];
       homepage = "http://github.com/lpsmith/json-builder";
       description = "Data structure agnostic JSON serialization";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "json-encoder" = callPackage
    ({ mkDerivation, base-prelude, bytestring, bytestring-tree-builder
     , contravariant, contravariant-extras, scientific, semigroups, text
     }:
     mkDerivation {
       pname = "json-encoder";
       version = "0.1.5";
       sha256 = "bd71014bca5df3be295bfd851eb39d4c30bc38acaa7fd277f6cb6d8ac60c9bd4";
       libraryHaskellDepends = [
         base-prelude bytestring bytestring-tree-builder contravariant
         contravariant-extras scientific semigroups text
       ];
       jailbreak = true;
       homepage = "https://github.com/sannsyn/json-encoder";
       description = "A direct-to-bytes single-pass JSON encoder with a declarative DSL";
       license = stdenv.lib.licenses.mit;
     }) {};

  "json-enumerator" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-builder-enumerator
     , bytestring, containers, enumerator, json-types, text
     , transformers
     }:
     mkDerivation {
       pname = "json-enumerator";
       version = "0.0.1.2";
       sha256 = "2dd58e7a85c2b45f78767e21069b2b6597e848e6c6339b678670ef5b42cdfc21";
       libraryHaskellDepends = [
         base blaze-builder blaze-builder-enumerator bytestring containers
         enumerator json-types text transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/json-enumerator";
       description = "Pure-Haskell utilities for dealing with JSON with the enumerator package. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-extra" = callPackage
    ({ mkDerivation, aeson, base, bytestring, data-default
     , template-haskell, unordered-containers, yaml
     }:
     mkDerivation {
       pname = "json-extra";
       version = "0.1.0.1";
       sha256 = "7a3a70ea9e1f4c9538a91563446ec0bcdfe6c10967b116fbe9b1ca99173216f3";
       revision = "1";
       editedCabalFile = "76113c3d47cb5d8087ffe18e1b09eaa22cc8dcd07010537739c7f1e4dc6b0741";
       libraryHaskellDepends = [
         aeson base bytestring data-default template-haskell
         unordered-containers yaml
       ];
       homepage = "https://bitbucket.org/tdammers/json-extra";
       description = "Utility functions to extend Aeson";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "json-fu" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , hashable, hspec, mtl, syb, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "json-fu";
       version = "0.1.1";
       sha256 = "4920e87a973b4ae700a7a5b5fb33006dd706057c6a440553e522e4174dd11725";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers hashable mtl syb text
         time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring containers hashable hspec mtl syb
         text time unordered-containers vector
       ];
       description = "Generic JSON serialization / deserialization";
       license = stdenv.lib.licenses.mit;
     }) {};

  "json-litobj" = callPackage
    ({ mkDerivation, base, hspec, json, QuickCheck }:
     mkDerivation {
       pname = "json-litobj";
       version = "0.1.0.0";
       sha256 = "4ac4bd3cc6a559d48445577763497f24b0fdd748bab81d241c1392abd8a41ce6";
       libraryHaskellDepends = [ base json ];
       testHaskellDepends = [ base hspec json QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/jonathankochems/json-litobj";
       description = "Extends Text.JSON to handle literal JS objects.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "json-pointer" = callPackage
    ({ mkDerivation, attoparsec, base-prelude, text }:
     mkDerivation {
       pname = "json-pointer";
       version = "0.1.1";
       sha256 = "443221a71faa40a5eddf8865a3219b5f48086a4c62efcdea9d468ae934410ee3";
       libraryHaskellDepends = [ attoparsec base-prelude text ];
       jailbreak = true;
       homepage = "https://github.com/sannsyn/json-pointer";
       description = "JSON Pointer parsing and interpretation utilities";
       license = stdenv.lib.licenses.mit;
     }) {};

  "json-pointer-hasql" = callPackage
    ({ mkDerivation, aeson, base-prelude, either, hasql, json-pointer
     , rebase, text, transformers
     }:
     mkDerivation {
       pname = "json-pointer-hasql";
       version = "0.1";
       sha256 = "5ed9ae42aadc1fde554480f055df77f751e5eb1c5386d0ed71883dfe9d534a8a";
       libraryHaskellDepends = [ base-prelude hasql json-pointer text ];
       testHaskellDepends = [
         aeson either hasql json-pointer rebase transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/sannsyn/json-pointer-hasql";
       description = "JSON Pointer extensions for Hasql";
       license = stdenv.lib.licenses.mit;
     }) {};

  "json-python" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, pureMD5
     , python, template-haskell
     }:
     mkDerivation {
       pname = "json-python";
       version = "0.4.0.1";
       sha256 = "c983c5781fd50cb44336d21e7d0e8619bd1e8aa131af43baa71d085c3765433d";
       libraryHaskellDepends = [
         aeson base bytestring containers pureMD5 template-haskell
       ];
       libraryPkgconfigDepends = [ python ];
       jailbreak = true;
       homepage = "http://stewart.guru";
       description = "Call python inline from haskell";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) python;};

  "json-qq" = callPackage
    ({ mkDerivation, base, haskell-src-meta, parsec, template-haskell
     }:
     mkDerivation {
       pname = "json-qq";
       version = "0.4.1";
       sha256 = "a61e1dcd911f8f24b1ae050d7728a19170a06b426b68d6d3c053424922d8ee66";
       libraryHaskellDepends = [
         base haskell-src-meta parsec template-haskell
       ];
       homepage = "http://github.com/finnsson/json-qq";
       description = "Json Quasiquatation library for Haskell";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-rpc" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, conduit
     , conduit-extra, deepseq, hashable, lifted-async, monad-control
     , monad-logger, mtl, QuickCheck, stm, stm-conduit, test-framework
     , test-framework-quickcheck2, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-rpc";
       version = "0.7.1.1";
       sha256 = "e7587e2a4bdbfcee27aaf28718f9ff9199a4f5f6d742a93b9b077e4df49ff247";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring conduit conduit-extra deepseq
         hashable lifted-async monad-control monad-logger mtl QuickCheck stm
         stm-conduit text transformers unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bytestring conduit lifted-async monad-logger mtl
         QuickCheck stm stm-conduit test-framework
         test-framework-quickcheck2 text transformers unordered-containers
       ];
       homepage = "https://github.com/xenog/json-rpc";
       description = "Fully-featured JSON-RPC 2.0 library";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-rpc-client" = callPackage
    ({ mkDerivation, aeson, base, bytestring, HUnit, json-rpc-server
     , mtl, QuickCheck, scientific, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, unordered-containers, vector
     , vector-algorithms
     }:
     mkDerivation {
       pname = "json-rpc-client";
       version = "0.2.3.0";
       sha256 = "6c4325ad6d9fc8552d496f6bf680444dd90454c44c3a4265ed7e9a5b473f6a3a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring json-rpc-server mtl text unordered-containers
         vector vector-algorithms
       ];
       testHaskellDepends = [
         aeson base bytestring HUnit json-rpc-server mtl QuickCheck
         scientific test-framework test-framework-hunit
         test-framework-quickcheck2 text unordered-containers vector
       ];
       homepage = "https://github.com/grayjay/json-rpc-client";
       description = "JSON-RPC 2.0 on the client side.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "json-rpc-server" = callPackage
    ({ mkDerivation, aeson, base, bytestring, deepseq, HUnit, mtl
     , test-framework, test-framework-hunit, text, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "json-rpc-server";
       version = "0.2.3.0";
       sha256 = "73d633f3bfeea0ad785916c53afb1f4e3d481bef55977dc20d51297180148337";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring deepseq mtl text unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bytestring HUnit mtl test-framework test-framework-hunit
         text unordered-containers vector
       ];
       homepage = "https://github.com/grayjay/json-rpc-server";
       description = "JSON-RPC 2.0 on the server side.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "json-schema_0_7_3_0" = callPackage
    ({ mkDerivation, aeson, aeson-utils, attoparsec, base, bytestring
     , containers, generic-aeson, generic-deriving, mtl, scientific
     , tagged, tasty, tasty-hunit, tasty-th, text, time
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-schema";
       version = "0.7.3.0";
       sha256 = "fc8393d3ea29d7c8aa60e1f7c4aea78103dc4d30dc6443beb70de918deafb049";
       revision = "1";
       editedCabalFile = "7e2a495b0e619886e9cfc353c2dbebafa9f7bf03727a92f18332b6c9c5adfa52";
       libraryHaskellDepends = [
         aeson base containers generic-aeson generic-deriving mtl scientific
         tagged text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-utils attoparsec base bytestring generic-aeson tagged
         tasty tasty-hunit tasty-th text vector
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       description = "Types and type classes for defining JSON schemas";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-schema_0_7_3_1" = callPackage
    ({ mkDerivation, aeson, aeson-utils, attoparsec, base, bytestring
     , containers, generic-aeson, generic-deriving, mtl, scientific
     , tagged, tasty, tasty-hunit, tasty-th, text, time
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-schema";
       version = "0.7.3.1";
       sha256 = "d7babcc1a7fd5a38f64837cd5de67603f1a7b177031ddab1de7eaa6d2cc85b1e";
       revision = "1";
       editedCabalFile = "052c5ad202c8b46e8acf3b85b5e992b43329135ddedb4f5ee5264303b3f2517f";
       libraryHaskellDepends = [
         aeson base containers generic-aeson generic-deriving mtl scientific
         tagged text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-utils attoparsec base bytestring generic-aeson tagged
         tasty tasty-hunit tasty-th text vector
       ];
       jailbreak = true;
       description = "Types and type classes for defining JSON schemas";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-schema_0_7_3_2" = callPackage
    ({ mkDerivation, aeson, aeson-utils, attoparsec, base, bytestring
     , containers, generic-aeson, generic-deriving, mtl, scientific
     , tagged, tasty, tasty-hunit, tasty-th, text, time
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-schema";
       version = "0.7.3.2";
       sha256 = "e6429ff6e0c0da1eebea861ef8d94a2f9e4f8bfd035bf0ccedfbec29b61fc0eb";
       revision = "1";
       editedCabalFile = "c6f8386ca805ae36a298a65059e71d4eeb2490e1534290f4016380e6ed105c67";
       libraryHaskellDepends = [
         aeson base containers generic-aeson generic-deriving mtl scientific
         tagged text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-utils attoparsec base bytestring generic-aeson tagged
         tasty tasty-hunit tasty-th text vector
       ];
       jailbreak = true;
       description = "Types and type classes for defining JSON schemas";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-schema_0_7_3_3" = callPackage
    ({ mkDerivation, aeson, aeson-utils, attoparsec, base, bytestring
     , containers, generic-aeson, generic-deriving, mtl, scientific
     , tagged, tasty, tasty-hunit, tasty-th, text, time
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-schema";
       version = "0.7.3.3";
       sha256 = "8c18742b005677317901a2e25459ef7ffb70e71c9faefbe6a5b103da46948518";
       revision = "1";
       editedCabalFile = "75e2beeeaabd3c37ea5114e7932a33c6a81b975fc01c96980b4a7e0e137f8698";
       libraryHaskellDepends = [
         aeson base containers generic-aeson generic-deriving mtl scientific
         tagged text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-utils attoparsec base bytestring generic-aeson tagged
         tasty tasty-hunit tasty-th text vector
       ];
       jailbreak = true;
       description = "Types and type classes for defining JSON schemas";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-schema_0_7_3_4" = callPackage
    ({ mkDerivation, aeson, aeson-utils, attoparsec, base, bytestring
     , containers, generic-aeson, generic-deriving, mtl, scientific
     , tasty, tasty-hunit, tasty-th, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "json-schema";
       version = "0.7.3.4";
       sha256 = "17f0137e2d7294ad66b8e2d134477bfdbf3ca1b136a6f545a0f0220a0d38355d";
       libraryHaskellDepends = [
         aeson base containers generic-aeson generic-deriving mtl scientific
         text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-utils attoparsec base bytestring generic-aeson tasty
         tasty-hunit tasty-th text vector
       ];
       jailbreak = true;
       description = "Types and type classes for defining JSON schemas";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-schema_0_7_3_5" = callPackage
    ({ mkDerivation, aeson, aeson-utils, attoparsec, base, bytestring
     , containers, generic-aeson, generic-deriving, mtl, scientific
     , tasty, tasty-hunit, tasty-th, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "json-schema";
       version = "0.7.3.5";
       sha256 = "50a0b05a79f79af0bda86cdd8648099112f8111c95ac794872da167206aaebf4";
       libraryHaskellDepends = [
         aeson base containers generic-aeson generic-deriving mtl scientific
         text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-utils attoparsec base bytestring generic-aeson tasty
         tasty-hunit tasty-th text vector
       ];
       jailbreak = true;
       description = "Types and type classes for defining JSON schemas";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-schema_0_7_3_6" = callPackage
    ({ mkDerivation, aeson, aeson-utils, attoparsec, base, bytestring
     , containers, generic-aeson, generic-deriving, mtl, scientific
     , tasty, tasty-hunit, tasty-th, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "json-schema";
       version = "0.7.3.6";
       sha256 = "7b195d285629182e89591b6b8152864ea06b8b27e8d81dafc26082c674912a74";
       libraryHaskellDepends = [
         aeson base containers generic-aeson generic-deriving mtl scientific
         text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-utils attoparsec base bytestring generic-aeson tasty
         tasty-hunit tasty-th text vector
       ];
       jailbreak = true;
       description = "Types and type classes for defining JSON schemas";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-schema_0_7_3_7" = callPackage
    ({ mkDerivation, aeson, aeson-utils, attoparsec, base, bytestring
     , containers, generic-aeson, generic-deriving, mtl, scientific
     , tasty, tasty-hunit, tasty-th, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "json-schema";
       version = "0.7.3.7";
       sha256 = "65ca1a44d5b62a3cdc80f183ba1e1ae12f53818575e44bbb194face6e12f3953";
       revision = "1";
       editedCabalFile = "94b50ebb4b1aa921270db172dbef2ed18c85846d147d1526ec9c85ea0be1705a";
       libraryHaskellDepends = [
         aeson base containers generic-aeson generic-deriving mtl scientific
         text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-utils attoparsec base bytestring generic-aeson tasty
         tasty-hunit tasty-th text vector
       ];
       jailbreak = true;
       description = "Types and type classes for defining JSON schemas";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-schema_0_7_4_0" = callPackage
    ({ mkDerivation, aeson, aeson-utils, attoparsec, base, bytestring
     , containers, generic-aeson, generic-deriving, mtl, scientific
     , tasty, tasty-hunit, tasty-th, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "json-schema";
       version = "0.7.4.0";
       sha256 = "c549fa4b199efcd885334538cfa15cc77226a1c9c9afa30f5867d75b79d2701c";
       revision = "4";
       editedCabalFile = "beff777d3390f1f927cf650ae4231f13e8f1d93fa5505fe7e8d337e356bd71b1";
       libraryHaskellDepends = [
         aeson base containers generic-aeson generic-deriving mtl scientific
         text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-utils attoparsec base bytestring generic-aeson tasty
         tasty-hunit tasty-th text vector
       ];
       jailbreak = true;
       description = "Types and type classes for defining JSON schemas";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-schema" = callPackage
    ({ mkDerivation, aeson, aeson-utils, attoparsec, base, bytestring
     , containers, generic-aeson, generic-deriving, mtl, scientific
     , tasty, tasty-hunit, tasty-th, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "json-schema";
       version = "0.7.4.1";
       sha256 = "560d6a17d6eab734f43d329e51967e3ed62f8df2a6fea4a92d06359fe77d7c96";
       revision = "3";
       editedCabalFile = "a919f70860dd9f379002ed0db301bbee85803dbf2661ae4c0d1f3045987f5233";
       libraryHaskellDepends = [
         aeson base containers generic-aeson generic-deriving mtl scientific
         text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-utils attoparsec base bytestring generic-aeson tasty
         tasty-hunit tasty-th text vector
       ];
       description = "Types and type classes for defining JSON schemas";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "json-sop" = callPackage
    ({ mkDerivation, aeson, base, generics-sop, lens-sop, tagged, text
     , time, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-sop";
       version = "0.2.0.0";
       sha256 = "2657ff212fa92b5a1cc1e36e85bee87807f7f33efb2c0d52f2967e001487ee02";
       libraryHaskellDepends = [
         aeson base generics-sop lens-sop tagged text time transformers
         unordered-containers vector
       ];
       description = "Generics JSON (de)serialization using generics-sop";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "json-state" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, libgit
     , time-units
     }:
     mkDerivation {
       pname = "json-state";
       version = "0.1.0.1";
       sha256 = "f10aa7fcf498ed25d6b90a616f0749d8089169e678116a01c3052780579d64f7";
       libraryHaskellDepends = [
         aeson aeson-pretty base bytestring libgit time-units
       ];
       homepage = "http://rel4tion.org/projects/json-state/";
       description = "Keep program state in JSON files";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "json-stream" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, doctest, hspec
     , QuickCheck, quickcheck-unicode, scientific, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-stream";
       version = "0.4.1.0";
       sha256 = "eaaec9b5f640203e2aa4d78988966440e24e8c76a97e25292db630cc51d3f497";
       libraryHaskellDepends = [
         aeson base bytestring scientific text unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bytestring directory doctest hspec QuickCheck
         quickcheck-unicode scientific text unordered-containers vector
       ];
       homepage = "https://github.com/ondrap/json-stream";
       description = "Incremental applicative JSON parser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "json-togo" = callPackage
    ({ mkDerivation, aeson, attoparsec, attoparsec-trans, base
     , bytestring, scientific, text, transformers, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "json-togo";
       version = "0.1.1.0";
       sha256 = "830224c0bf74c70a3c4035f432874348bb4d883a0027b94d9194321df66c802b";
       libraryHaskellDepends = [
         aeson attoparsec attoparsec-trans base bytestring scientific text
         transformers unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/srijs/haskell-json-togo";
       description = "Effectful parsing of JSON documents";
       license = stdenv.lib.licenses.mit;
     }) {};

  "json-tools" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , process, tar, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "json-tools";
       version = "0.5.0";
       sha256 = "6ee24c93da6d76e5b6024e53cac0360f36c4479a6d364debbb1e0440b0863e8e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson attoparsec base bytestring containers process tar text
         unordered-containers vector
       ];
       description = "A collection of JSON tools";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json-types" = callPackage
    ({ mkDerivation, base, containers, text }:
     mkDerivation {
       pname = "json-types";
       version = "0.1";
       sha256 = "b6e16d9417ece7f41a960e0793b925ec4918e31ea8046f96972d36b071721121";
       libraryHaskellDepends = [ base containers text ];
       description = "Basic types for representing JSON";
       license = stdenv.lib.licenses.mit;
     }) {};

  "json2" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers
     , json2-types, mtl, old-locale, parsec, pretty, time, utf8-string
     }:
     mkDerivation {
       pname = "json2";
       version = "0.8.3";
       sha256 = "289f98c84aab889762c0e1a57c26df07dfe3202f0d4b291114d9aee9d931fdf0";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers json2-types mtl old-locale
         parsec pretty time utf8-string
       ];
       description = "Library provides support for JSON";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json2-hdbc" = callPackage
    ({ mkDerivation, base, containers, HDBC, json2, json2-types, time
     , utf8-string
     }:
     mkDerivation {
       pname = "json2-hdbc";
       version = "0.5.1";
       sha256 = "b20db63e92693467de93b64adae747362b5c86e7d12558386369d4ea91818bba";
       libraryHaskellDepends = [
         base containers HDBC json2 json2-types time utf8-string
       ];
       description = "Support JSON for SQL Database";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "json2-types" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "json2-types";
       version = "0.1";
       sha256 = "f97ee727b721cf7b9d9775bc8cb97c19b4ce6b8d8b1b2e1547734364a2ab253f";
       libraryHaskellDepends = [ base containers ];
       description = "Defined JSON data types and function for renders JSON to string";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "json2yaml" = callPackage
    ({ mkDerivation, aeson, base, bytestring, yaml }:
     mkDerivation {
       pname = "json2yaml";
       version = "0.3.2.3";
       sha256 = "b6a5efda5ffcc0fcc2a644b6e7904ed2ad0fb46f811ac9fa1f3b95fcf3c3e9c6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ aeson base bytestring yaml ];
       homepage = "http://github.com/snoyberg/json2yaml/tree/master";
       description = "Utility to convert a file from JSON to YAML format. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "jsonresume" = callPackage
    ({ mkDerivation, aeson, base, bytestring, old-locale, text, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "jsonresume";
       version = "0.1.0.1";
       sha256 = "441dea0a84413c07ac51eebe70b63cd4f4653a2c0148b941cca90628170b7b92";
       libraryHaskellDepends = [
         aeson base bytestring old-locale text time unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/dpwright/jsonresume.hs";
       description = "Parser and datatypes for the JSON Resume format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jsonrpc-conduit" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, conduit
     , conduit-extra, hspec, mtl, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "jsonrpc-conduit";
       version = "0.3.0";
       sha256 = "9e2407e7a2f086d2d4c3ec7e8952a663bca6e487936d147cfb643dfcd1d1014e";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring conduit conduit-extra mtl text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring conduit conduit-extra hspec text
       ];
       description = "JSON-RPC 2.0 server over a Conduit.";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "jsonschema-gen" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, process
     , scientific, tagged, text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "jsonschema-gen";
       version = "0.3.0.1";
       sha256 = "4dec2d9f267920de58bc446e4c54ff56f42ff8002493aea5b5f64a188f320ca2";
       libraryHaskellDepends = [
         aeson base bytestring containers scientific tagged text time
         unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bytestring containers process tagged text
       ];
       jailbreak = true;
       homepage = "https://github.com/yuga/jsonschema-gen";
       description = "JSON Schema generator from Algebraic data type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "jsonsql" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , HUnit, optparse-applicative, scientific, string-qq, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "jsonsql";
       version = "0.1.2.1";
       sha256 = "93234e108034457f59e078cd2d6205a7ed4218262f0c7a39a91600e915b7966b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson attoparsec base bytestring containers HUnit
         optparse-applicative scientific string-qq text unordered-containers
         vector
       ];
       jailbreak = true;
       homepage = "https://github.com/danchoi/jsonsql";
       description = "Interpolate JSON object values into SQL strings";
       license = stdenv.lib.licenses.mit;
     }) {};

  "jsontsv" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , csv, optparse-applicative, scientific, string-qq, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "jsontsv";
       version = "0.1.5.0";
       sha256 = "85756b958fa6655fc3d438609a4e3dfe45715db91fccae7f1b2f144cc2863462";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson attoparsec base bytestring containers csv
         optparse-applicative scientific string-qq text unordered-containers
         vector
       ];
       jailbreak = true;
       homepage = "https://github.com/danchoi/jsontsv";
       description = "JSON to TSV transformer";
       license = stdenv.lib.licenses.mit;
     }) {};

  "jspath" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-trie, JSONb
     , utf8-string
     }:
     mkDerivation {
       pname = "jspath";
       version = "0.1";
       sha256 = "c7a2104a737035f72807f03e4a44f0ea7e238470901980f8180e2b776335581c";
       libraryHaskellDepends = [
         base bytestring bytestring-trie JSONb utf8-string
       ];
       description = "Extract substructures from JSON by following a path";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "judy" = callPackage
    ({ mkDerivation, base, bytestring, ghc-prim, hspec, Judy
     , QuickCheck
     }:
     mkDerivation {
       pname = "judy";
       version = "0.3.0";
       sha256 = "f483c31bcab0383a9db31ec41b527b3125e12ea302e126ec3ce45d2bb6a2cb9d";
       libraryHaskellDepends = [ base bytestring ghc-prim ];
       librarySystemDepends = [ Judy ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "http://github.com/mwotton/judy";
       description = "Fast, scalable, mutable dynamic arrays, maps and hashes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {Judy = null;};

  "jukebox" = callPackage
    ({ mkDerivation, alex, array, base, containers, directory, dlist
     , filepath, minisat, pretty, process, symbol, transformers
     , uglymemo
     }:
     mkDerivation {
       pname = "jukebox";
       version = "0.2.3";
       sha256 = "e57562e66b77b22f9297f5bc9e8c0e0fb00d6073f3ab0a04839284db5c6f67f9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers directory dlist filepath minisat pretty
         process symbol transformers uglymemo
       ];
       libraryToolDepends = [ alex ];
       executableHaskellDepends = [ base ];
       description = "A first-order reasoning toolbox";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "jumpthefive" = callPackage
    ({ mkDerivation, base, parallel }:
     mkDerivation {
       pname = "jumpthefive";
       version = "0.0.1";
       sha256 = "f436832dcb69748e532a7847531bbef357401bcb3adfc386edf2283a273cb77a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base parallel ];
       executableHaskellDepends = [ base parallel ];
       description = "an elementary symmetric chiffre for pragmatically protecting one's effects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "jvm-parser" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , data-binary-ieee754, fgl, fingertree, pretty, zlib
     }:
     mkDerivation {
       pname = "jvm-parser";
       version = "0.2.1";
       sha256 = "39eed730f80b4eaa7eab3a6e1f14833e2aea194c7453ac06c5d066af83eb1166";
       libraryHaskellDepends = [
         array base binary bytestring containers data-binary-ieee754 fgl
         fingertree pretty zlib
       ];
       description = "A parser for JVM bytecode files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "jwt" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , containers, cryptohash, data-default, http-types, HUnit, lens
     , lens-aeson, network, network-uri, QuickCheck, scientific
     , semigroups, tasty, tasty-hunit, tasty-quickcheck, tasty-th, text
     , time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "jwt";
       version = "0.6.0";
       sha256 = "1c18fac09a7f3c86e32f735f4e2bf1172601a7882f80d7527ef8e57cbe0dcb0a";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring containers cryptohash
         data-default http-types network network-uri scientific semigroups
         text time unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base base64-bytestring bytestring containers cryptohash
         data-default http-types HUnit lens lens-aeson network network-uri
         QuickCheck scientific semigroups tasty tasty-hunit tasty-quickcheck
         tasty-th text time unordered-containers vector
       ];
       doCheck = false;
       homepage = "https://bitbucket.org/ssaasen/haskell-jwt";
       description = "JSON Web Token (JWT) decoding and encoding";
       license = stdenv.lib.licenses.mit;
     }) {};

  "kademlia" = callPackage
    ({ mkDerivation, base, bytestring, containers, HUnit, mtl, network
     , QuickCheck, stm, tasty, tasty-hunit, tasty-quickcheck
     , transformers, transformers-compat
     }:
     mkDerivation {
       pname = "kademlia";
       version = "1.1.0.0";
       sha256 = "de03367642be75a42615414d26df1eb09861a807e49544aa6546d70533d55e72";
       libraryHaskellDepends = [
         base bytestring containers mtl network stm transformers
         transformers-compat
       ];
       testHaskellDepends = [
         base bytestring containers HUnit mtl network QuickCheck stm tasty
         tasty-hunit tasty-quickcheck transformers transformers-compat
       ];
       homepage = "https://github.com/froozen/kademlia";
       description = "An implementation of the Kademlia DHT Protocol";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "kafka-client" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, digest
     , dlist, hspec, hspec-discover, network, process, QuickCheck
     , snappy, temporary, time, zlib
     }:
     mkDerivation {
       pname = "kafka-client";
       version = "0.7.0.1";
       sha256 = "51b9180a78da95ad92a009165ad0bb068ec22374561fd70f6f79389af4d0e794";
       libraryHaskellDepends = [
         base bytestring cereal digest dlist network snappy time zlib
       ];
       testHaskellDepends = [
         base bytestring cereal containers hspec hspec-discover network
         process QuickCheck temporary time
       ];
       homepage = "https://github.com/abhinav/kafka-client";
       description = "Low-level Haskell client library for Apache Kafka 0.7.";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "kan-extensions_4_1_1" = callPackage
    ({ mkDerivation, adjunctions, array, base, comonad, containers
     , contravariant, distributive, free, mtl, pointed, semigroupoids
     , tagged, transformers
     }:
     mkDerivation {
       pname = "kan-extensions";
       version = "4.1.1";
       sha256 = "5959adbf3b3c0b23998eabbc0bf136859f7bb5f8a559eb11c01b6e29d819ff3c";
       revision = "1";
       editedCabalFile = "d9810fd1776711e2ed8d39698af5a971b2cb0005639d831e72cca0dc35a8a83e";
       libraryHaskellDepends = [
         adjunctions array base comonad containers contravariant
         distributive free mtl pointed semigroupoids tagged transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/kan-extensions/";
       description = "Kan extensions, Kan lifts, various forms of the Yoneda lemma, and (co)density (co)monads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kan-extensions_4_2" = callPackage
    ({ mkDerivation, adjunctions, array, base, comonad, containers
     , contravariant, distributive, free, mtl, semigroupoids, tagged
     , transformers
     }:
     mkDerivation {
       pname = "kan-extensions";
       version = "4.2";
       sha256 = "1d2675c28817ad8f691482741b9f6d619c02868486e686388b3568f3be4adfad";
       revision = "1";
       editedCabalFile = "9a79b987064b6cf73fba45b90f4a4eb843ebed8df0c99d5690b39bebf3d6ffe5";
       libraryHaskellDepends = [
         adjunctions array base comonad containers contravariant
         distributive free mtl semigroupoids tagged transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/kan-extensions/";
       description = "Kan extensions, Kan lifts, various forms of the Yoneda lemma, and (co)density (co)monads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kan-extensions_4_2_1" = callPackage
    ({ mkDerivation, adjunctions, array, base, comonad, containers
     , contravariant, distributive, free, mtl, semigroupoids, tagged
     , transformers
     }:
     mkDerivation {
       pname = "kan-extensions";
       version = "4.2.1";
       sha256 = "947fe2b7bc9d426620f59750310c12ca522f4fae6bcc6f744cf0072e6d80d553";
       revision = "1";
       editedCabalFile = "c0b1fdbd894c452f2658615bb14db240921b9ba5115f4f232d173ecbdae83ead";
       libraryHaskellDepends = [
         adjunctions array base comonad containers contravariant
         distributive free mtl semigroupoids tagged transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/kan-extensions/";
       description = "Kan extensions, Kan lifts, various forms of the Yoneda lemma, and (co)density (co)monads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kan-extensions_4_2_2" = callPackage
    ({ mkDerivation, adjunctions, array, base, comonad, containers
     , contravariant, distributive, free, mtl, semigroupoids, tagged
     , transformers
     }:
     mkDerivation {
       pname = "kan-extensions";
       version = "4.2.2";
       sha256 = "e51d6dd583045b22bcffe5d0054616f2da5880187e4d7261890d7d987fa61837";
       libraryHaskellDepends = [
         adjunctions array base comonad containers contravariant
         distributive free mtl semigroupoids tagged transformers
       ];
       homepage = "http://github.com/ekmett/kan-extensions/";
       description = "Kan extensions, Kan lifts, various forms of the Yoneda lemma, and (co)density (co)monads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kan-extensions" = callPackage
    ({ mkDerivation, adjunctions, array, base, comonad, containers
     , contravariant, distributive, free, mtl, semigroupoids, tagged
     , transformers
     }:
     mkDerivation {
       pname = "kan-extensions";
       version = "4.2.3";
       sha256 = "334f0edbbf08ebf93c9f7db5473086dcababc6a72d75fa9d8e43237f9b5adc47";
       libraryHaskellDepends = [
         adjunctions array base comonad containers contravariant
         distributive free mtl semigroupoids tagged transformers
       ];
       homepage = "http://github.com/ekmett/kan-extensions/";
       description = "Kan extensions, Kan lifts, various forms of the Yoneda lemma, and (co)density (co)monads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "kan-extensions_5_0_1" = callPackage
    ({ mkDerivation, adjunctions, array, base, comonad, containers
     , contravariant, distributive, free, mtl, semigroupoids, tagged
     , transformers
     }:
     mkDerivation {
       pname = "kan-extensions";
       version = "5.0.1";
       sha256 = "01de9fe57064a125ecb1d1161519df27043c2058ca246bbd5cd2d73c899ba0e2";
       libraryHaskellDepends = [
         adjunctions array base comonad containers contravariant
         distributive free mtl semigroupoids tagged transformers
       ];
       homepage = "http://github.com/ekmett/kan-extensions/";
       description = "Kan extensions, Kan lifts, various forms of the Yoneda lemma, and (co)density (co)monads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kangaroo" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "kangaroo";
       version = "0.4.0";
       sha256 = "dd8c9e43f2870cbe2b70c1b3b0d510b9bfdd8a05703cbcec78a2f50c5b38ebd0";
       libraryHaskellDepends = [ array base ];
       jailbreak = true;
       homepage = "http://code.google.com/p/copperbox/";
       description = "Binary parsing with random access";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kanji" = callPackage
    ({ mkDerivation, base, bytestring, containers, microlens, text }:
     mkDerivation {
       pname = "kanji";
       version = "1.0.0";
       sha256 = "fbee1da853ed627eed6236a1c33086a8ce4ae541fe070aa5ca4c3847928d0c2a";
       libraryHaskellDepends = [
         base bytestring containers microlens text
       ];
       homepage = "https://github.com/fosskers/nanq";
       description = "Perform 漢字検定 (National Kanji Exam) level analysis on Japanese Kanji";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "kansas-comet_0_3_1" = callPackage
    ({ mkDerivation, aeson, base, containers, data-default, scotty, stm
     , text, time, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "kansas-comet";
       version = "0.3.1";
       sha256 = "a16321948906376664deb3f1eb3cd6e9e7f7ef176149003b7c7156ca48bc6a75";
       libraryHaskellDepends = [
         aeson base containers data-default scotty stm text time
         transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/ku-fpg/kansas-comet/";
       description = "A JavaScript push mechanism based on the comet idiom";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kansas-comet" = callPackage
    ({ mkDerivation, aeson, base, containers, data-default-class
     , scotty, stm, text, time, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "kansas-comet";
       version = "0.4";
       sha256 = "1f1a4565f2e955b8947bafcb9611789b0ccdf9efdfed8aaa2a2aa162a07339e1";
       revision = "5";
       editedCabalFile = "4f00c7ffbc136b1d6176804ddd8214e169e13419ff6c81816e128784ef501cbd";
       libraryHaskellDepends = [
         aeson base containers data-default-class scotty stm text time
         transformers unordered-containers
       ];
       homepage = "https://github.com/ku-fpg/kansas-comet/";
       description = "A JavaScript push mechanism based on the comet idiom";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "kansas-lava" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, containers
     , data-default, data-reify, directory, dotgen, filepath, netlist
     , netlist-to-vhdl, process, random, sized-types, strict
     , template-haskell
     }:
     mkDerivation {
       pname = "kansas-lava";
       version = "0.2.4.3";
       sha256 = "3bf057340e4a1953e2eef099e26215cd99d4c595feab82cc43c6be1cbf2c5344";
       revision = "1";
       editedCabalFile = "7b1860125ab2958d3831cb2536a6b939879f09951199649182bb848e70b583eb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cmdargs containers data-default data-reify
         directory dotgen filepath netlist netlist-to-vhdl process random
         sized-types strict template-haskell
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://ittc.ku.edu/csdl/fpg/Tools/KansasLava";
       description = "Kansas Lava is a hardware simulator and VHDL generator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kansas-lava-cores" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, data-default
     , directory, filepath, kansas-lava, network, sized-types
     }:
     mkDerivation {
       pname = "kansas-lava-cores";
       version = "0.1.2.2";
       sha256 = "15502f0da60b224fc6b5a6fed21c2507c34ddbdbc51377736c3bc254186ad01c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base bytestring data-default directory filepath
         kansas-lava network sized-types
       ];
       executableHaskellDepends = [ base ];
       homepage = "http://ittc.ku.edu/csdl/fpg/Tools/KansasLava";
       description = "FPGA Cores Written in Kansas Lava";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kansas-lava-papilio" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, data-default
     , directory, filepath, kansas-lava, kansas-lava-cores, netlist
     , network, sized-types
     }:
     mkDerivation {
       pname = "kansas-lava-papilio";
       version = "0.3.1";
       sha256 = "1e805c00181d992744de32fce6a83bcd3c8f359c1572a03e5e4c1cfa7c740e59";
       libraryHaskellDepends = [
         ansi-terminal base bytestring data-default directory filepath
         kansas-lava kansas-lava-cores netlist network sized-types
       ];
       description = "Kansas Lava support files for the Papilio FPGA board";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kansas-lava-shake" = callPackage
    ({ mkDerivation, base, hastache, kansas-lava, shake, text }:
     mkDerivation {
       pname = "kansas-lava-shake";
       version = "0.2.0";
       sha256 = "34837e499a3007fb9eeb84e7c0bfd7c3c3d53e9cb84a8a8851e98b1c84f4f6a4";
       libraryHaskellDepends = [ base hastache kansas-lava shake text ];
       description = "Shake rules for building Kansas Lava projects";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "karakuri" = callPackage
    ({ mkDerivation, base, comonad, containers, minioperational, mtl
     , transformers
     }:
     mkDerivation {
       pname = "karakuri";
       version = "0.1.1";
       sha256 = "6c9ce1adae30c14d58ab8247efbf1fdedd8a6af45e9b271f59b9277c499f447b";
       libraryHaskellDepends = [
         base comonad containers minioperational mtl transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/fumieval/karakuri";
       description = "Good stateful automata";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "karver" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, hspec, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "karver";
       version = "0.1.2";
       sha256 = "21defef8ec665b7642e0b8b335389a05ca30483661fc0baaf16833a93a877d65";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring text unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base hspec text unordered-containers vector
       ];
       description = "A simple template engine, inspired by jinja2";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "katt" = callPackage
    ({ mkDerivation, aeson, base, bytestring, ConfigFile, containers
     , directory, errors, filepath, lens, mtl, parsec, text, url, wreq
     , zip-archive
     }:
     mkDerivation {
       pname = "katt";
       version = "0.2.0.3";
       sha256 = "0f56961a30d2c5e7aabc07f93a512d55aac5e6bed026ca0d3fe73f9ef21071c3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring ConfigFile containers directory errors
         filepath lens mtl parsec text url wreq zip-archive
       ];
       executableHaskellDepends = [ base bytestring mtl ];
       testHaskellDepends = [ base bytestring directory mtl ];
       jailbreak = true;
       homepage = "https://github.com/davnils/katt";
       description = "Client for the Kattis judge system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kazura-queue" = callPackage
    ({ mkDerivation, async, atomic-primops, base, containers, deepseq
     , doctest, exceptions, free, hspec, hspec-expectations, HUnit, mtl
     , primitive, QuickCheck, transformers
     }:
     mkDerivation {
       pname = "kazura-queue";
       version = "0.1.0.2";
       sha256 = "0ed0544bdfea6364acabaebb8e07ba36ee98dcf9c6afca4241e8f87613dddc7b";
       libraryHaskellDepends = [
         async atomic-primops base containers primitive
       ];
       testHaskellDepends = [
         async base containers deepseq doctest exceptions free hspec
         hspec-expectations HUnit mtl QuickCheck transformers
       ];
       homepage = "http://github.com/asakamirai/kazura-queue";
       description = "Fast concurrent queues much inspired by unagi-chan";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "kbq-gu" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "kbq-gu";
       version = "0.2";
       sha256 = "cf48b063dc5d647c9b51f216a9d412c68d86eb271871d438e977f149a90f7fea";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       homepage = "http://tcana.info/rpoku";
       description = "Rpoku spoken word programming language";
       license = "GPL";
     }) {};

  "kd-tree" = callPackage
    ({ mkDerivation, base, lens, linear, vector, vector-algorithms }:
     mkDerivation {
       pname = "kd-tree";
       version = "0.1.0";
       sha256 = "a7da66764e9e030d36a3d5dc10a718818b5b4fed9728a5cbfa5af497aea23c49";
       libraryHaskellDepends = [
         base lens linear vector vector-algorithms
       ];
       jailbreak = true;
       homepage = "http://github.com/bgamari/kd-tree";
       description = "A simple k-d tree implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "kdesrc-build-extra" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, cmdargs
     , directory, MissingH, parsec, process
     }:
     mkDerivation {
       pname = "kdesrc-build-extra";
       version = "0.1.0.2";
       sha256 = "d9961b2e8d2668804d3e864c039ec2f82d56a19496af05edd98f1ba1669429d8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base bytestring cmdargs directory MissingH parsec
         process
       ];
       jailbreak = true;
       description = "Build profiles for kdesrc-build";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "kdt_0_2_2" = callPackage
    ({ mkDerivation, base, deepseq, deepseq-generics, pqueue
     , QuickCheck
     }:
     mkDerivation {
       pname = "kdt";
       version = "0.2.2";
       sha256 = "7147d63c98c85481a95f3208ec1a52f622e3a4190a53b160e2ba16e53b0949ce";
       libraryHaskellDepends = [ base deepseq deepseq-generics pqueue ];
       testHaskellDepends = [ base deepseq deepseq-generics QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/giogadi/kdt";
       description = "Fast and flexible k-d trees for various types of point queries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kdt" = callPackage
    ({ mkDerivation, base, deepseq, deepseq-generics, heap, QuickCheck
     }:
     mkDerivation {
       pname = "kdt";
       version = "0.2.3";
       sha256 = "d387e3f98b7bd270ba972e649733b7badefbe75022f7278076d05a390aed1d32";
       libraryHaskellDepends = [ base deepseq deepseq-generics heap ];
       testHaskellDepends = [ base deepseq deepseq-generics QuickCheck ];
       homepage = "https://github.com/giogadi/kdt";
       description = "Fast and flexible k-d trees for various types of point queries";
       license = stdenv.lib.licenses.mit;
     }) {};

  "keera-callbacks" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "keera-callbacks";
       version = "0.1";
       sha256 = "38da91a06a3d243bf901853df29c1a797081e5d4750de4d1743619f5c178fdf5";
       libraryHaskellDepends = [ base mtl ];
       description = "Mutable memory locations with callbacks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "keera-hails-i18n" = callPackage
    ({ mkDerivation, base, directory, filepath, glib, hgettext
     , MissingK, setlocale, utf8-string
     }:
     mkDerivation {
       pname = "keera-hails-i18n";
       version = "0.0.3.3";
       sha256 = "9134831fd898a7a519556f7aec5879f24992cf2bbb698cb775d93aff7a15302a";
       libraryHaskellDepends = [
         base directory filepath glib hgettext MissingK setlocale
         utf8-string
       ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Rapid Gtk Application Development - I18N";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "keera-hails-mvc-controller" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "keera-hails-mvc-controller";
       version = "0.0.3.3";
       sha256 = "ebdb74680c84599849ccd7258c53cda8906c3628cc097279970343503f2b1903";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Haskell on Gtk rails - Gtk-based controller for MVC applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "keera-hails-mvc-environment-gtk" = callPackage
    ({ mkDerivation, base, keera-hails-mvc-model-protectedmodel
     , keera-hails-mvc-view, keera-hails-mvc-view-gtk
     }:
     mkDerivation {
       pname = "keera-hails-mvc-environment-gtk";
       version = "0.0.3.3";
       sha256 = "b9f2a9f1e0fd5ddba0729dd829be11389c4773fdf2388f6dad5b2fd4430a632e";
       libraryHaskellDepends = [
         base keera-hails-mvc-model-protectedmodel keera-hails-mvc-view
         keera-hails-mvc-view-gtk
       ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Haskell on Gtk rails - Gtk-based global environment for MVC applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keera-hails-mvc-model-lightmodel" = callPackage
    ({ mkDerivation, base, containers, keera-hails-reactivevalues
     , MissingK, stm, template-haskell
     }:
     mkDerivation {
       pname = "keera-hails-mvc-model-lightmodel";
       version = "0.0.3.4";
       sha256 = "208515f5cbcfb650db9b49e1ef5cb6e4970c676c941c73e792c86164e2bdb820";
       libraryHaskellDepends = [
         base containers keera-hails-reactivevalues MissingK stm
         template-haskell
       ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Rapid Gtk Application Development - Reactive Protected Light Models";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keera-hails-mvc-model-protectedmodel" = callPackage
    ({ mkDerivation, base, containers, keera-hails-reactivevalues
     , MissingK, stm, template-haskell
     }:
     mkDerivation {
       pname = "keera-hails-mvc-model-protectedmodel";
       version = "0.0.3.5";
       sha256 = "5db339932fecf5f91547d0daf8d12c777ce45df54d3edfe9fbf40e6942085592";
       libraryHaskellDepends = [
         base containers keera-hails-reactivevalues MissingK stm
         template-haskell
       ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Rapid Gtk Application Development - Protected Reactive Models";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keera-hails-mvc-solutions-config" = callPackage
    ({ mkDerivation, base, directory, filepath, MissingK }:
     mkDerivation {
       pname = "keera-hails-mvc-solutions-config";
       version = "0.0.3.3";
       sha256 = "a1a3e437e3f1052252a2f95afcbebc9ee9bb703ea20fddad205970ec0ab48699";
       libraryHaskellDepends = [ base directory filepath MissingK ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Haskell on Gtk rails - Easy handling of configuration files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "keera-hails-mvc-solutions-gtk" = callPackage
    ({ mkDerivation, base, gtk, hslogger, HTTP
     , keera-hails-mvc-environment-gtk
     , keera-hails-mvc-model-protectedmodel, keera-hails-mvc-view
     , keera-hails-mvc-view-gtk, keera-hails-reactivevalues, MissingK
     , mtl, network, network-uri, template-haskell
     }:
     mkDerivation {
       pname = "keera-hails-mvc-solutions-gtk";
       version = "0.0.3.4";
       sha256 = "b51a7461f3fb665fbf08e56ef5fc00fe52091baa38a53b3827bb6764edd75307";
       libraryHaskellDepends = [
         base gtk hslogger HTTP keera-hails-mvc-environment-gtk
         keera-hails-mvc-model-protectedmodel keera-hails-mvc-view
         keera-hails-mvc-view-gtk keera-hails-reactivevalues MissingK mtl
         network network-uri template-haskell
       ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Haskell on Gtk rails - Common solutions to recurrent problems in Gtk applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keera-hails-mvc-view" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "keera-hails-mvc-view";
       version = "0.0.3.3";
       sha256 = "17151bd00efff334fa5ec681cce35a793acdd185a14c6707fa45ad21f85d7c4a";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Haskell on Gtk rails - Generic View for MVC applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "keera-hails-mvc-view-gtk" = callPackage
    ({ mkDerivation, base, gtk, gtk-helpers, keera-hails-mvc-view }:
     mkDerivation {
       pname = "keera-hails-mvc-view-gtk";
       version = "0.0.3.3";
       sha256 = "9f744992c6cfba879f83e44f6c0b7b1cc707cfa30ff9f4980a03850c6a6ee4fb";
       libraryHaskellDepends = [
         base gtk gtk-helpers keera-hails-mvc-view
       ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Haskell on Gtk rails - Gtk-based View for MVC applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "keera-hails-reactive-fs" = callPackage
    ({ mkDerivation, base, directory, fsnotify
     , keera-hails-reactivevalues, system-filepath
     }:
     mkDerivation {
       pname = "keera-hails-reactive-fs";
       version = "0.0.3.4";
       sha256 = "9e1574e7c7ce070fe3440dc6404e46572718f2e2f68154eda2ad77042ea436fa";
       libraryHaskellDepends = [
         base directory fsnotify keera-hails-reactivevalues system-filepath
       ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Haskell on Rails - Files as Reactive Values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keera-hails-reactive-gtk" = callPackage
    ({ mkDerivation, base, bytestring, cairo, glib, gtk, gtk-helpers
     , keera-hails-reactivevalues, mtl, transformers
     }:
     mkDerivation {
       pname = "keera-hails-reactive-gtk";
       version = "0.3";
       sha256 = "7b647e929779e021a324864ad370998eafc47cbc985a181f84816bd2004c722c";
       libraryHaskellDepends = [
         base bytestring cairo glib gtk gtk-helpers
         keera-hails-reactivevalues mtl transformers
       ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Haskell on Gtk rails - Reactive Fields for Gtk widgets";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keera-hails-reactive-network" = callPackage
    ({ mkDerivation, base, keera-hails-reactivevalues, network }:
     mkDerivation {
       pname = "keera-hails-reactive-network";
       version = "0.0.3.3";
       sha256 = "4375703d2bee8e599f2a4ea30da436ed0f00a54cb31edd8e99c6dae2b76ce98c";
       libraryHaskellDepends = [
         base keera-hails-reactivevalues network
       ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Haskell on Rails - Sockets as Reactive Values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keera-hails-reactive-polling" = callPackage
    ({ mkDerivation, base, keera-callbacks, keera-hails-reactivevalues
     }:
     mkDerivation {
       pname = "keera-hails-reactive-polling";
       version = "0.0.3.3";
       sha256 = "0862e35b2987e79acc10d1e7c651327ec089180a079ad2842ede7892245c13ce";
       libraryHaskellDepends = [
         base keera-callbacks keera-hails-reactivevalues
       ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Haskell on Rails - Polling based Readable RVs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keera-hails-reactive-wx" = callPackage
    ({ mkDerivation, base, keera-hails-reactivevalues, wx, wxcore }:
     mkDerivation {
       pname = "keera-hails-reactive-wx";
       version = "0.0.3.3";
       sha256 = "7c95b6d4e5eb1fb584bcffe2e517b7b4818aa196a1358c42ce7664fe1cc6330a";
       libraryHaskellDepends = [
         base keera-hails-reactivevalues wx wxcore
       ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Haskell on Rails - Reactive Fields for WX widgets";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keera-hails-reactive-yampa" = callPackage
    ({ mkDerivation, base, keera-callbacks, keera-hails-reactivevalues
     , time, Yampa
     }:
     mkDerivation {
       pname = "keera-hails-reactive-yampa";
       version = "0.0.3.3";
       sha256 = "813ff459dbff0c042e1cdb64be67e8e7412d9bcb01427efd4b5c077653f63dd8";
       libraryHaskellDepends = [
         base keera-callbacks keera-hails-reactivevalues time Yampa
       ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Haskell on Rails - FRP Yampa Signal Functions as RVs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keera-hails-reactivelenses" = callPackage
    ({ mkDerivation, base, keera-hails-reactivevalues, lens }:
     mkDerivation {
       pname = "keera-hails-reactivelenses";
       version = "0.0.1";
       sha256 = "1dd8aaa86cef010f783f525cc7d1e49aa0c3e39926f89325ec7a638e0cd3e2b0";
       libraryHaskellDepends = [ base keera-hails-reactivevalues lens ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Reactive Haskell on Rails - Lenses applied to Reactive Values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keera-hails-reactivevalues" = callPackage
    ({ mkDerivation, base, contravariant, directory, filepath, hlint
     , HUnit, mtl, process, QuickCheck, regex-posix, tasty, tasty-hunit
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "keera-hails-reactivevalues";
       version = "0.2.2.0";
       sha256 = "27756d64d0b275d9556f0ffbefdad8e1bb9942f5fc17d585e6148cfc31496e8b";
       libraryHaskellDepends = [ base contravariant ];
       testHaskellDepends = [
         base directory filepath hlint HUnit mtl process QuickCheck
         regex-posix tasty tasty-hunit tasty-quickcheck
       ];
       homepage = "http://www.keera.es/blog/community/";
       description = "Haskell on Rails - Reactive Values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keera-posture" = callPackage
    ({ mkDerivation, allocated-processor, base, bytestring, cmdargs
     , containers, cv-combinators, directory, filepath, gio, glib, gtk
     , gtk-helpers, hgettext, HOpenCV, HTTP, IfElse, keera-hails-i18n
     , keera-hails-mvc-controller, keera-hails-mvc-environment-gtk
     , keera-hails-mvc-model-protectedmodel
     , keera-hails-mvc-solutions-config, keera-hails-mvc-solutions-gtk
     , keera-hails-mvc-view-gtk, keera-hails-reactive-gtk
     , keera-hails-reactivevalues, MissingK, mtl, network, process, SDL
     , SDL-mixer, SDL_mixer, setlocale, time, utf8-string
     }:
     mkDerivation {
       pname = "keera-posture";
       version = "0.2.3";
       sha256 = "ab35dd2ebf2cd49602cc47e40a35d79f3a2f113214689ad2306ac09d0aee6952";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         allocated-processor base bytestring cmdargs containers
         cv-combinators directory filepath gio glib gtk gtk-helpers hgettext
         HOpenCV HTTP IfElse keera-hails-i18n keera-hails-mvc-controller
         keera-hails-mvc-environment-gtk
         keera-hails-mvc-model-protectedmodel
         keera-hails-mvc-solutions-config keera-hails-mvc-solutions-gtk
         keera-hails-mvc-view-gtk keera-hails-reactive-gtk
         keera-hails-reactivevalues MissingK mtl network process SDL
         SDL-mixer setlocale time utf8-string
       ];
       executableSystemDepends = [ SDL_mixer ];
       homepage = "http://keera.co.uk/projects/keera-posture";
       description = "Get notifications when your sitting posture is inappropriate";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) SDL_mixer;};

  "keiretsu" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, async, base, bytestring
     , conduit, conduit-extra, directory, filepath, hslogger, network
     , optparse-applicative, process, text, unix, unordered-containers
     , yaml
     }:
     mkDerivation {
       pname = "keiretsu";
       version = "0.4.4";
       sha256 = "69098f3227a34abc55b13abe920dafa5adce2c9168ed5ede8db611b055d79c2f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson ansi-terminal async base bytestring conduit conduit-extra
         directory filepath hslogger network optparse-applicative process
         text unix unordered-containers yaml
       ];
       jailbreak = true;
       description = "Multi-process orchestration for development and integration testing";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keter_1_3_6" = callPackage
    ({ mkDerivation, aeson, array, async, attoparsec, base
     , blaze-builder, bytestring, case-insensitive, conduit
     , conduit-extra, containers, data-default, directory, filepath
     , fsnotify, hspec, http-client, http-conduit, http-reverse-proxy
     , http-types, lifted-base, mtl, network, network-conduit-tls
     , process, random, regex-tdfa, stm, system-fileio, system-filepath
     , tar, template-haskell, text, time, transformers, unix
     , unix-compat, unordered-containers, vector, wai, wai-app-static
     , wai-extra, warp, warp-tls, yaml, zlib
     }:
     mkDerivation {
       pname = "keter";
       version = "1.3.6";
       sha256 = "e9c4b16fc6dca967a6a10c82c5f5c89900df10e27f93316d1a730ef9d523e301";
       revision = "2";
       editedCabalFile = "793f63a47c529acca895b3ca0225b2058f6175cb83af62c169267e62f6c28f60";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array async attoparsec base blaze-builder bytestring
         case-insensitive conduit conduit-extra containers data-default
         directory filepath fsnotify http-client http-conduit
         http-reverse-proxy http-types lifted-base mtl network
         network-conduit-tls process random regex-tdfa stm system-fileio
         system-filepath tar template-haskell text time transformers unix
         unix-compat unordered-containers vector wai wai-app-static
         wai-extra warp warp-tls yaml zlib
       ];
       executableHaskellDepends = [
         base bytestring data-default directory http-types system-filepath
         transformers wai wai-extra warp
       ];
       testHaskellDepends = [
         base bytestring conduit hspec transformers unix
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Web application deployment manager, focusing on Haskell web frameworks";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keter_1_3_7" = callPackage
    ({ mkDerivation, aeson, array, async, attoparsec, base
     , blaze-builder, bytestring, case-insensitive, conduit
     , conduit-extra, containers, data-default, directory, filepath
     , fsnotify, hspec, http-client, http-conduit, http-reverse-proxy
     , http-types, lifted-base, mtl, network, network-conduit-tls
     , process, random, regex-tdfa, stm, system-fileio, system-filepath
     , tar, template-haskell, text, time, transformers, unix
     , unix-compat, unordered-containers, vector, wai, wai-app-static
     , wai-extra, warp, warp-tls, yaml, zlib
     }:
     mkDerivation {
       pname = "keter";
       version = "1.3.7";
       sha256 = "a0710bf072a8829f5e696a6cf760554b26006d520f311ae29a53bf46e96f98c3";
       revision = "3";
       editedCabalFile = "97b84a04bdbef02b95c502f4a4e27791dc3a6e10f40a4797cf267311be1c6875";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array async attoparsec base blaze-builder bytestring
         case-insensitive conduit conduit-extra containers data-default
         directory filepath fsnotify http-client http-conduit
         http-reverse-proxy http-types lifted-base mtl network
         network-conduit-tls process random regex-tdfa stm system-fileio
         system-filepath tar template-haskell text time transformers unix
         unix-compat unordered-containers vector wai wai-app-static
         wai-extra warp warp-tls yaml zlib
       ];
       executableHaskellDepends = [
         base bytestring data-default directory http-types system-filepath
         transformers wai wai-extra warp
       ];
       testHaskellDepends = [
         base bytestring conduit hspec transformers unix
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Web application deployment manager, focusing on Haskell web frameworks";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keter_1_3_7_1" = callPackage
    ({ mkDerivation, aeson, array, async, attoparsec, base
     , blaze-builder, bytestring, case-insensitive, conduit
     , conduit-extra, containers, data-default, directory, filepath
     , fsnotify, hspec, http-client, http-conduit, http-reverse-proxy
     , http-types, lifted-base, mtl, network, network-conduit-tls
     , process, random, regex-tdfa, stm, system-fileio, system-filepath
     , tar, template-haskell, text, time, transformers, unix
     , unix-compat, unordered-containers, vector, wai, wai-app-static
     , wai-extra, warp, warp-tls, yaml, zlib
     }:
     mkDerivation {
       pname = "keter";
       version = "1.3.7.1";
       sha256 = "003ce327d5b8ce407df901b46a99a37109b2ce14d6f51e50212130ba5ed9843e";
       revision = "3";
       editedCabalFile = "a534637676d741ad4b3a5c0ba745df72206f16008e52ed037cc7de8cb4db2556";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array async attoparsec base blaze-builder bytestring
         case-insensitive conduit conduit-extra containers data-default
         directory filepath fsnotify http-client http-conduit
         http-reverse-proxy http-types lifted-base mtl network
         network-conduit-tls process random regex-tdfa stm system-fileio
         system-filepath tar template-haskell text time transformers unix
         unix-compat unordered-containers vector wai wai-app-static
         wai-extra warp warp-tls yaml zlib
       ];
       executableHaskellDepends = [
         base bytestring data-default directory http-types system-filepath
         transformers wai wai-extra warp
       ];
       testHaskellDepends = [
         base bytestring conduit hspec transformers unix
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Web application deployment manager, focusing on Haskell web frameworks";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keter_1_3_8" = callPackage
    ({ mkDerivation, aeson, array, async, attoparsec, base
     , blaze-builder, bytestring, case-insensitive, conduit
     , conduit-extra, containers, data-default, directory, filepath
     , fsnotify, hspec, http-client, http-conduit, http-reverse-proxy
     , http-types, HUnit, lifted-base, mtl, network, network-conduit-tls
     , process, random, regex-tdfa, stm, system-fileio, system-filepath
     , tar, template-haskell, text, time, transformers, unix
     , unix-compat, unordered-containers, vector, wai, wai-app-static
     , wai-extra, warp, warp-tls, yaml, zlib
     }:
     mkDerivation {
       pname = "keter";
       version = "1.3.8";
       sha256 = "fc985c21edd9d3298849e1036e9a8784ac96aa3d5a6ec244b34593a6d08c4884";
       revision = "1";
       editedCabalFile = "75776bcb557bb2a5c622731a009bd8058706f36b5207ae3cfdcd9412ad406099";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array async attoparsec base blaze-builder bytestring
         case-insensitive conduit conduit-extra containers data-default
         directory filepath fsnotify http-client http-conduit
         http-reverse-proxy http-types lifted-base mtl network
         network-conduit-tls process random regex-tdfa stm system-fileio
         system-filepath tar template-haskell text time transformers unix
         unix-compat unordered-containers vector wai wai-app-static
         wai-extra warp warp-tls yaml zlib
       ];
       executableHaskellDepends = [ base data-default system-filepath ];
       testHaskellDepends = [
         base bytestring conduit hspec HUnit transformers unix
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Web application deployment manager, focusing on Haskell web frameworks";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keter_1_3_9_1" = callPackage
    ({ mkDerivation, aeson, array, async, attoparsec, base
     , blaze-builder, bytestring, case-insensitive, conduit
     , conduit-extra, containers, data-default, directory, filepath
     , fsnotify, hspec, http-client, http-conduit, http-reverse-proxy
     , http-types, HUnit, lifted-base, mtl, network, network-conduit-tls
     , process, random, regex-tdfa, stm, system-fileio, system-filepath
     , tar, template-haskell, text, time, transformers, unix
     , unix-compat, unordered-containers, vector, wai, wai-app-static
     , wai-extra, warp, warp-tls, yaml, zlib
     }:
     mkDerivation {
       pname = "keter";
       version = "1.3.9.1";
       sha256 = "e9bd0bb381193e383e7b382fc55945daead888148d3b84301198649fe471062d";
       revision = "1";
       editedCabalFile = "80fca9788f8694510909a239f3ad8902645527b6b84c81ae10c198d8cc6981c4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array async attoparsec base blaze-builder bytestring
         case-insensitive conduit conduit-extra containers data-default
         directory filepath fsnotify http-client http-conduit
         http-reverse-proxy http-types lifted-base mtl network
         network-conduit-tls process random regex-tdfa stm system-fileio
         system-filepath tar template-haskell text time transformers unix
         unix-compat unordered-containers vector wai wai-app-static
         wai-extra warp warp-tls yaml zlib
       ];
       executableHaskellDepends = [ base data-default system-filepath ];
       testHaskellDepends = [
         base bytestring conduit hspec HUnit transformers unix
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Web application deployment manager, focusing on Haskell web frameworks";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keter_1_3_9_2" = callPackage
    ({ mkDerivation, aeson, array, async, attoparsec, base
     , blaze-builder, bytestring, case-insensitive, conduit
     , conduit-extra, containers, data-default, directory, filepath
     , fsnotify, hspec, http-client, http-conduit, http-reverse-proxy
     , http-types, HUnit, lifted-base, mtl, network, process, random
     , regex-tdfa, stm, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, unix, unix-compat
     , unordered-containers, vector, wai, wai-app-static, wai-extra
     , warp, warp-tls, yaml, zlib
     }:
     mkDerivation {
       pname = "keter";
       version = "1.3.9.2";
       sha256 = "99c8cfff445a4f4a99290170aba0afd81da687519c056b0b3326f9c626d3b0b0";
       revision = "1";
       editedCabalFile = "8fca5e98766f971e19a05cf3b562ba18da55c32a0a741f7555a385e1315266fd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array async attoparsec base blaze-builder bytestring
         case-insensitive conduit conduit-extra containers data-default
         directory filepath fsnotify http-client http-conduit
         http-reverse-proxy http-types lifted-base mtl network process
         random regex-tdfa stm system-fileio system-filepath tar
         template-haskell text time transformers unix unix-compat
         unordered-containers vector wai wai-app-static wai-extra warp
         warp-tls yaml zlib
       ];
       executableHaskellDepends = [ base data-default system-filepath ];
       testHaskellDepends = [
         base bytestring conduit hspec HUnit transformers unix
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Web application deployment manager, focusing on Haskell web frameworks";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keter_1_3_10_1" = callPackage
    ({ mkDerivation, aeson, array, async, attoparsec, base
     , blaze-builder, bytestring, case-insensitive, conduit
     , conduit-extra, containers, data-default, directory, filepath
     , fsnotify, hspec, http-client, http-conduit, http-reverse-proxy
     , http-types, HUnit, lifted-base, mtl, network, process, random
     , regex-tdfa, stm, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, unix, unix-compat
     , unordered-containers, vector, wai, wai-app-static, wai-extra
     , warp, warp-tls, yaml, zlib
     }:
     mkDerivation {
       pname = "keter";
       version = "1.3.10.1";
       sha256 = "f9e87d84a3a205a69c5ca4b6cc208eb4f1af299f5e589c26b5b89722c0031eaf";
       revision = "1";
       editedCabalFile = "fa11261e1f473e74ad0108acefbc16c23b4dd484d7e4b019a3e4d43312bb778e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array async attoparsec base blaze-builder bytestring
         case-insensitive conduit conduit-extra containers data-default
         directory filepath fsnotify http-client http-conduit
         http-reverse-proxy http-types lifted-base mtl network process
         random regex-tdfa stm system-fileio system-filepath tar
         template-haskell text time transformers unix unix-compat
         unordered-containers vector wai wai-app-static wai-extra warp
         warp-tls yaml zlib
       ];
       executableHaskellDepends = [ base data-default system-filepath ];
       testHaskellDepends = [
         base bytestring conduit hspec HUnit transformers unix
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Web application deployment manager, focusing on Haskell web frameworks";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keter" = callPackage
    ({ mkDerivation, aeson, array, async, attoparsec, base
     , blaze-builder, bytestring, case-insensitive, conduit
     , conduit-extra, containers, data-default, directory, filepath
     , fsnotify, hspec, http-client, http-conduit, http-reverse-proxy
     , http-types, HUnit, lifted-base, mtl, network, process, random
     , regex-tdfa, stm, tar, template-haskell, text, time, transformers
     , unix, unix-compat, unordered-containers, vector, wai
     , wai-app-static, wai-extra, warp, warp-tls, yaml, zlib
     }:
     mkDerivation {
       pname = "keter";
       version = "1.4.3.1";
       sha256 = "1111d0f97dc36e84c041f34176d652911a1e7b9c48943533835ac73ccf37582f";
       revision = "1";
       editedCabalFile = "197ee783d18b293bb5fbe286623ca588695ec2115a012c3547535702fafc571f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array async attoparsec base blaze-builder bytestring
         case-insensitive conduit conduit-extra containers data-default
         directory filepath fsnotify http-client http-conduit
         http-reverse-proxy http-types lifted-base mtl network process
         random regex-tdfa stm tar template-haskell text time transformers
         unix unix-compat unordered-containers vector wai wai-app-static
         wai-extra warp warp-tls yaml zlib
       ];
       executableHaskellDepends = [ base data-default filepath ];
       testHaskellDepends = [
         base bytestring conduit hspec HUnit transformers unix
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Web application deployment manager, focusing on Haskell web frameworks";
       license = stdenv.lib.licenses.mit;
     }) {};

  "kevin" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , cprng-aes, damnpacket, data-default, exceptions, HTTP, lens, mtl
     , network, regex-pcre-builtin, stm, text, time, tls, tls-extra
     }:
     mkDerivation {
       pname = "kevin";
       version = "0.11.0";
       sha256 = "21f3e784c1d61b5b96268550de7452e97cafd1d11649e0d63ca8214848830f02";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base bytestring containers cprng-aes damnpacket
         data-default exceptions HTTP lens mtl network regex-pcre-builtin
         stm text time tls tls-extra
       ];
       description = "a dAmn ↔ IRC proxy";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keycode_0_1" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "keycode";
       version = "0.1";
       sha256 = "fb2efe1e2b85a638f784c6739533aaf5f52a6ad61f6ab6468d4fe1feab4992b3";
       revision = "1";
       editedCabalFile = "ae7140460eef7a9df0ba104ef06004cbfa6274282ec85eee26ae3d0e5c1b402c";
       libraryHaskellDepends = [ base containers ];
       homepage = "https://github.com/RyanGlScott/keycode";
       description = "Maps web browser keycodes to their corresponding keyboard keys";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keycode" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "keycode";
       version = "0.1.1";
       sha256 = "7db8ed3fb0ccfbf9cb98124a3585e883a65a93c320e2573df6bd28089276435e";
       revision = "1";
       editedCabalFile = "0f1d9c1425d12dca378d47830e034f179e444584599934d8e360b298b780645c";
       libraryHaskellDepends = [ base containers ];
       homepage = "https://github.com/RyanGlScott/keycode";
       description = "Maps web browser keycodes to their corresponding keyboard keys";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "keyed" = callPackage
    ({ mkDerivation, base, containers, vector }:
     mkDerivation {
       pname = "keyed";
       version = "0.3.0.0";
       sha256 = "b85cbba508e47c61bc49a3651068f7a86285501bbe0af66d90bb2eb5c8b6a360";
       libraryHaskellDepends = [ base containers vector ];
       homepage = "https://github.com/wyager/keyed";
       description = "Generic indexing for many data structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "keyring" = callPackage
    ({ mkDerivation, base, udbus }:
     mkDerivation {
       pname = "keyring";
       version = "0.1.0.4";
       sha256 = "2ddbfe06b0cdbd888c5e2e420e698d746fd3f98ce9ba4f6cc3594f7db2f5f6c8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base udbus ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/lunaryorn/haskell-keyring";
       description = "Keyring access";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keys_3_10_1" = callPackage
    ({ mkDerivation, array, base, comonad, containers, free
     , semigroupoids, semigroups, transformers
     }:
     mkDerivation {
       pname = "keys";
       version = "3.10.1";
       sha256 = "9644f4aeb3744cfe46c59712bb5396554eb06527ec67cdf563c116abdc5df400";
       libraryHaskellDepends = [
         array base comonad containers free semigroupoids semigroups
         transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/keys/";
       description = "Keyed functors and containers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keys_3_10_2" = callPackage
    ({ mkDerivation, array, base, comonad, containers, free, hashable
     , semigroupoids, semigroups, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "keys";
       version = "3.10.2";
       sha256 = "425f1ee508efd371220d2eae4d81be1423797968af2387a2a83b937fb186bef6";
       libraryHaskellDepends = [
         array base comonad containers free hashable semigroupoids
         semigroups transformers unordered-containers
       ];
       homepage = "http://github.com/ekmett/keys/";
       description = "Keyed functors and containers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keys" = callPackage
    ({ mkDerivation, array, base, comonad, containers, free, hashable
     , semigroupoids, semigroups, transformers, transformers-compat
     , unordered-containers
     }:
     mkDerivation {
       pname = "keys";
       version = "3.11";
       sha256 = "0cf397b7e6eb8cda930a02118c0bf262f9ef80c5a2f91822238b7778042cc4b2";
       revision = "1";
       editedCabalFile = "b1a0c0d734a3dba396f4df1418e521da6f2287a56ed344ddda78d6133d27cfd3";
       libraryHaskellDepends = [
         array base comonad containers free hashable semigroupoids
         semigroups transformers transformers-compat unordered-containers
       ];
       homepage = "http://github.com/ekmett/keys/";
       description = "Keyed functors and containers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "keystore" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, ansi-wl-pprint, api-tools
     , asn1-encoding, asn1-types, base, base64-bytestring, byteable
     , bytestring, cipher-aes, containers, crypto-pubkey, crypto-random
     , directory, filepath, lens, mtl, old-locale, optparse-applicative
     , pbkdf, process, raw-strings-qq, regex-compat-tdfa, safe, setenv
     , text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "keystore";
       version = "0.8.0.0";
       sha256 = "45c57cffd3690fc3c20531645eca8bda86a8c6b4cbf6e40f80cb4f874ecb9e12";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty ansi-wl-pprint api-tools asn1-encoding
         asn1-types base base64-bytestring byteable bytestring cipher-aes
         containers crypto-pubkey crypto-random directory filepath lens mtl
         old-locale optparse-applicative pbkdf regex-compat-tdfa safe setenv
         text time unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson ansi-wl-pprint api-tools base bytestring directory filepath
         mtl optparse-applicative process raw-strings-qq setenv text
         unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/cdornan/keystore";
       description = "Managing stores of secret things";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "keyvaluehash" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, derive, directory
     , filepath, hashable, mmap, storable-record
     }:
     mkDerivation {
       pname = "keyvaluehash";
       version = "0.3.1.2";
       sha256 = "f49da00974d20f22cb7cc528718432b31a859fd3825ad33ffc12f7d01d23f0be";
       libraryHaskellDepends = [
         array base binary bytestring derive directory filepath hashable
         mmap storable-record
       ];
       description = "Pure Haskell key/value store implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "keyword-args" = callPackage
    ({ mkDerivation, base, bytestring, cassava, containers, hspec
     , parsec, parseerror-eq
     }:
     mkDerivation {
       pname = "keyword-args";
       version = "0.2.0.2";
       sha256 = "5d92ce609e8927566da40d3735b5a4fe94a0425455d0567fafe73402101592a1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers parsec ];
       executableHaskellDepends = [
         base bytestring cassava containers parsec
       ];
       testHaskellDepends = [
         base containers hspec parsec parseerror-eq
       ];
       homepage = "https://github.com/stackbuilders/keyword-args";
       description = "Extract data from a keyword-args config file format";
       license = stdenv.lib.licenses.mit;
     }) {};

  "kibro" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "kibro";
       version = "0.5.0";
       sha256 = "9a3665c0f98d0e84ba2e3eea61011101687158b743b16bb8b8c382ef25e9de79";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "kicad-data" = callPackage
    ({ mkDerivation, base, ieee754, lens-family, parsec, parsec-numbers
     , pretty-compact, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "kicad-data";
       version = "0.3.0.0";
       sha256 = "6270a5f62dad9920ca169c1c8867f6ba0d2d36e64299cada90d526b4c73d3ee7";
       libraryHaskellDepends = [
         base ieee754 lens-family parsec parsec-numbers pretty-compact
       ];
       testHaskellDepends = [
         base ieee754 lens-family parsec parsec-numbers pretty-compact
         QuickCheck test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/kasbah/haskell-kicad-data";
       description = "Parser and writer for KiCad files";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kickass-torrents-dump-parser" = callPackage
    ({ mkDerivation, base, bytestring, cassava, hspec
     , hspec-expectations, string-qq, text, vector
     }:
     mkDerivation {
       pname = "kickass-torrents-dump-parser";
       version = "0.0.1";
       sha256 = "9393792a8e26ffd2a899fa6eabc5d2464b04de0067fa6fa95212745df6011baf";
       libraryHaskellDepends = [ base bytestring cassava text vector ];
       testHaskellDepends = [
         base bytestring cassava hspec hspec-expectations string-qq text
         vector
       ];
       jailbreak = true;
       description = "Parses kat.ph torrent dumps";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kickchan" = callPackage
    ({ mkDerivation, base, containers, HUnit, primitive, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , vector
     }:
     mkDerivation {
       pname = "kickchan";
       version = "0.1.0.4";
       sha256 = "c70287e1679793b766b4e02b5843435fe4339d871ee67406abe588fa4443b7be";
       libraryHaskellDepends = [ base containers primitive vector ];
       testHaskellDepends = [
         base containers HUnit primitive QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 vector
       ];
       homepage = "https://github.com/JohnLato/kickchan";
       description = "Kick Channels: bounded channels with non-blocking writes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "kif-parser" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, hostname, old-time
     , parsec, twine
     }:
     mkDerivation {
       pname = "kif-parser";
       version = "0.0.3";
       sha256 = "73744691ffb8561317311dde8967d0d4edee4fabdf805ab1638f5544495b0ab5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs hostname old-time parsec twine
       ];
       description = "Process KIF iOS test logs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kinds" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "kinds";
       version = "0.0.1.5";
       sha256 = "e5893d8a0fe0f73f74737309821db4da5c01631d4b17663497b31e6bc1122e99";
       libraryHaskellDepends = [ base ];
       homepage = "http://darcs.wolfgang.jeltsch.info/haskell/kinds";
       description = "Emulation of subkinds and subkind polymorphism";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "kit" = callPackage
    ({ mkDerivation, ansi-terminal, attoparsec, base, cabal-file-th
     , cmdargs, containers, directory, errors, filepath, Glob, mtl
     , process, text, unix, unordered-containers, yaml
     }:
     mkDerivation {
       pname = "kit";
       version = "0.7.12";
       sha256 = "3c6ec5721ee0f32fec8b11a73c49ceed1a93354307600a804aedafa365d8a714";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal attoparsec base cabal-file-th cmdargs containers
         directory errors filepath Glob mtl process text unix
         unordered-containers yaml
       ];
       homepage = "http://github.com/nkpart/kit";
       description = "A dependency manager for Xcode (Objective-C) projects";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kmeans" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "kmeans";
       version = "0.1.3";
       sha256 = "3d9e24a12ce01354c2a731ee079144c3bea2c9f011ffd51db82e5c26da1a2c0b";
       libraryHaskellDepends = [ base ];
       description = "K-means clustering algorithm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "kmeans-par" = callPackage
    ({ mkDerivation, base, hspec, metric, normaldistribution, parallel
     , QuickCheck, semigroups, vector
     }:
     mkDerivation {
       pname = "kmeans-par";
       version = "1.5.1";
       sha256 = "2c19fbd9e353d8ba20b215ea31bc03c85b755cb6170392e8d37e4bea520eff20";
       libraryHaskellDepends = [ base metric parallel semigroups vector ];
       testHaskellDepends = [
         base hspec metric normaldistribution parallel QuickCheck semigroups
         vector
       ];
       description = "Sequential and parallel implementations of Lloyd's algorithm";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kmeans-vector" = callPackage
    ({ mkDerivation, base, mtl, probable, vector }:
     mkDerivation {
       pname = "kmeans-vector";
       version = "0.3.2";
       sha256 = "bb2d34b3681d3e86b9b829f85163c5ad49a7ca20d034c6015def63ce6b1b7cb2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl vector ];
       executableHaskellDepends = [ base probable vector ];
       homepage = "http://github.com/alpmestan/kmeans-vector";
       description = "An implementation of the kmeans clustering algorithm based on the vector package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "knob" = callPackage
    ({ mkDerivation, base, bytestring, transformers }:
     mkDerivation {
       pname = "knob";
       version = "0.1.1";
       sha256 = "8c2c84cfa20f3a2d7ca0636d2b3f2822c62501358075bfa356eb964b803e1217";
       libraryHaskellDepends = [ base bytestring transformers ];
       homepage = "https://john-millikin.com/software/knob/";
       description = "Memory-backed handles";
       license = stdenv.lib.licenses.mit;
     }) {};

  "knots" = callPackage
    ({ mkDerivation, array, base, containers, data-default, deepseq
     , mtl, parallel, vector, yap
     }:
     mkDerivation {
       pname = "knots";
       version = "0.1.0.1";
       sha256 = "04811f9a7daa8fc3b3035f5aa7d8516e7349fafafa2ad30c94372ae4ec3362fb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers data-default deepseq mtl parallel vector yap
       ];
       executableHaskellDepends = [ base containers parallel ];
       jailbreak = true;
       description = "Khovanov homology computations";
       license = stdenv.lib.licenses.mit;
     }) {};

  "koellner-phonetic" = callPackage
    ({ mkDerivation, base, HUnit }:
     mkDerivation {
       pname = "koellner-phonetic";
       version = "0.0";
       sha256 = "6f26961a1cb19c549c8071e51de821283ba9c9d2c2955fb0b7c127a2f75bef64";
       libraryHaskellDepends = [ base HUnit ];
       testHaskellDepends = [ base HUnit ];
       doHaddock = false;
       description = "\"map German words to code representing pronunciation\"";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kontrakcja-templates" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, hslogger
     , HStringTemplate, html, HUnit, MissingH, mtl, old-time, parsec
     , string-templates, syb, test-framework, test-framework-hunit
     , test-framework-quickcheck2, time, transformers, utf8-string
     }:
     mkDerivation {
       pname = "kontrakcja-templates";
       version = "0.1";
       sha256 = "48a6e6138592e56eed9ab28254fa2bdff68d037f7ca7b546635df54640631b08";
       libraryHaskellDepends = [
         base bytestring containers directory HStringTemplate html MissingH
         mtl old-time parsec transformers utf8-string
       ];
       testHaskellDepends = [
         base containers directory hslogger HStringTemplate HUnit MissingH
         mtl old-time string-templates syb test-framework
         test-framework-hunit test-framework-quickcheck2 time
       ];
       jailbreak = true;
       description = "Utilities for working with many HStringTemplate templates from files";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {string-templates = null;};

  "koofr-client" = callPackage
    ({ mkDerivation, aeson, base, bytestring, filepath, http-client
     , http-client-tls, http-types, mtl
     }:
     mkDerivation {
       pname = "koofr-client";
       version = "1.0.0.3";
       sha256 = "2ab6f0af8be4f1912ad06ad860db993f9c33c8f0206f87ff0b566b7dda54e7af";
       libraryHaskellDepends = [
         aeson base bytestring filepath http-client http-client-tls
         http-types mtl
       ];
       homepage = "https://github.com/edofic/koofr-api-hs";
       description = "Client to Koofr API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "korfu" = callPackage
    ({ mkDerivation, base, bio, bytestring, haskell98, simpleargs }:
     mkDerivation {
       pname = "korfu";
       version = "0.2";
       sha256 = "9f036ee1c568bf1cecc1467e161b837e2886074a686ec3b85aa7503f906b96d7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bio bytestring haskell98 simpleargs
       ];
       homepage = "http://blog.malde.org/";
       description = "The Korfu ORF Utility";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kqueue" = callPackage
    ({ mkDerivation, base, c2hs, directory, filepath, mtl, time, unix
     }:
     mkDerivation {
       pname = "kqueue";
       version = "0.1.2.6";
       sha256 = "e851243826ecadda865809289d6f6921483ab5fed54f9d12453277dd355445e0";
       libraryHaskellDepends = [ base directory filepath mtl time unix ];
       libraryToolDepends = [ c2hs ];
       jailbreak = true;
       homepage = "http://github.com/hesselink/kqueue";
       description = "A binding to the kqueue event library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kraken" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-client
     , http-client-tls, mtl
     }:
     mkDerivation {
       pname = "kraken";
       version = "0.0.1";
       sha256 = "227f6e535ef40cdad52efbcf412126b9a90494648bd824e7f8eec3cc8b79c6b5";
       libraryHaskellDepends = [
         aeson base bytestring http-client http-client-tls mtl
       ];
       description = "Kraken.io API client";
       license = stdenv.lib.licenses.mit;
     }) {};

  "krpc" = callPackage
    ({ mkDerivation, base, bencoding, bytestring, containers
     , data-default-class, hspec, lifted-base, monad-control
     , monad-logger, mtl, network, QuickCheck, quickcheck-instances
     , text, transformers
     }:
     mkDerivation {
       pname = "krpc";
       version = "0.6.1.0";
       sha256 = "49f45d457b2c63e12b6115c735f87b0d99e738ab4e6b198797e43a081579b051";
       libraryHaskellDepends = [
         base bencoding bytestring containers data-default-class lifted-base
         monad-control monad-logger mtl network text transformers
       ];
       testHaskellDepends = [
         base bencoding bytestring hspec monad-logger mtl network QuickCheck
         quickcheck-instances
       ];
       homepage = "https://github.com/cobit/krpc";
       description = "KRPC protocol implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ks-test" = callPackage
    ({ mkDerivation, base, gamma, random-fu, roots, vector }:
     mkDerivation {
       pname = "ks-test";
       version = "0.1";
       sha256 = "d537aa3d9e92079954403025da0fe00711d8d03dc6d13cbab279681eb95d49f6";
       libraryHaskellDepends = [ base gamma random-fu roots vector ];
       description = "Kolmogorov distribution and Kolmogorov-Smirnov test";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "ktx" = callPackage
    ({ mkDerivation, base, bytestring, egl, glew, OpenGL }:
     mkDerivation {
       pname = "ktx";
       version = "0.2";
       sha256 = "aeefa9e99b0533239710f0f8c2786c48370f6deb424fa3a49e579b748fe0f2e8";
       libraryHaskellDepends = [ base bytestring OpenGL ];
       libraryPkgconfigDepends = [ egl glew ];
       jailbreak = true;
       homepage = "https://github.com/corngood/ktx";
       description = "A binding for libktx from Khronos";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {egl = null; inherit (pkgs) glew;};

  "kure_2_4_10" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "kure";
       version = "2.4.10";
       sha256 = "3065e4df85512d6654a576aad017c94b85624ce09f3e43aeca59ab12c2f623df";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.ittc.ku.edu/csdl/fpg/Tools/KURE";
       description = "Combinators for Strategic Programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kure_2_16_4" = callPackage
    ({ mkDerivation, base, dlist, transformers }:
     mkDerivation {
       pname = "kure";
       version = "2.16.4";
       sha256 = "5dddcdaf623f1d1f8d82e1882461fd83ea7ce3d7185a196987246ade201e0d1f";
       libraryHaskellDepends = [ base dlist transformers ];
       homepage = "http://www.ittc.ku.edu/csdl/fpg/software/kure.html";
       description = "Combinators for Strategic Programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kure_2_16_6" = callPackage
    ({ mkDerivation, base, dlist, transformers }:
     mkDerivation {
       pname = "kure";
       version = "2.16.6";
       sha256 = "8a00f4010285f3cd4d3c15d4fe29d1a3890d528bb2186ef53c68737f07442293";
       libraryHaskellDepends = [ base dlist transformers ];
       homepage = "http://www.ittc.ku.edu/csdl/fpg/software/kure.html";
       description = "Combinators for Strategic Programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kure_2_16_8" = callPackage
    ({ mkDerivation, base, dlist, transformers }:
     mkDerivation {
       pname = "kure";
       version = "2.16.8";
       sha256 = "5ed7a77ac4cc287fe65572664404ba92cdea46a5cb64033539ebab929d422604";
       libraryHaskellDepends = [ base dlist transformers ];
       homepage = "http://www.ittc.ku.edu/csdl/fpg/software/kure.html";
       description = "Combinators for Strategic Programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kure_2_16_10" = callPackage
    ({ mkDerivation, base, dlist, transformers }:
     mkDerivation {
       pname = "kure";
       version = "2.16.10";
       sha256 = "15d201c36a7f0f1d24b7a33b71ac42ca2f3d4c73152544c849370a9ec6cdd675";
       libraryHaskellDepends = [ base dlist transformers ];
       homepage = "http://www.ittc.ku.edu/csdl/fpg/software/kure.html";
       description = "Combinators for Strategic Programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kure" = callPackage
    ({ mkDerivation, base, dlist, transformers }:
     mkDerivation {
       pname = "kure";
       version = "2.16.12";
       sha256 = "4c3e7d60fc33254f80ee5535d4fb5b254c1f52ab5f8ea1105eafcb2e637025d9";
       libraryHaskellDepends = [ base dlist transformers ];
       homepage = "http://www.ittc.ku.edu/csdl/fpg/software/kure.html";
       description = "Combinators for Strategic Programming";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "kure-your-boilerplate" = callPackage
    ({ mkDerivation, base, kure, template-haskell }:
     mkDerivation {
       pname = "kure-your-boilerplate";
       version = "0.1.3";
       sha256 = "2b342a06b652e6b7bbafdcdc5e60128c7886d5f677652ad8dc4194ef42afcc2d";
       libraryHaskellDepends = [ base kure template-haskell ];
       jailbreak = true;
       homepage = "http://ittc.ku.edu/~andygill/kure.php";
       description = "Generator for Boilerplate KURE Combinators";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "kyotocabinet" = callPackage
    ({ mkDerivation, base, bytestring, cereal, kyotocabinet }:
     mkDerivation {
       pname = "kyotocabinet";
       version = "0.1.3";
       sha256 = "dfcfbd39122b17ff66738d5d997eb756f31af58a67424b5762a33301ababfcf3";
       libraryHaskellDepends = [ base bytestring cereal ];
       librarySystemDepends = [ kyotocabinet ];
       description = "Mid level bindings to Kyoto Cabinet";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) kyotocabinet;};

  "l-bfgs-b" = callPackage
    ({ mkDerivation, base, lbfgsb, vector }:
     mkDerivation {
       pname = "l-bfgs-b";
       version = "0.1.0.1";
       sha256 = "c793456b91118d5a7023c8d75d3ef89c34e3f8a0571cb5b093adae9b059eff7a";
       libraryHaskellDepends = [ base vector ];
       librarySystemDepends = [ lbfgsb ];
       homepage = "http://nonempty.org/software/haskell-l-bfgs-b";
       description = "Bindings to L-BFGS-B, Fortran code for limited-memory quasi-Newton bound-constrained optimization";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {lbfgsb = null;};

  "labeled-graph" = callPackage
    ({ mkDerivation, base, labeled-tree }:
     mkDerivation {
       pname = "labeled-graph";
       version = "1.0.0.0";
       sha256 = "f9b8ac5e727e29c326c06417d99e55d777625d3a5f43314dec1bc100a9dd1618";
       libraryHaskellDepends = [ base labeled-tree ];
       description = "Labeled graph structure";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "labeled-tree" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "labeled-tree";
       version = "1.0.0.0";
       sha256 = "471f18851740747fdeaf5ac53799f65e5632e035a6d7db2f0cc2975f58f4d6b2";
       libraryHaskellDepends = [ base ];
       description = "Labeled tree structure";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "laborantin-hs" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, cmdlib, containers
     , directory, hslogger, mtl, old-locale, parsec, random, split, text
     , time, transformers, uuid
     }:
     mkDerivation {
       pname = "laborantin-hs";
       version = "0.1.5.2";
       sha256 = "9a05f214e60c047bd9537f97d24dbd978111a4ce5ff6730f747cc045766a6fa1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bytestring cmdlib containers directory hslogger
         mtl old-locale parsec random split text time transformers uuid
       ];
       executableHaskellDepends = [
         aeson base bytestring cmdlib containers directory hslogger mtl
         random split text transformers uuid
       ];
       jailbreak = true;
       homepage = "https://github.com/lucasdicioccio/laborantin-hs";
       description = "an experiment management framework";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "labyrinth" = callPackage
    ({ mkDerivation, base, containers, derive, HTF, HUnit, lens
     , monad-loops, MonadRandom, mtl, parsec, QuickCheck, random
     , safecopy, template-haskell, transformers
     }:
     mkDerivation {
       pname = "labyrinth";
       version = "0.5.0.0";
       sha256 = "943938a0cf91e5bb5a4df08c26eac00445f6d4d845898f00e7482222de1e25fa";
       libraryHaskellDepends = [
         base containers derive lens monad-loops MonadRandom mtl parsec
         random safecopy template-haskell transformers
       ];
       testHaskellDepends = [
         base containers derive HTF HUnit lens monad-loops MonadRandom mtl
         parsec QuickCheck random safecopy template-haskell transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/koterpillar/labyrinth";
       description = "A complicated turn-based game";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "labyrinth-server" = callPackage
    ({ mkDerivation, acid-state, aeson, base, bytestring, containers
     , derive, directory, filepath, hamlet, HTF, http-types, HUnit
     , labyrinth, lens, mtl, parsec, QuickCheck, random, safecopy
     , shakespeare-css, shakespeare-js, template-haskell, text
     , transformers, unordered-containers, utf8-string, vector, wai
     , wai-test, wai-websockets, warp, websockets, yesod, yesod-static
     }:
     mkDerivation {
       pname = "labyrinth-server";
       version = "0.1.4.1";
       sha256 = "5c993072ac910b7206829acbf3238852f3c38dc86403152014972bcceb47bd02";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         acid-state aeson base bytestring containers derive filepath hamlet
         labyrinth lens mtl parsec random safecopy shakespeare-css
         shakespeare-js template-haskell text transformers
         unordered-containers utf8-string vector wai-websockets warp
         websockets yesod yesod-static
       ];
       testHaskellDepends = [
         acid-state aeson base bytestring containers derive directory
         filepath hamlet HTF http-types HUnit labyrinth lens mtl parsec
         QuickCheck random safecopy shakespeare-css shakespeare-js
         template-haskell text transformers unordered-containers utf8-string
         vector wai wai-test wai-websockets warp websockets yesod
         yesod-static
       ];
       jailbreak = true;
       homepage = "https://github.com/koterpillar/labyrinth-server";
       description = "A complicated turn-based game - Web server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lackey" = callPackage
    ({ mkDerivation, base, servant, tasty, tasty-hspec }:
     mkDerivation {
       pname = "lackey";
       version = "0.1.0";
       sha256 = "3d7c49e9598f14711518a2dc0c420c42246c64ea8ad92fe340845dcabf7b0bb9";
       libraryHaskellDepends = [ base servant ];
       testHaskellDepends = [ base servant tasty tasty-hspec ];
       jailbreak = true;
       description = "A library for generating Ruby consumers of Servant APIs";
       license = stdenv.lib.licenses.mit;
     }) {};

  "lagrangian" = callPackage
    ({ mkDerivation, ad, base, hmatrix, HUnit, nonlinear-optimization
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , vector
     }:
     mkDerivation {
       pname = "lagrangian";
       version = "0.6.0.1";
       sha256 = "5b1cabf2012f0b8e66e47c532d4c14f8cffa8d9ef0cc54a3d782606bbdab541e";
       libraryHaskellDepends = [
         ad base hmatrix nonlinear-optimization vector
       ];
       testHaskellDepends = [
         ad base hmatrix HUnit nonlinear-optimization test-framework
         test-framework-hunit test-framework-quickcheck2 vector
       ];
       jailbreak = true;
       homepage = "http://github.com/jfischoff/lagrangian";
       description = "Solve Lagrange multiplier problems";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "laika" = callPackage
    ({ mkDerivation, attoparsec, base-prelude, either, record
     , system-fileio, system-filepath, template-haskell, text
     , transformers
     }:
     mkDerivation {
       pname = "laika";
       version = "0.1.3.1";
       sha256 = "a1873cd1fb75cc1ff45cca4565cf950ce25fa63bb4d15231349131f07fd63e2f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base-prelude either record system-fileio system-filepath
         template-haskell text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/laika";
       description = "Minimalistic type-checked compile-time template engine";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambda-ast" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "lambda-ast";
       version = "0.0.12";
       sha256 = "ae24f8a90b50bfc95b008003392bd92bb332e25804dacc73f2f3cf0d0f77201e";
       libraryHaskellDepends = [ base ];
       description = "Lambda Calculi Abstract Syntax Trees";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lambda-bridge" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "lambda-bridge";
       version = "0.1";
       sha256 = "432f86cabf25808903c29b9e19af637f5282e4a6c4301c9670cd09b315e13862";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       homepage = "http://www.ittc.ku.edu/csdl/fpg/Tools/LambdaBridge";
       description = "A bridge from Haskell (on a CPU) to VHDL on a FPGA";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambda-canvas" = callPackage
    ({ mkDerivation, base, GLUT, mtl, OpenGL, time }:
     mkDerivation {
       pname = "lambda-canvas";
       version = "0.1";
       sha256 = "2231d5a0563a722c2d3cc704edf203b73366c8006097a69cf44102a6030f9493";
       libraryHaskellDepends = [ base GLUT mtl OpenGL time ];
       jailbreak = true;
       description = "Educational drawing canvas for FP explorers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "lambda-devs" = callPackage
    ({ mkDerivation, base, binary, containers, dimensional
     , distributed-process, HUnit, numtype, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "lambda-devs";
       version = "0.4.0";
       sha256 = "306ff1c56c0b938b38a31beb07c857e7199063f3571d4865dbce9551293352c8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary containers dimensional distributed-process
       ];
       executableHaskellDepends = [
         base binary containers dimensional distributed-process numtype
       ];
       testHaskellDepends = [
         base binary containers dimensional distributed-process HUnit
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       homepage = "http://github.com/alios/lambda-devs";
       description = "a Paralell-DEVS implementaion based on distributed-process";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambda-options" = callPackage
    ({ mkDerivation, base, containers, mtl, read-bounded }:
     mkDerivation {
       pname = "lambda-options";
       version = "0.9.0.0";
       sha256 = "440852153cc682a7eb056b71713ea299329acbaeab8ecd5a422b89ebc831e976";
       libraryHaskellDepends = [ base containers mtl read-bounded ];
       jailbreak = true;
       homepage = "https://github.com/thomaseding/lambda-options";
       description = "A modern command-line parser for Haskell";
       license = "unknown";
     }) {};

  "lambda-placeholders" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "lambda-placeholders";
       version = "0.0.0.0";
       sha256 = "ed0d787de92a61f81a6dbbc8c2c953d26673637b0d6197070e5a16857d297e68";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/mmirman/lambda-placeholders";
       description = "A library to emulate laceholders similar to Scala";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lambda-toolbox" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "lambda-toolbox";
       version = "1.0.1";
       sha256 = "352ed6da674cddecbd4a59785142995a557abf2e7010108618aa5a82797b21d4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       homepage = "http://scravy.de/blog/2012-02-20/a-lambda-toolbox-in-haskell.htm";
       description = "An application to work with the lambda calculus (for learning)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambda2js" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "lambda2js";
       version = "0.1.0.1";
       sha256 = "75285559fe329da8d788d1b493aa1aea631b12d4595db2ecfed75ef474535258";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base parsec ];
       jailbreak = true;
       homepage = "https://github.com/xkollar/lambda2js";
       description = "Untyped Lambda calculus to JavaScript compiler";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "lambdaBase" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "lambdaBase";
       version = "0.0.2.0";
       sha256 = "cd12817d945ac61194656962b81a390532fca954647e7c9ea262d178635f82a5";
       libraryHaskellDepends = [ base parsec ];
       testHaskellDepends = [ base parsec ];
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdaFeed" = callPackage
    ({ mkDerivation, base, haskell98, html }:
     mkDerivation {
       pname = "lambdaFeed";
       version = "0.3.1";
       sha256 = "08123f5c02d14f84b9a8494d0cfcd7b1da5b1cb7d5533671a30ba7d4a304513e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskell98 html ];
       homepage = "http://www.cse.unsw.edu.au/~chak/haskell/lambdaFeed/";
       description = "RSS 2.0 feed generator";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdaLit" = callPackage
    ({ mkDerivation, base, bytestring, haskeline, lambdaBase, mtl
     , network
     }:
     mkDerivation {
       pname = "lambdaLit";
       version = "0.1.1.0";
       sha256 = "10f41b51abb7b0ab6791addaaa2c41612c4d80e79bb79183ff9913844d2281f7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring haskeline lambdaBase mtl network
       ];
       description = "...";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdabot" = callPackage
    ({ mkDerivation, base, lambdabot-core, lambdabot-haskell-plugins
     , lambdabot-irc-plugins, lambdabot-misc-plugins
     , lambdabot-novelty-plugins, lambdabot-reference-plugins
     , lambdabot-social-plugins
     }:
     mkDerivation {
       pname = "lambdabot";
       version = "5.0.3";
       sha256 = "423a1836d6bfcef66fb56038202b131f77b056a5441a9a3afb9200537eaf79cd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base lambdabot-core lambdabot-haskell-plugins lambdabot-irc-plugins
         lambdabot-misc-plugins lambdabot-novelty-plugins
         lambdabot-reference-plugins lambdabot-social-plugins
       ];
       homepage = "http://haskell.org/haskellwiki/Lambdabot";
       description = "Lambdabot is a development tool and advanced IRC bot";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdabot-core" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , dependent-map, dependent-sum, dependent-sum-template, directory
     , edit-distance, filepath, haskeline, hslogger, HTTP, lifted-base
     , monad-control, mtl, network, parsec, random, random-fu
     , random-source, regex-tdfa, SafeSemaphore, split, template-haskell
     , time, transformers, transformers-base, unix, utf8-string, zlib
     }:
     mkDerivation {
       pname = "lambdabot-core";
       version = "5.0.3";
       sha256 = "03e40557b5dc94dc509c17f3424cf3a8e36b7afe9b7f02733090e156a3e6ea89";
       libraryHaskellDepends = [
         base binary bytestring containers dependent-map dependent-sum
         dependent-sum-template directory edit-distance filepath haskeline
         hslogger HTTP lifted-base monad-control mtl network parsec random
         random-fu random-source regex-tdfa SafeSemaphore split
         template-haskell time transformers transformers-base unix
         utf8-string zlib
       ];
       jailbreak = true;
       homepage = "http://haskell.org/haskellwiki/Lambdabot";
       description = "Lambdabot core functionality";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdabot-haskell-plugins" = callPackage
    ({ mkDerivation, array, arrows, base, bytestring, containers
     , data-memocombinators, directory, filepath, haskell-src-exts
     , hoogle, HTTP, IOSpec, lambdabot-core, lambdabot-reference-plugins
     , lambdabot-trusted, lifted-base, logict, MonadRandom, mtl, mueval
     , network, numbers, oeis, parsec, pretty, process, QuickCheck
     , regex-tdfa, show, split, syb, transformers, utf8-string
     , vector-space
     }:
     mkDerivation {
       pname = "lambdabot-haskell-plugins";
       version = "5.0.3";
       sha256 = "a11f264918af611b4dd48e698302b73b70952f196307051acd584979e327ca47";
       revision = "1";
       editedCabalFile = "32242e812c3d3dff424a6672d6678878132aefa8e195b438da45124dbdca0e9a";
       libraryHaskellDepends = [
         array arrows base bytestring containers data-memocombinators
         directory filepath haskell-src-exts hoogle HTTP IOSpec
         lambdabot-core lambdabot-reference-plugins lambdabot-trusted
         lifted-base logict MonadRandom mtl mueval network numbers oeis
         parsec pretty process QuickCheck regex-tdfa show split syb
         transformers utf8-string vector-space
       ];
       jailbreak = true;
       homepage = "http://haskell.org/haskellwiki/Lambdabot";
       description = "Lambdabot Haskell plugins";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdabot-irc-plugins" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , lambdabot-core, lifted-base, mtl, network, SafeSemaphore, split
     , time
     }:
     mkDerivation {
       pname = "lambdabot-irc-plugins";
       version = "5.0.3";
       sha256 = "3cd375427c9c491fef9385a163a9ea317b1c8b44b0f5da4c8fc9bf26bd809fec";
       libraryHaskellDepends = [
         base bytestring containers directory filepath lambdabot-core
         lifted-base mtl network SafeSemaphore split time
       ];
       homepage = "http://haskell.org/haskellwiki/Lambdabot";
       description = "IRC plugins for lambdabot";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdabot-misc-plugins" = callPackage
    ({ mkDerivation, base, bytestring, containers, filepath, hstatsd
     , lambdabot-core, lifted-base, mtl, network, network-uri, parsec
     , process, random, random-fu, random-source, regex-tdfa
     , SafeSemaphore, split, tagsoup, template-haskell, time
     , transformers, transformers-base, unix, utf8-string, zlib
     }:
     mkDerivation {
       pname = "lambdabot-misc-plugins";
       version = "5.0.1";
       sha256 = "77aa8e3bf275dcf97c5ddff2fce370b802645949ef76f9b1bf993f7a34e5b021";
       libraryHaskellDepends = [
         base bytestring containers filepath hstatsd lambdabot-core
         lifted-base mtl network network-uri parsec process random random-fu
         random-source regex-tdfa SafeSemaphore split tagsoup
         template-haskell time transformers transformers-base unix
         utf8-string zlib
       ];
       homepage = "http://haskell.org/haskellwiki/Lambdabot";
       description = "Lambdabot miscellaneous plugins";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdabot-novelty-plugins" = callPackage
    ({ mkDerivation, base, binary, brainfuck, bytestring, containers
     , dice, directory, lambdabot-core, misfortune, process, random-fu
     , regex-tdfa, unlambda
     }:
     mkDerivation {
       pname = "lambdabot-novelty-plugins";
       version = "5.0.3";
       sha256 = "fecaa0830dbf817b9e1c8f981d7e13ead31634f136c83ea5fce22125d245de20";
       revision = "1";
       editedCabalFile = "f86a4fc89b03db22bbd8bbcdd9cd57ba97d777fb9e7f38daaf04bbf63763dcb5";
       libraryHaskellDepends = [
         base binary brainfuck bytestring containers dice directory
         lambdabot-core misfortune process random-fu regex-tdfa unlambda
       ];
       homepage = "http://haskell.org/haskellwiki/Lambdabot";
       description = "Novelty plugins for Lambdabot";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdabot-reference-plugins" = callPackage
    ({ mkDerivation, base, bytestring, containers, HTTP, lambdabot-core
     , mtl, network, network-uri, oeis, process, regex-tdfa, split
     , tagsoup, utf8-string
     }:
     mkDerivation {
       pname = "lambdabot-reference-plugins";
       version = "5.0.3";
       sha256 = "ff873c348657d8781c88f21f37cfd8aa18846aafec3f470516d5474225a081fb";
       libraryHaskellDepends = [
         base bytestring containers HTTP lambdabot-core mtl network
         network-uri oeis process regex-tdfa split tagsoup utf8-string
       ];
       homepage = "http://haskell.org/haskellwiki/Lambdabot";
       description = "Lambdabot reference plugins";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdabot-social-plugins" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , lambdabot-core, mtl, split, time
     }:
     mkDerivation {
       pname = "lambdabot-social-plugins";
       version = "5.0.1";
       sha256 = "6c6e4d0e33f2c0a0e411a1bac20c12fd01bdeb2008c4feb4231672522420977a";
       revision = "1";
       editedCabalFile = "a4543b07e078f70dbfee02c7bf58ea46d2d5067b1fa5eb5d7069a5b03f17937f";
       libraryHaskellDepends = [
         base binary bytestring containers lambdabot-core mtl split time
       ];
       homepage = "http://haskell.org/haskellwiki/Lambdabot";
       description = "Social plugins for Lambdabot";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdabot-trusted" = callPackage
    ({ mkDerivation, base, oeis, QuickCheck, QuickCheck-safe }:
     mkDerivation {
       pname = "lambdabot-trusted";
       version = "5.0.2.1";
       sha256 = "1070f98a979aa1e92b96e898f4aaafe4b549dc2c42391800b3af6fd012861e1d";
       libraryHaskellDepends = [ base oeis QuickCheck QuickCheck-safe ];
       homepage = "http://haskell.org/haskellwiki/Lambdabot";
       description = "Lambdabot trusted code";
       license = "GPL";
     }) {};

  "lambdabot-utils" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, haskell-src
     , mtl, network, old-time, process, random, regex-compat
     , regex-posix, syb, tagsoup, unix, utf8-string, zlib
     }:
     mkDerivation {
       pname = "lambdabot-utils";
       version = "4.2.2";
       sha256 = "a715912af48c3fcd56a5c786f7f3c831d2008909cf985fb7b21ded6d6c4ebf56";
       revision = "3";
       editedCabalFile = "f54d43d6964d63f1d8796606419b512a6e7b87b1defe960748c27c7417f59a08";
       libraryHaskellDepends = [
         base binary bytestring containers haskell-src mtl network old-time
         process random regex-compat regex-posix syb tagsoup unix
         utf8-string zlib
       ];
       jailbreak = true;
       homepage = "http://haskell.org/haskellwiki/Lambdabot";
       description = "Utility libraries for the advanced IRC bot, Lambdabot";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdacat" = callPackage
    ({ mkDerivation, base, cmdargs, containers, dyre, glade, gtk, mtl
     , network, webkit
     }:
     mkDerivation {
       pname = "lambdacat";
       version = "0.1.1";
       sha256 = "79857fc94a4526bdd5263c8ee9d04c42c4b2b84914671e6c58d1885829f8a7a2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cmdargs containers dyre glade gtk mtl network webkit
       ];
       jailbreak = true;
       homepage = "http://github.com/baldo/lambdacat";
       description = "Webkit Browser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdacms-core" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, classy-prelude
     , classy-prelude-yesod, containers, data-default, esqueleto
     , file-embed, friendly-time, gravatar, hspec, lists, mime-mail
     , old-locale, persistent, shakespeare, template-haskell, text, time
     , uuid, wai, yesod, yesod-auth, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "lambdacms-core";
       version = "0.3.0.2";
       sha256 = "e6d816746634e502964259abd842d5eaaf1ceaa5bae30e71233e32f6ab8f1755";
       libraryHaskellDepends = [
         base blaze-html bytestring containers data-default esqueleto
         file-embed friendly-time gravatar lists mime-mail old-locale
         persistent shakespeare template-haskell text time uuid wai yesod
         yesod-auth yesod-core yesod-form
       ];
       testHaskellDepends = [
         base classy-prelude classy-prelude-yesod hspec yesod yesod-core
       ];
       homepage = "http://lambdacms.org";
       description = "LambdaCms 'core' subsite for Yesod apps";
       license = stdenv.lib.licenses.mit;
     }) {};

  "lambdacms-media" = callPackage
    ({ mkDerivation, base, directory, filepath, lambdacms-core
     , persistent, shakespeare, text, time, yesod, yesod-form
     }:
     mkDerivation {
       pname = "lambdacms-media";
       version = "0.4.0.0";
       sha256 = "acac0386aedea9331d48b3d4c28af1ab5f91610acc409925114c2b7b2f16036f";
       libraryHaskellDepends = [
         base directory filepath lambdacms-core persistent shakespeare text
         time yesod yesod-form
       ];
       homepage = "http://lambdacms.org";
       description = "LambdaCms \"media\" extension";
       license = stdenv.lib.licenses.mit;
     }) {};

  "lambdacube" = callPackage
    ({ mkDerivation, base, editline, mtl, pretty }:
     mkDerivation {
       pname = "lambdacube";
       version = "2008.12.25";
       sha256 = "6b40b96bfaadecd28234cbaebe1865c6cc2e46969eb6f1a9bcad517df4629ce3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base editline mtl pretty ];
       description = "A simple lambda cube type checker";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdacube-bullet" = callPackage
    ({ mkDerivation, base, bullet, lambdacube-engine, mtl, vector }:
     mkDerivation {
       pname = "lambdacube-bullet";
       version = "0.2.1";
       sha256 = "9badc01807b1869e918450ae7ca29549ad05f51b0da047ba6d0e8070df46dbf2";
       libraryHaskellDepends = [
         base bullet lambdacube-engine mtl vector
       ];
       homepage = "http://www.haskell.org/haskellwiki/LambdaCubeEngine";
       description = "Example for combining LambdaCube and Bullet";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdacube-compiler" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, containers
     , deepseq, directory, exceptions, filepath, indentation
     , lambdacube-ir, monad-control, mtl, optparse-applicative, parsec
     , pretty-compact, QuickCheck, tasty, tasty-quickcheck, text, time
     , vector
     }:
     mkDerivation {
       pname = "lambdacube-compiler";
       version = "0.4.0.1";
       sha256 = "4487798702474096e80a7b0582dc9e2feceef4f82155d65226da474e40f7e4b3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base containers deepseq directory exceptions filepath
         indentation lambdacube-ir mtl parsec pretty-compact text vector
       ];
       executableHaskellDepends = [
         aeson async base bytestring containers deepseq directory exceptions
         filepath indentation lambdacube-ir monad-control mtl
         optparse-applicative parsec pretty-compact QuickCheck tasty
         tasty-quickcheck text time vector
       ];
       doHaddock = false;
       homepage = "http://lambdacube3d.com";
       description = "LambdaCube 3D is a DSL to program GPUs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lambdacube-core" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-trie, containers, mtl
     , vector
     }:
     mkDerivation {
       pname = "lambdacube-core";
       version = "0.2.0";
       sha256 = "34cd373d9f23db1bdb2654d7d60d330aaa3256e2647a3300e4aa0503c3e03600";
       libraryHaskellDepends = [
         base bytestring bytestring-trie containers mtl vector
       ];
       jailbreak = true;
       homepage = "http://lambdacube3d.wordpress.com/";
       description = "LambdaCube 3D IR";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lambdacube-edsl" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-trie, containers
     , ghc-prim, lambdacube-core, mtl, vector
     }:
     mkDerivation {
       pname = "lambdacube-edsl";
       version = "0.2.0";
       sha256 = "1549874c3dd242c502ca24f818ecf93e7bc38b2974af2516d307f2c4a09e8ba2";
       libraryHaskellDepends = [
         base bytestring bytestring-trie containers ghc-prim lambdacube-core
         mtl vector
       ];
       jailbreak = true;
       homepage = "http://lambdacube3d.wordpress.com/";
       description = "LambdaCube 3D EDSL definition";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lambdacube-engine" = callPackage
    ({ mkDerivation, array, base, binary, bitmap, bytestring
     , bytestring-trie, containers, directory, filepath, mtl, OpenGLRaw
     , stb-image, uulib, vect, vector, vector-algorithms, xml
     , zip-archive
     }:
     mkDerivation {
       pname = "lambdacube-engine";
       version = "0.2.4";
       sha256 = "6eb4d86760a1fe4d5fc4a5b38593cb293d3064cf98fb660277b559ea2d08b7f5";
       libraryHaskellDepends = [
         array base binary bitmap bytestring bytestring-trie containers
         directory filepath mtl OpenGLRaw stb-image uulib vect vector
         vector-algorithms xml zip-archive
       ];
       homepage = "http://www.haskell.org/haskellwiki/LambdaCubeEngine";
       description = "3D rendering engine written entirely in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdacube-examples" = callPackage
    ({ mkDerivation, base, elerea, GLFW-b, lambdacube-engine, mtl }:
     mkDerivation {
       pname = "lambdacube-examples";
       version = "0.2.2";
       sha256 = "690132f41ac9d1d81c57fe2e3010674f81c3858f385f627d8597aeb998058492";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base elerea GLFW-b lambdacube-engine mtl
       ];
       homepage = "http://www.haskell.org/haskellwiki/LambdaCubeEngine";
       description = "Examples for LambdaCube";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdacube-gl" = callPackage
    ({ mkDerivation, base, bytestring, containers, JuicyPixels
     , lambdacube-ir, mtl, OpenGLRaw, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "lambdacube-gl";
       version = "0.4.0.2";
       sha256 = "f9ebec4a981381ffa9f998a636c0aba3f4425b4fb2ae06650ff24e9109328174";
       libraryHaskellDepends = [
         base bytestring containers JuicyPixels lambdacube-ir mtl OpenGLRaw
         vector vector-algorithms
       ];
       doHaddock = false;
       homepage = "http://lambdacube3d.com";
       description = "OpenGL 3.3 Core Profile backend for LambdaCube 3D";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdacube-ir" = callPackage
    ({ mkDerivation, aeson, base, containers, mtl, text, vector }:
     mkDerivation {
       pname = "lambdacube-ir";
       version = "0.2.0.0";
       sha256 = "488cbb21a8dca80c16552d3aca868d5aa7085b7bfa2e9ea7c92965bd1e288c48";
       libraryHaskellDepends = [ aeson base containers mtl text vector ];
       description = "LambdaCube 3D intermediate representation of 3D graphics pipelines";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lambdacube-samples" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-trie, elerea, GLFW-b
     , lambdacube-core, lambdacube-edsl, lambdacube-gl, mtl, OpenGLRaw
     , stb-image, time, vect, vector
     }:
     mkDerivation {
       pname = "lambdacube-samples";
       version = "0.2.0";
       sha256 = "a1098254e7ceabf4f6ab1d8cb644211c824546748b2577e0783b20454469897e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring bytestring-trie elerea GLFW-b lambdacube-core
         lambdacube-edsl lambdacube-gl mtl OpenGLRaw stb-image time vect
         vector
       ];
       jailbreak = true;
       homepage = "http://lambdacube3d.wordpress.com/";
       description = "Samples for LambdaCube 3D";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdatex" = callPackage
    ({ mkDerivation, async, base, containers, directory, HaTeX, hspec
     , mtl, QuickCheck, quickcheck-text, text, transformers
     }:
     mkDerivation {
       pname = "lambdatex";
       version = "0.1.0.3";
       sha256 = "d233ed18d1a6383544146832b45c0e56cbf1a95ececbb6b12963ccb27bcd4bc9";
       libraryHaskellDepends = [
         async base containers directory HaTeX mtl text transformers
       ];
       testHaskellDepends = [
         base hspec QuickCheck quickcheck-text text
       ];
       jailbreak = true;
       homepage = "http://github.com/NorfairKing/lambdatex";
       description = "Type-Safe LaTeX EDSL";
       license = "GPL";
     }) {};

  "lambdatwit" = callPackage
    ({ mkDerivation, acid-state, authenticate-oauth, base, bytestring
     , case-insensitive, conduit, containers, data-default, exceptions
     , hint, http-conduit, http-types, lens, MissingH, monad-control
     , monad-logger, mtl, mueval, network-uri, resourcet, safecopy, text
     , transformers, transformers-base, twitter-conduit, twitter-types
     , utf8-string
     }:
     mkDerivation {
       pname = "lambdatwit";
       version = "0.1.0.0";
       sha256 = "5d5252eda31531f4d707eee5dc64a4fcfe6adae922919fc4f36382832dacb806";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         acid-state authenticate-oauth base bytestring case-insensitive
         conduit containers data-default exceptions hint http-conduit
         http-types lens MissingH monad-control monad-logger mtl mueval
         network-uri resourcet safecopy text transformers transformers-base
         twitter-conduit twitter-types utf8-string
       ];
       jailbreak = true;
       homepage = "http://github.com/ashyisme/lambdatwit";
       description = "Lambdabot running as a twitter bot. Similar to the @fsibot f# bot.";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lambdiff" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , bytestring, enumerator, gtk, mtl
     }:
     mkDerivation {
       pname = "lambdiff";
       version = "0.1";
       sha256 = "9eb31fc64858e76f9c3474b7fdc5d38c43238ccfd3f3a277dbc1ee0432f99b76";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec attoparsec-enumerator base bytestring enumerator gtk mtl
       ];
       jailbreak = true;
       homepage = "https://github.com/jamwt/lambdiff.git";
       description = "Diff Viewer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lame-tester" = callPackage
    ({ mkDerivation, base, bifunctors, containers, semigroups, tasty
     , tasty-hunit, validation
     }:
     mkDerivation {
       pname = "lame-tester";
       version = "1.2";
       sha256 = "de04042967c5d7879ce46ba7d77cd315e71f2f151432121139cbc1a3108147f1";
       libraryHaskellDepends = [
         base bifunctors containers semigroups validation
       ];
       testHaskellDepends = [ base containers tasty tasty-hunit ];
       homepage = "http://github.com/TheBizzle";
       description = "A strange and unnecessary selective test-running library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-asn1" = callPackage
    ({ mkDerivation, base, parsec, syb }:
     mkDerivation {
       pname = "language-asn1";
       version = "0.5";
       sha256 = "e3fef756ed6c53c0e9d5058291071ca804f47a418ad0cada816bb440c3c45191";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base parsec syb ];
       homepage = "http://patch-tag.com/r/adept/language-asn1";
       description = "Parsing of ASN1 definitions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-bash" = callPackage
    ({ mkDerivation, base, parsec, pretty, process, QuickCheck, tasty
     , tasty-quickcheck, transformers
     }:
     mkDerivation {
       pname = "language-bash";
       version = "0.6.1";
       sha256 = "7fb4fb293aec5f3c9b0e7ca2b99f895115d1bbe13f8dbfe02003560e3c063c8d";
       libraryHaskellDepends = [ base parsec pretty transformers ];
       testHaskellDepends = [
         base parsec process QuickCheck tasty tasty-quickcheck
       ];
       homepage = "http://github.com/knrafto/language-bash/";
       description = "Parsing and pretty-printing Bash shell scripts";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-boogie" = callPackage
    ({ mkDerivation, ansi-terminal, base, cmdargs, containers, filepath
     , HUnit, lens, mtl, parsec, pretty, random, stream-monad, time
     , transformers
     }:
     mkDerivation {
       pname = "language-boogie";
       version = "0.2";
       sha256 = "3da4e53dd7733e217b755346a67e8a1ef868b00c2ddd938de082d0f8464fd698";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers lens mtl parsec pretty random stream-monad
         transformers
       ];
       executableHaskellDepends = [
         ansi-terminal base cmdargs containers filepath HUnit lens mtl
         parsec pretty random stream-monad time transformers
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/nadiapolikarpova/boogaloo";
       description = "Interpreter and language infrastructure for Boogie";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-c" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers
     , directory, filepath, happy, pretty, process, syb
     }:
     mkDerivation {
       pname = "language-c";
       version = "0.4.7";
       sha256 = "5f6dc9d86b1f88dec1800e1a4fc43aa52f85fe4bb865ba268aca34b399a512e4";
       libraryHaskellDepends = [
         array base bytestring containers directory filepath pretty process
         syb
       ];
       libraryToolDepends = [ alex happy ];
       homepage = "http://www.sivity.net/projects/language.c/";
       description = "Analysis and generation of C code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-c-comments" = callPackage
    ({ mkDerivation, alex, array, base, language-c }:
     mkDerivation {
       pname = "language-c-comments";
       version = "0.3";
       sha256 = "c2652b01c50aa2afcbb87da3300198aba531c4d3b4afb5efc1ec7e719c8bace6";
       libraryHaskellDepends = [ array base language-c ];
       libraryToolDepends = [ alex ];
       homepage = "http://github.com/ghulette/language-c-comments";
       description = "Extracting comments from C code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-c-inline" = callPackage
    ({ mkDerivation, array, base, containers, filepath
     , language-c-quote, mainland-pretty, template-haskell
     }:
     mkDerivation {
       pname = "language-c-inline";
       version = "0.7.9.2";
       sha256 = "da975b3d40de997e4f21a47867894aa0208e8581015bed70b903fe199eb1f62d";
       libraryHaskellDepends = [
         array base containers filepath language-c-quote mainland-pretty
         template-haskell
       ];
       testHaskellDepends = [ base language-c-quote ];
       jailbreak = true;
       homepage = "https://github.com/mchakravarty/language-c-inline/";
       description = "Inline C & Objective-C code in Haskell for language interoperability";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-c-quote_0_10_2" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers
     , exception-mtl, exception-transformers, filepath, happy
     , haskell-src-meta, HUnit, mainland-pretty, mtl, srcloc, syb
     , symbol, template-haskell, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "language-c-quote";
       version = "0.10.2";
       sha256 = "7116b0ac84053cd639616751a711d7e373b136a735f449dbdb61a2d43f94d20c";
       libraryHaskellDepends = [
         array base bytestring containers exception-mtl
         exception-transformers filepath haskell-src-meta mainland-pretty
         mtl srcloc syb symbol template-haskell
       ];
       libraryToolDepends = [ alex happy ];
       testHaskellDepends = [
         base HUnit srcloc symbol test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "C/CUDA/OpenCL/Objective-C quasiquoting library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-c-quote_0_10_2_1" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers
     , exception-mtl, exception-transformers, filepath, happy
     , haskell-src-meta, HUnit, mainland-pretty, mtl, srcloc, syb
     , symbol, template-haskell, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "language-c-quote";
       version = "0.10.2.1";
       sha256 = "62941752567ffbe84eaa16fbf9934130e8d14c517d70982cd50bc5a6c93a994e";
       libraryHaskellDepends = [
         array base bytestring containers exception-mtl
         exception-transformers filepath haskell-src-meta mainland-pretty
         mtl srcloc syb symbol template-haskell
       ];
       libraryToolDepends = [ alex happy ];
       testHaskellDepends = [
         base HUnit srcloc symbol test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "C/CUDA/OpenCL/Objective-C quasiquoting library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-c-quote_0_10_2_2" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers
     , exception-mtl, exception-transformers, filepath, happy
     , haskell-src-meta, HUnit, mainland-pretty, mtl, srcloc, syb
     , symbol, template-haskell, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "language-c-quote";
       version = "0.10.2.2";
       sha256 = "5a5fecf0032bde5f51969a132bd7ea0b4d913ffe5bbee18d3d36f44f3aadc578";
       libraryHaskellDepends = [
         array base bytestring containers exception-mtl
         exception-transformers filepath haskell-src-meta mainland-pretty
         mtl srcloc syb symbol template-haskell
       ];
       libraryToolDepends = [ alex happy ];
       testHaskellDepends = [
         base HUnit srcloc symbol test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "C/CUDA/OpenCL/Objective-C quasiquoting library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-c-quote_0_10_2_3" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers
     , exception-mtl, exception-transformers, filepath, happy
     , haskell-src-meta, HUnit, mainland-pretty, mtl, srcloc, syb
     , symbol, template-haskell, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "language-c-quote";
       version = "0.10.2.3";
       sha256 = "50a0ee33b22637b69de426e5a56612f32dd17c69d1f10f70df549b7e3910f335";
       libraryHaskellDepends = [
         array base bytestring containers exception-mtl
         exception-transformers filepath haskell-src-meta mainland-pretty
         mtl srcloc syb symbol template-haskell
       ];
       libraryToolDepends = [ alex happy ];
       testHaskellDepends = [
         base HUnit srcloc symbol test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "C/CUDA/OpenCL/Objective-C quasiquoting library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-c-quote_0_11" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers
     , exception-mtl, exception-transformers, filepath, happy
     , haskell-src-meta, HUnit, mainland-pretty, mtl, srcloc, syb
     , symbol, template-haskell, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "language-c-quote";
       version = "0.11";
       sha256 = "87d191b5839f8a8336fdfc1749364b9df9a56f810ecc385bdff6349d7fbda5ec";
       libraryHaskellDepends = [
         array base bytestring containers exception-mtl
         exception-transformers filepath haskell-src-meta mainland-pretty
         mtl srcloc syb symbol template-haskell
       ];
       libraryToolDepends = [ alex happy ];
       testHaskellDepends = [
         base bytestring HUnit mainland-pretty srcloc symbol test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "C/CUDA/OpenCL/Objective-C quasiquoting library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-c-quote_0_11_0_1" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers
     , exception-mtl, exception-transformers, filepath, happy
     , haskell-src-meta, HUnit, mainland-pretty, mtl, srcloc, syb
     , symbol, template-haskell, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "language-c-quote";
       version = "0.11.0.1";
       sha256 = "ca65065a9c5cea2cf02c58398d6352fcf29d9294d1286efa6058bf4ebd0e1dd8";
       libraryHaskellDepends = [
         array base bytestring containers exception-mtl
         exception-transformers filepath haskell-src-meta mainland-pretty
         mtl srcloc syb symbol template-haskell
       ];
       libraryToolDepends = [ alex happy ];
       testHaskellDepends = [
         base bytestring HUnit mainland-pretty srcloc symbol test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "C/CUDA/OpenCL/Objective-C quasiquoting library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-c-quote_0_11_2" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers
     , exception-mtl, exception-transformers, filepath, happy
     , haskell-src-meta, HUnit, mainland-pretty, mtl, srcloc, syb
     , symbol, template-haskell, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "language-c-quote";
       version = "0.11.2";
       sha256 = "3776dea34b86cc6032e9883f50a1f801c93b9add4c167d051db4a438a5d1803f";
       libraryHaskellDepends = [
         array base bytestring containers exception-mtl
         exception-transformers filepath haskell-src-meta mainland-pretty
         mtl srcloc syb symbol template-haskell
       ];
       libraryToolDepends = [ alex happy ];
       testHaskellDepends = [
         base bytestring HUnit mainland-pretty srcloc symbol test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "C/CUDA/OpenCL/Objective-C quasiquoting library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-c-quote_0_11_2_1" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers
     , exception-mtl, exception-transformers, filepath, happy
     , haskell-src-meta, HUnit, mainland-pretty, mtl, srcloc, syb
     , symbol, template-haskell, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "language-c-quote";
       version = "0.11.2.1";
       sha256 = "4bdb018f8a1baff09c079290ab486f25c09c8b043815e8c218079f028e95d464";
       libraryHaskellDepends = [
         array base bytestring containers exception-mtl
         exception-transformers filepath haskell-src-meta mainland-pretty
         mtl srcloc syb symbol template-haskell
       ];
       libraryToolDepends = [ alex happy ];
       testHaskellDepends = [
         base bytestring HUnit mainland-pretty srcloc symbol test-framework
         test-framework-hunit
       ];
       doCheck = false;
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "C/CUDA/OpenCL/Objective-C quasiquoting library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-c-quote_0_11_3" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers
     , exception-mtl, exception-transformers, filepath, happy
     , haskell-src-meta, HUnit, mainland-pretty, mtl, srcloc, syb
     , symbol, template-haskell, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "language-c-quote";
       version = "0.11.3";
       sha256 = "42f9b13e7e1b9d9106158671ec3fc42d7375d61e50f7739a714e5f69caee02d0";
       libraryHaskellDepends = [
         array base bytestring containers exception-mtl
         exception-transformers filepath haskell-src-meta mainland-pretty
         mtl srcloc syb symbol template-haskell
       ];
       libraryToolDepends = [ alex happy ];
       testHaskellDepends = [
         base bytestring HUnit mainland-pretty srcloc symbol test-framework
         test-framework-hunit
       ];
       doCheck = false;
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "C/CUDA/OpenCL/Objective-C quasiquoting library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-c-quote" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers
     , exception-mtl, exception-transformers, filepath, happy
     , haskell-src-meta, HUnit, mainland-pretty, mtl, srcloc, syb
     , symbol, template-haskell, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "language-c-quote";
       version = "0.11.4";
       sha256 = "5794da453deb5dbe4f875e2c16af0514f39c809895061c5bb96c7b1dd1732a89";
       libraryHaskellDepends = [
         array base bytestring containers exception-mtl
         exception-transformers filepath haskell-src-meta mainland-pretty
         mtl srcloc syb symbol template-haskell
       ];
       libraryToolDepends = [ alex happy ];
       testHaskellDepends = [
         base bytestring HUnit mainland-pretty srcloc symbol test-framework
         test-framework-hunit
       ];
       doCheck = false;
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "C/CUDA/OpenCL/Objective-C quasiquoting library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-cil" = callPackage
    ({ mkDerivation, base, bool-extras }:
     mkDerivation {
       pname = "language-cil";
       version = "0.2.2";
       sha256 = "caf1a739da2681f6fd5c2c6825081a2dc0cefe8f33957554ec8aaf51ec557e2c";
       libraryHaskellDepends = [ base bool-extras ];
       jailbreak = true;
       homepage = "https://github.com/tomlokhorst/language-cil";
       description = "Manipulating Common Intermediate Language AST";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-css" = callPackage
    ({ mkDerivation, base, pretty }:
     mkDerivation {
       pname = "language-css";
       version = "0.0.3";
       sha256 = "2f459ba844a6df5e2c2ba8f696ae15e14263ddc259c771c81885909f118015bc";
       libraryHaskellDepends = [ base pretty ];
       description = "CSS 2.1 syntax";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-dot" = callPackage
    ({ mkDerivation, base, mtl, parsec, pretty }:
     mkDerivation {
       pname = "language-dot";
       version = "0.0.8";
       sha256 = "5d9dc8f2d3281888cdbf6435a55144a88b9473d36bbfe357e9806a564f755232";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl parsec pretty ];
       description = "A library for the analysis and creation of Graphviz DOT files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-ecmascript_0_16_2" = callPackage
    ({ mkDerivation, base, containers, data-default-class, Diff
     , directory, filepath, HUnit, mtl, parsec, QuickCheck
     , template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, testing-feat, uniplate, wl-pprint
     }:
     mkDerivation {
       pname = "language-ecmascript";
       version = "0.16.2";
       sha256 = "33e038250d3b69c78bbe2eee681d3ca11b3d6d731fd3f53684c774baf8c05b96";
       revision = "1";
       editedCabalFile = "450d12a049ad525891ed8beec5395726d6b11a0bb5e399e427dd0ddfc22b3d9c";
       libraryHaskellDepends = [
         base containers data-default-class Diff mtl parsec QuickCheck
         template-haskell testing-feat uniplate wl-pprint
       ];
       testHaskellDepends = [
         base containers data-default-class Diff directory filepath HUnit
         mtl parsec QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 uniplate wl-pprint
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/jswebtools/language-ecmascript";
       description = "JavaScript parser and pretty-printer library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-ecmascript_0_17" = callPackage
    ({ mkDerivation, base, containers, data-default-class, Diff
     , directory, filepath, HUnit, mtl, parsec, QuickCheck
     , template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, testing-feat, uniplate, wl-pprint
     }:
     mkDerivation {
       pname = "language-ecmascript";
       version = "0.17";
       sha256 = "e6a0467a0bea7ce052ba41943195da46ef7ba6a6105c0dacf4a880932eb76097";
       revision = "3";
       editedCabalFile = "ed58e3f951b32ecbefd7d1c2c16042b20408d43b036c6926a2ddeee5ee777d2b";
       libraryHaskellDepends = [
         base containers data-default-class Diff mtl parsec QuickCheck
         template-haskell testing-feat uniplate wl-pprint
       ];
       testHaskellDepends = [
         base containers data-default-class Diff directory filepath HUnit
         mtl parsec QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 uniplate wl-pprint
       ];
       jailbreak = true;
       homepage = "http://github.com/jswebtools/language-ecmascript";
       description = "JavaScript parser and pretty-printer library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-ecmascript_0_17_0_1" = callPackage
    ({ mkDerivation, base, containers, data-default-class, Diff
     , directory, filepath, HUnit, mtl, parsec, QuickCheck
     , template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, testing-feat, uniplate, wl-pprint
     }:
     mkDerivation {
       pname = "language-ecmascript";
       version = "0.17.0.1";
       sha256 = "94e0043d181cbfdf2f41f0c6e199f8ea4e3e5f0b6145d19f4bef74eacdb45cf9";
       libraryHaskellDepends = [
         base containers data-default-class Diff mtl parsec QuickCheck
         template-haskell testing-feat uniplate wl-pprint
       ];
       testHaskellDepends = [
         base containers data-default-class Diff directory filepath HUnit
         mtl parsec QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 uniplate wl-pprint
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/jswebtools/language-ecmascript";
       description = "JavaScript parser and pretty-printer library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-ecmascript" = callPackage
    ({ mkDerivation, base, containers, data-default-class, Diff
     , directory, filepath, HUnit, mtl, parsec, QuickCheck
     , template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, testing-feat, uniplate, wl-pprint
     }:
     mkDerivation {
       pname = "language-ecmascript";
       version = "0.17.0.2";
       sha256 = "97412d2cf4b5a61de49548b22e4271fe20cba6746a2dc58dcc55c82c56591059";
       libraryHaskellDepends = [
         base containers data-default-class Diff mtl parsec QuickCheck
         template-haskell testing-feat uniplate wl-pprint
       ];
       testHaskellDepends = [
         base containers data-default-class Diff directory filepath HUnit
         mtl parsec QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 uniplate wl-pprint
       ];
       doCheck = false;
       homepage = "http://github.com/jswebtools/language-ecmascript";
       description = "JavaScript parser and pretty-printer library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-ecmascript-analysis" = callPackage
    ({ mkDerivation, base, containers, language-ecmascript, parsec
     , uniplate
     }:
     mkDerivation {
       pname = "language-ecmascript-analysis";
       version = "0.9.2";
       sha256 = "afb477f63477edd7cd21c817dc2e7f7addede510eff60df07d76daeddf8ba691";
       libraryHaskellDepends = [
         base containers language-ecmascript parsec uniplate
       ];
       homepage = "http://github.com/jswebtools/language-ecmascript-analysis";
       description = "JavaScript static analysis library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-eiffel" = callPackage
    ({ mkDerivation, alex, array, base, binary, bytestring, containers
     , deepseq, derive, ghc-prim, hashable, lens, mtl, parsec, pretty
     , text, unordered-containers
     }:
     mkDerivation {
       pname = "language-eiffel";
       version = "0.1.2";
       sha256 = "95d1ffd31ff6bedf71300d7e5f75cb5bc204f5f7744325127ef592ee5c1875ec";
       libraryHaskellDepends = [
         array base binary bytestring containers deepseq derive ghc-prim
         hashable lens mtl parsec pretty text unordered-containers
       ];
       libraryToolDepends = [ alex ];
       homepage = "https://github.com/scottgw/language-eiffel";
       description = "Parser and pretty printer for the Eiffel language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-fortran" = callPackage
    ({ mkDerivation, alex, array, base, happy, haskell-src, parsec, syb
     }:
     mkDerivation {
       pname = "language-fortran";
       version = "0.4";
       sha256 = "6274cb5cf9ebea85f616bd0276345bda76160766e67ad4d7f6173f5f19b7780e";
       libraryHaskellDepends = [ array base haskell-src parsec syb ];
       libraryToolDepends = [ alex happy ];
       description = "Fortran lexer and parser, language support, and extensions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-gcl" = callPackage
    ({ mkDerivation, base, bifunctors, parsers }:
     mkDerivation {
       pname = "language-gcl";
       version = "0.2";
       sha256 = "2e5366663d4f1487cceb93e3182a62949758f87f7b652074d53af2047f22d08b";
       libraryHaskellDepends = [ base bifunctors parsers ];
       jailbreak = true;
       description = "Something similar to Dijkstra's guarded command language";
       license = stdenv.lib.licenses.mit;
     }) {};

  "language-glsl_0_1_1" = callPackage
    ({ mkDerivation, base, HUnit, parsec, pretty, prettyclass
     , test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "language-glsl";
       version = "0.1.1";
       sha256 = "be042ae45ac644026a4012d14be1a24c6c905fbedf0ed5e4fbad31a1d218ac19";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base parsec prettyclass ];
       executableHaskellDepends = [ base parsec pretty prettyclass ];
       testHaskellDepends = [
         base HUnit parsec prettyclass test-framework test-framework-hunit
       ];
       description = "GLSL abstract syntax tree, parser, and pretty-printer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-glsl" = callPackage
    ({ mkDerivation, base, HUnit, parsec, prettyclass, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "language-glsl";
       version = "0.2.0";
       sha256 = "236348543fb992e7cc563f80e1118ba942527ad295eba1a9466a30165cfcaef2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base parsec prettyclass ];
       executableHaskellDepends = [ base parsec prettyclass ];
       testHaskellDepends = [
         base HUnit parsec prettyclass test-framework test-framework-hunit
       ];
       description = "GLSL abstract syntax tree, parser, and pretty-printer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-go" = callPackage
    ({ mkDerivation, array, base, parsec, utf8-string }:
     mkDerivation {
       pname = "language-go";
       version = "0.8";
       sha256 = "6cffbe5f179a62b6afc17ce4f477f32751d52971a028e97e25789c5e4228a4dc";
       libraryHaskellDepends = [ array base parsec utf8-string ];
       jailbreak = true;
       description = "A library for analysis and synthesis of Go code";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-guess" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers }:
     mkDerivation {
       pname = "language-guess";
       version = "0.1.2";
       sha256 = "e08e6e05f45d03659d813caf03905a6ac314b83b39cd4d12b1ac8205039bb63d";
       libraryHaskellDepends = [ base bytestring cereal containers ];
       jailbreak = true;
       description = "Guess at which language a text is written in using trigrams";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-haskell-extract" = callPackage
    ({ mkDerivation, base, regex-posix, template-haskell }:
     mkDerivation {
       pname = "language-haskell-extract";
       version = "0.2.4";
       sha256 = "14da16e56665bf971723e0c5fd06dbb7cc30b4918cf8fb5748570785ded1acdb";
       libraryHaskellDepends = [ base regex-posix template-haskell ];
       homepage = "http://github.com/finnsson/template-helper";
       description = "Module to automatically extract functions from the local code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-java_0_2_7" = callPackage
    ({ mkDerivation, alex, array, base, cpphs, directory, filepath
     , HUnit, mtl, parsec, pretty, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "language-java";
       version = "0.2.7";
       sha256 = "cecf386d3c5addbf2bbd4055711e0bb2d6033e1ea6e8dee8d4c4012e757e2994";
       libraryHaskellDepends = [ array base cpphs parsec pretty ];
       libraryToolDepends = [ alex ];
       testHaskellDepends = [
         base directory filepath HUnit mtl QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://github.com/vincenthz/language-java";
       description = "Manipulating Java source: abstract syntax, lexer, parser, and pretty-printer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-java" = callPackage
    ({ mkDerivation, alex, array, base, cpphs, directory, filepath
     , HUnit, mtl, parsec, pretty, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "language-java";
       version = "0.2.8";
       sha256 = "0b789e089e4b18bf6248c2a1a9f3eff23cc19548899899f912597a1c33e9c367";
       libraryHaskellDepends = [ array base cpphs parsec pretty ];
       libraryToolDepends = [ alex ];
       testHaskellDepends = [
         base directory filepath HUnit mtl QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "http://github.com/vincenthz/language-java";
       description = "Manipulating Java source: abstract syntax, lexer, parser, and pretty-printer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-java-classfile" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , data-binary-ieee754, data-flags, deepseq, language-java, LibZip
     , mtl, parsec, utf8-string
     }:
     mkDerivation {
       pname = "language-java-classfile";
       version = "0.2.0";
       sha256 = "8ebd823a604da485cc3026d0db0332f03898f7fe252c846c3500ec5cfadff45f";
       libraryHaskellDepends = [
         array base binary bytestring containers data-binary-ieee754
         data-flags deepseq language-java LibZip mtl parsec utf8-string
       ];
       description = "Parser for Java .class files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-javascript_0_5_13" = callPackage
    ({ mkDerivation, alex, array, base, blaze-builder, bytestring
     , Cabal, containers, happy, HUnit, mtl, QuickCheck, test-framework
     , test-framework-hunit, utf8-light, utf8-string
     }:
     mkDerivation {
       pname = "language-javascript";
       version = "0.5.13";
       sha256 = "5cd824989ab56a87874dacc4335aa89cb97a649d71747a555c6fc45ea0e38640";
       libraryHaskellDepends = [
         array base blaze-builder bytestring containers mtl utf8-string
       ];
       libraryToolDepends = [ alex happy ];
       testHaskellDepends = [
         array base blaze-builder bytestring Cabal containers HUnit mtl
         QuickCheck test-framework test-framework-hunit utf8-light
         utf8-string
       ];
       jailbreak = true;
       homepage = "http://github.com/alanz/language-javascript";
       description = "Parser for JavaScript";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-javascript_0_5_13_3" = callPackage
    ({ mkDerivation, alex, array, base, blaze-builder, bytestring
     , Cabal, containers, happy, HUnit, mtl, QuickCheck, test-framework
     , test-framework-hunit, utf8-light, utf8-string
     }:
     mkDerivation {
       pname = "language-javascript";
       version = "0.5.13.3";
       sha256 = "fd90e90a4fdd97db1280f8c3159eb454fa585b7f8cf1ae0ac6602713baba3a19";
       libraryHaskellDepends = [
         array base blaze-builder bytestring containers mtl utf8-string
       ];
       libraryToolDepends = [ alex happy ];
       testHaskellDepends = [
         array base blaze-builder bytestring Cabal containers HUnit mtl
         QuickCheck test-framework test-framework-hunit utf8-light
         utf8-string
       ];
       homepage = "http://github.com/alanz/language-javascript";
       description = "Parser for JavaScript";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-javascript_0_5_13_4" = callPackage
    ({ mkDerivation, alex, array, base, blaze-builder, bytestring
     , Cabal, containers, happy, HUnit, mtl, QuickCheck, test-framework
     , test-framework-hunit, utf8-light, utf8-string
     }:
     mkDerivation {
       pname = "language-javascript";
       version = "0.5.13.4";
       sha256 = "b50651b82e754d3cec35d97dd5d2525516227969cd7aa59cd5ee528d254ee34d";
       libraryHaskellDepends = [
         array base blaze-builder bytestring containers mtl utf8-string
       ];
       libraryToolDepends = [ alex happy ];
       testHaskellDepends = [
         array base blaze-builder bytestring Cabal containers HUnit mtl
         QuickCheck test-framework test-framework-hunit utf8-light
         utf8-string
       ];
       homepage = "http://github.com/erikd/language-javascript";
       description = "Parser for JavaScript";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-javascript" = callPackage
    ({ mkDerivation, alex, array, base, blaze-builder, bytestring
     , Cabal, containers, happy, HUnit, mtl, QuickCheck, test-framework
     , test-framework-hunit, utf8-light, utf8-string
     }:
     mkDerivation {
       pname = "language-javascript";
       version = "0.5.14.2";
       sha256 = "2a86bd58b1821f1522be191c8d77a80e35550d43637a37644cbb15caac37d546";
       libraryHaskellDepends = [
         array base blaze-builder bytestring containers mtl utf8-string
       ];
       libraryToolDepends = [ alex happy ];
       testHaskellDepends = [
         array base blaze-builder bytestring Cabal containers HUnit mtl
         QuickCheck test-framework test-framework-hunit utf8-light
         utf8-string
       ];
       homepage = "http://github.com/erikd/language-javascript";
       description = "Parser for JavaScript";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-kort" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, QuickCheck
     , random, razom-text-util, regex-applicative, smaoin, text
     , text-position, utf8-string, vocabulary-kadma
     }:
     mkDerivation {
       pname = "language-kort";
       version = "0.1.0.0";
       sha256 = "2082166bcf06325d23fb221b84756216a0efdf67e9bd1faf9cdb417048fb1936";
       revision = "1";
       editedCabalFile = "970931caa4cb222825b70791198b4adc27877dbab25f0fb912348556e347fbf7";
       libraryHaskellDepends = [
         base base64-bytestring bytestring random razom-text-util
         regex-applicative smaoin text text-position utf8-string
         vocabulary-kadma
       ];
       testHaskellDepends = [
         base bytestring QuickCheck smaoin text vocabulary-kadma
       ];
       homepage = "http://rel4tion.org/projects/language-kort/";
       description = "Parser and serializer for the Kort information language";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "language-lua" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, deepseq, directory
     , filepath, mtl, parsec, QuickCheck, tasty, tasty-hunit
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "language-lua";
       version = "0.8.1";
       sha256 = "e6adaf71da11914ebb68094dd3e441134343f9fa821585de8fa72343005f1028";
       libraryHaskellDepends = [
         array base bytestring deepseq mtl parsec
       ];
       libraryToolDepends = [ alex ];
       testHaskellDepends = [
         base bytestring deepseq directory filepath parsec QuickCheck tasty
         tasty-hunit tasty-quickcheck
       ];
       homepage = "http://github.com/osa1/language-lua";
       description = "Lua parser and pretty-printer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-lua-qq" = callPackage
    ({ mkDerivation, base, haskell-src-meta, language-lua, mtl, syb
     , template-haskell, text
     }:
     mkDerivation {
       pname = "language-lua-qq";
       version = "0.1.0.0";
       sha256 = "d2f90a5b5051aa2591960a10d00a0d9ae6392360d32bf361d068e06c0ecde04d";
       libraryHaskellDepends = [
         base haskell-src-meta language-lua mtl syb template-haskell text
       ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/konn/language-lua-qq#readme";
       description = "Initial project template from stack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-lua2" = callPackage
    ({ mkDerivation, base, containers, deepseq, Earley
     , lexer-applicative, microlens, optparse-applicative, QuickCheck
     , regex-applicative, semigroups, srcloc, tasty, tasty-hunit
     , tasty-quickcheck, transformers, unordered-containers, wl-pprint
     }:
     mkDerivation {
       pname = "language-lua2";
       version = "0.1.0.5";
       sha256 = "4f24d7b015dbe1c7e9d1ead835ce426223531b8b6f408ee97b3d18904424393d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers Earley lexer-applicative microlens
         regex-applicative semigroups srcloc transformers
         unordered-containers wl-pprint
       ];
       executableHaskellDepends = [
         base Earley lexer-applicative optparse-applicative srcloc wl-pprint
       ];
       testHaskellDepends = [
         base deepseq lexer-applicative QuickCheck semigroups srcloc tasty
         tasty-hunit tasty-quickcheck unordered-containers
       ];
       doCheck = false;
       homepage = "http://github.com/mitchellwrosen/language-lua2";
       description = "Lua parser and pretty printer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-mixal" = callPackage
    ({ mkDerivation, base, mtl, parsec, pretty }:
     mkDerivation {
       pname = "language-mixal";
       version = "0.1";
       sha256 = "65b38dc828f19beba75454c0e62b556822aab747ef65f3495cc0ae01409ff239";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl parsec pretty ];
       executableHaskellDepends = [ base pretty ];
       homepage = "http://github.com/jtdaugherty/language-mixal/";
       description = "Parser, pretty-printer, and AST types for the MIXAL assembly language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-nix" = callPackage
    ({ mkDerivation, base, base-compat, Cabal, deepseq, doctest, lens
     , pretty, QuickCheck
     }:
     mkDerivation {
       pname = "language-nix";
       version = "2.1";
       sha256 = "ade0e0d0722e5b4fca532b4f0d1bc4827b767f912393b9023a80554fa889e044";
       libraryHaskellDepends = [
         base base-compat Cabal deepseq lens pretty QuickCheck
       ];
       testHaskellDepends = [
         base base-compat Cabal deepseq doctest lens pretty QuickCheck
       ];
       homepage = "https://github.com/peti/language-nix#readme";
       description = "Data types and useful functions to represent and manipulate the Nix language";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "language-objc" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers
     , directory, filepath, happy, newtype, pretty, process, syb
     }:
     mkDerivation {
       pname = "language-objc";
       version = "0.4.2.8";
       sha256 = "5b9acdc7765ed601acf923eac8dd2f97f447fac0f50b03d7547314b8be431d37";
       libraryHaskellDepends = [
         array base bytestring containers directory filepath newtype pretty
         process syb
       ];
       libraryToolDepends = [ alex happy ];
       jailbreak = true;
       homepage = "http://www.tiresiaspress.us/haskell/language-objc";
       description = "Analysis and generation of Objective C code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-openscad" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring }:
     mkDerivation {
       pname = "language-openscad";
       version = "0.1.6";
       sha256 = "592b393586fdecb03ca573f98794c7b78ec1836985e256e9d736769d15687c75";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ attoparsec base bytestring ];
       executableHaskellDepends = [ attoparsec base bytestring ];
       jailbreak = true;
       homepage = "http://www.github.com/bgamari/language-openscad";
       description = "A simple parser for OpenSCAD";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-pig" = callPackage
    ({ mkDerivation, base, Cabal, containers, HUnit, parsec
     , pretty-tree, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "language-pig";
       version = "0.3.0.1";
       sha256 = "c281be626aab3a5272fd56211ef2a61c753a174816cce0574e35425146fd68d3";
       libraryHaskellDepends = [
         base Cabal containers parsec pretty-tree
       ];
       testHaskellDepends = [
         base Cabal HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       jailbreak = true;
       description = "Pig parser in haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "language-puppet" = callPackage
    ({ mkDerivation, aeson, ansi-wl-pprint, attoparsec, base
     , base16-bytestring, bytestring, case-insensitive, containers
     , cryptonite, directory, either, exceptions, filecache, formatting
     , Glob, hashable, hruby, hslogger, hslua, hspec, HUnit, lens
     , lens-aeson, megaparsec, memory, mtl, operational
     , optparse-applicative, parallel-io, parsec, pcre-utils, process
     , random, regex-pcre-builtin, scientific, semigroups, servant
     , servant-client, split, stm, strict-base-types, temporary, text
     , time, transformers, unix, unordered-containers, vector, yaml
     }:
     mkDerivation {
       pname = "language-puppet";
       version = "1.1.5";
       sha256 = "1448e6a601ccf3468b856c6c53e0ba1e0b3d7df91da26e727e80ee203189fccc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-wl-pprint attoparsec base base16-bytestring bytestring
         case-insensitive containers cryptonite directory either exceptions
         filecache formatting hashable hruby hslogger hslua hspec lens
         lens-aeson megaparsec memory mtl operational parsec pcre-utils
         process random regex-pcre-builtin scientific semigroups servant
         servant-client split stm strict-base-types text time transformers
         unix unordered-containers vector yaml
       ];
       executableHaskellDepends = [
         aeson base bytestring containers either Glob hslogger lens
         megaparsec optparse-applicative parallel-io regex-pcre-builtin
         servant-client strict-base-types text unordered-containers vector
         yaml
       ];
       testHaskellDepends = [
         ansi-wl-pprint base either Glob hspec HUnit lens megaparsec
         scientific strict-base-types temporary text unix
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "http://lpuppet.banquise.net/";
       description = "Tools to parse and evaluate the Puppet DSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-python" = callPackage
    ({ mkDerivation, alex, array, base, containers, happy, monads-tf
     , pretty, transformers, utf8-string
     }:
     mkDerivation {
       pname = "language-python";
       version = "0.5.2";
       sha256 = "6c8bbde209ca62c32b9b89745f19203007c3dd407acc2f860a737b5a51446437";
       libraryHaskellDepends = [
         array base containers monads-tf pretty transformers utf8-string
       ];
       libraryToolDepends = [ alex happy ];
       homepage = "http://github.com/bjpop/language-python";
       description = "Parsing and pretty printing of Python code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-python-colour" = callPackage
    ({ mkDerivation, base, haskell98, language-python, xhtml }:
     mkDerivation {
       pname = "language-python-colour";
       version = "0.1";
       sha256 = "ffbe07bb62aca31cf11e9725a4489275dbd415459614b3b25c94d40676c857b3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base haskell98 language-python xhtml
       ];
       homepage = "http://www.cs.mu.oz.au/~bjpop/";
       description = "Generate coloured XHTML for Python code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-python-test" = callPackage
    ({ mkDerivation, base, language-python }:
     mkDerivation {
       pname = "language-python-test";
       version = "0.5.2";
       sha256 = "bf6828c9b940a0b42e7b46f0c75517ac6a50e858525416257fcc45957bb6e1a9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base language-python ];
       homepage = "http://github.com/bjpop/language-python-test";
       description = "testing code for the language-python library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-qux" = callPackage
    ({ mkDerivation, base, containers, either, indents
     , llvm-general-pure, mtl, parsec, pretty, transformers
     }:
     mkDerivation {
       pname = "language-qux";
       version = "0.2.0.0";
       sha256 = "1214e38b1ce62f40f43982667d61ccb3f9419f9854008d0d34910f285801ca75";
       libraryHaskellDepends = [
         base containers either indents llvm-general-pure mtl parsec pretty
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/qux-lang/language-qux";
       description = "Utilities for working with the Qux language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-sh" = callPackage
    ({ mkDerivation, base, directory, filepath, mtl, parsec, pcre-light
     }:
     mkDerivation {
       pname = "language-sh";
       version = "0.0.3.1";
       sha256 = "b334cd7565b39561ecb60af6b371a0f3e431837e4830497aaf61451d9af5d28b";
       libraryHaskellDepends = [
         base directory filepath mtl parsec pcre-light
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/shsh/";
       description = "A package for parsing shell scripts";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-slice" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, parsec, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , transformers
     }:
     mkDerivation {
       pname = "language-slice";
       version = "0.3.0.0";
       sha256 = "fe3788523faa8b914984fcb2f3e191b36ee7817c48c263cb3f62701b7e202fb5";
       libraryHaskellDepends = [ base bytestring parsec transformers ];
       testHaskellDepends = [
         base bytestring HUnit parsec QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 transformers
       ];
       homepage = "https://github.com/paulkoerbitz/language-slice";
       description = "AST and parser for the ZeroC Slice language (Specification language for ICE)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "language-spelling" = callPackage
    ({ mkDerivation, array, base, bk-tree, bytestring, containers
     , criterion, ListLike, listlike-instances, random-shuffle, text
     , time, tst, vector
     }:
     mkDerivation {
       pname = "language-spelling";
       version = "0.3.2";
       sha256 = "d50fb06fd80313372101704a2ba682a90e264ede098a1a738b2a2dc772e84f16";
       libraryHaskellDepends = [
         array base bk-tree bytestring containers ListLike
         listlike-instances text tst vector
       ];
       testHaskellDepends = [
         base bytestring criterion random-shuffle time
       ];
       homepage = "https://github.com/bitonic/language-spelling";
       description = "Various tools to detect/correct mistakes in words";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-sqlite" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, mtl
     , template-haskell, utf8-string
     }:
     mkDerivation {
       pname = "language-sqlite";
       version = "1.1";
       sha256 = "75242e5974d1a09f37bcf5142e99d5be1a9cf29e0028ea2a91a6e3d74db9ebd6";
       libraryHaskellDepends = [
         array base bytestring containers mtl template-haskell utf8-string
       ];
       homepage = "http://dankna.com/software/";
       description = "Full parser and generator for SQL as implemented by SQLite3";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-thrift_0_6_2_0" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, hspec, hspec-discover, lens
     , parsers, QuickCheck, template-haskell, text, transformers
     , trifecta, wl-pprint
     }:
     mkDerivation {
       pname = "language-thrift";
       version = "0.6.2.0";
       sha256 = "eeac9f1310fc93286f196e7421861b428db79c69cfac7465ef00525297a89d32";
       libraryHaskellDepends = [
         ansi-wl-pprint base lens parsers template-haskell text transformers
         trifecta wl-pprint
       ];
       testHaskellDepends = [
         ansi-wl-pprint base hspec hspec-discover parsers QuickCheck text
         trifecta wl-pprint
       ];
       homepage = "https://github.com/abhinav/language-thrift";
       description = "Parser and pretty printer for the Thrift IDL format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-thrift_0_7_0_0" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, hspec, hspec-discover, lens
     , parsers, QuickCheck, template-haskell, text, transformers
     , trifecta, wl-pprint
     }:
     mkDerivation {
       pname = "language-thrift";
       version = "0.7.0.0";
       sha256 = "41ebf1f8f630b6add359b648b32c366a85e68007ffd4af6e6649ace2fd3b79ab";
       libraryHaskellDepends = [
         ansi-wl-pprint base lens parsers template-haskell text transformers
         trifecta wl-pprint
       ];
       testHaskellDepends = [
         ansi-wl-pprint base hspec hspec-discover parsers QuickCheck text
         trifecta wl-pprint
       ];
       homepage = "https://github.com/abhinav/language-thrift";
       description = "Parser and pretty printer for the Thrift IDL format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-thrift_0_7_0_1" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, hspec, hspec-discover, lens
     , parsers, QuickCheck, text, transformers, trifecta, wl-pprint
     }:
     mkDerivation {
       pname = "language-thrift";
       version = "0.7.0.1";
       sha256 = "67d26a72529fe49bb3e9a9cc087dc5ee302ba3cf19b62cda601e9a68adfbbdc5";
       libraryHaskellDepends = [
         ansi-wl-pprint base lens parsers text transformers trifecta
         wl-pprint
       ];
       testHaskellDepends = [
         ansi-wl-pprint base hspec hspec-discover parsers QuickCheck text
         trifecta wl-pprint
       ];
       homepage = "https://github.com/abhinav/language-thrift";
       description = "Parser and pretty printer for the Thrift IDL format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-thrift" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, hspec, hspec-discover
     , megaparsec, QuickCheck, text, transformers
     }:
     mkDerivation {
       pname = "language-thrift";
       version = "0.8.0.0";
       sha256 = "1bfb07ecaa49d8cffa2b985f1d820607ca6369692a98ea7f9f3ec3133959452a";
       libraryHaskellDepends = [
         ansi-wl-pprint base megaparsec text transformers
       ];
       testHaskellDepends = [
         ansi-wl-pprint base hspec hspec-discover megaparsec QuickCheck text
       ];
       homepage = "https://github.com/abhinav/language-thrift";
       description = "Parser and pretty printer for the Thrift IDL format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "language-typescript" = callPackage
    ({ mkDerivation, base, containers, parsec, pretty }:
     mkDerivation {
       pname = "language-typescript";
       version = "0.0.4";
       sha256 = "ed8b3c8c12d505ce2ae7bdec28bf8093c78442011573ffca12d2b053491b951e";
       libraryHaskellDepends = [ base containers parsec pretty ];
       homepage = "http://github.com/paf31/language-typescript";
       description = "A library for working with TypeScript Definition files";
       license = stdenv.lib.licenses.mit;
     }) {};

  "language-vhdl" = callPackage
    ({ mkDerivation, base, pretty }:
     mkDerivation {
       pname = "language-vhdl";
       version = "0.1.2.6";
       sha256 = "87d000bdf5872b26329980825c0dd668ae6070f48e32836d13e3817ad10f7ddc";
       libraryHaskellDepends = [ base pretty ];
       homepage = "https://github.com/markus-git/language-vhdl";
       description = "VHDL AST and pretty printer in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "largeword_1_2_3" = callPackage
    ({ mkDerivation, base, binary, bytestring, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "largeword";
       version = "1.2.3";
       sha256 = "960e341af0de950db4e7c47a987bb0789f7759bb27c801ac26e89a28add5acd1";
       libraryHaskellDepends = [ base binary ];
       testHaskellDepends = [
         base binary bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/idontgetoutmuch/largeword";
       description = "Provides Word128, Word192 and Word256 and a way of producing other large words if required";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "largeword" = callPackage
    ({ mkDerivation, base, binary, bytestring, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "largeword";
       version = "1.2.5";
       sha256 = "00b3b06d846649bf404f52a725c88349a38bc8c810e16c99f3100c4e1e9d7d46";
       libraryHaskellDepends = [ base binary ];
       testHaskellDepends = [
         base binary bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/idontgetoutmuch/largeword";
       description = "Provides Word128, Word192 and Word256 and a way of producing other large words if required";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lat" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, cmdargs, directory, filepath
     , haskell98, haxr, HDBC, HDBC-sqlite3, hsini, HTTP, mtl, old-locale
     , regex-compat, tagsoup, time
     }:
     mkDerivation {
       pname = "lat";
       version = "0.6";
       sha256 = "b6ff412595fa2d9ce88e980d972f4ba5364fdee1460afe180e7cec032663df6a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-wl-pprint base cmdargs directory filepath haskell98 haxr HDBC
         HDBC-sqlite3 hsini HTTP mtl old-locale regex-compat tagsoup time
       ];
       jailbreak = true;
       description = "Tool to track security alerts on LWN";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "latest-npm-version" = callPackage
    ({ mkDerivation, aeson, base, cmdargs, hspec, http-client
     , http-types, lens, network, pipes, pipes-attoparsec
     , pipes-bytestring, pipes-http, text, text-format, transformers
     }:
     mkDerivation {
       pname = "latest-npm-version";
       version = "0.3.1";
       sha256 = "c0663c0d5cffc3512356f711b6aafb25daa1d1bc060aeb5db424a79622a0d27c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base http-client http-types lens network pipes
         pipes-attoparsec pipes-bytestring pipes-http text text-format
         transformers
       ];
       executableHaskellDepends = [
         aeson base cmdargs http-client http-types lens network pipes
         pipes-attoparsec pipes-bytestring pipes-http text text-format
         transformers
       ];
       testHaskellDepends = [
         aeson base hspec http-client http-types lens network pipes
         pipes-attoparsec pipes-bytestring pipes-http text text-format
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/passy/latest-npm-version";
       description = "Find the latest version of a package on npm";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "latex" = callPackage
    ({ mkDerivation, base, containers, utility-ht }:
     mkDerivation {
       pname = "latex";
       version = "0.1.0.3";
       sha256 = "b742ff5c83f6019469e55d2f3559d8efbc7ce62607e5de76485a7cb314e636d2";
       libraryHaskellDepends = [ base containers utility-ht ];
       homepage = "http://www.haskell.org/haskellwiki/LaTeX";
       description = "Parse, format and process LaTeX files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "latex-formulae-hakyll_0_2_0_0" = callPackage
    ({ mkDerivation, base, hakyll, latex-formulae-image
     , latex-formulae-pandoc, lrucache, pandoc-types
     }:
     mkDerivation {
       pname = "latex-formulae-hakyll";
       version = "0.2.0.0";
       sha256 = "54fdac8793f69b97b3a5cd6e758a5f21afe2066d5414b5cb26af60d386d3ba96";
       libraryHaskellDepends = [
         base hakyll latex-formulae-image latex-formulae-pandoc lrucache
         pandoc-types
       ];
       jailbreak = true;
       homepage = "https://github.com/liamoc/latex-formulae#readme";
       description = "Use actual LaTeX to render formulae inside Hakyll pages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "latex-formulae-hakyll" = callPackage
    ({ mkDerivation, base, hakyll, latex-formulae-image
     , latex-formulae-pandoc, lrucache, pandoc-types
     }:
     mkDerivation {
       pname = "latex-formulae-hakyll";
       version = "0.2.0.1";
       sha256 = "cf1e0cc594866b0b835ba8ac035f66c25b0f555157b10a1771acb9a9c2450a93";
       libraryHaskellDepends = [
         base hakyll latex-formulae-image latex-formulae-pandoc lrucache
         pandoc-types
       ];
       homepage = "https://github.com/liamoc/latex-formulae#readme";
       description = "Use actual LaTeX to render formulae inside Hakyll pages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "latex-formulae-image_0_1_1_0" = callPackage
    ({ mkDerivation, base, directory, errors, filepath, JuicyPixels
     , process, temporary, transformers
     }:
     mkDerivation {
       pname = "latex-formulae-image";
       version = "0.1.1.0";
       sha256 = "39918993fd736ebfe316ab49a644bf73e918b03697daf98b550854887a1a5f93";
       libraryHaskellDepends = [
         base directory errors filepath JuicyPixels process temporary
         transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/liamoc/latex-formulae#readme";
       description = "A library for rendering LaTeX formulae as images using an actual LaTeX installation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "latex-formulae-image" = callPackage
    ({ mkDerivation, base, directory, errors, filepath, JuicyPixels
     , process, temporary, transformers
     }:
     mkDerivation {
       pname = "latex-formulae-image";
       version = "0.1.1.1";
       sha256 = "6c663420647282ec20c71421a2faf95629f2690283df4b9279ae53536cac3f61";
       libraryHaskellDepends = [
         base directory errors filepath JuicyPixels process temporary
         transformers
       ];
       homepage = "http://github.com/liamoc/latex-formulae#readme";
       description = "A library for rendering LaTeX formulae as images using an actual LaTeX installation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "latex-formulae-pandoc_0_2_0_2" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, directory
     , filepath, JuicyPixels, latex-formulae-image, pandoc-types
     }:
     mkDerivation {
       pname = "latex-formulae-pandoc";
       version = "0.2.0.2";
       sha256 = "a59da804cc67510a3f6347a98b3e7376a72debe21d2f92872dba3951799df167";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring bytestring directory filepath JuicyPixels
         latex-formulae-image pandoc-types
       ];
       executableHaskellDepends = [
         base latex-formulae-image pandoc-types
       ];
       jailbreak = true;
       homepage = "http://github.com/liamoc/latex-formulae#readme";
       description = "Render LaTeX formulae in pandoc documents to images with an actual LaTeX installation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "latex-formulae-pandoc" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, directory
     , filepath, JuicyPixels, latex-formulae-image, pandoc-types
     }:
     mkDerivation {
       pname = "latex-formulae-pandoc";
       version = "0.2.0.3";
       sha256 = "289720149572814da30b9854b8a7b0798125c3fa3508b28ca53c9d382f65d12d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring bytestring directory filepath JuicyPixels
         latex-formulae-image pandoc-types
       ];
       executableHaskellDepends = [
         base latex-formulae-image pandoc-types
       ];
       homepage = "http://github.com/liamoc/latex-formulae#readme";
       description = "Render LaTeX formulae in pandoc documents to images with an actual LaTeX installation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lattices_1_2_1_1" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "lattices";
       version = "1.2.1.1";
       sha256 = "e6d2387c1a1b5e8966fdf0450a4f598881a223c76eac4194ffa6ecc307dbf85e";
       libraryHaskellDepends = [ base containers ];
       description = "Fine-grained library for constructing and manipulating lattices";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lattices_1_3" = callPackage
    ({ mkDerivation, base, containers, deepseq, hashable
     , unordered-containers
     }:
     mkDerivation {
       pname = "lattices";
       version = "1.3";
       sha256 = "74dc2a60eb0dc6118881c7b8c97443d1ea48790a223a0ad44c2ec717601ee6ca";
       revision = "1";
       editedCabalFile = "614ea39ee90b5f3bc38f4af7dc823f886391f485a6e20b7d83f082b73e94a79e";
       libraryHaskellDepends = [
         base containers deepseq hashable unordered-containers
       ];
       homepage = "http://github.com/phadej/lattices/";
       description = "Fine-grained library for constructing and manipulating lattices";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lattices" = callPackage
    ({ mkDerivation, base, containers, deepseq, hashable, QuickCheck
     , semigroups, tagged, tasty, tasty-quickcheck, transformers
     , universe-base, universe-reverse-instances, unordered-containers
     , void
     }:
     mkDerivation {
       pname = "lattices";
       version = "1.5.0";
       sha256 = "c6e3fb4334503b9087209195f40c96f56819497f999959358a2ff5d843a45d1f";
       revision = "1";
       editedCabalFile = "566d0c60f273b1d938dd9db805546fbcd4b53c132f1dfa259d6d23e212e88512";
       libraryHaskellDepends = [
         base containers deepseq hashable semigroups tagged universe-base
         universe-reverse-instances unordered-containers void
       ];
       testHaskellDepends = [
         base QuickCheck tasty tasty-quickcheck transformers
       ];
       homepage = "http://github.com/phadej/lattices/";
       description = "Fine-grained library for constructing and manipulating lattices";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "launchpad-control" = callPackage
    ({ mkDerivation, array, base, containers, hmidi, mtl, transformers
     }:
     mkDerivation {
       pname = "launchpad-control";
       version = "0.0.1.0";
       sha256 = "0223b73078105dc974814eea8bd237b84574f05f3b27b5767d7b44c74bcd7951";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers hmidi mtl transformers
       ];
       executableHaskellDepends = [ base ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "High and low-level interface to the Novation Launchpad midi controller";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lax" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "lax";
       version = "0.1.0.3";
       sha256 = "9e5105eb293e99fe2adc6ad80d674f4153a7610ba4bda1370365da428a98c089";
       libraryHaskellDepends = [ base ];
       homepage = "http://darcs.wolfgang.jeltsch.info/haskell/lax";
       description = "Lax arrows";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "layers" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "layers";
       version = "0.1";
       sha256 = "ae553ef07a6117fe13d296abd7db21fee75453480440cba8e608a4d51fd7c8fa";
       libraryHaskellDepends = [ base transformers ];
       jailbreak = true;
       homepage = "http://github.com/duairc/layers";
       description = "Modular type class machinery for monad transformer stacks";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "layers-game" = callPackage
    ({ mkDerivation, base, cmdargs, composition, data-lens, Gamgine
     , GLFW-b, ListZipper, mtl, OpenGLRaw, pretty-show
     }:
     mkDerivation {
       pname = "layers-game";
       version = "0.5";
       sha256 = "688e13233f97989e999571a73163c5a15631da753db7715328b5a226077e4106";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs composition data-lens Gamgine GLFW-b ListZipper mtl
         OpenGLRaw pretty-show
       ];
       jailbreak = true;
       description = "A prototypical 2d platform game";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "layout" = callPackage
    ({ mkDerivation, base, convertible, hinduce-missingh }:
     mkDerivation {
       pname = "layout";
       version = "0.0.0.1";
       sha256 = "0f483650f9d95f35aa5089135164d07187bb95d125f69bb872d110e3442f0710";
       libraryHaskellDepends = [ base convertible hinduce-missingh ];
       description = "Turn values into pretty text or markup";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "layout-bootstrap" = callPackage
    ({ mkDerivation, base, blaze-html, containers, text }:
     mkDerivation {
       pname = "layout-bootstrap";
       version = "0.2.2";
       sha256 = "11fb383fe7725186f75214521b5f0bf77b67ba6b7bbc4c7454c5a04768e1a066";
       libraryHaskellDepends = [ base blaze-html containers text ];
       homepage = "https://bitbucket.org/dpwiz/layout-bootstrap";
       description = "Template and widgets for Bootstrap2 to use with Text.Blaze.Html5";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lazy-csv_0_5" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "lazy-csv";
       version = "0.5";
       sha256 = "00b6d0f6fb51d851826c25482a4fad025b9587f115e56399548e0b0ff990a576";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring ];
       executableHaskellDepends = [ base bytestring ];
       homepage = "http://code.haskell.org/lazy-csv";
       description = "Efficient lazy parsers for CSV (comma-separated values)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lazy-csv" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "lazy-csv";
       version = "0.5.1";
       sha256 = "888bcbdd43886099f197c1c246cea324c97c076d4839e97eea0b8d6d7b49649f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring ];
       executableHaskellDepends = [ base bytestring ];
       homepage = "http://code.haskell.org/lazy-csv";
       description = "Efficient lazy parsers for CSV (comma-separated values)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lazy-io" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "lazy-io";
       version = "0.1.0";
       sha256 = "c953ce66bb15c763b7f0eac890f46d08b1a372b6ae558133a99ddccd39aa7b39";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/kawu/lazy-io";
       description = "Lazy IO";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lazyarray" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "lazyarray";
       version = "0.1.3";
       sha256 = "f6dc33dd419979e6d95b9bfe332fc72407c5545bbf2c4f10fbb57987fab1822d";
       libraryHaskellDepends = [ array base ];
       description = "Efficient implementation of lazy monolithic arrays (lazy in indexes)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lazyio" = callPackage
    ({ mkDerivation, base, transformers, unsafe }:
     mkDerivation {
       pname = "lazyio";
       version = "0.1.0.1";
       sha256 = "6ca1411fe34f1249f2cfac3ec60018449b0e6e9de9bf7918e6de55e6a20f9499";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base transformers unsafe ];
       homepage = "http://www.haskell.org/haskellwiki/Lazy_IO";
       description = "Run IO actions lazily while respecting their order";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lazysmallcheck" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "lazysmallcheck";
       version = "0.6";
       sha256 = "9dd4dfb590c77e4f6aff68296602de58422eed5e7148fc29190d875a4e7d0f53";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.cs.york.ac.uk/~mfn/lazysmallcheck/";
       description = "A library for demand-driven testing of Haskell programs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lazysplines" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "lazysplines";
       version = "0.2";
       sha256 = "de00c0313670612ff9df5bacaf7196fa5379122e0165b718fa5677e5cd1adf64";
       libraryHaskellDepends = [ base ];
       description = "Differential solving with lazy splines";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lbfgs" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "lbfgs";
       version = "0.0.5";
       sha256 = "0628f41210ccf045e42d37f86535ec9be95b94b39bb5a1caba5ecf510086c948";
       libraryHaskellDepends = [ array base ];
       description = "L-BFGS optimization";
       license = "unknown";
     }) {};

  "lca_0_2_4" = callPackage
    ({ mkDerivation, base, doctest }:
     mkDerivation {
       pname = "lca";
       version = "0.2.4";
       sha256 = "51afe62e4043271fa7e0a2ad8ee7d4c8f2f9b8441ed5d8eb8df865cbcbc74736";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base doctest ];
       homepage = "http://github.com/ekmett/lca/";
       description = "O(log n) persistent on-line lowest common ancestor calculation without preprocessing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lca" = callPackage
    ({ mkDerivation, base, doctest }:
     mkDerivation {
       pname = "lca";
       version = "0.3";
       sha256 = "ea4f35072f7b1b217cb0d65493afd8e8449017c7062afe092768ed1219982e20";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base doctest ];
       homepage = "http://github.com/ekmett/lca/";
       description = "O(log n) persistent on-line lowest common ancestor calculation without preprocessing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lcs" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "lcs";
       version = "0.2";
       sha256 = "b4db67ead4e2f58c4d462d4c1006d2158744ef3ca8597295a1dfa08537401ff1";
       libraryHaskellDepends = [ array base ];
       homepage = "http://urchin.earth.li/~ian/cabal/lcs/";
       description = "Find longest common sublist of two lists";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lda" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, mtl, random-fu
     , random-source, rvar, vector
     }:
     mkDerivation {
       pname = "lda";
       version = "0.0.2";
       sha256 = "42c7216454c6c9404edb3afaf417f7250458c8240367024d19e6f1ebbc3ebe88";
       libraryHaskellDepends = [
         base containers ghc-prim mtl random-fu random-source rvar vector
       ];
       homepage = "https://bitbucket.org/gchrupala/colada";
       description = "Online Latent Dirichlet Allocation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ldap-client" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, async, base, bytestring
     , connection, containers, hspec, network, process, semigroups, stm
     , text
     }:
     mkDerivation {
       pname = "ldap-client";
       version = "0.1.0";
       sha256 = "c4b10f1a57476139f1077f34e9d5f1cdde8673851eea3e596cfb28fe9c1c83a1";
       libraryHaskellDepends = [
         asn1-encoding asn1-types async base bytestring connection
         containers network semigroups stm text
       ];
       testHaskellDepends = [ base bytestring hspec process semigroups ];
       homepage = "https://supki.github.io/ldap-client";
       description = "Pure Haskell LDAP Client Library";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ldif" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, containers, directory
     , filepath, HUnit, parsec, rosezipper
     }:
     mkDerivation {
       pname = "ldif";
       version = "0.0.13";
       sha256 = "0a85736fab260470789772e75a1e180985fd55390f9a0790c3b9c6f7e566c055";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cmdargs containers directory filepath parsec
         rosezipper
       ];
       executableHaskellDepends = [
         base bytestring cmdargs containers filepath
       ];
       testHaskellDepends = [ base HUnit ];
       jailbreak = true;
       homepage = "http://rampa.sk/static/ldif.html";
       description = "The LDAP Data Interchange Format (LDIF) tools";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "leaf" = callPackage
    ({ mkDerivation, base, blaze-html, directory, filepath, pandoc
     , split
     }:
     mkDerivation {
       pname = "leaf";
       version = "1.0.1.1";
       sha256 = "df40c69cc9e78f36b64cb5004b6ae79fbac80c0e3019f39b6ce709d54523f3b3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-html directory filepath pandoc split
       ];
       jailbreak = true;
       homepage = "https://github.com/skypers/leaf";
       description = "A simple portfolio generator";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "leaky" = callPackage
    ({ mkDerivation, base, cpphs, deepseq-bounded, deepseq-generics
     , generics-sop, random, seqaid, template-haskell
     }:
     mkDerivation {
       pname = "leaky";
       version = "0.4.0.0";
       sha256 = "c02dfab3bf9e77bc1129fbeb211441cbd8112fb1ac75bed8742b3af6750d9a9d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cpphs deepseq-bounded deepseq-generics generics-sop random
         seqaid template-haskell
       ];
       jailbreak = true;
       homepage = "http://fremissant.net/leaky";
       description = "Robust space leak, and its strictification";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "leankit-api" = callPackage
    ({ mkDerivation, aeson, base, bytestring, colour, curl, split }:
     mkDerivation {
       pname = "leankit-api";
       version = "0.4";
       sha256 = "278b739d6f28cf67cf4238efb8ddef850cf044e4bca683fcd3ab36260e4f5d91";
       libraryHaskellDepends = [
         aeson base bytestring colour curl split
       ];
       description = "LeanKit API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "leapseconds-announced" = callPackage
    ({ mkDerivation, base, QuickCheck, time }:
     mkDerivation {
       pname = "leapseconds-announced";
       version = "2015.0.0.1";
       sha256 = "15fabb848809ffd47010161bc7cd3f301862b63f93f3c7c5e228b3809d84134d";
       libraryHaskellDepends = [ base time ];
       testHaskellDepends = [ base QuickCheck time ];
       homepage = "https://github.com/bjornbm/leapseconds-announced";
       description = "Leap seconds announced at library release time";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "learn" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "learn";
       version = "0.1.1";
       sha256 = "f26e4aa36e63755620aefcc945977ddf6c0a0acce562a93b901daf572fb159c4";
       libraryHaskellDepends = [ base containers ];
       description = "Learning Algorithms";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "learn-physics" = callPackage
    ({ mkDerivation, base, gloss, gnuplot, not-gloss, spatial-math
     , vector-space
     }:
     mkDerivation {
       pname = "learn-physics";
       version = "0.5.2";
       sha256 = "473585c2c6c8c3503bba1dcbfc308dcb402a67c942a8edb5ed3bfbad1e91830d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base gloss gnuplot not-gloss spatial-math vector-space
       ];
       executableHaskellDepends = [
         base gloss gnuplot not-gloss spatial-math
       ];
       description = "Haskell code for learning physics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "learn-physics-examples" = callPackage
    ({ mkDerivation, base, gloss, gnuplot, learn-physics, not-gloss
     , spatial-math
     }:
     mkDerivation {
       pname = "learn-physics-examples";
       version = "0.5.0.1";
       sha256 = "73e0422c7890cd637c4d868408e5618c788557d0fc341923d32aeb54f061953b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base gloss gnuplot learn-physics not-gloss spatial-math
       ];
       jailbreak = true;
       description = "examples for learn-physics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "learning-hmm" = callPackage
    ({ mkDerivation, base, containers, deepseq, hmatrix, random-fu
     , random-source, vector
     }:
     mkDerivation {
       pname = "learning-hmm";
       version = "0.3.2.2";
       sha256 = "3a730fa97866640d89f15a73fd7af0261e027c5d5a939231a38a5aead8494aa8";
       libraryHaskellDepends = [
         base containers deepseq hmatrix random-fu random-source vector
       ];
       homepage = "https://github.com/mnacamura/learning-hmm";
       description = "Yet another library for hidden Markov models";
       license = stdenv.lib.licenses.mit;
     }) {};

  "leetify" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "leetify";
       version = "0.1.0.1";
       sha256 = "795b64c6edfef43e700b5d6200a4a66764b35c827642e7316ec7a84af3c9d780";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers ];
       jailbreak = true;
       homepage = "http://github.com/phaazon/leetify";
       description = "Leetify text";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "leksah" = callPackage
    ({ mkDerivation, array, base, binary, binary-shared, blaze-html
     , bytestring, Cabal, conduit, containers, cpphs, deepseq, directory
     , executable-path, filepath, ghc, ghcjs-codemirror, ghcjs-dom, gio
     , glib, gtk3, gtksourceview3, haskell-src-exts, hlint, hslogger
     , jsaddle, leksah-server, lens, ltk, monad-loops, mtl, network
     , network-uri, old-time, parsec, pretty, pretty-show, QuickCheck
     , regex-base, regex-tdfa, regex-tdfa-text, shakespeare, stm, strict
     , text, time, transformers, unix, utf8-string, vado, vcsgui
     , vcswrapper, webkitgtk3, webkitgtk3-javascriptcore
     }:
     mkDerivation {
       pname = "leksah";
       version = "0.15.1.4";
       sha256 = "85f60091febd593f996c90cb9fa0e2f2dd1bff1f18a443244be1111540ea30ad";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary binary-shared blaze-html bytestring Cabal conduit
         containers cpphs deepseq directory executable-path filepath ghc
         ghcjs-codemirror gio glib gtk3 gtksourceview3 haskell-src-exts
         hlint hslogger jsaddle leksah-server lens ltk mtl network
         network-uri old-time parsec pretty pretty-show QuickCheck
         regex-base regex-tdfa regex-tdfa-text shakespeare stm strict text
         time transformers unix utf8-string vado vcsgui vcswrapper
         webkitgtk3 webkitgtk3-javascriptcore
       ];
       executableHaskellDepends = [
         base ghcjs-dom gtk3 gtksourceview3 jsaddle stm webkitgtk3
         webkitgtk3-javascriptcore
       ];
       testHaskellDepends = [
         base Cabal containers glib gtk3 gtksourceview3 hslogger
         leksah-server ltk monad-loops QuickCheck stm text transformers
         webkitgtk3
       ];
       jailbreak = true;
       homepage = "http://www.leksah.org";
       description = "Haskell IDE written in Haskell";
       license = "GPL";
     }) {};

  "leksah-server" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-conduit, base
     , bin-package-db, binary, binary-shared, bytestring, Cabal, conduit
     , conduit-extra, containers, deepseq, directory, executable-path
     , filepath, ghc, haddock-api, haddock-library, hslogger, HTTP
     , HUnit, ltk, network, network-uri, parsec, pretty, process
     , resourcet, strict, text, time, transformers, unix
     }:
     mkDerivation {
       pname = "leksah-server";
       version = "0.15.0.9";
       sha256 = "78f2ee49b1a06fa12de242a35a9eeaaf3e8b90d7af8bffef3e1b20561826abe5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec attoparsec-conduit base bin-package-db binary
         binary-shared bytestring Cabal conduit conduit-extra containers
         deepseq directory executable-path filepath ghc haddock-api
         haddock-library hslogger HTTP ltk network network-uri parsec pretty
         process resourcet strict text time transformers unix
       ];
       executableHaskellDepends = [
         attoparsec attoparsec-conduit base bin-package-db binary
         binary-shared bytestring Cabal conduit conduit-extra containers
         deepseq directory executable-path filepath ghc haddock-api
         haddock-library hslogger HTTP ltk network network-uri parsec pretty
         process resourcet strict text time transformers unix
       ];
       testHaskellDepends = [
         base conduit conduit-extra hslogger HUnit process resourcet
         transformers
       ];
       jailbreak = true;
       homepage = "http://leksah.org";
       description = "Metadata collection for leksah";
       license = "GPL";
     }) {};

  "lendingclub" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, HsOpenSSL
     , http-streams, io-streams, mtl, scientific, text, vector
     }:
     mkDerivation {
       pname = "lendingclub";
       version = "0.1.1";
       sha256 = "dd71c97413e3e35a5a706f686d85e22b071435c417d26f7bfb6f17e24ec580e4";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring HsOpenSSL http-streams
         io-streams mtl scientific text vector
       ];
       homepage = "https://www.lendingclub.com/developers/lc-api.action";
       description = "Bindings for the LendingClub marketplace API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lens_4_6_0_1" = callPackage
    ({ mkDerivation, array, base, bifunctors, bytestring, comonad
     , containers, contravariant, deepseq, directory, distributive
     , doctest, exceptions, filepath, free, generic-deriving, ghc-prim
     , hashable, hlint, HUnit, mtl, nats, parallel, primitive
     , profunctors, QuickCheck, reflection, semigroupoids, semigroups
     , simple-reflect, split, tagged, template-haskell, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     , test-framework-th, text, transformers, transformers-compat
     , unordered-containers, vector, void
     }:
     mkDerivation {
       pname = "lens";
       version = "4.6.0.1";
       sha256 = "e26f3b91d738d8cc9e66cf5286aa2559d4f79dcaa26dd59374fda7a1d8843025";
       revision = "2";
       editedCabalFile = "9cbb6759a7a8fc65288bca8eeb232fad669fad44746b946cb126b88225c37469";
       libraryHaskellDepends = [
         array base bifunctors bytestring comonad containers contravariant
         distributive exceptions filepath free ghc-prim hashable mtl
         parallel primitive profunctors reflection semigroupoids semigroups
         split tagged template-haskell text transformers transformers-compat
         unordered-containers vector void
       ];
       testHaskellDepends = [
         base bytestring containers deepseq directory doctest filepath
         generic-deriving hlint HUnit mtl nats parallel QuickCheck
         semigroups simple-reflect split test-framework test-framework-hunit
         test-framework-quickcheck2 test-framework-th text transformers
         unordered-containers vector
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/ekmett/lens/";
       description = "Lenses, Folds and Traversals";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lens_4_7_0_1" = callPackage
    ({ mkDerivation, array, base, bifunctors, bytestring, comonad
     , containers, contravariant, deepseq, directory, distributive
     , doctest, exceptions, filepath, free, generic-deriving, ghc-prim
     , hashable, hlint, HUnit, mtl, nats, parallel, primitive
     , profunctors, QuickCheck, reflection, semigroupoids, semigroups
     , simple-reflect, split, tagged, template-haskell, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     , test-framework-th, text, transformers, transformers-compat
     , unordered-containers, vector, void
     }:
     mkDerivation {
       pname = "lens";
       version = "4.7.0.1";
       sha256 = "4186ca783a8bf6450be87e2c30c5d3a1f735c52ac0c38db2c01f0da9c93b2dc9";
       revision = "3";
       editedCabalFile = "6ac87d4c8600c9497c965d54b1e97f10d0073bed3c45381b78d1ba4b81da57c8";
       libraryHaskellDepends = [
         array base bifunctors bytestring comonad containers contravariant
         distributive exceptions filepath free ghc-prim hashable mtl
         parallel primitive profunctors reflection semigroupoids semigroups
         split tagged template-haskell text transformers transformers-compat
         unordered-containers vector void
       ];
       testHaskellDepends = [
         base bytestring containers deepseq directory doctest filepath
         generic-deriving hlint HUnit mtl nats parallel QuickCheck
         semigroups simple-reflect split test-framework test-framework-hunit
         test-framework-quickcheck2 test-framework-th text transformers
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/lens/";
       description = "Lenses, Folds and Traversals";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lens_4_12_3" = callPackage
    ({ mkDerivation, array, base, base-orphans, bifunctors, bytestring
     , comonad, containers, contravariant, deepseq, directory
     , distributive, doctest, exceptions, filepath, free
     , generic-deriving, ghc-prim, hashable, hlint, HUnit
     , kan-extensions, mtl, nats, parallel, profunctors, QuickCheck
     , reflection, semigroupoids, semigroups, simple-reflect, tagged
     , template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, test-framework-th, text, transformers
     , transformers-compat, unordered-containers, vector, void
     }:
     mkDerivation {
       pname = "lens";
       version = "4.12.3";
       sha256 = "48fa9d46b37ff4f650204f82df7d40f7ae78418badf40d9d3fc7eba479f82821";
       revision = "1";
       editedCabalFile = "25acec37a9866c00c8a5cae15827616f8ac3f07717a8db23000708d5bf20b21a";
       libraryHaskellDepends = [
         array base base-orphans bifunctors bytestring comonad containers
         contravariant distributive exceptions filepath free ghc-prim
         hashable kan-extensions mtl parallel profunctors reflection
         semigroupoids semigroups tagged template-haskell text transformers
         transformers-compat unordered-containers vector void
       ];
       testHaskellDepends = [
         base bytestring containers deepseq directory doctest filepath
         generic-deriving hlint HUnit mtl nats parallel QuickCheck
         semigroups simple-reflect test-framework test-framework-hunit
         test-framework-quickcheck2 test-framework-th text transformers
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/lens/";
       description = "Lenses, Folds and Traversals";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lens" = callPackage
    ({ mkDerivation, array, base, base-orphans, bifunctors, bytestring
     , comonad, containers, contravariant, deepseq, directory
     , distributive, doctest, exceptions, filepath, free
     , generic-deriving, ghc-prim, hashable, hlint, HUnit
     , kan-extensions, mtl, nats, parallel, profunctors, QuickCheck
     , reflection, semigroupoids, semigroups, simple-reflect, tagged
     , template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, test-framework-th, text, transformers
     , transformers-compat, unordered-containers, vector, void
     }:
     mkDerivation {
       pname = "lens";
       version = "4.13";
       sha256 = "3556e7bf69d13fca0e73c5e429c8d25a876931c24ae5aa1f4755acac67078f3c";
       libraryHaskellDepends = [
         array base base-orphans bifunctors bytestring comonad containers
         contravariant distributive exceptions filepath free ghc-prim
         hashable kan-extensions mtl parallel profunctors reflection
         semigroupoids semigroups tagged template-haskell text transformers
         transformers-compat unordered-containers vector void
       ];
       testHaskellDepends = [
         base bytestring containers deepseq directory doctest filepath
         generic-deriving hlint HUnit mtl nats parallel QuickCheck
         semigroups simple-reflect test-framework test-framework-hunit
         test-framework-quickcheck2 test-framework-th text transformers
         unordered-containers vector
       ];
       doCheck = false;
       homepage = "http://github.com/ekmett/lens/";
       description = "Lenses, Folds and Traversals";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lens_4_13_2" = callPackage
    ({ mkDerivation, array, base, base-orphans, bifunctors, bytestring
     , comonad, containers, contravariant, deepseq, directory
     , distributive, doctest, exceptions, filepath, free
     , generic-deriving, ghc-prim, hashable, hlint, HUnit
     , kan-extensions, mtl, nats, parallel, profunctors, QuickCheck
     , reflection, semigroupoids, semigroups, simple-reflect, tagged
     , template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, test-framework-th, text, transformers
     , transformers-compat, unordered-containers, vector, void
     }:
     mkDerivation {
       pname = "lens";
       version = "4.13.2";
       sha256 = "814b7b35949cc8a3ad1a35fc39b88fc3b78bbfb339097f3f3438627048155b78";
       libraryHaskellDepends = [
         array base base-orphans bifunctors bytestring comonad containers
         contravariant distributive exceptions filepath free ghc-prim
         hashable kan-extensions mtl parallel profunctors reflection
         semigroupoids semigroups tagged template-haskell text transformers
         transformers-compat unordered-containers vector void
       ];
       testHaskellDepends = [
         base bytestring containers deepseq directory doctest filepath
         generic-deriving hlint HUnit mtl nats parallel QuickCheck
         semigroups simple-reflect test-framework test-framework-hunit
         test-framework-quickcheck2 test-framework-th text transformers
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/lens/";
       description = "Lenses, Folds and Traversals";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lens-action_0_1_0_1" = callPackage
    ({ mkDerivation, base, comonad, contravariant, directory, doctest
     , filepath, lens, mtl, profunctors, semigroupoids, semigroups
     , transformers
     }:
     mkDerivation {
       pname = "lens-action";
       version = "0.1.0.1";
       sha256 = "2feeeb3a74af809923709ffb22f20eefc86f4375136199ddd883e1c997d38a79";
       revision = "1";
       editedCabalFile = "64e5700d04fc9c94b70620642f50b908d2032b75d3736c3b5be2a692e6506d81";
       libraryHaskellDepends = [
         base comonad contravariant lens mtl profunctors semigroupoids
         semigroups transformers
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/lens-action/";
       description = "Monadic Getters and Folds";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lens-action_0_2_0_1" = callPackage
    ({ mkDerivation, base, comonad, contravariant, directory, doctest
     , filepath, lens, mtl, profunctors, semigroupoids, semigroups
     , transformers
     }:
     mkDerivation {
       pname = "lens-action";
       version = "0.2.0.1";
       sha256 = "36d5ae806d8d28cab983c11bbb31915874fbeab4d44f683bfc62fc3c879a8e98";
       revision = "1";
       editedCabalFile = "9865cfb30d56a5931766070532961ef10295adcfb0dca84dd588b173c9cef24c";
       libraryHaskellDepends = [
         base comonad contravariant lens mtl profunctors semigroupoids
         semigroups transformers
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/lens-action/";
       description = "Monadic Getters and Folds";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lens-action" = callPackage
    ({ mkDerivation, base, comonad, contravariant, directory, doctest
     , filepath, lens, mtl, profunctors, semigroupoids, semigroups
     , transformers
     }:
     mkDerivation {
       pname = "lens-action";
       version = "0.2.0.2";
       sha256 = "e26c70b2de68a7cfbce97bcdabdcdfb45b2c50708207a14f8dd24c3e29c6d371";
       libraryHaskellDepends = [
         base comonad contravariant lens mtl profunctors semigroupoids
         semigroups transformers
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/ekmett/lens-action/";
       description = "Monadic Getters and Folds";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lens-aeson_1_0_0_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, directory
     , doctest, filepath, generic-deriving, lens, scientific, semigroups
     , simple-reflect, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "lens-aeson";
       version = "1.0.0.3";
       sha256 = "4c9da986d150c6575bf4a5954c4b9cc9f959f56e9ac5615b519ff1acbeb2cb71";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring lens scientific text
         unordered-containers vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       jailbreak = true;
       homepage = "http://github.com/lens/lens-aeson/";
       description = "Law-abiding lenses for aeson";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lens-aeson_1_0_0_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, directory
     , doctest, filepath, generic-deriving, lens, scientific, semigroups
     , simple-reflect, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "lens-aeson";
       version = "1.0.0.4";
       sha256 = "fb78946cb9ff8c59501ba633a1a433bedd9693dce4a346f71d8f2fe20b31547e";
       revision = "2";
       editedCabalFile = "f9ddeac68a237cb5dbe8ab7457fb7529bdeeb675c5e80bc122e196255072393d";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring lens scientific text
         unordered-containers vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       homepage = "http://github.com/lens/lens-aeson/";
       description = "Law-abiding lenses for aeson";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lens-aeson" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, directory
     , doctest, filepath, generic-deriving, lens, scientific, semigroups
     , simple-reflect, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "lens-aeson";
       version = "1.0.0.5";
       sha256 = "65faad5b75852209b4c6df43ae1f7460c2b94bf3bbc10b5cd529f43c743a5d9f";
       revision = "2";
       editedCabalFile = "fb2b4c4dc5b44f95da81837394ea09416dd0211dd98e23c30c2473e2b39e844c";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring lens scientific text
         unordered-containers vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       homepage = "http://github.com/lens/lens-aeson/";
       description = "Law-abiding lenses for aeson";
       license = stdenv.lib.licenses.mit;
     }) {};

  "lens-datetime" = callPackage
    ({ mkDerivation, base, lens, time }:
     mkDerivation {
       pname = "lens-datetime";
       version = "0.2.1";
       sha256 = "e2445f051d99a3f76890f7a6c91c7baccb1e587e1ba6d67ea4d20e6efdd113f3";
       libraryHaskellDepends = [ base lens time ];
       homepage = "http://github.com/nilcons/lens-datetime";
       description = "Lenses for Data.Time.* types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lens-family" = callPackage
    ({ mkDerivation, base, containers, lens-family-core, mtl
     , transformers
     }:
     mkDerivation {
       pname = "lens-family";
       version = "1.2.0";
       sha256 = "ab92ac8b3da79ba948aa64db330301417f5572a0352fc219b42675a906e97e5d";
       libraryHaskellDepends = [
         base containers lens-family-core mtl transformers
       ];
       description = "Lens Families";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lens-family-core" = callPackage
    ({ mkDerivation, base, containers, transformers }:
     mkDerivation {
       pname = "lens-family-core";
       version = "1.2.0";
       sha256 = "5f6598512b45cf4eee7b0196fecce37c24c0e2eb5f2c45b275ca7d45d85ab943";
       libraryHaskellDepends = [ base containers transformers ];
       description = "Haskell 98 Lens Families";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lens-family-th_0_4_0_0" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "lens-family-th";
       version = "0.4.0.0";
       sha256 = "a52e7e99bb0e324ca9dc09f441db98443ad7d9af227221a461c29f75ef1ccc09";
       revision = "1";
       editedCabalFile = "b2236e693bf705ef944458bc08e449b6e62da03c9370cee79858a3df01ef78dd";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/DanBurton/lens-family-th#readme";
       description = "Generate lens-family style lenses";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lens-family-th" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "lens-family-th";
       version = "0.4.1.0";
       sha256 = "754fdc4c7c292b160a87974ec3690b755fb93f3877c8080d331cfa6ec4b39e20";
       revision = "2";
       editedCabalFile = "978c149edc250ed1c91c03be304b752415e93ab5eb76aacb194bbe94135c356a";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/DanBurton/lens-family-th#readme";
       description = "Generate lens-family style lenses";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lens-prelude" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, contravariant
     , either, hashable, lens, mtl, text, time, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "lens-prelude";
       version = "0.2";
       sha256 = "b791b36b946f34dc0b3437a2923b670790d8a6cdec171c9ce4b13290b1471f29";
       libraryHaskellDepends = [
         array base bytestring containers contravariant either hashable lens
         mtl text time transformers unordered-containers vector
       ];
       homepage = "https://github.com/andrewthad/lens-prelude";
       description = "Alternate prelude that exports lens combinators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lens-properties" = callPackage
    ({ mkDerivation, base, lens, QuickCheck, transformers }:
     mkDerivation {
       pname = "lens-properties";
       version = "4.11";
       sha256 = "3c0ccdd7cf33cc3c79a86bb51815ab1a402dbe4fdff317c3f05e15adcbb1e031";
       libraryHaskellDepends = [ base lens QuickCheck transformers ];
       homepage = "http://github.com/ekmett/lens/";
       description = "QuickCheck properties for lens";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lens-regex" = callPackage
    ({ mkDerivation, array, base, directory, doctest, filepath, lens
     , regex-base, regex-posix, template-haskell
     }:
     mkDerivation {
       pname = "lens-regex";
       version = "0.1.0";
       sha256 = "4954b3ae395661e916c536bfe837c42a1cd8223ea81ffd86b1fdd9b6abfc5142";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base lens regex-base template-haskell
       ];
       testHaskellDepends = [
         base directory doctest filepath regex-posix
       ];
       homepage = "https://github.com/himura/lens-regex";
       description = "Lens powered regular expression";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lens-simple_0_1_0_7" = callPackage
    ({ mkDerivation, base, lens-family, lens-family-core
     , lens-family-th, mtl, transformers
     }:
     mkDerivation {
       pname = "lens-simple";
       version = "0.1.0.7";
       sha256 = "b8e00c791052f159463d1aa6e4738ac4fed5de4d0ebfdab21ec0500a3fe8d623";
       libraryHaskellDepends = [
         base lens-family lens-family-core lens-family-th mtl transformers
       ];
       homepage = "https://github.com/michaelt/lens-simple";
       description = "simplified import of elementary lens-family combinators";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lens-simple" = callPackage
    ({ mkDerivation, base, lens-family, lens-family-core
     , lens-family-th, mtl, transformers
     }:
     mkDerivation {
       pname = "lens-simple";
       version = "0.1.0.8";
       sha256 = "26a144c5b274947b58f6fe0a65d8200edb43f5e99ff4519a2dfce74fffb28458";
       libraryHaskellDepends = [
         base lens-family lens-family-core lens-family-th mtl transformers
       ];
       homepage = "https://github.com/michaelt/lens-simple";
       description = "simplified import of elementary lens-family combinators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lens-sop" = callPackage
    ({ mkDerivation, base, fclabels, generics-sop, transformers }:
     mkDerivation {
       pname = "lens-sop";
       version = "0.2.0.0";
       sha256 = "36f5a59ee68921496502c5586cd968ca2524cbb4be718763892c0daf26c7280a";
       libraryHaskellDepends = [
         base fclabels generics-sop transformers
       ];
       description = "Computing lenses generically using generics-sop";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lens-text-encoding" = callPackage
    ({ mkDerivation, base, bytestring, lens, text }:
     mkDerivation {
       pname = "lens-text-encoding";
       version = "0.1.0.0";
       sha256 = "5b3b2202bf61431de89ddd0dd57ba5282a80cebaa835fd0a03f499c80e5aaafb";
       libraryHaskellDepends = [ base bytestring lens text ];
       jailbreak = true;
       homepage = "http://github.com/iand675/text-lens-encoding";
       description = "Isomorphisms and prisms for text <=> bytestring conversions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "lens-time" = callPackage
    ({ mkDerivation, base, lens, time }:
     mkDerivation {
       pname = "lens-time";
       version = "0.1.0.0";
       sha256 = "ea17516a6fd2830112570dd574e0d6ce53f7a887832323ff60fe28894d4b37c3";
       libraryHaskellDepends = [ base lens time ];
       jailbreak = true;
       description = "lens for Data.Time";
       license = stdenv.lib.licenses.mit;
     }) {};

  "lens-tutorial" = callPackage
    ({ mkDerivation, base, doctest, lens }:
     mkDerivation {
       pname = "lens-tutorial";
       version = "1.0.1";
       sha256 = "66494550d66d4c62ea56d0184d118e302d3f1f12505c5c7c0a00e098e77272ab";
       libraryHaskellDepends = [ base lens ];
       testHaskellDepends = [ base doctest ];
       description = "Tutorial for the lens library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lens-utils" = callPackage
    ({ mkDerivation, base, lens }:
     mkDerivation {
       pname = "lens-utils";
       version = "1.2";
       sha256 = "2baa0afaf1cfd406335b940c9fc375ab5bbd0bb1f26fb8eca613b901e04d59fb";
       libraryHaskellDepends = [ base lens ];
       homepage = "https://github.com/wdanilo/lens-utils";
       description = "Collection of missing lens utilities";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "lenses" = callPackage
    ({ mkDerivation, base, mtl, template-haskell }:
     mkDerivation {
       pname = "lenses";
       version = "0.1.7";
       sha256 = "a4cb3d1e654295470c1e8c215715780440d689b3922778eccabf09180bbce126";
       libraryHaskellDepends = [ base mtl template-haskell ];
       homepage = "http://github.com/jvranish/Lenses/tree/master";
       description = "Simple Functional Lenses";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lensref" = callPackage
    ({ mkDerivation, base, monad-control, mtl, transformers }:
     mkDerivation {
       pname = "lensref";
       version = "0.2";
       sha256 = "76919a922e1fbfa2c20f99356f4d65584fcb27a2043f6bdd6b28859d311c4436";
       libraryHaskellDepends = [ base monad-control mtl transformers ];
       testHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/LGtk";
       description = "References which can be joined and on which lenses can be applied";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lentil" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, csv, directory, filemanip
     , filepath, hspec, natural-sort, optparse-applicative, parsec
     , regex-tdfa
     }:
     mkDerivation {
       pname = "lentil";
       version = "0.1.9.0";
       sha256 = "661932f5ee624a25f2a343accc88be8442a584938be891b842c1c165b2afa80e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-wl-pprint base csv directory filemanip filepath natural-sort
         optparse-applicative parsec regex-tdfa
       ];
       testHaskellDepends = [
         ansi-wl-pprint base csv directory filemanip filepath hspec
         natural-sort optparse-applicative parsec regex-tdfa
       ];
       homepage = "http://www.ariis.it/static/articles/lentil/page.html";
       description = "frugal issue tracker";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "lenz" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, transformers }:
     mkDerivation {
       pname = "lenz";
       version = "0.1";
       sha256 = "98b3aef14ca16218ecd6643812e9df5dde5c60af6e2f56f98ec523ecc0917397";
       libraryHaskellDepends = [ base base-unicode-symbols transformers ];
       description = "Van Laarhoven lenses";
       license = "unknown";
     }) {};

  "lenz-template" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, containers, lenz
     , template-haskell
     }:
     mkDerivation {
       pname = "lenz-template";
       version = "0.1";
       sha256 = "f03ca02d69c19f34c191f7cc41a15f167cba9e60c0791069eac7cd302a5877b1";
       libraryHaskellDepends = [
         base base-unicode-symbols containers lenz template-haskell
       ];
       description = "Van Laarhoven lens templates";
       license = "unknown";
     }) {};

  "level-monad" = callPackage
    ({ mkDerivation, base, fmlist }:
     mkDerivation {
       pname = "level-monad";
       version = "0.4.1";
       sha256 = "0a0db3c067adbb2174587e787a9b672fa6fe88970bddf77c7544b2b52ff4b2d0";
       libraryHaskellDepends = [ base fmlist ];
       homepage = "http://github.com/sebfisch/level-monad";
       description = "Non-Determinism Monad for Level-Wise Search";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "leveldb-haskell" = callPackage
    ({ mkDerivation, async, base, bytestring, data-default, directory
     , exceptions, filepath, leveldb, mtl, QuickCheck, resourcet, tasty
     , tasty-quickcheck, temporary, transformers
     }:
     mkDerivation {
       pname = "leveldb-haskell";
       version = "0.6.3";
       sha256 = "65de64b4caa7812a97b8e0715e313c56de6996d182cefacfe4c3d4d498e4926e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring data-default exceptions filepath resourcet
         transformers
       ];
       librarySystemDepends = [ leveldb ];
       executableHaskellDepends = [
         async base bytestring data-default resourcet transformers
       ];
       testHaskellDepends = [
         base bytestring data-default directory exceptions mtl QuickCheck
         tasty tasty-quickcheck temporary transformers
       ];
       homepage = "http://github.com/kim/leveldb-haskell";
       description = "Haskell bindings to LevelDB";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) leveldb;};

  "leveldb-haskell-fork" = callPackage
    ({ mkDerivation, async, base, bytestring, data-default, filepath
     , hspec, hspec-expectations, leveldb, mtl, process, QuickCheck
     , resourcet, transformers
     }:
     mkDerivation {
       pname = "leveldb-haskell-fork";
       version = "0.3.4.4";
       sha256 = "589935f658b432546ba3e82f1473c55365a2a3fd01e3751faa93f3c2a79f2c08";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring data-default filepath resourcet transformers
       ];
       librarySystemDepends = [ leveldb ];
       executableHaskellDepends = [
         async base bytestring data-default resourcet transformers
       ];
       testHaskellDepends = [
         base bytestring data-default hspec hspec-expectations mtl process
         QuickCheck transformers
       ];
       homepage = "http://github.com/kim/leveldb-haskell";
       description = "Haskell bindings to LevelDB";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) leveldb;};

  "levmar" = callPackage
    ({ mkDerivation, base, bindings-levmar, hmatrix, vector }:
     mkDerivation {
       pname = "levmar";
       version = "1.2.1.5";
       sha256 = "727ec5ebd523997b471685c7aed6f1a91120707e3b273734d23a6fc6a35d5525";
       libraryHaskellDepends = [ base bindings-levmar hmatrix vector ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/levmar";
       description = "An implementation of the Levenberg-Marquardt algorithm";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-darwin" ];
     }) {};

  "levmar-chart" = callPackage
    ({ mkDerivation, base, Chart, colour, data-accessor, levmar, random
     }:
     mkDerivation {
       pname = "levmar-chart";
       version = "0.2";
       sha256 = "5271f6dadec35b22d6fd00900992c819d2e7a7daa7e53016c9f19879a3684973";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base Chart colour data-accessor levmar ];
       executableHaskellDepends = [
         base Chart colour data-accessor levmar random
       ];
       jailbreak = true;
       description = "Plots the results of the Levenberg-Marquardt algorithm in a chart";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lexer-applicative" = callPackage
    ({ mkDerivation, base, deepseq, regex-applicative, srcloc, tasty
     , tasty-hunit
     }:
     mkDerivation {
       pname = "lexer-applicative";
       version = "2.1.0.1";
       sha256 = "3e9612800e7d70f997e0d3396628b91133568b9e85e2c160834d1eb96acca49c";
       libraryHaskellDepends = [ base regex-applicative srcloc ];
       testHaskellDepends = [
         base deepseq regex-applicative srcloc tasty tasty-hunit
       ];
       homepage = "https://github.com/feuerbach/lexer-applicative";
       description = "Simple lexer based on applicative regular expressions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "lgtk" = callPackage
    ({ mkDerivation, array, base, cairo, colour, containers
     , diagrams-cairo, diagrams-lib, directory, filepath, fsnotify
     , GLFW-b, groups, lens, lensref, monad-control, mtl, OpenGLRaw
     , operational, random, random-shuffle, semigroups, system-filepath
     , transformers, vector
     }:
     mkDerivation {
       pname = "lgtk";
       version = "0.8.0.4";
       sha256 = "65571ad08db84660f9f2fee92b4ab7745fdaf2eae22dac111bfbdb8f6202f0ae";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cairo colour containers diagrams-cairo diagrams-lib directory
         filepath fsnotify GLFW-b groups lens lensref monad-control mtl
         OpenGLRaw operational semigroups system-filepath transformers
         vector
       ];
       executableHaskellDepends = [
         array base containers diagrams-lib lens mtl random random-shuffle
         vector
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/LGtk";
       description = "Lens GUI Toolkit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lha" = callPackage
    ({ mkDerivation, haskell2010 }:
     mkDerivation {
       pname = "lha";
       version = "0.1.2";
       sha256 = "21ceb7eeb33769bc50022e422304006011da7366757e321310fedaa6410bb028";
       libraryHaskellDepends = [ haskell2010 ];
       homepage = "https://github.com/bytbox/lha.hs";
       description = "Data structures for the Les Houches Accord";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lhae" = callPackage
    ({ mkDerivation, array, base, containers, directory, filepath
     , hgettext, mtl, parsec, process, setlocale, utf8-string, wx
     , wxcore
     }:
     mkDerivation {
       pname = "lhae";
       version = "0.0.3";
       sha256 = "e321777e626e5f35aa454661ef322419bd414caf25cf8d9f50bbb4c541470f88";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory filepath hgettext mtl parsec
         process setlocale utf8-string wx wxcore
       ];
       jailbreak = true;
       homepage = "http://www.imn.htwk-leipzig.de/~abau/lhae";
       description = "Simple spreadsheet program";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lhc" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, binary, bytestring
     , bytestring-trie, Cabal, containers, core, derive, digest
     , directory, extensible-exceptions, filepath, haskell98, HUnit, mtl
     , parallel, pretty, process, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck, time, unix
     , xhtml
     }:
     mkDerivation {
       pname = "lhc";
       version = "0.10";
       sha256 = "23b3cd7479108864b5a167b3fd1b1f58bf49b1773f590c68c766dcd4a999a0f4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-wl-pprint base binary bytestring bytestring-trie Cabal
         containers core derive digest directory extensible-exceptions
         filepath haskell98 HUnit mtl parallel pretty process QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck time
         unix xhtml
       ];
       homepage = "http://lhc.seize.it/";
       description = "LHC Haskell Compiler";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "lhe" = callPackage
    ({ mkDerivation, bytestring, haskell2010, HaXml, lha }:
     mkDerivation {
       pname = "lhe";
       version = "0.5";
       sha256 = "4989ab085f6b9eb6faf666a418753645c8104276852d4c6e4cd186134b2ee220";
       libraryHaskellDepends = [ bytestring haskell2010 HaXml lha ];
       description = "Parser and writer for Les-Houches event files";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lhs2TeX-hl" = callPackage
    ({ mkDerivation, base, cmdargs, filepath, haskell-src-exts, syb
     , uu-parsinglib
     }:
     mkDerivation {
       pname = "lhs2TeX-hl";
       version = "0.1.4.5";
       sha256 = "34c5dbf422072e18590fa07d570518894f5c911b78a9027d11407eb3e38ca6d6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs filepath haskell-src-exts syb uu-parsinglib
       ];
       jailbreak = true;
       homepage = "http://spockz.github.com/lhs2texhl/";
       description = "Literate highlighter preprocessor for lhs2tex";
       license = stdenv.lib.licenses.mit;
     }) {};

  "lhs2html" = callPackage
    ({ mkDerivation, base, directory, filepath, Glob }:
     mkDerivation {
       pname = "lhs2html";
       version = "0.999999";
       sha256 = "9b3176a491fa3bf55e3de1640dc4ef17124af8156c60d38bcea501ca8cbd9bb3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath Glob ];
       description = "Compile lhs in bird style to md, html, hs";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "lhs2tex_1_18_1" = callPackage
    ({ mkDerivation, base, directory, filepath, mtl, process
     , regex-compat
     }:
     mkDerivation {
       pname = "lhs2tex";
       version = "1.18.1";
       sha256 = "dccae22231a1db64cddc38b6f7ac98ac4d5677f03df2f548b2efe9a5e63e9648";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath mtl process regex-compat
       ];
       homepage = "http://www.andres-loeh.de/lhs2tex/";
       description = "Preprocessor for typesetting Haskell sources with LaTeX";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lhs2tex" = callPackage
    ({ mkDerivation, base, directory, filepath, mtl, process
     , regex-compat
     }:
     mkDerivation {
       pname = "lhs2tex";
       version = "1.19";
       sha256 = "24ae0557d95673e0c6d9b0aca829181b734359880dd58802ac154b89f384b00e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath mtl process regex-compat
       ];
       homepage = "http://www.andres-loeh.de/lhs2tex/";
       description = "Preprocessor for typesetting Haskell sources with LaTeX";
       license = "GPL";
     }) {};

  "lhslatex" = callPackage
    ({ mkDerivation, base, directory, filepath, process, regex-posix }:
     mkDerivation {
       pname = "lhslatex";
       version = "0.1.0.0";
       sha256 = "c71dddb6bd4bf15727822a8f18a627066ba01b7a140f01ffa33e87084ce8f54d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath process regex-posix
       ];
       jailbreak = true;
       homepage = "https://github.com/tvh/lhslatex";
       description = "Tool for using pdflatex with .lhs files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "libGenI" = callPackage
    ({ mkDerivation, base, binary, containers, HUnit, mtl, parsec
     , process, QuickCheck
     }:
     mkDerivation {
       pname = "libGenI";
       version = "0.16.1";
       sha256 = "bff2dc6597e84d8ab664dc82aaf9c736eb1ddf756db15f043186805e19bb67d8";
       libraryHaskellDepends = [
         base binary containers HUnit mtl parsec process QuickCheck
       ];
       homepage = "http://trac.loria.fr/~geni";
       description = "A natural language generator (specifically, an FB-LTAG surface realiser)";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "libarchive-conduit" = callPackage
    ({ mkDerivation, archive, base, bytestring, conduit, resourcet
     , transformers
     }:
     mkDerivation {
       pname = "libarchive-conduit";
       version = "0.1.0.0";
       sha256 = "045c321b10c1b77922347ba53c77b6b89fa37b787ecc46d9978c90cf7bb74e08";
       libraryHaskellDepends = [
         base bytestring conduit resourcet transformers
       ];
       librarySystemDepends = [ archive ];
       description = "Read many archive formats with libarchive and conduit";
       license = stdenv.lib.licenses.bsd3;
     }) {archive = null;};

  "libconfig" = callPackage
    ({ mkDerivation, base, binary, c2hs, deepseq, doctest, doctest-prop
     , hashable, libconfig, text, text-binary, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "libconfig";
       version = "0.3.0.0";
       sha256 = "22605b11f7e9e9b9a94cbbc12172660e177e968384bbc462573c79c3bcdb5994";
       libraryHaskellDepends = [
         base binary deepseq hashable text text-binary transformers
         transformers-compat
       ];
       librarySystemDepends = [ libconfig ];
       libraryToolDepends = [ c2hs ];
       testHaskellDepends = [ base doctest doctest-prop ];
       homepage = "https://github.com/peddie/libconfig-haskell";
       description = "Haskell bindings to libconfig";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libconfig;};

  "libcspm" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , directory, filepath, graph-wrapper, hashable, hashtables, mtl
     , pretty, test-framework, text, value-supply
     }:
     mkDerivation {
       pname = "libcspm";
       version = "1.0.0";
       sha256 = "3b1deccd3662c94cc27bd25f27dbd925529ea62719a285a5970ea87050441ced";
       libraryHaskellDepends = [
         array base bytestring containers deepseq directory filepath
         graph-wrapper hashable hashtables mtl pretty text value-supply
       ];
       testHaskellDepends = [
         base directory filepath mtl test-framework
       ];
       jailbreak = true;
       homepage = "https://github.com/tomgr/libcspm";
       description = "A library providing a parser, type checker and evaluator for CSPM";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "libexpect" = callPackage
    ({ mkDerivation, base, expect, tcl, unix }:
     mkDerivation {
       pname = "libexpect";
       version = "0.3.2";
       sha256 = "4c678a92c503528b62b77ae69e1287fa7af3314f93a7953e79382e135462fa76";
       libraryHaskellDepends = [ base unix ];
       librarySystemDepends = [ expect tcl ];
       description = "Library for interacting with console applications via pseudoterminals";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) expect; inherit (pkgs) tcl;};

  "libffi" = callPackage
    ({ mkDerivation, base, bytestring, ffi, libffi }:
     mkDerivation {
       pname = "libffi";
       version = "0.1";
       sha256 = "48387067c0f33bcfadf7a3bebbf48a55294202500f2b754229ffc8f12cb4f23c";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ ffi ];
       libraryPkgconfigDepends = [ libffi ];
       description = "A binding to libffi";
       license = stdenv.lib.licenses.bsd3;
     }) {ffi = null; inherit (pkgs) libffi;};

  "libgit_0_3_0" = callPackage
    ({ mkDerivation, base, mtl, process }:
     mkDerivation {
       pname = "libgit";
       version = "0.3.0";
       sha256 = "2632b4d2a41fb503cc516ad69d1fb385068fc3f3ccd5d0ea38176882da41424c";
       libraryHaskellDepends = [ base mtl process ];
       homepage = "http://github.com/vincenthz/hs-tls";
       description = "Simple Git Wrapper";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "libgit" = callPackage
    ({ mkDerivation, base, mtl, process }:
     mkDerivation {
       pname = "libgit";
       version = "0.3.1";
       sha256 = "1d4c60dd987c363d77c4be947678d01a51ab4b568964c30a33827ccc854f7522";
       libraryHaskellDepends = [ base mtl process ];
       homepage = "https://github.com/vincenthz/hs-libgit";
       description = "Simple Git Wrapper";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "libgraph" = callPackage
    ({ mkDerivation, array, base, containers, monads-tf, process
     , union-find
     }:
     mkDerivation {
       pname = "libgraph";
       version = "1.10";
       sha256 = "d5d6152c80ae8be8c43ff02f1e74ac114b734254426a289f2b89e5815f9f232f";
       libraryHaskellDepends = [
         array base containers monads-tf process union-find
       ];
       homepage = "http://maartenfaddegon.nl";
       description = "Store and manipulate data in a graph";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "libhbb" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, filepath, ghc
     , ghc-paths, hspec, mtl, process, syb, text, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "libhbb";
       version = "0.4.1.0";
       sha256 = "4807247c377442e07d050ae854ec6859b1678060a9ed81bb4348b870ad639e9f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring directory filepath ghc ghc-paths mtl process
         syb text time unordered-containers
       ];
       executableHaskellDepends = [ base bytestring directory ];
       testHaskellDepends = [
         base bytestring ghc ghc-paths hspec mtl syb
       ];
       homepage = "https://bitbucket.org/bhris/libhbb";
       description = "Backend for text editors to provide better Haskell editing support";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "libinfluxdb" = callPackage
    ({ mkDerivation, base, bytestring, clock, containers, http-client
     , http-client-tls, http-types, resource-pool, stm, text
     }:
     mkDerivation {
       pname = "libinfluxdb";
       version = "0.0.3";
       sha256 = "ef915c368e9e7f3cc4fc0386f266d90b39e960ae4f82462c8a7883ea24ee759c";
       libraryHaskellDepends = [
         base bytestring clock containers http-client http-client-tls
         http-types resource-pool stm text
       ];
       description = "libinfluxdb";
       license = stdenv.lib.licenses.mit;
     }) {};

  "libjenkins" = callPackage
    ({ mkDerivation, async, attoparsec, base, bytestring, conduit
     , containers, directory, doctest, filepath, free, hspec
     , hspec-expectations-lens, http-client, http-conduit, http-types
     , lens, lifted-async, lifted-base, monad-control, mtl, network
     , network-uri, profunctors, resourcet, text, transformers
     , xml-conduit
     }:
     mkDerivation {
       pname = "libjenkins";
       version = "0.8.2";
       sha256 = "206f7e82ee6496f408347dc0828aea8018b0e7269cae02fcfa7504c750f79ec9";
       libraryHaskellDepends = [
         async attoparsec base bytestring conduit containers free
         http-client http-conduit http-types monad-control mtl network
         network-uri profunctors resourcet text transformers
       ];
       testHaskellDepends = [
         async attoparsec base bytestring conduit containers directory
         doctest filepath free hspec hspec-expectations-lens http-client
         http-conduit http-types lens lifted-async lifted-base monad-control
         mtl network network-uri profunctors resourcet text transformers
         xml-conduit
       ];
       description = "Jenkins API interface";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "liblastfm" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cereal, containers
     , cryptonite, hspec, hspec-expectations-lens, http-client
     , http-client-tls, HUnit, lens, lens-aeson, network-uri
     , profunctors, semigroups, text, transformers, xml-conduit
     , xml-html-conduit-lens
     }:
     mkDerivation {
       pname = "liblastfm";
       version = "0.6.0";
       sha256 = "2f00f7713e9c235e271c133a41f1806c193a03827b9c675f80b83cd11bc1d264";
       libraryHaskellDepends = [
         aeson base bytestring cereal containers cryptonite http-client
         http-client-tls network-uri profunctors semigroups text
         transformers xml-conduit
       ];
       testHaskellDepends = [
         aeson base bytestring cereal containers cryptonite hspec
         hspec-expectations-lens http-client http-client-tls HUnit lens
         lens-aeson network-uri profunctors text transformers xml-conduit
         xml-html-conduit-lens
       ];
       description = "Lastfm API interface";
       license = stdenv.lib.licenses.mit;
     }) {};

  "liblinear-enumerator" = callPackage
    ({ mkDerivation, base, bindings-DSL, enumerator, mtl, vector }:
     mkDerivation {
       pname = "liblinear-enumerator";
       version = "0.1.2";
       sha256 = "226262bc6696573b9c347f283c7ae1ed54af8fd1e693afb101f90aebc0f1a0a7";
       libraryHaskellDepends = [
         base bindings-DSL enumerator mtl vector
       ];
       jailbreak = true;
       homepage = "http://github.com/NathanHowell/liblinear-enumerator";
       description = "liblinear iteratee";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "libltdl" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "libltdl";
       version = "0.1.0.3";
       sha256 = "f96f21553b2d6758aab7f59ecd96ad93b01dd61ae9aeca812214081e08a24415";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       homepage = "http://www.eecs.harvard.edu/~mainland/projects/libffi";
       description = "FFI interface to libltdl";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "libmpd" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , data-default-class, filepath, hspec, mtl, network, old-locale
     , QuickCheck, text, time, unix, utf8-string
     }:
     mkDerivation {
       pname = "libmpd";
       version = "0.9.0.4";
       sha256 = "bdaa57a410396b2f02ddb9896823ce0a176751fa84261f445e9a5b7671333a7a";
       libraryHaskellDepends = [
         attoparsec base bytestring containers data-default-class filepath
         mtl network old-locale text time utf8-string
       ];
       testHaskellDepends = [
         attoparsec base bytestring containers data-default-class filepath
         hspec mtl network old-locale QuickCheck text time unix utf8-string
       ];
       homepage = "http://github.com/vimus/libmpd-haskell#readme";
       description = "An MPD client library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "libnotify" = callPackage
    ({ mkDerivation, base, bytestring, glib, gtk, libnotify }:
     mkDerivation {
       pname = "libnotify";
       version = "0.1.1.0";
       sha256 = "206ff7bb29530cd1cfabd417a9ae1aa38bf9f1a834a0f8db914d3d45c24e81f1";
       libraryHaskellDepends = [ base bytestring glib gtk ];
       librarySystemDepends = [ libnotify ];
       description = "Bindings to libnotify library";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) libnotify;};

  "libnvvm" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, Cabal, cuda, HUnit, nvvm
     , test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "libnvvm";
       version = "1.0.0";
       sha256 = "bdb65595a7f97512e47ca1c34697a65d25bb6d3604ad31f243d3ff64d0a56b03";
       libraryHaskellDepends = [ base bytestring cuda ];
       librarySystemDepends = [ nvvm ];
       libraryToolDepends = [ c2hs ];
       testHaskellDepends = [
         base bytestring Cabal HUnit test-framework test-framework-hunit
       ];
       homepage = "https://github.com/nvidia-compiler-sdk/hsnvvm";
       description = "FFI binding to libNVVM, a compiler SDK component from NVIDIA";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {nvvm = null;};

  "liboleg" = callPackage
    ({ mkDerivation, base, CC-delcont, containers, mtl
     , template-haskell, unix
     }:
     mkDerivation {
       pname = "liboleg";
       version = "2010.1.10.0";
       sha256 = "461dfdf46c4cf1a1227841fb570ea9443d4e6d613b9ac37a730b797d038d60d3";
       libraryHaskellDepends = [
         base CC-delcont containers mtl template-haskell unix
       ];
       homepage = "http://okmij.org/ftp/";
       description = "An evolving collection of Oleg Kiselyov's Haskell modules";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "libpafe" = callPackage
    ({ mkDerivation, base, bytestring, iconv, pafe, transformers }:
     mkDerivation {
       pname = "libpafe";
       version = "0.1.1.0";
       sha256 = "9a5b4a003f695166119a3823e27ec12afc57cc52794be1b9edaf16803c4a5ad0";
       libraryHaskellDepends = [ base transformers ];
       librarySystemDepends = [ pafe ];
       testHaskellDepends = [ base bytestring iconv transformers ];
       jailbreak = true;
       description = "Wrapper for libpafe";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {pafe = null;};

  "libpq" = callPackage
    ({ mkDerivation, base, bytestring, postgresql, unix }:
     mkDerivation {
       pname = "libpq";
       version = "0.4.1";
       sha256 = "270ac70be12966fbc013408afdf9c0acb86da63e7b34e75fc39fe383bbfa4887";
       libraryHaskellDepends = [ base bytestring unix ];
       librarySystemDepends = [ postgresql ];
       homepage = "http://github.com/tnarg/haskell-libpq";
       description = "libpq binding for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) postgresql;};

  "librandomorg" = callPackage
    ({ mkDerivation, base, bytestring, curl }:
     mkDerivation {
       pname = "librandomorg";
       version = "0.0.1.0";
       sha256 = "b6cf23821a444e0e4f738d21b0a86dbb3bc172f86ba0be6445874b445c2aaf1f";
       libraryHaskellDepends = [ base bytestring curl ];
       jailbreak = true;
       homepage = "https://github.com/supki/haskell-random.org";
       description = "Wrapper to Random.org API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "librato" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, either
     , http-client, http-conduit, http-types, mtl, resourcet, text
     , unordered-containers, uri-templater, vector
     }:
     mkDerivation {
       pname = "librato";
       version = "0.2.0.1";
       sha256 = "e42365b06c6ee5d99742801330950a8e6fcb747974954f2f7dc3940dfa4418d0";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either http-client http-conduit
         http-types mtl resourcet text unordered-containers uri-templater
         vector
       ];
       homepage = "https://github.com/SaneTracker/librato";
       description = "Bindings to the Librato API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "libravatar" = callPackage
    ({ mkDerivation, base, bytestring, crypto-api, data-default-class
     , dns, network-uri, pureMD5, random, SHA, url, utf8-string
     }:
     mkDerivation {
       pname = "libravatar";
       version = "0.3.0.0";
       sha256 = "2371b91f8ff4abdeba4374d20b4fa9c90fe0e9871c874bd61f32380b32ef88bf";
       libraryHaskellDepends = [
         base bytestring crypto-api data-default-class dns network-uri
         pureMD5 random SHA url utf8-string
       ];
       homepage = "http://rel4tion.org/projects/libravatar/";
       description = "Use Libravatar, the decentralized avatar delivery service";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "libssh2" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, libssh2, network, ssh2
     , syb, time
     }:
     mkDerivation {
       pname = "libssh2";
       version = "0.2.0.3";
       sha256 = "7caa9f23ae3ff54a819ff56bbecc7953fe39aa958c77feebd52849f2bf86cd75";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring network syb time ];
       librarySystemDepends = [ ssh2 ];
       libraryPkgconfigDepends = [ libssh2 ];
       libraryToolDepends = [ c2hs ];
       homepage = "https://github.com/portnov/libssh2-hs";
       description = "FFI bindings to libssh2 SSH2 client library (http://libssh2.org/)";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) libssh2; ssh2 = null;};

  "libssh2-conduit" = callPackage
    ({ mkDerivation, base, conduit, libssh2, monad-control, stm
     , transformers
     }:
     mkDerivation {
       pname = "libssh2-conduit";
       version = "0.1";
       sha256 = "10b1095e6048924247a097973c1c4849a5f4f9bffa53dc1e6b7712c6b191ecfe";
       libraryHaskellDepends = [
         base conduit libssh2 monad-control stm transformers
       ];
       homepage = "http://redmine.iportnov.ru/projects/libssh2-hs";
       description = "Conduit wrappers for libssh2 FFI bindings (see libssh2 package)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "libstackexchange" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , data-default, http-conduit, profunctors, text
     }:
     mkDerivation {
       pname = "libstackexchange";
       version = "0.3.0.0";
       sha256 = "48203528e8e6d5210435e9a8e254267f4a43a0338031bb82044bb76366856803";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers data-default
         http-conduit profunctors text
       ];
       homepage = "https://github.com/supki/libstackexchange";
       description = "StackExchange API interface";
       license = stdenv.lib.licenses.mit;
     }) {};

  "libsystemd-daemon" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, libsystemd-daemon
     , network, systemd-daemon, test-framework, test-framework-hunit
     , utf8-string
     }:
     mkDerivation {
       pname = "libsystemd-daemon";
       version = "0.1.0.1";
       sha256 = "c03dbef58f9d32fecce539cc3f118f43e9a92418736cb8b96960f87c14f3bfe6";
       libraryHaskellDepends = [ base bytestring network utf8-string ];
       librarySystemDepends = [ systemd-daemon ];
       libraryPkgconfigDepends = [ libsystemd-daemon ];
       testHaskellDepends = [
         base HUnit network test-framework test-framework-hunit
       ];
       description = "Haskell bindings for libsystemd-daemon";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {libsystemd-daemon = null; systemd-daemon = null;};

  "libsystemd-journal" = callPackage
    ({ mkDerivation, base, bytestring, hashable, hsyslog, pipes
     , pipes-safe, systemd, text, transformers, uniplate
     , unix-bytestring, unordered-containers, uuid, vector
     }:
     mkDerivation {
       pname = "libsystemd-journal";
       version = "1.4.0";
       sha256 = "31b20c903a6662eb2bbcf9aa2998936bc216e0711587134325bbe12fb615efd2";
       libraryHaskellDepends = [
         base bytestring hashable hsyslog pipes pipes-safe text transformers
         uniplate unix-bytestring unordered-containers uuid vector
       ];
       libraryPkgconfigDepends = [ systemd ];
       homepage = "http://github.com/ocharles/libsystemd-journal";
       description = "Haskell bindings to libsystemd-journal";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) systemd;};

  "libtagc" = callPackage
    ({ mkDerivation, base, bytestring, glib, taglib }:
     mkDerivation {
       pname = "libtagc";
       version = "0.12.0";
       sha256 = "4a6e34c8d110e1c27966c73c3199ba1ca733e1375ea4d933c3b9cfec9840f9b8";
       libraryHaskellDepends = [ base bytestring glib ];
       librarySystemDepends = [ taglib ];
       libraryPkgconfigDepends = [ taglib ];
       jailbreak = true;
       homepage = "https://patch-tag.com/r/AndyStewart/libtagc/home";
       description = "Binding to TagLib C library";
       license = stdenv.lib.licenses.lgpl21;
     }) {inherit (pkgs) taglib;};

  "libvirt-hs" = callPackage
    ({ mkDerivation, base, c2hs, syb, virt }:
     mkDerivation {
       pname = "libvirt-hs";
       version = "0.1";
       sha256 = "8cac2bdf11da09cef333fe7f88315cc4d24e4dd680a28134245a14eefedffd39";
       libraryHaskellDepends = [ base syb ];
       librarySystemDepends = [ virt ];
       libraryToolDepends = [ c2hs ];
       homepage = "http://redmine.iportnov.ru/projects/libvirt-hs";
       description = "FFI bindings to libvirt virtualization API (http://libvirt.org)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {virt = null;};

  "libvorbis" = callPackage
    ({ mkDerivation, base, bytestring, cpu }:
     mkDerivation {
       pname = "libvorbis";
       version = "0.1.0.1";
       sha256 = "346fbe26e9229b1e7a8a1841b288b07ae683f6bfdbf2a6aea7caa752b6147b7a";
       libraryHaskellDepends = [ base bytestring cpu ];
       homepage = "https://github.com/the-real-blackh/libvorbis";
       description = "Haskell binding for libvorbis, for decoding Ogg Vorbis audio files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "libxml" = callPackage
    ({ mkDerivation, base, bytestring, libxml2, mtl }:
     mkDerivation {
       pname = "libxml";
       version = "0.1.1";
       sha256 = "d1e92affb41e7abe1c7b692aa24ae47dbcf3636f2753bb85a3469c370d9afb07";
       libraryHaskellDepends = [ base bytestring mtl ];
       librarySystemDepends = [ libxml2 ];
       description = "Binding to libxml2";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libxml2;};

  "libxml-enumerator" = callPackage
    ({ mkDerivation, base, bytestring, enumerator, libxml-sax, text
     , transformers, xml-types
     }:
     mkDerivation {
       pname = "libxml-enumerator";
       version = "0.5";
       sha256 = "ef96c33f75f638cfbe2f6ad46e301a496deb1141b641cd663973b8c049211057";
       libraryHaskellDepends = [
         base bytestring enumerator libxml-sax text transformers xml-types
       ];
       jailbreak = true;
       homepage = "http://john-millikin.com/software/libxml-enumerator/";
       description = "Enumerator-based API for libXML's SAX interface";
       license = stdenv.lib.licenses.mit;
     }) {};

  "libxml-sax" = callPackage
    ({ mkDerivation, base, bytestring, libxml2, text, xml-types }:
     mkDerivation {
       pname = "libxml-sax";
       version = "0.7.5";
       sha256 = "99141784cc0d6c5749f0df618b2d46922391eede09f4f9ccfc36fb58a9c16d51";
       libraryHaskellDepends = [ base bytestring text xml-types ];
       librarySystemDepends = [ libxml2 ];
       libraryPkgconfigDepends = [ libxml2 ];
       homepage = "https://john-millikin.com/software/haskell-libxml/";
       description = "Bindings for the libXML2 SAX interface";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) libxml2;};

  "libxslt" = callPackage
    ({ mkDerivation, base, bytestring, libxml, xslt }:
     mkDerivation {
       pname = "libxslt";
       version = "0.1";
       sha256 = "aad8ea748a8c787bf791a83fb6e3937413a64d42318e1e9f5b0df150e747ffeb";
       libraryHaskellDepends = [ base bytestring libxml ];
       librarySystemDepends = [ xslt ];
       jailbreak = true;
       description = "Binding to libxslt";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {xslt = null;};

  "life" = callPackage
    ({ mkDerivation, array, base, GLUT, OpenGL, random }:
     mkDerivation {
       pname = "life";
       version = "0.1";
       sha256 = "586b8ac937bc7b966dbbdc7c02919488faa8f734522805d4c91e85015ad83a37";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base GLUT OpenGL random ];
       homepage = "http://github.com/sproingie/haskell-cells/";
       description = "Conway's Life cellular automaton";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "lift-generics" = callPackage
    ({ mkDerivation, base, base-compat, generic-deriving, ghc-prim
     , hspec, template-haskell
     }:
     mkDerivation {
       pname = "lift-generics";
       version = "0.1.1";
       sha256 = "07cf2cc4416fb7b0e45595da8a964459498da976e18cdcc169ac2416143930cb";
       libraryHaskellDepends = [
         base generic-deriving ghc-prim template-haskell
       ];
       testHaskellDepends = [
         base base-compat generic-deriving hspec template-haskell
       ];
       homepage = "https://github.com/RyanGlScott/lift-generics";
       description = "GHC.Generics-based Language.Haskell.TH.Syntax.lift implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lifted-async_0_2_0_2" = callPackage
    ({ mkDerivation, async, base, HUnit, lifted-base, monad-control
     , mtl, tasty, tasty-hunit, tasty-th, transformers-base
     }:
     mkDerivation {
       pname = "lifted-async";
       version = "0.2.0.2";
       sha256 = "ee512dc63f21cc212db1a85f5acc49a96b6400f85012ed6fe68ede4e477b581f";
       revision = "1";
       editedCabalFile = "a519f7fc27186ce283aa5e49de459f08ecba8f97c461f7e31c8094f95c1993e6";
       libraryHaskellDepends = [
         async base lifted-base monad-control transformers-base
       ];
       testHaskellDepends = [
         async base HUnit lifted-base monad-control mtl tasty tasty-hunit
         tasty-th
       ];
       jailbreak = true;
       homepage = "https://github.com/maoe/lifted-async";
       description = "Run lifted IO operations asynchronously and wait for their results";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lifted-async_0_7_0" = callPackage
    ({ mkDerivation, async, base, constraints, HUnit, lifted-base
     , monad-control, mtl, tasty, tasty-hunit, tasty-th
     , transformers-base
     }:
     mkDerivation {
       pname = "lifted-async";
       version = "0.7.0";
       sha256 = "a679faded7f7e0675229b7863d7557217a81b41a0eca73bd7c0056f4efa93cc5";
       libraryHaskellDepends = [
         async base constraints lifted-base monad-control transformers-base
       ];
       testHaskellDepends = [
         async base HUnit lifted-base monad-control mtl tasty tasty-hunit
         tasty-th
       ];
       jailbreak = true;
       homepage = "https://github.com/maoe/lifted-async";
       description = "Run lifted IO operations asynchronously and wait for their results";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lifted-async_0_7_0_1" = callPackage
    ({ mkDerivation, async, base, constraints, HUnit, lifted-base
     , monad-control, mtl, tasty, tasty-hunit, tasty-th
     , transformers-base
     }:
     mkDerivation {
       pname = "lifted-async";
       version = "0.7.0.1";
       sha256 = "c3235d0f4a90baba3217269562bee655c6d9c538e2b57b6c5b23da4ef1bb6e6a";
       libraryHaskellDepends = [
         async base constraints lifted-base monad-control transformers-base
       ];
       testHaskellDepends = [
         async base HUnit lifted-base monad-control mtl tasty tasty-hunit
         tasty-th
       ];
       jailbreak = true;
       homepage = "https://github.com/maoe/lifted-async";
       description = "Run lifted IO operations asynchronously and wait for their results";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lifted-async_0_7_0_2" = callPackage
    ({ mkDerivation, async, base, constraints, HUnit, lifted-base
     , monad-control, mtl, tasty, tasty-hunit, tasty-th
     , transformers-base
     }:
     mkDerivation {
       pname = "lifted-async";
       version = "0.7.0.2";
       sha256 = "0e8a97500b5cb387c711e8dc0db27a07b61d21d610ba8aebf4cae5f92920b7ac";
       libraryHaskellDepends = [
         async base constraints lifted-base monad-control transformers-base
       ];
       testHaskellDepends = [
         async base HUnit lifted-base monad-control mtl tasty tasty-hunit
         tasty-th
       ];
       jailbreak = true;
       homepage = "https://github.com/maoe/lifted-async";
       description = "Run lifted IO operations asynchronously and wait for their results";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lifted-async" = callPackage
    ({ mkDerivation, async, base, constraints, HUnit, lifted-base
     , monad-control, mtl, tasty, tasty-hunit, tasty-th
     , transformers-base
     }:
     mkDerivation {
       pname = "lifted-async";
       version = "0.8.0.1";
       sha256 = "ef8ca870155abb93e4ce742c46606ac59ab031ed86da31c75a6179c62be5f9bf";
       libraryHaskellDepends = [
         async base constraints lifted-base monad-control transformers-base
       ];
       testHaskellDepends = [
         async base HUnit lifted-base monad-control mtl tasty tasty-hunit
         tasty-th
       ];
       homepage = "https://github.com/maoe/lifted-async";
       description = "Run lifted IO operations asynchronously and wait for their results";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lifted-base_0_2_2_1" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, HUnit, monad-control
     , test-framework, test-framework-hunit, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "lifted-base";
       version = "0.2.2.1";
       sha256 = "68fe7b3c5b1f78d0c54a3d77bb7cc1552ad1f7e57346ed40dab93ccb8ff1818f";
       libraryHaskellDepends = [
         base base-unicode-symbols monad-control transformers-base
       ];
       testHaskellDepends = [
         base HUnit monad-control test-framework test-framework-hunit
         transformers transformers-base
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/lifted-base";
       description = "lifted IO operations from the base library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lifted-base_0_2_3_3" = callPackage
    ({ mkDerivation, base, HUnit, monad-control, test-framework
     , test-framework-hunit, transformers, transformers-base
     }:
     mkDerivation {
       pname = "lifted-base";
       version = "0.2.3.3";
       sha256 = "83c9d6c5ea77dbe3a5d261735ab71ff50dae132b20f8d8b29e01fa1b442c01d8";
       libraryHaskellDepends = [ base monad-control transformers-base ];
       testHaskellDepends = [
         base HUnit monad-control test-framework test-framework-hunit
         transformers transformers-base
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/lifted-base";
       description = "lifted IO operations from the base library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lifted-base" = callPackage
    ({ mkDerivation, base, HUnit, monad-control, test-framework
     , test-framework-hunit, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "lifted-base";
       version = "0.2.3.6";
       sha256 = "57c5837d83f569bb72136ca89256e50e1ac168ee935804a8e7763e9d8322e1fb";
       libraryHaskellDepends = [ base monad-control transformers-base ];
       testHaskellDepends = [
         base HUnit monad-control test-framework test-framework-hunit
         transformers transformers-base transformers-compat
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/basvandijk/lifted-base";
       description = "lifted IO operations from the base library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lifted-threads" = callPackage
    ({ mkDerivation, base, monad-control, threads, transformers-base }:
     mkDerivation {
       pname = "lifted-threads";
       version = "1.0";
       sha256 = "7f7dd54c54b252f3f3884a18282364a2b785ace96e8922b1d013fd62573800eb";
       libraryHaskellDepends = [
         base monad-control threads transformers-base
       ];
       homepage = "https://github.com/scrive/lifted-threads";
       description = "lifted IO operations from the threads library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lifter" = callPackage
    ({ mkDerivation, array, base, bitmap, bytestring, directory
     , filepath, gloss, mtl, stb-image
     }:
     mkDerivation {
       pname = "lifter";
       version = "0.1";
       sha256 = "ecb2ef028cf858543708c7e9b27c00017eac5d4dd547426ddc99dcdcaa908085";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bitmap bytestring directory filepath gloss mtl stb-image
       ];
       homepage = "http://icfpcontest2012.wordpress.com/";
       description = "A boulderdash-like game and solution validator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ligature" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "ligature";
       version = "0.1.0.0";
       sha256 = "2bb369a7c271fccfccf974149bb4d4899ba674d6d021a66f8529de0b1705030e";
       libraryHaskellDepends = [ base text ];
       jailbreak = true;
       description = "Expand ligatures in unicode text";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ligd" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ligd";
       version = "0.2";
       sha256 = "376b3f4eed6211308bfa0f9a4d4fde9a6eb7d569affd8f5fca30654542e9aec3";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/spl/ligd";
       description = "Lightweight Implementation of Generics and Dynamics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lighttpd-conf" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, happy, packedstring
     , pretty, template-haskell
     }:
     mkDerivation {
       pname = "lighttpd-conf";
       version = "0.4";
       sha256 = "c835afb47ca0f6916ccfc94f9666ba884c70ac5f7c7d7275601e5f2eccd2b520";
       libraryHaskellDepends = [
         array base bytestring packedstring pretty template-haskell
       ];
       libraryToolDepends = [ alex happy ];
       description = "Lighttpd configuration file tools";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lighttpd-conf-qq" = callPackage
    ({ mkDerivation, array, base, bytestring, haskell-src-exts
     , lighttpd-conf, template-haskell
     }:
     mkDerivation {
       pname = "lighttpd-conf-qq";
       version = "0.5";
       sha256 = "d840cca76d6336c3df195b1e0a981e1d5c3eaac1d49c97c9c09f1b086d04a3d9";
       libraryHaskellDepends = [
         array base bytestring haskell-src-exts lighttpd-conf
         template-haskell
       ];
       description = "A QuasiQuoter for lighttpd configuration files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lilypond" = callPackage
    ({ mkDerivation, base, data-default, music-dynamics-literal
     , music-pitch-literal, prettify, process, semigroups, vector-space
     }:
     mkDerivation {
       pname = "lilypond";
       version = "1.9.0";
       sha256 = "fc11db8e2c79a17137513ed1a0486d498a375922cdb3b8969c4baf57ee9c66d9";
       libraryHaskellDepends = [
         base data-default music-dynamics-literal music-pitch-literal
         prettify process semigroups vector-space
       ];
       description = "Bindings to Lilypond";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "limp" = callPackage
    ({ mkDerivation, base, containers, QuickCheck, tasty
     , tasty-quickcheck, tasty-th
     }:
     mkDerivation {
       pname = "limp";
       version = "0.3.2.1";
       sha256 = "53d6a827cc09868a0dab698d8c4abaab96453eb82a3ea5a8010c1f42e9c1a83b";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [
         base containers QuickCheck tasty tasty-quickcheck tasty-th
       ];
       jailbreak = true;
       homepage = "https://github.com/amosr/limp";
       description = "representation of Integer Linear Programs";
       license = stdenv.lib.licenses.mit;
     }) {};

  "limp-cbc" = callPackage
    ({ mkDerivation, base, c2hs, containers, limp, vector }:
     mkDerivation {
       pname = "limp-cbc";
       version = "0.3.2.1";
       sha256 = "5e76c9001938826f949f50a6712eb565cdbf0fba726d9ea13c75f3654dfa8a60";
       libraryHaskellDepends = [ base containers limp vector ];
       libraryToolDepends = [ c2hs ];
       testHaskellDepends = [ base limp ];
       jailbreak = true;
       homepage = "https://github.com/amosr/limp-cbc";
       description = "bindings for integer linear programming solver Coin/CBC";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lin-alg" = callPackage
    ({ mkDerivation, base, NumInstances, vector }:
     mkDerivation {
       pname = "lin-alg";
       version = "0.1.0.2";
       sha256 = "0cdf23a797b4e11be1a2b5c6b7c6228a6372b7ad2930e36b3214d763d21c22a4";
       libraryHaskellDepends = [ base NumInstances vector ];
       description = "Low-dimensional matrices and vectors for graphics and physics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linda" = callPackage
    ({ mkDerivation, base, hmatrix, HUnit }:
     mkDerivation {
       pname = "linda";
       version = "0.1.2";
       sha256 = "85e81818bda1643d9874100dc1f14600a55421f4c19d48f2dfc9e70d9389a834";
       libraryHaskellDepends = [ base hmatrix HUnit ];
       description = "LINear Discriminant Analysis";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lindenmayer" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "lindenmayer";
       version = "0.1.0.1";
       sha256 = "c1979f5f74ae6fb4763806721dc9406e0241ff412e38739973507dbf1725ff1d";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/reinh/hs-lindenmayer";
       description = "L-systems in Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "line-break" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "line-break";
       version = "0.1.0.0";
       sha256 = "2430db2915ce1f910a3053a2c342d5f15d3862262ca3c54cb49b048bca5c8507";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       description = "Convert newlines in text";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "line2pdf" = callPackage
    ({ mkDerivation, base, bytestring, containers }:
     mkDerivation {
       pname = "line2pdf";
       version = "0.0.7";
       sha256 = "253db37ee661b0003024b2ab23b9242f7c21597c4ebbf614b8cfc4d4a45c1375";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring containers ];
       executableHaskellDepends = [ base bytestring containers ];
       description = "Simple command-line utility to convert text into PDF";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "linear_1_15_5" = callPackage
    ({ mkDerivation, adjunctions, base, binary, bytestring, containers
     , directory, distributive, doctest, filepath, ghc-prim, hashable
     , HUnit, lens, reflection, semigroupoids, semigroups
     , simple-reflect, tagged, template-haskell, test-framework
     , test-framework-hunit, transformers, unordered-containers, vector
     , void
     }:
     mkDerivation {
       pname = "linear";
       version = "1.15.5";
       sha256 = "b1965b45c9a87a8076ee75eb2f762df761658fbd7fa0a2dda3731bf913f9dd9d";
       revision = "1";
       editedCabalFile = "8299e69032ccb46e06a18cb528ba64d9554b0bb346a72114983d6f131f92df68";
       libraryHaskellDepends = [
         adjunctions base binary containers distributive ghc-prim hashable
         lens reflection semigroupoids semigroups tagged template-haskell
         transformers unordered-containers vector void
       ];
       testHaskellDepends = [
         base binary bytestring directory doctest filepath HUnit lens
         simple-reflect test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/linear/";
       description = "Linear Algebra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linear_1_18_0_1" = callPackage
    ({ mkDerivation, adjunctions, base, binary, bytes, bytestring
     , cereal, containers, deepseq, directory, distributive, doctest
     , filepath, ghc-prim, hashable, HUnit, lens, reflection
     , semigroupoids, semigroups, simple-reflect, tagged
     , template-haskell, test-framework, test-framework-hunit
     , transformers, transformers-compat, unordered-containers, vector
     , void
     }:
     mkDerivation {
       pname = "linear";
       version = "1.18.0.1";
       sha256 = "2fae59edec0158e27f742ecf4a7307d979e930a7423c1214353a6d7f72cdeb19";
       revision = "2";
       editedCabalFile = "5d53e22d7c7ae21e256891cac4d137e23f6cb03fd7f9c3466e80f3924d2901ca";
       libraryHaskellDepends = [
         adjunctions base binary bytes cereal containers deepseq
         distributive ghc-prim hashable lens reflection semigroupoids
         semigroups tagged template-haskell transformers transformers-compat
         unordered-containers vector void
       ];
       testHaskellDepends = [
         base binary bytestring directory doctest filepath HUnit lens
         simple-reflect test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/linear/";
       description = "Linear Algebra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linear_1_18_1" = callPackage
    ({ mkDerivation, adjunctions, base, binary, bytes, bytestring
     , cereal, containers, deepseq, directory, distributive, doctest
     , filepath, ghc-prim, hashable, HUnit, lens, reflection
     , semigroupoids, semigroups, simple-reflect, tagged
     , template-haskell, test-framework, test-framework-hunit
     , transformers, transformers-compat, unordered-containers, vector
     , void
     }:
     mkDerivation {
       pname = "linear";
       version = "1.18.1";
       sha256 = "7f5c6d1052cff445b6ba65073a490fe4f053637005814d4b11b2d35f090c52d7";
       revision = "2";
       editedCabalFile = "54d1f7fa323fc6406f15d098bf681898b16c7ba78a12449b95ea294b81f5345a";
       libraryHaskellDepends = [
         adjunctions base binary bytes cereal containers deepseq
         distributive ghc-prim hashable lens reflection semigroupoids
         semigroups tagged template-haskell transformers transformers-compat
         unordered-containers vector void
       ];
       testHaskellDepends = [
         base binary bytestring directory doctest filepath HUnit lens
         simple-reflect test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/linear/";
       description = "Linear Algebra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linear_1_18_1_1" = callPackage
    ({ mkDerivation, adjunctions, base, binary, bytes, bytestring
     , cereal, containers, deepseq, directory, distributive, doctest
     , filepath, ghc-prim, hashable, HUnit, lens, reflection
     , semigroupoids, semigroups, simple-reflect, tagged
     , template-haskell, test-framework, test-framework-hunit
     , transformers, transformers-compat, unordered-containers, vector
     , void
     }:
     mkDerivation {
       pname = "linear";
       version = "1.18.1.1";
       sha256 = "37e16fad7e5e4d6ecedbd7d68f4aef49e37813913e0e2106c392123c98d9f7e1";
       revision = "2";
       editedCabalFile = "8c57bd840e0c9ab84b032d65a2a48ed6d20da4fb780f0d89d8c53adccc632ba4";
       libraryHaskellDepends = [
         adjunctions base binary bytes cereal containers deepseq
         distributive ghc-prim hashable lens reflection semigroupoids
         semigroups tagged template-haskell transformers transformers-compat
         unordered-containers vector void
       ];
       testHaskellDepends = [
         base binary bytestring directory doctest filepath HUnit lens
         simple-reflect test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/linear/";
       description = "Linear Algebra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linear_1_18_3" = callPackage
    ({ mkDerivation, adjunctions, base, binary, bytes, bytestring
     , cereal, containers, deepseq, directory, distributive, doctest
     , filepath, ghc-prim, hashable, HUnit, lens, reflection
     , semigroupoids, semigroups, simple-reflect, tagged
     , template-haskell, test-framework, test-framework-hunit
     , transformers, transformers-compat, unordered-containers, vector
     , void
     }:
     mkDerivation {
       pname = "linear";
       version = "1.18.3";
       sha256 = "a7e6cd7b97c2dbf1d4c75ef4ddf5484b490b75e433f1d4b31f6051580e9c0611";
       libraryHaskellDepends = [
         adjunctions base binary bytes cereal containers deepseq
         distributive ghc-prim hashable lens reflection semigroupoids
         semigroups tagged template-haskell transformers transformers-compat
         unordered-containers vector void
       ];
       testHaskellDepends = [
         base binary bytestring directory doctest filepath HUnit lens
         simple-reflect test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/linear/";
       description = "Linear Algebra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linear_1_19_1_3" = callPackage
    ({ mkDerivation, adjunctions, base, binary, bytes, bytestring
     , cereal, containers, deepseq, directory, distributive, doctest
     , filepath, ghc-prim, hashable, HUnit, lens, reflection
     , semigroupoids, semigroups, simple-reflect, tagged
     , template-haskell, test-framework, test-framework-hunit
     , transformers, transformers-compat, unordered-containers, vector
     , void
     }:
     mkDerivation {
       pname = "linear";
       version = "1.19.1.3";
       sha256 = "229580102e261cc2121d6f58adc807411a4345faf65b7b6740d4541b34acf9c2";
       libraryHaskellDepends = [
         adjunctions base binary bytes cereal containers deepseq
         distributive ghc-prim hashable lens reflection semigroupoids
         semigroups tagged template-haskell transformers transformers-compat
         unordered-containers vector void
       ];
       testHaskellDepends = [
         base binary bytestring directory doctest filepath HUnit lens
         simple-reflect test-framework test-framework-hunit
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/ekmett/linear/";
       description = "Linear Algebra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linear_1_20_3" = callPackage
    ({ mkDerivation, adjunctions, base, binary, bytes, bytestring
     , cereal, containers, deepseq, directory, distributive, doctest
     , filepath, ghc-prim, hashable, HUnit, lens, reflection
     , semigroupoids, semigroups, simple-reflect, tagged
     , template-haskell, test-framework, test-framework-hunit
     , transformers, transformers-compat, unordered-containers, vector
     , void
     }:
     mkDerivation {
       pname = "linear";
       version = "1.20.3";
       sha256 = "50f63a5b6019acb53ae06886749dea80443b18876c2990ca5376578c94537ac4";
       libraryHaskellDepends = [
         adjunctions base binary bytes cereal containers deepseq
         distributive ghc-prim hashable lens reflection semigroupoids
         semigroups tagged template-haskell transformers transformers-compat
         unordered-containers vector void
       ];
       testHaskellDepends = [
         base binary bytestring directory doctest filepath HUnit lens
         simple-reflect test-framework test-framework-hunit
       ];
       homepage = "http://github.com/ekmett/linear/";
       description = "Linear Algebra";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linear" = callPackage
    ({ mkDerivation, adjunctions, base, base-orphans, binary, bytes
     , bytestring, cereal, containers, deepseq, directory, distributive
     , doctest, filepath, ghc-prim, hashable, HUnit, lens, reflection
     , semigroupoids, semigroups, simple-reflect, tagged
     , template-haskell, test-framework, test-framework-hunit
     , transformers, transformers-compat, unordered-containers, vector
     , void
     }:
     mkDerivation {
       pname = "linear";
       version = "1.20.4";
       sha256 = "7bd91c482611f9b7226ec346a9630d2cf1975672b3a67e1b52ae24cdd039ddd3";
       libraryHaskellDepends = [
         adjunctions base base-orphans binary bytes cereal containers
         deepseq distributive ghc-prim hashable lens reflection
         semigroupoids semigroups tagged template-haskell transformers
         transformers-compat unordered-containers vector void
       ];
       testHaskellDepends = [
         base binary bytestring directory doctest filepath HUnit lens
         simple-reflect test-framework test-framework-hunit
       ];
       homepage = "http://github.com/ekmett/linear/";
       description = "Linear Algebra";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "linear-accelerate" = callPackage
    ({ mkDerivation, accelerate, base, lens, linear }:
     mkDerivation {
       pname = "linear-accelerate";
       version = "0.2";
       sha256 = "e62ad99a2f2366c457a75eecba34c0fe8036ecf3f60d59ad41936b26f8af6310";
       libraryHaskellDepends = [ accelerate base lens linear ];
       homepage = "http://github.com/ekmett/linear-accelerate/";
       description = "Instances to use linear vector spaces on accelerate backends";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "linear-algebra-cblas" = callPackage
    ({ mkDerivation, base, ieee754, QuickCheck, storable-complex
     , test-framework, test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "linear-algebra-cblas";
       version = "0.1";
       sha256 = "71c03d8b48ba9098f3144669f2aab52f52bfdd7b434cde529ee4d1fc4fb04af3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base ieee754 QuickCheck storable-complex vector
       ];
       executableHaskellDepends = [
         QuickCheck test-framework test-framework-quickcheck2
       ];
       homepage = "http://github.com/cartazio/hs-cblas";
       description = "A linear algebra library with bindings to BLAS and LAPACK";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linear-circuit" = callPackage
    ({ mkDerivation, base, comfort-graph, containers, hmatrix
     , non-empty, QuickCheck, transformers, utility-ht
     }:
     mkDerivation {
       pname = "linear-circuit";
       version = "0.0";
       sha256 = "8daca90d45a7a0a99910e863f2bedaf46b4b7caaa32cc0ef58e4c4376d72b93e";
       libraryHaskellDepends = [
         base comfort-graph containers hmatrix utility-ht
       ];
       testHaskellDepends = [
         base comfort-graph containers non-empty QuickCheck transformers
         utility-ht
       ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/thielema/linear-circuit";
       description = "Compute resistance of linear electrical circuits";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linear-grammar" = callPackage
    ({ mkDerivation, base, containers, hspec, QuickCheck }:
     mkDerivation {
       pname = "linear-grammar";
       version = "0.0.2.1";
       sha256 = "273d7796a24d0a8773f9cb175f1878e5c9052822c28ae055585f990731836e03";
       libraryHaskellDepends = [ base containers QuickCheck ];
       testHaskellDepends = [ base containers hspec QuickCheck ];
       description = "A simple grammar for building linear equations and inclusive inequalities";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "linear-maps" = callPackage
    ({ mkDerivation, base, containers, HUnit }:
     mkDerivation {
       pname = "linear-maps";
       version = "0.6.1";
       sha256 = "3385bb02476f73cad97447e65a2e7751ccb233671262c4bc170f6f4e52bfe118";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers HUnit ];
       jailbreak = true;
       description = "Finite maps for linear use";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linear-opengl" = callPackage
    ({ mkDerivation, base, distributive, lens, linear, OpenGL
     , OpenGLRaw, tagged
     }:
     mkDerivation {
       pname = "linear-opengl";
       version = "0.2.0.10";
       sha256 = "9dc10dc309a2b6eb64da004106fa6a4c50beabc6c06e5fbb917e46ce5133217d";
       libraryHaskellDepends = [
         base distributive lens linear OpenGL OpenGLRaw tagged
       ];
       jailbreak = true;
       homepage = "http://www.github.com/bgamari/linear-opengl";
       description = "Isomorphisms between linear and OpenGL types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linear-vect" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "linear-vect";
       version = "0.1.1.0";
       sha256 = "5ea6aa5361d1664bf82e4e48829a887cc3d2e11d064f439f9fd333fc2e08df44";
       libraryHaskellDepends = [ base random ];
       jailbreak = true;
       homepage = "https://github.com/capsjac/linear-vect";
       description = "A low-dimensional linear algebra library, operating on the Num typeclass";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "linearEqSolver" = callPackage
    ({ mkDerivation, base, sbv }:
     mkDerivation {
       pname = "linearEqSolver";
       version = "1.3";
       sha256 = "378b8a81d3175832cdb2a432cddaef016236a61c76f61fc6f4e4a92366885f2f";
       libraryHaskellDepends = [ base sbv ];
       homepage = "http://github.com/LeventErkok/linearEqSolver";
       description = "Use SMT solvers to solve linear systems over integers and rationals";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "linearscan" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, mtl, transformers }:
     mkDerivation {
       pname = "linearscan";
       version = "1.0.0";
       sha256 = "75a936a9eb2dfe95824556207cecb785570d33bca4f793614e4e26f344a4e18a";
       libraryHaskellDepends = [
         base containers ghc-prim mtl transformers
       ];
       homepage = "http://github.com/jwiegley/linearscan";
       description = "Linear scan register allocator, formally verified in Coq";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "linearscan-hoopl" = callPackage
    ({ mkDerivation, base, containers, deepseq, free, hoopl, hspec
     , hspec-expectations, lens-family-core, linearscan, QuickCheck
     , transformers
     }:
     mkDerivation {
       pname = "linearscan-hoopl";
       version = "1.0.0";
       sha256 = "e5796e9b1ed7eeb08b954e483010e0bf9e6bb126da6c87f2ff2439323b6e8370";
       libraryHaskellDepends = [
         base containers free hoopl linearscan QuickCheck transformers
       ];
       testHaskellDepends = [
         base containers deepseq hoopl hspec hspec-expectations
         lens-family-core linearscan QuickCheck transformers
       ];
       homepage = "http://github.com/jwiegley/linearscan-hoopl";
       description = "Makes it easy to use the linearscan register allocator with Hoopl";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linebreak" = callPackage
    ({ mkDerivation, base, hyphenation }:
     mkDerivation {
       pname = "linebreak";
       version = "1.0.0.3";
       sha256 = "e70e7d1274c923f23506fbe41fc8c86247618a9dba24dc4c62dac9a85f15bab9";
       libraryHaskellDepends = [ base hyphenation ];
       homepage = "http://ariis.it/static/articles/linebreak/page.html";
       description = "breaks strings to fit width";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "linguistic-ordinals" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "linguistic-ordinals";
       version = "0.1.0.1";
       sha256 = "68c0ada6fa1931d46310ad74891d0148ad6ad4912f3df28c3a67adeb961c540b";
       libraryHaskellDepends = [ base text ];
       homepage = "http://github.com/argiopetech/linguistic-ordinals";
       description = "Express Integral types as linguistic ordinals (1st, 2nd, 3rd, etc)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "link-relations" = callPackage
    ({ mkDerivation, base, bytestring, hashable, unordered-containers
     , uri-bytestring
     }:
     mkDerivation {
       pname = "link-relations";
       version = "0.1.1.0";
       sha256 = "3d6805c4e0f78239d3aedfa0baf9b488da9163058e5d4c58e4b7440b508cbb2a";
       libraryHaskellDepends = [
         base bytestring hashable unordered-containers uri-bytestring
       ];
       homepage = "http://hub.darcs.net/fr33domlover/link-relations";
       description = "Use web link relation types (RFC 5988) in Haskell";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "linkchk" = callPackage
    ({ mkDerivation, base, gtk, haskell98, popenhs, regex-compat, unix
     }:
     mkDerivation {
       pname = "linkchk";
       version = "0.0.2";
       sha256 = "8d1b3b6f779c0199573ee6b68500a359cdb6439969c2a2c9a36f966591fdfa3b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base gtk haskell98 popenhs regex-compat unix
       ];
       homepage = "http://www.haskell.org/~petersen/haskell/linkchk/";
       description = "linkchk is a network interface link ping monitor";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linkcore" = callPackage
    ({ mkDerivation, base, containers, extcore, filepath, process }:
     mkDerivation {
       pname = "linkcore";
       version = "0.4.1";
       sha256 = "01e128d244f6f1db4e1712802a632f3281036a1b06069b1bfb3eae3d14e63254";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers extcore filepath process
       ];
       description = "Combines multiple GHC Core modules into a single module";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linkedhashmap" = callPackage
    ({ mkDerivation, base, containers, deepseq, hashable, mtl, tasty
     , tasty-hunit, unordered-containers
     }:
     mkDerivation {
       pname = "linkedhashmap";
       version = "0.4.0.0";
       sha256 = "d87310f12abcfe0b50e15ea896685152710b5b1a8a5e9b159223efb8d34b63af";
       libraryHaskellDepends = [
         base containers deepseq hashable unordered-containers
       ];
       testHaskellDepends = [
         base containers deepseq hashable mtl tasty tasty-hunit
         unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/abasko/linkedhashmap";
       description = "Persistent LinkedHashMap data structure";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "linklater" = callPackage
    ({ mkDerivation, aeson, base, base-prelude, bytestring, containers
     , http-types, text, wai, wreq
     }:
     mkDerivation {
       pname = "linklater";
       version = "3.2.0.0";
       sha256 = "d9e5370d04d8849aa4c8df68d9a3bc7867c0a679f1a66f858be585e687b98695";
       libraryHaskellDepends = [
         aeson base base-prelude bytestring containers http-types text wai
         wreq
       ];
       homepage = "https://github.com/hlian/linklater";
       description = "The fast and fun way to write Slack.com bots";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "linode" = callPackage
    ({ mkDerivation, aeson, async, base, binary, bytestring, containers
     , errors, lens, process, retry, safe, tasty, tasty-hunit
     , tasty-quickcheck, text, transformers, wreq
     }:
     mkDerivation {
       pname = "linode";
       version = "0.2.0.0";
       sha256 = "3a5c1d507121a40848217ad8e092c3347c1c26a1ada09ccfa1450b30d22d59fa";
       libraryHaskellDepends = [
         aeson async base binary bytestring containers errors lens process
         retry safe text transformers wreq
       ];
       testHaskellDepends = [
         aeson base bytestring containers tasty tasty-hunit tasty-quickcheck
         text
       ];
       jailbreak = true;
       homepage = "http://github.com/Helkafen/haskell-linode#readme";
       description = "Bindings to the Linode API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linux-blkid" = callPackage
    ({ mkDerivation, base, blkid, monad-control, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "linux-blkid";
       version = "0.2.0.0";
       sha256 = "1dff1aa354d6f841e0363ae0a4877c0105645831d7b3018ad1f77d4016ffc719";
       libraryHaskellDepends = [
         base monad-control transformers transformers-base
       ];
       libraryPkgconfigDepends = [ blkid ];
       jailbreak = true;
       description = "Linux libblkid";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {blkid = null;};

  "linux-cgroup" = callPackage
    ({ mkDerivation, base, filepath }:
     mkDerivation {
       pname = "linux-cgroup";
       version = "0.1.1.2";
       sha256 = "c1bf7f5b28b77b87daf6fa4432461c30f774a1fa33f66969cc2e7963438ca135";
       libraryHaskellDepends = [ base filepath ];
       jailbreak = true;
       description = "Very basic interface to the Linux CGroup Virtual Filesystem";
       license = stdenv.lib.licenses.mit;
     }) {};

  "linux-evdev" = callPackage
    ({ mkDerivation, base, bytestring, time, unix }:
     mkDerivation {
       pname = "linux-evdev";
       version = "0.3.1";
       sha256 = "60ae93f19740216028c633c2c94fdb876e791408c1853a885c6b664308a8a5ff";
       libraryHaskellDepends = [ base bytestring time unix ];
       homepage = "http://github.com/bgamari/linux-evdev";
       description = "Bindings to Linux evdev input device interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "linux-file-extents" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "linux-file-extents";
       version = "0.2.0.0";
       sha256 = "6c7cd9e700f666f774736d31a0e6aa7bfe9bd1e075c11eed701ba95095fd9bd0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base unix ];
       homepage = "https://github.com/redneb/linux-file-extents";
       description = "Retrieve file fragmentation information under Linux";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "linux-inotify" = callPackage
    ({ mkDerivation, base, bytestring, hashable, unix }:
     mkDerivation {
       pname = "linux-inotify";
       version = "0.3.0.1";
       sha256 = "34bc9c0f2c7b5a16284fd15ab8228a2b13d80407d06043517e79872b154e393a";
       libraryHaskellDepends = [ base bytestring hashable unix ];
       description = "Thinner binding to the Linux Kernel's inotify interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "linux-kmod" = callPackage
    ({ mkDerivation, base, directory, libkmod }:
     mkDerivation {
       pname = "linux-kmod";
       version = "0.1.0.1";
       sha256 = "9ac32a731276cddc7d0da1a92cc2ea2254a3bc8e4ce0b207c886bb91ee8a0bef";
       libraryHaskellDepends = [ base directory ];
       libraryPkgconfigDepends = [ libkmod ];
       homepage = "https://github.com/tensor5/linux-kmod";
       description = "Linux kernel modules support";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {libkmod = null;};

  "linux-mount" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "linux-mount";
       version = "0.2.0.1";
       sha256 = "d15bad134e7e80c450523cfa794ff9e4b75b4671eb3579c8a8cfbcaea2cd7c89";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "https://github.com/tensor5/linux-mount";
       description = "Mount and unmount filesystems";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "linux-namespaces" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "linux-namespaces";
       version = "0.1.2.0";
       sha256 = "585c69130dfcc499cfba00385ae7facc8ab9f2c26bdf746a6e25fc96d3b5f67b";
       libraryHaskellDepends = [ base unix ];
       homepage = "https://github.com/redneb/hs-linux-namespaces";
       description = "Create new or enter an existing linux namespaces";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "linux-perf" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , filepath, ghc-events, mtl, pretty, process, unix
     }:
     mkDerivation {
       pname = "linux-perf";
       version = "0.3";
       sha256 = "2114d462f25efbc01c04d5ee8984b74bf3c677fc2e926b33d74e70bc9e9253a1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers mtl pretty
       ];
       executableHaskellDepends = [
         base bytestring containers directory filepath ghc-events process
         unix
       ];
       jailbreak = true;
       homepage = "https://github.com/bjpop/haskell-linux-perf";
       description = "Read files generated by perf on Linux";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linux-ptrace" = callPackage
    ({ mkDerivation, base, bytestring, mmap, posix-waitpid, process
     , template-haskell, unix
     }:
     mkDerivation {
       pname = "linux-ptrace";
       version = "0.1.2";
       sha256 = "75108b21c04301c3f2e9f8912fcd2e101cd0ed6bbda79c27d68b79ba938ff643";
       libraryHaskellDepends = [
         base bytestring mmap posix-waitpid process template-haskell unix
       ];
       jailbreak = true;
       description = "Wrapping of Linux' ptrace(2)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "linux-xattr" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "linux-xattr";
       version = "0.1.1.0";
       sha256 = "e69537b1e88d9c465280ff4ed288ccf490fc9cd32e8b168f10f59d52aa2ef866";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "https://github.com/tensor5/linux-xattr";
       description = "Read, set and list extended attributes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "linx-gateway" = callPackage
    ({ mkDerivation, base, binary, bytestring, network, QuickCheck
     , test-framework, test-framework-quickcheck2, time
     }:
     mkDerivation {
       pname = "linx-gateway";
       version = "0.1.0.2";
       sha256 = "98859b14ffb44511aea77dc384ffabb4c266ddcab85546bff351e0db37672a36";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base binary bytestring network ];
       executableHaskellDepends = [ base binary bytestring network time ];
       testHaskellDepends = [
         base binary bytestring QuickCheck test-framework
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/kosmoskatten/linx-gateway";
       description = "Implementation of the Enea LINX gateway protocol";
       license = stdenv.lib.licenses.mit;
     }) {};

  "lio" = callPackage
    ({ mkDerivation, base, bytestring, containers, hashable }:
     mkDerivation {
       pname = "lio";
       version = "0.11.5.0";
       sha256 = "229c64f8b6580e6eb2cecf0899e06489573f5a05d32e54306b28a1d051f0b182";
       libraryHaskellDepends = [ base bytestring containers hashable ];
       description = "Labeled IO Information Flow Control Library";
       license = "GPL";
     }) {};

  "lio-eci11" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, dclabel-eci11
     , directory, filepath, mtl, old-time, SHA, time, unix
     }:
     mkDerivation {
       pname = "lio-eci11";
       version = "0.2";
       sha256 = "88e512fac0f48cae26147ddf4e23055ba6374debdb0fcb67b3bd7160e7117487";
       libraryHaskellDepends = [
         array base bytestring containers dclabel-eci11 directory filepath
         mtl old-time SHA time unix
       ];
       description = "Labeled IO library";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lio-fs" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , lio, SHA, unix, xattr
     }:
     mkDerivation {
       pname = "lio-fs";
       version = "0.0.1.2";
       sha256 = "c9620b6016fc436140ec6e64881fd4dfd73273141c6bf8b9a87d8d3741d6fdff";
       libraryHaskellDepends = [
         base bytestring containers directory filepath lio SHA unix xattr
       ];
       description = "Labeled File System interface for LIO";
       license = "GPL";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "lio-simple" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bytestring, cmdargs, conduit, directory, filepath, http-types
     , lio, simple, simple-templates, text, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "lio-simple";
       version = "0.0.2.2";
       sha256 = "a40400ab819299bf5346ca3cd2778af739d61b22ccca68bc8a2b2d33a78aadd9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring bytestring conduit filepath http-types lio
         simple simple-templates text wai wai-extra warp
       ];
       executableHaskellDepends = [
         aeson attoparsec base bytestring cmdargs directory filepath
         simple-templates text
       ];
       jailbreak = true;
       homepage = "http://simple.cx";
       description = "LIO support for the Simple web framework";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lipsum-gen" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "lipsum-gen";
       version = "0.1.0.2";
       sha256 = "6c4caaecfd8fc61e0e6d516c8cde84d653392dd17fbd30bc2cc7c9caccee731d";
       libraryHaskellDepends = [ base QuickCheck ];
       jailbreak = true;
       description = "Generators for random sequences of English-like nonsense text";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "liquid-fixpoint" = callPackage
    ({ mkDerivation, ansi-terminal, array, attoparsec, base, bifunctors
     , bytestring, cmdargs, containers, deepseq, directory, filemanip
     , filepath, ghc-prim, hashable, intern, mtl, ocaml, parsec, pretty
     , process, syb, tasty, tasty-hunit, tasty-rerun, text, text-format
     , transformers, unordered-containers, z3
     }:
     mkDerivation {
       pname = "liquid-fixpoint";
       version = "0.4.0.0";
       sha256 = "7414b580a3ec8185da5e5148b46cef5d15e347080eb2561fcd228c72e7669816";
       revision = "2";
       editedCabalFile = "10397e387d91256dcd35cae36cb27ae302418c3c80da6e65d417657783beaf6b";
       configureFlags = [ "-fbuild-external" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal array attoparsec base bifunctors bytestring cmdargs
         containers deepseq directory filemanip filepath ghc-prim hashable
         intern mtl parsec pretty process syb text text-format transformers
         unordered-containers
       ];
       executableHaskellDepends = [
         ansi-terminal array base bifunctors bytestring cmdargs containers
         deepseq directory filepath hashable mtl parsec pretty process syb
         text text-format unordered-containers
       ];
       executableSystemDepends = [ ocaml ];
       testHaskellDepends = [
         base directory filepath process tasty tasty-hunit tasty-rerun text
       ];
       testSystemDepends = [ z3 ];
       homepage = "https://github.com/ucsd-progsys/liquid-fixpoint";
       description = "Predicate Abstraction-based Horn-Clause/Implication Constraint Solver";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ gridaphobe ];
     }) {inherit (pkgs) ocaml; inherit (pkgs) z3;};

  "liquidhaskell" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, array, base, bifunctors
     , bytestring, Cabal, cmdargs, containers, cpphs, data-default
     , deepseq, Diff, directory, filemanip, filepath, fingertree, ghc
     , ghc-paths, hashable, hpc, hscolour, intern, liquid-fixpoint, mtl
     , optparse-applicative, parsec, pretty, process, stm, syb, tagged
     , tasty, tasty-hunit, tasty-rerun, template-haskell, text, time
     , transformers, unordered-containers, vector, z3
     }:
     mkDerivation {
       pname = "liquidhaskell";
       version = "0.5.0.1";
       sha256 = "27f31e7652cd9ef0b97d2e3936c8e9c759961ac153b324c3e84f11cb441ab89a";
       revision = "2";
       editedCabalFile = "54142d52274f85af299d405bd5daac25b574f9d3f16c8e42b7f5b999d9a34a1d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal array base bifunctors bytestring Cabal cmdargs
         containers cpphs data-default deepseq Diff directory filemanip
         filepath fingertree ghc ghc-paths hashable hpc hscolour intern
         liquid-fixpoint mtl parsec pretty process syb template-haskell text
         time unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson ansi-terminal array base bifunctors bytestring cmdargs
         containers cpphs data-default deepseq Diff directory filemanip
         filepath fingertree ghc ghc-paths hashable hpc hscolour
         liquid-fixpoint mtl parsec pretty process syb template-haskell text
         time unordered-containers vector
       ];
       testHaskellDepends = [
         base containers directory filepath mtl optparse-applicative process
         stm tagged tasty tasty-hunit tasty-rerun transformers
       ];
       testSystemDepends = [ z3 ];
       jailbreak = true;
       homepage = "http://goto.ucsd.edu/liquidhaskell";
       description = "Liquid Types for Haskell";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ gridaphobe ];
     }) {inherit (pkgs) z3;};

  "lispparser" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "lispparser";
       version = "0.3.1";
       sha256 = "88034eeb852f838e1853a44de4f480b54a33bc0b8a1bd49fe04fdcfe2b7745c2";
       libraryHaskellDepends = [ base parsec ];
       description = "Simple parser for LISP S-expressions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "list-extras" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "list-extras";
       version = "0.4.1.4";
       sha256 = "3c6e701a1792c10a3fc1145305afa87ffa0184d99f72d443752ef23fbc997297";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.haskell.org/~wren/";
       description = "Common not-so-common functions for lists";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "list-fusion-probe_0_1_0_3" = callPackage
    ({ mkDerivation, base, tasty, tasty-hunit }:
     mkDerivation {
       pname = "list-fusion-probe";
       version = "0.1.0.3";
       sha256 = "57a299acdfdeceee0d5014dc670a9d323f4f8a23b2b882f926e656cb978155b6";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       jailbreak = true;
       description = "testing list fusion for success";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "list-fusion-probe_0_1_0_4" = callPackage
    ({ mkDerivation, base, tasty, tasty-hunit }:
     mkDerivation {
       pname = "list-fusion-probe";
       version = "0.1.0.4";
       sha256 = "1a1ccf5c823de1771c1841ab0dc53e146e7911e332bd155b198025348deca689";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       description = "testing list fusion for success";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "list-fusion-probe" = callPackage
    ({ mkDerivation, base, tasty, tasty-hunit }:
     mkDerivation {
       pname = "list-fusion-probe";
       version = "0.1.0.5";
       sha256 = "7471363bd737abca1888bb8274cb3fef8f4fc925875b27fa0901efa1358adb50";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       description = "testing list fusion for success";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "list-grouping" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "list-grouping";
       version = "0.1.1";
       sha256 = "74182f76b1af721ecea70d1ee1819eff7a1353e80af980e847174c9219322e71";
       libraryHaskellDepends = [ base ];
       homepage = "http://coder.bsimmons.name/blog/2009/08/list-grouping-module-released/";
       description = "Functions for grouping a list into sublists";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "list-mux" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "list-mux";
       version = "1.0";
       sha256 = "da5b52d5ba7d783630962f976761d6f6f4e2e5663b2dc0c32d2a9d674a58ff90";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://github.com/hellertime/list-mux";
       description = "List Multiplexing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "list-prompt" = callPackage
    ({ mkDerivation, ansi-terminal, base, data-default, hspec, stm
     , terminal-size, vty
     }:
     mkDerivation {
       pname = "list-prompt";
       version = "0.1.1.0";
       sha256 = "c7323c7a802940deba1a7be46265fd8c01f548174d5f08923a607e1730ca4dee";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base data-default stm terminal-size vty
       ];
       executableHaskellDepends = [
         ansi-terminal base data-default stm terminal-size vty
       ];
       testHaskellDepends = [
         ansi-terminal base data-default hspec stm terminal-size vty
       ];
       homepage = "https://github.com/yamadapc/list-prompt.git";
       description = "A simple list prompt UI for the terminal";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "list-remote-forwards" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, configurator
     , containers, directory, dns, doctest, filemanip, filepath, HDBC
     , HDBC-postgresql, HDBC-sqlite3, MissingH, tasty, tasty-hunit
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "list-remote-forwards";
       version = "0.0.1";
       sha256 = "da772a92043fcdfd60698bd24c03c1a73cd0531ab88923dd1dbe13ed091105af";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs configurator containers directory dns
         filepath HDBC HDBC-postgresql HDBC-sqlite3 MissingH tasty
         tasty-hunit tasty-quickcheck
       ];
       testHaskellDepends = [
         base bytestring cmdargs configurator containers directory dns
         doctest filemanip filepath HDBC HDBC-postgresql HDBC-sqlite3
         MissingH tasty tasty-hunit tasty-quickcheck
       ];
       description = "List all remote forwards for mail accounts stored in a SQL database";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "list-t_0_3_0" = callPackage
    ({ mkDerivation, base-prelude, HTF, mmorph, monad-control
     , mtl-prelude, transformers, transformers-base
     }:
     mkDerivation {
       pname = "list-t";
       version = "0.3.0";
       sha256 = "a93292bac262cbadaf0faf357ff9a16ec79512afa0f308ae6852e9f80ef92f24";
       libraryHaskellDepends = [
         base-prelude mmorph monad-control transformers transformers-base
       ];
       testHaskellDepends = [ base-prelude HTF mtl-prelude ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/list-t";
       description = "ListT done right";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "list-t_0_3_1" = callPackage
    ({ mkDerivation, base-prelude, HTF, mmorph, monad-control
     , mtl-prelude, transformers, transformers-base
     }:
     mkDerivation {
       pname = "list-t";
       version = "0.3.1";
       sha256 = "e2536f9e62d3913bf1ca7a5aa7fa8494dc5c546c4c114d90ff1eb6c0d45d3517";
       libraryHaskellDepends = [
         base-prelude mmorph monad-control transformers transformers-base
       ];
       testHaskellDepends = [ base-prelude HTF mtl-prelude ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/list-t";
       description = "ListT done right";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "list-t_0_3_2" = callPackage
    ({ mkDerivation, base-prelude, HTF, mmorph, monad-control
     , mtl-prelude, transformers, transformers-base
     }:
     mkDerivation {
       pname = "list-t";
       version = "0.3.2";
       sha256 = "5db363d25920fcfd4fa14e22d50c63719fdbde07ff110a3544128aba57795667";
       libraryHaskellDepends = [
         base-prelude mmorph monad-control transformers transformers-base
       ];
       testHaskellDepends = [ base-prelude HTF mmorph mtl-prelude ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/list-t";
       description = "ListT done right";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "list-t_0_4_2" = callPackage
    ({ mkDerivation, base-prelude, HTF, mmorph, monad-control
     , mtl-prelude, transformers, transformers-base
     }:
     mkDerivation {
       pname = "list-t";
       version = "0.4.2";
       sha256 = "7b80a6ac4bf4123b10156b30134148a5ec4e885d490df86ad24ada5fec61df58";
       libraryHaskellDepends = [
         base-prelude mmorph monad-control transformers transformers-base
       ];
       testHaskellDepends = [ base-prelude HTF mmorph mtl-prelude ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/list-t";
       description = "ListT done right";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "list-t_0_4_3" = callPackage
    ({ mkDerivation, base-prelude, HTF, mmorph, monad-control
     , mtl-prelude, transformers, transformers-base
     }:
     mkDerivation {
       pname = "list-t";
       version = "0.4.3";
       sha256 = "2dea61a7b4451757ae18c0b26e46509c5da5b47b78cbafac3e634576d2e02336";
       libraryHaskellDepends = [
         base-prelude mmorph monad-control transformers transformers-base
       ];
       testHaskellDepends = [ base-prelude HTF mmorph mtl-prelude ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/list-t";
       description = "ListT done right";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "list-t_0_4_4" = callPackage
    ({ mkDerivation, base-prelude, HTF, mmorph, monad-control, mtl
     , mtl-prelude, transformers, transformers-base
     }:
     mkDerivation {
       pname = "list-t";
       version = "0.4.4";
       sha256 = "92ef3abd375c7049aacbab5f0c15930d4781573f216f5e60f0b412262003b302";
       libraryHaskellDepends = [
         base-prelude mmorph monad-control mtl transformers
         transformers-base
       ];
       testHaskellDepends = [ base-prelude HTF mmorph mtl-prelude ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/list-t";
       description = "ListT done right";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "list-t_0_4_5_1" = callPackage
    ({ mkDerivation, base-prelude, HTF, mmorph, monad-control, mtl
     , mtl-prelude, transformers, transformers-base
     }:
     mkDerivation {
       pname = "list-t";
       version = "0.4.5.1";
       sha256 = "6a5c6b182c6a059d8ec113667526933b8a4177ac70ca1aedd3822d76c16ec155";
       libraryHaskellDepends = [
         base-prelude mmorph monad-control mtl transformers
         transformers-base
       ];
       testHaskellDepends = [ base-prelude HTF mmorph mtl-prelude ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/list-t";
       description = "ListT done right";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "list-t" = callPackage
    ({ mkDerivation, base-prelude, HTF, mmorph, monad-control, mtl
     , mtl-prelude, transformers, transformers-base
     }:
     mkDerivation {
       pname = "list-t";
       version = "0.4.6";
       sha256 = "fe49a4fee6f166c677758e26bb26dadd8fa57c5a8fa288c64bbcaeeb420467b2";
       libraryHaskellDepends = [
         base-prelude mmorph monad-control mtl transformers
         transformers-base
       ];
       testHaskellDepends = [ base-prelude HTF mmorph mtl-prelude ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/list-t";
       description = "ListT done right";
       license = stdenv.lib.licenses.mit;
     }) {};

  "list-t-attoparsec" = callPackage
    ({ mkDerivation, attoparsec, base-prelude, either, hspec, list-t
     , list-t-text, text, transformers
     }:
     mkDerivation {
       pname = "list-t-attoparsec";
       version = "0.4.0.2";
       sha256 = "614950a96b0f465b6bd084c250f4c399f433e305928305934623237ef129590b";
       libraryHaskellDepends = [
         attoparsec base-prelude either list-t text transformers
       ];
       testHaskellDepends = [
         attoparsec base-prelude either hspec list-t list-t-text text
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/list-t-attoparsec";
       description = "An \"attoparsec\" adapter for \"list-t\"";
       license = stdenv.lib.licenses.mit;
     }) {};

  "list-t-html-parser" = callPackage
    ({ mkDerivation, base-prelude, case-insensitive, conversion
     , conversion-case-insensitive, conversion-text, either, hspec
     , html-entities, html-tokenizer, list-t, list-t-attoparsec
     , list-t-text, mtl-prelude, text, xml-types
     }:
     mkDerivation {
       pname = "list-t-html-parser";
       version = "0.4.1.1";
       sha256 = "42f9b2c5e77acfa154a56ac538b29888d943d451487a45a70040d32458c24f27";
       libraryHaskellDepends = [
         base-prelude case-insensitive conversion
         conversion-case-insensitive conversion-text either html-entities
         html-tokenizer list-t mtl-prelude text xml-types
       ];
       testHaskellDepends = [
         base-prelude conversion conversion-text either hspec html-tokenizer
         list-t-attoparsec list-t-text text xml-types
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/list-t-html-parser";
       description = "Streaming HTML parser";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "list-t-http-client" = callPackage
    ({ mkDerivation, base-prelude, bytestring, http-client, list-t
     , mtl-prelude
     }:
     mkDerivation {
       pname = "list-t-http-client";
       version = "0.1.0.1";
       sha256 = "e20dce9470d93127649c8a46b534ec1bab7a64dce3366f3f6367ff1e9dc69d0b";
       libraryHaskellDepends = [
         base-prelude bytestring http-client list-t mtl-prelude
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/list-t-http-client";
       description = "A streaming HTTP client";
       license = stdenv.lib.licenses.mit;
     }) {};

  "list-t-libcurl" = callPackage
    ({ mkDerivation, base, base-prelude, bytestring, curlhs, either
     , list-t, mtl-prelude, resource-pool, stm
     }:
     mkDerivation {
       pname = "list-t-libcurl";
       version = "0.3.0.0";
       sha256 = "257b5f7b2121b88e2dcbc18cb70e0d0bdb53e17be412a9638f661e7c50ee8fc1";
       libraryHaskellDepends = [
         base base-prelude bytestring curlhs either list-t mtl-prelude
         resource-pool stm
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/list-t-libcurl";
       description = "A \"libcurl\"-based streaming HTTP client";
       license = stdenv.lib.licenses.mit;
     }) {};

  "list-t-text" = callPackage
    ({ mkDerivation, base, base-prelude, bytestring, hspec, list-t
     , mtl-prelude, QuickCheck, quickcheck-instances, text, transformers
     }:
     mkDerivation {
       pname = "list-t-text";
       version = "0.2.0.2";
       sha256 = "95e2d3647608d2e8a527f4ab0666a4fe98ed7f67b17e4831fc2e5f59b78e4bc3";
       libraryHaskellDepends = [
         base-prelude bytestring list-t mtl-prelude text
       ];
       testHaskellDepends = [
         base base-prelude bytestring hspec list-t QuickCheck
         quickcheck-instances text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/list-t-text";
       description = "A streaming text codec";
       license = stdenv.lib.licenses.mit;
     }) {};

  "list-tries" = callPackage
    ({ mkDerivation, base, binary, containers, dlist }:
     mkDerivation {
       pname = "list-tries";
       version = "0.6.1";
       sha256 = "b886f6563a97680545bf54f47f7bfa2dace0540185e08c1fd4230e0ff947911a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base binary containers dlist ];
       executableHaskellDepends = [ base binary containers dlist ];
       homepage = "http://iki.fi/matti.niemenmaa/list-tries/";
       description = "Tries and Patricia tries: finite sets and maps for list keys";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "list-zip-def" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "list-zip-def";
       version = "0.1.0.1";
       sha256 = "d0447f7e5347eb2b8e6d27ddcc647677b5e33a44c3e61995c2faa99deed3ca1d";
       libraryHaskellDepends = [ base ];
       description = "Provides zips where the combining doesn't stop premature, but instead uses default values";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "listlike-instances" = callPackage
    ({ mkDerivation, base, bytestring, ListLike, text, vector }:
     mkDerivation {
       pname = "listlike-instances";
       version = "0.2.3.1";
       sha256 = "5583a4ee3265b297a84582c2af56eaa69ddb6bd753c11d77ff57777e2cb67056";
       libraryHaskellDepends = [ base bytestring ListLike text vector ];
       jailbreak = true;
       homepage = "http://jwlato.webfactional.com/haskell/listlike-instances";
       description = "Extra instances of the ListLike class";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lists" = callPackage
    ({ mkDerivation, base, list-extras, split }:
     mkDerivation {
       pname = "lists";
       version = "0.4.2";
       sha256 = "965a9e475a09e96fb899527c12872c7eada9169b52e1fd33da863e03f58c5f62";
       libraryHaskellDepends = [ base list-extras split ];
       description = "Functions for dealing with lists";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "listsafe" = callPackage
    ({ mkDerivation, base, exceptions }:
     mkDerivation {
       pname = "listsafe";
       version = "0.1.0.1";
       sha256 = "1a073247edfbea7dd7b7f9629fc64ddd3bce67fa61695da23ff43fb31d398d69";
       libraryHaskellDepends = [ base exceptions ];
       homepage = "https://github.com/ombocomp/listsafe";
       description = "Safe wrappers for partial list functions, supporting MonadThrow";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "lit" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, cheapskate
     , directory, filepath, highlighting-kate, parsec, text, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "lit";
       version = "0.1.10.0";
       sha256 = "549f3ad1a97c14c4bae4d74e49322efa5a10f5ad9056ab82b7d9529ae04f3636";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-html blaze-markup cheapskate directory filepath
         highlighting-kate parsec text time unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/cdosborn/lit";
       description = "A simple tool for literate programming";
       license = "GPL";
     }) {};

  "literals" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "literals";
       version = "1.0";
       sha256 = "526848d8b01b84f6544fdcb400303f070dd3eabd151f811045476b0ceed6c41a";
       libraryHaskellDepends = [ base ];
       description = "Non-overloaded functions for concrete literals";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "live-sequencer" = callPackage
    ({ mkDerivation, alsa-core, alsa-seq, base, bytestring, cgi
     , concurrent-split, containers, data-accessor
     , data-accessor-transformers, directory, event-list
     , explicit-exception, filepath, html, httpd-shed, midi, midi-alsa
     , network, non-empty, non-negative, parsec, pretty, process, stm
     , stm-split, strict, transformers, unix, utility-ht, wx, wxcore
     }:
     mkDerivation {
       pname = "live-sequencer";
       version = "0.0.4";
       sha256 = "d4981f43c98752a8258a67b40e2ecd49821a03c0795176a5fbd48b73aed0c812";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base event-list non-negative ];
       executableHaskellDepends = [
         alsa-core alsa-seq base bytestring cgi concurrent-split containers
         data-accessor data-accessor-transformers directory
         explicit-exception filepath html httpd-shed midi midi-alsa network
         non-empty parsec pretty process stm stm-split strict transformers
         unix utility-ht wx wxcore
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Live-Sequencer";
       description = "Live coding of MIDI music";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ll-picosat" = callPackage
    ({ mkDerivation, base, picosat }:
     mkDerivation {
       pname = "ll-picosat";
       version = "0.1.0.0";
       sha256 = "f01837f708aadef578a8b37ad426d3f9b42fc9f62f7025120163da482d63230d";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ picosat ];
       jailbreak = true;
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) picosat;};

  "llrbtree" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "llrbtree";
       version = "0.1.1";
       sha256 = "c1c857fbce835cb8bd35a304ca66ce3deadf56e8022c04c87bf4df1a5cb8eb14";
       libraryHaskellDepends = [ base ];
       description = "Purely functional sets and heaps";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "llsd" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, containers
     , dataenc, ghc-prim, hexpat, mtl, network, old-locale, parsec
     , pretty, random, template-haskell, text, time, utf8-string, uuid
     }:
     mkDerivation {
       pname = "llsd";
       version = "0.2.0.0";
       sha256 = "2fff9bd39961e34fbb670990bd0309684696723b6ffc3851f9666201a4523eec";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring cereal containers dataenc ghc-prim hexpat
         mtl network old-locale parsec pretty random template-haskell text
         time utf8-string uuid
       ];
       jailbreak = true;
       homepage = "http://wiki.secondlife.com/wiki/LLSD";
       description = "An implementation of the LLSD data system";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "llvm" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, llvm-base
     , mtl, process, type-level
     }:
     mkDerivation {
       pname = "llvm";
       version = "3.2.0.2";
       sha256 = "39d744ff56a7b5d0827ec32e98b80414441103fdfd25e8e373a6a7b701aa6186";
       libraryHaskellDepends = [
         base bytestring containers directory llvm-base mtl process
         type-level
       ];
       homepage = "https://github.com/bos/llvm";
       description = "Bindings to the LLVM compiler toolkit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "llvm-analysis" = callPackage
    ({ mkDerivation, array, base, boomerang, bytestring, containers
     , deepseq, directory, failure, fgl, filemanip, filepath
     , GenericPretty, graphviz, hashable, hoopl, HUnit, ifscs
     , itanium-abi, lens, llvm-base-types, llvm-data-interop, monad-par
     , process, temporary, test-framework, test-framework-hunit, text
     , transformers, uniplate, unordered-containers, vector
     }:
     mkDerivation {
       pname = "llvm-analysis";
       version = "0.3.0";
       sha256 = "13d5a1202cb920fc8bc1b65ad138b3b91e91b824264a65b4963c04cf130b9349";
       libraryHaskellDepends = [
         array base boomerang bytestring containers deepseq directory
         failure fgl filemanip filepath GenericPretty graphviz hashable
         hoopl HUnit ifscs itanium-abi lens llvm-base-types monad-par
         process temporary test-framework test-framework-hunit text
         transformers uniplate unordered-containers vector
       ];
       testHaskellDepends = [
         base bytestring containers filepath HUnit itanium-abi
         llvm-data-interop transformers uniplate unordered-containers
       ];
       description = "A Haskell library for analyzing LLVM bitcode";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "llvm-base" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "llvm-base";
       version = "3.2.0.2";
       sha256 = "96e454d8167e59862a2920a29c9c3b9030a595227451b30db82d5a58d0b2e6b8";
       libraryHaskellDepends = [ base mtl ];
       homepage = "https://github.com/bos/llvm";
       description = "FFI bindings to the LLVM compiler toolkit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "llvm-base-types" = callPackage
    ({ mkDerivation, base, c2hs, containers, deepseq, dwarf, failure
     , GenericPretty, graphviz, hashable, pretty, regex-tdfa, text
     , transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "llvm-base-types";
       version = "0.3.0";
       sha256 = "768dc670dfb3bc64ccd50f5a30fb0a55e20c0b7ba45a0c4cb7c08322f8615d90";
       libraryHaskellDepends = [
         base containers deepseq dwarf failure GenericPretty graphviz
         hashable pretty regex-tdfa text transformers unordered-containers
         vector
       ];
       libraryToolDepends = [ c2hs ];
       description = "The base types for a mostly pure Haskell LLVM analysis library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "llvm-base-util" = callPackage
    ({ mkDerivation, base, llvm-base }:
     mkDerivation {
       pname = "llvm-base-util";
       version = "3.0.1.0";
       sha256 = "5c889f94d67f5f226e69b1837985bcd12a815e0ae72880f9c4069e37f96e061f";
       libraryHaskellDepends = [ base llvm-base ];
       homepage = "https://github.com/bos/llvm";
       description = "Utilities for bindings to the LLVM compiler toolkit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "llvm-data-interop" = callPackage
    ({ mkDerivation, array, base, bytestring, c2hs, containers
     , data-default, deepseq, dwarf, hashable, hashtables
     , llvm-base-types, loch-th, mtl, text, transformers, unification-fd
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "llvm-data-interop";
       version = "0.3.0";
       sha256 = "c1b7a9440ea22241d384817ead036da0200a17f83f6ab1acb9d62a0c56a76e22";
       libraryHaskellDepends = [
         array base bytestring containers data-default deepseq dwarf
         hashable hashtables llvm-base-types loch-th mtl text transformers
         unification-fd unordered-containers vector
       ];
       libraryToolDepends = [ c2hs ];
       description = "A low-level data interoperability binding for LLVM";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "llvm-extra" = callPackage
    ({ mkDerivation, base, containers, cpuid, llvm-tf, non-empty, tfp
     , transformers, unsafe, utility-ht
     }:
     mkDerivation {
       pname = "llvm-extra";
       version = "0.6";
       sha256 = "c814cd36aacbf0f8627d4aa40fb8ea880f2100b3dd5b7e65f0877d70002d905a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers cpuid llvm-tf non-empty tfp transformers unsafe
         utility-ht
       ];
       homepage = "http://code.haskell.org/~thielema/llvm-extra/";
       description = "Utility functions for the llvm interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "llvm-ffi" = callPackage
    ({ mkDerivation, base, llvm }:
     mkDerivation {
       pname = "llvm-ffi";
       version = "3.0.0";
       sha256 = "9b012f897d95f852e69221b87225d0b16ecfe06685007d65bef581c98f250b1e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       libraryPkgconfigDepends = [ llvm ];
       homepage = "http://haskell.org/haskellwiki/LLVM";
       description = "FFI bindings to the LLVM compiler toolkit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (self.llvmPackages) llvm;};

  "llvm-general" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, HUnit
     , llvm-config, llvm-general-pure, mtl, parsec, QuickCheck, setenv
     , template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, transformers, transformers-compat
     , utf8-string
     }:
     mkDerivation {
       pname = "llvm-general";
       version = "3.5.1.2";
       sha256 = "2075b44cc1475a8623e7164add94d7b9f31ca9a157e099b23389b892886bd297";
       libraryHaskellDepends = [
         array base bytestring containers llvm-general-pure mtl parsec
         setenv template-haskell transformers transformers-compat
         utf8-string
       ];
       libraryToolDepends = [ llvm-config ];
       testHaskellDepends = [
         base containers HUnit llvm-general-pure mtl QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
         transformers transformers-compat
       ];
       homepage = "http://github.com/bscarlet/llvm-general/";
       description = "General purpose LLVM bindings";
       license = stdenv.lib.licenses.bsd3;
     }) {llvm-config = null;};

  "llvm-general-pure" = callPackage
    ({ mkDerivation, base, containers, HUnit, mtl, parsec, QuickCheck
     , setenv, template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "llvm-general-pure";
       version = "3.5.1.0";
       sha256 = "e5349189b1c203793dd4f0e2a582b633f09fa311340189b3ade004f4794b8097";
       libraryHaskellDepends = [
         base containers mtl parsec setenv template-haskell transformers
       ];
       testHaskellDepends = [
         base containers HUnit mtl QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "http://github.com/bscarlet/llvm-general/";
       description = "Pure Haskell LLVM functionality (no FFI)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "llvm-general-quote" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers, happy
     , haskell-src-meta, HUnit, llvm-general-pure, mainland-pretty, mtl
     , split, srcloc, syb, symbol, tasty, tasty-hunit, template-haskell
     , th-lift
     }:
     mkDerivation {
       pname = "llvm-general-quote";
       version = "0.2.0.0";
       sha256 = "e5acc18c0f9bcce3fb955d5f6768bf4bab223c78d2a6e6588e46175fd5b5430a";
       libraryHaskellDepends = [
         array base bytestring containers haskell-src-meta llvm-general-pure
         mainland-pretty mtl split srcloc syb symbol template-haskell
         th-lift
       ];
       libraryToolDepends = [ alex happy ];
       testHaskellDepends = [
         base containers HUnit llvm-general-pure tasty tasty-hunit
       ];
       jailbreak = true;
       homepage = "https://github.com/tvh/llvm-general-quote";
       description = "QuasiQuoting llvm code for llvm-general";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "llvm-ht" = callPackage
    ({ mkDerivation, base, bytestring, directory, mtl, process
     , type-level
     }:
     mkDerivation {
       pname = "llvm-ht";
       version = "0.7.0.0";
       sha256 = "c6fa920dbb8aed7c4bae2a9f829b78ee38a2558ee7cbe0f67b4d4a29aee7c8fa";
       libraryHaskellDepends = [
         base bytestring directory mtl process type-level
       ];
       homepage = "http://darcs.serpentine.com/llvm/";
       description = "Bindings to the LLVM compiler toolkit with some custom extensions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "llvm-pkg-config" = callPackage
    ({ mkDerivation, base, Cabal, explicit-exception, process
     , transformers, utility-ht
     }:
     mkDerivation {
       pname = "llvm-pkg-config";
       version = "0.0";
       sha256 = "dcf41d2b13c0b1af4c6f7d1d89f43e1bdf6c9603059e5a5155915bb80248dce9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal explicit-exception process transformers utility-ht
       ];
       jailbreak = true;
       description = "Generate Pkg-Config configuration file for LLVM";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "llvm-pretty" = callPackage
    ({ mkDerivation, base, containers, monadLib, pretty }:
     mkDerivation {
       pname = "llvm-pretty";
       version = "0.4.0.1";
       sha256 = "637506a2356076fefbf7515baa4c19ef2828fc404ab3c0ae0f9b1b2d5f04a42b";
       libraryHaskellDepends = [ base containers monadLib pretty ];
       description = "A pretty printing library inspired by the llvm binding";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "llvm-pretty-bc-parser" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, containers
     , directory, fgl, fgl-visualize, filepath, llvm-pretty, monadLib
     , pretty, process
     }:
     mkDerivation {
       pname = "llvm-pretty-bc-parser";
       version = "0.2.1.0";
       sha256 = "2d852be9dc0aa29d7a3c898486a201748c2f1a0276393a1f156e624eee108a8a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cereal containers fgl llvm-pretty monadLib
         pretty
       ];
       executableHaskellDepends = [
         array base bytestring cereal containers fgl fgl-visualize
         llvm-pretty monadLib pretty
       ];
       testHaskellDepends = [
         base bytestring directory filepath llvm-pretty process
       ];
       description = "LLVM bitcode parsing library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "llvm-tf" = callPackage
    ({ mkDerivation, base, containers, llvm-ffi, non-empty, process
     , storable-record, tfp, transformers, utility-ht
     }:
     mkDerivation {
       pname = "llvm-tf";
       version = "3.0.3.1";
       sha256 = "096c1de602ca2ae1d09e0a8ffa3bd3746aaa9619d078db2109fcb8b29f417d2e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers llvm-ffi non-empty process storable-record tfp
         transformers utility-ht
       ];
       description = "Bindings to the LLVM compiler toolkit using type families";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "llvm-tools" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-conduit, base, blaze-html
     , blaze-markup, bytestring, conduit, containers, directory
     , filemanip, filepath, graphviz, llvm-analysis, llvm-data-interop
     , optparse-applicative, parallel-io, process-conduit
     , unordered-containers, xml
     }:
     mkDerivation {
       pname = "llvm-tools";
       version = "0.2.0.1";
       sha256 = "0d6edef77bc384a8391f50fc5fc1094ab88af4a8f5f5b385134a69dc9e06d7db";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html blaze-markup bytestring directory filemanip
         filepath graphviz llvm-analysis llvm-data-interop parallel-io xml
       ];
       executableHaskellDepends = [
         attoparsec attoparsec-conduit base bytestring conduit containers
         graphviz llvm-analysis llvm-data-interop optparse-applicative
         process-conduit unordered-containers
       ];
       jailbreak = true;
       description = "Useful tools built on llvm-analysis";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lmdb" = callPackage
    ({ mkDerivation, array, base, lmdb }:
     mkDerivation {
       pname = "lmdb";
       version = "0.2.5";
       sha256 = "80552856211cdce06b808685d621bdd9c33a5ac5540a4dafe120c6b20c901c7d";
       libraryHaskellDepends = [ array base ];
       librarySystemDepends = [ lmdb ];
       homepage = "http://github.com/dmbarbour/haskell-lmdb";
       description = "Lightning MDB bindings";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) lmdb;};

  "lmonad" = callPackage
    ({ mkDerivation, base, containers, exceptions, HUnit, monad-control
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "lmonad";
       version = "0.1.0.0";
       sha256 = "610403335028e21a0eb7f31d5d9a1e9a6befcb53edb28c3a44fb38de14218240";
       libraryHaskellDepends = [
         base containers exceptions monad-control transformers
         transformers-base
       ];
       testHaskellDepends = [
         base containers exceptions HUnit monad-control transformers
         transformers-base
       ];
       description = "LMonad is an Information Flow Control (IFC) framework for Haskell applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lmonad-yesod" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup
     , containers, esqueleto, haskell-src-meta, lifted-base, lmonad, mtl
     , persistent, shakespeare, tagged, template-haskell, text
     , transformers, yesod-core, yesod-persistent
     }:
     mkDerivation {
       pname = "lmonad-yesod";
       version = "0.1.0.0";
       sha256 = "bd2389ecb5d8c734c72da1bb77f76824bacbabb42ae727d2c161184a4f9f508f";
       libraryHaskellDepends = [
         attoparsec base blaze-html blaze-markup containers esqueleto
         haskell-src-meta lifted-base lmonad mtl persistent shakespeare
         tagged template-haskell text transformers yesod-core
         yesod-persistent
       ];
       description = "LMonad for Yesod integrates LMonad's IFC with Yesod web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "load-env" = callPackage
    ({ mkDerivation, base, directory, hspec, HUnit, parsec }:
     mkDerivation {
       pname = "load-env";
       version = "0.1.1";
       sha256 = "8fe39c08a7f58f94732776b211a884834ada6d9f8cf560e6b7ec9a74e9edfd16";
       libraryHaskellDepends = [ base directory parsec ];
       testHaskellDepends = [ base directory hspec HUnit parsec ];
       description = "Load environment variables from a file";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "loadavg" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "loadavg";
       version = "0.1";
       sha256 = "66524cfd13744f37e25aa54b359fe0e486c35aa5578ccf654a00ceef71f7028f";
       libraryHaskellDepends = [ base ];
       description = "Load average parsing from /proc/loadavg and bindings to getloadavg (3)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "local-address" = callPackage
    ({ mkDerivation, base, network }:
     mkDerivation {
       pname = "local-address";
       version = "0.0.1";
       sha256 = "a9a32960b9c3d0df151d60d7bafbff1c1efd5d7c0e86cbba8d0e310934a486a0";
       libraryHaskellDepends = [ base network ];
       homepage = "http://bitbucket.org/khibino/haskell-local-address";
       description = "Functions to get local interface address";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "local-search" = callPackage
    ({ mkDerivation, base, combinatorial-problems, containers, erf
     , random
     }:
     mkDerivation {
       pname = "local-search";
       version = "0.0.7";
       sha256 = "ae0bdb1a28e1218b5aa899b9cea786a0ea4dc59dadaff350217f392c2a193777";
       libraryHaskellDepends = [
         base combinatorial-problems containers erf random
       ];
       homepage = "http://www.comp.leeds.ac.uk/sc06r2s/Projects/HaskellLocalSearch";
       description = "Generalised local search within Haskell, for applications in combinatorial optimisation";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "located-base" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "located-base";
       version = "0.1.0.0";
       sha256 = "f23a297515bde2600a6f040f0e0b5c987a0ba2d55225fe60546faffd54fc6449";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/gridaphobe/located-base";
       description = "Location-aware variants of partial functions";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ gridaphobe ];
     }) {};

  "locators" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, cryptohash
     , hspec, hspec-expectations, HUnit, QuickCheck
     }:
     mkDerivation {
       pname = "locators";
       version = "0.2.4.2";
       sha256 = "e40d330653805c0e4de46be4d63970b6ebb8ee47e2a5fbb45309dc50565f4e9c";
       libraryHaskellDepends = [
         base bytestring cereal containers cryptohash
       ];
       testHaskellDepends = [
         base bytestring cereal containers cryptohash hspec
         hspec-expectations HUnit QuickCheck
       ];
       description = "Human exchangable identifiers and locators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "loch" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "loch";
       version = "0.2";
       sha256 = "a3d1acf07d52d3103eba88b4fb584b5d982ff95074819c3330cd8568ce269bb7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       description = "Support for precise error locations in source files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "loch-th" = callPackage
    ({ mkDerivation, base, pretty, template-haskell }:
     mkDerivation {
       pname = "loch-th";
       version = "0.2.1";
       sha256 = "77541dcb8fb0ae2c7984fc704e53635dbec83974a172611339941bfc9f96d9cd";
       libraryHaskellDepends = [ base pretty template-haskell ];
       homepage = "https://github.com/liskin/loch-th";
       description = "Support for precise error locations in source files (Template Haskell version)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lock-file" = callPackage
    ({ mkDerivation, base, data-default-class, directory, exceptions
     , filepath, HUnit, tagged-exception-core, test-framework
     , test-framework-hunit, test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "lock-file";
       version = "0.5.0.2";
       sha256 = "274ecb94d0af66fed7b624fca402381d7f262f510ac7c4271037153efda49ad0";
       revision = "1";
       editedCabalFile = "ef22bf7dfd46708eebcc8a895a0a265e6bbf1d05a7ebfdf0f9ee6513d838df8e";
       libraryHaskellDepends = [
         base data-default-class directory exceptions tagged-exception-core
         transformers
       ];
       testHaskellDepends = [
         base data-default-class directory exceptions filepath HUnit
         tagged-exception-core test-framework test-framework-hunit
         test-framework-quickcheck2 transformers
       ];
       homepage = "https://github.com/trskop/lock-file";
       description = "Provide exclusive access to a resource using lock file";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "locked-poll" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, clock, containers
     , lens, QuickCheck, random, regex-genex, tasty, tasty-golden
     , tasty-hunit, tasty-quickcheck, time
     }:
     mkDerivation {
       pname = "locked-poll";
       version = "0.1.0";
       sha256 = "6a369cb194ce975fe663b97eef47adcdc5d96e73abeea0f5087a00ee9201a164";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base clock containers ];
       executableHaskellDepends = [ base clock containers ];
       testHaskellDepends = [
         attoparsec base bytestring clock containers lens QuickCheck random
         regex-genex tasty tasty-golden tasty-hunit tasty-quickcheck time
       ];
       description = "Very simple poll lock";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lockfree-queue" = callPackage
    ({ mkDerivation, abstract-deque, abstract-deque-tests
     , atomic-primops, base, bytestring, ghc-prim, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "lockfree-queue";
       version = "0.2.3.1";
       sha256 = "2a576a54bae8eabde01ebe901c9fd26a11bebb30516841de4525b5b60c0f3a8c";
       libraryHaskellDepends = [
         abstract-deque atomic-primops base bytestring ghc-prim
       ];
       testHaskellDepends = [
         abstract-deque abstract-deque-tests atomic-primops base bytestring
         ghc-prim HUnit test-framework test-framework-hunit
       ];
       homepage = "https://github.com/rrnewton/haskell-lockfree/wiki";
       description = "Michael and Scott lock-free queues";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "log" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, base64-bytestring
     , bytestring, deepseq, exceptions, hpqtypes, lifted-base
     , monad-control, monad-time, mtl, old-locale, split, stm, text
     , time, transformers-base, unordered-containers, vector
     }:
     mkDerivation {
       pname = "log";
       version = "0.3.1";
       sha256 = "6239019b513145e0e8117dff2deaca0a85c9f36f0419c892c7c93def98624b0e";
       libraryHaskellDepends = [
         aeson aeson-pretty base base64-bytestring bytestring deepseq
         exceptions hpqtypes lifted-base monad-control monad-time mtl
         old-locale split stm text time transformers-base
         unordered-containers vector
       ];
       homepage = "https://github.com/scrive/log";
       description = "Structured logging solution with multiple backends";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "log-domain_0_9_3" = callPackage
    ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq
     , directory, distributive, doctest, filepath, generic-deriving
     , hashable, hashable-extras, safecopy, semigroupoids, semigroups
     , simple-reflect, vector
     }:
     mkDerivation {
       pname = "log-domain";
       version = "0.9.3";
       sha256 = "1545cf816f074e3076816c1debfc55e60220427eebb8438e1fd3734b4fbc07d0";
       libraryHaskellDepends = [
         base binary bytes cereal comonad deepseq distributive
         generic-deriving hashable hashable-extras safecopy semigroupoids
         semigroups vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       jailbreak = true;
       homepage = "http://github.com/analytics/log-domain/";
       description = "Log-domain arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "log-domain_0_10_0_1" = callPackage
    ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq
     , directory, distributive, doctest, filepath, generic-deriving
     , hashable, hashable-extras, safecopy, semigroupoids, semigroups
     , simple-reflect, vector
     }:
     mkDerivation {
       pname = "log-domain";
       version = "0.10.0.1";
       sha256 = "e2e995668506069813d6e318bdef9807251a1c263e07a1abffcfa11b2e9a6712";
       libraryHaskellDepends = [
         base binary bytes cereal comonad deepseq distributive
         generic-deriving hashable hashable-extras safecopy semigroupoids
         semigroups vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       jailbreak = true;
       homepage = "http://github.com/analytics/log-domain/";
       description = "Log-domain arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "log-domain_0_10_1" = callPackage
    ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq
     , directory, distributive, doctest, filepath, generic-deriving
     , hashable, hashable-extras, safecopy, semigroupoids, semigroups
     , simple-reflect, vector
     }:
     mkDerivation {
       pname = "log-domain";
       version = "0.10.1";
       sha256 = "10354b99d68ec1c49299500eae43e83247d18a022f0cc920be05ba4205487a3d";
       libraryHaskellDepends = [
         base binary bytes cereal comonad deepseq distributive
         generic-deriving hashable hashable-extras safecopy semigroupoids
         semigroups vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       jailbreak = true;
       homepage = "http://github.com/analytics/log-domain/";
       description = "Log-domain arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "log-domain_0_10_1_1" = callPackage
    ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq
     , directory, distributive, doctest, filepath, generic-deriving
     , hashable, hashable-extras, safecopy, semigroupoids, semigroups
     , simple-reflect, vector
     }:
     mkDerivation {
       pname = "log-domain";
       version = "0.10.1.1";
       sha256 = "ef38e4fa379b03b1f2962f981412641f8ea36213f441e27bf700bca3a0fa9520";
       libraryHaskellDepends = [
         base binary bytes cereal comonad deepseq distributive
         generic-deriving hashable hashable-extras safecopy semigroupoids
         semigroups vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       jailbreak = true;
       homepage = "http://github.com/analytics/log-domain/";
       description = "Log-domain arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "log-domain_0_10_2" = callPackage
    ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq
     , directory, distributive, doctest, filepath, generic-deriving
     , hashable, hashable-extras, safecopy, semigroupoids, semigroups
     , simple-reflect, vector
     }:
     mkDerivation {
       pname = "log-domain";
       version = "0.10.2";
       sha256 = "e431fe38c30c87fbade98507e9ac42bf6749cb5faa583748f50cf0b768ec216d";
       libraryHaskellDepends = [
         base binary bytes cereal comonad deepseq distributive hashable
         hashable-extras safecopy semigroupoids semigroups vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       jailbreak = true;
       homepage = "http://github.com/analytics/log-domain/";
       description = "Log-domain arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "log-domain_0_10_2_1" = callPackage
    ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq
     , directory, distributive, doctest, filepath, generic-deriving
     , hashable, hashable-extras, safecopy, semigroupoids, semigroups
     , simple-reflect, vector
     }:
     mkDerivation {
       pname = "log-domain";
       version = "0.10.2.1";
       sha256 = "174045ba21aa787db043e8b592bb74906da2290e14c2469f9fb1e07bb760f11c";
       libraryHaskellDepends = [
         base binary bytes cereal comonad deepseq distributive hashable
         hashable-extras safecopy semigroupoids semigroups vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       jailbreak = true;
       homepage = "http://github.com/analytics/log-domain/";
       description = "Log-domain arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "log-domain_0_10_3" = callPackage
    ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq
     , directory, distributive, doctest, filepath, generic-deriving
     , hashable, hashable-extras, safecopy, semigroupoids, semigroups
     , simple-reflect, vector
     }:
     mkDerivation {
       pname = "log-domain";
       version = "0.10.3";
       sha256 = "9e0df2214ffd7b258e23dc535b7c75e0927df0b791f5dc579eb08ffaaf0b51bb";
       libraryHaskellDepends = [
         base binary bytes cereal comonad deepseq distributive hashable
         hashable-extras safecopy semigroupoids semigroups vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/log-domain/";
       description = "Log-domain arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "log-domain" = callPackage
    ({ mkDerivation, base, binary, bytes, cereal, comonad, deepseq
     , directory, distributive, doctest, filepath, generic-deriving
     , hashable, hashable-extras, safecopy, semigroupoids, semigroups
     , simple-reflect, vector
     }:
     mkDerivation {
       pname = "log-domain";
       version = "0.10.3.1";
       sha256 = "36f427506218358b20a2066d5fb38406816fabac18ca26c807a416a795643815";
       libraryHaskellDepends = [
         base binary bytes cereal comonad deepseq distributive hashable
         hashable-extras safecopy semigroupoids semigroups vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       homepage = "http://github.com/ekmett/log-domain/";
       description = "Log-domain arithmetic";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "log-effect" = callPackage
    ({ mkDerivation, base, bytestring, extensible-effects, fast-logger
     , time
     }:
     mkDerivation {
       pname = "log-effect";
       version = "0.4.0.1";
       sha256 = "950439deae3c461656557cab7e3aa76079ad335107d58ea6e13a5eaf17293d17";
       libraryHaskellDepends = [
         base bytestring extensible-effects fast-logger time
       ];
       jailbreak = true;
       homepage = "https://github.com/ibotty/log-effect";
       description = "An extensible log effect using extensible-effects";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "log2json" = callPackage
    ({ mkDerivation, base, containers, json, parsec }:
     mkDerivation {
       pname = "log2json";
       version = "0.1";
       sha256 = "ee97e5daa82cbd6f9003dc040079aff9ce3126b55782bce2c56de33d7f8a2d32";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [ base containers json parsec ];
       jailbreak = true;
       homepage = "https://github.com/haroldl/log2json";
       description = "Turn log file records into JSON";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "logfloat_0_12_1" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "logfloat";
       version = "0.12.1";
       sha256 = "0540467e6a818cce6236f16fecabce3c75a723cd1f26c96020c335b2b19423cc";
       libraryHaskellDepends = [ array base ];
       homepage = "http://code.haskell.org/~wren/";
       description = "Log-domain floating point numbers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "logfloat" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "logfloat";
       version = "0.13.3.3";
       sha256 = "f774bd71d82ae053046ab602aa451ce4f65440d5c634dc8d950ae87f53527f82";
       libraryHaskellDepends = [ array base ];
       homepage = "http://code.haskell.org/~wren/";
       description = "Log-domain floating point numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "logger" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, containers, lens, mtl
     , template-haskell, time, time-locale-compat, transformers
     , transformers-compat, unagi-chan
     }:
     mkDerivation {
       pname = "logger";
       version = "0.1.0.2";
       sha256 = "ed88d5a9dfb261a9928f446f98c21308bb4dd31f02d8abb4d1bbce671d2f6472";
       libraryHaskellDepends = [
         ansi-wl-pprint base containers lens mtl template-haskell time
         time-locale-compat transformers transformers-compat unagi-chan
       ];
       homepage = "https://github.com/wdanilo/haskell-logger";
       description = "Fast & extensible logging framework";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "logging" = callPackage
    ({ mkDerivation, base, binary, bytestring, fast-logger, hspec
     , lifted-base, monad-control, old-locale, pcre-light, text, time
     , time-locale-compat, transformers, unix
     }:
     mkDerivation {
       pname = "logging";
       version = "3.0.2";
       sha256 = "72ae6d6fde21af8dd58031d0da054d12115c6cf6e64a4236150562d8f5c8818a";
       libraryHaskellDepends = [
         base binary bytestring fast-logger lifted-base monad-control
         old-locale pcre-light text time time-locale-compat transformers
       ];
       testHaskellDepends = [ base hspec unix ];
       description = "Simplified logging in IO for application writers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "logging-effect" = callPackage
    ({ mkDerivation, async, base, exceptions, free, monad-control, mtl
     , stm, stm-delay, text, time, transformers, transformers-base
     , wl-pprint-text
     }:
     mkDerivation {
       pname = "logging-effect";
       version = "1.0.1";
       sha256 = "8a27b42451dbcda3faba5db20c275061f8133441b09b0138ac36037ff0108af1";
       libraryHaskellDepends = [
         async base exceptions free monad-control mtl stm stm-delay text
         time transformers transformers-base wl-pprint-text
       ];
       homepage = "https://github.com/ocharles/logging-effect";
       description = "A mtl-style monad transformer for general purpose & compositional logging";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "logging-facade_0_0_0" = callPackage
    ({ mkDerivation, base, hspec, template-haskell, transformers }:
     mkDerivation {
       pname = "logging-facade";
       version = "0.0.0";
       sha256 = "e883c154b638269359f6f2bd2fcad834acb659df3a4215dd32a5ac236f23f544";
       revision = "1";
       editedCabalFile = "18d32076d981102462c3f24c95c6d9dc2470be80f5f36f99759cb23cc3db2d24";
       libraryHaskellDepends = [ base template-haskell transformers ];
       testHaskellDepends = [ base hspec ];
       description = "Simple logging abstraction that allows multiple backends";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "logging-facade" = callPackage
    ({ mkDerivation, base, hspec, template-haskell, transformers }:
     mkDerivation {
       pname = "logging-facade";
       version = "0.1.0";
       sha256 = "9e1801542faf81bec8fc44cf49f4a0d6f6ac7da72aa99a53f02b4920bd5c0d7e";
       libraryHaskellDepends = [ base template-haskell transformers ];
       testHaskellDepends = [ base hspec ];
       description = "Simple logging abstraction that allows multiple back-ends";
       license = stdenv.lib.licenses.mit;
     }) {};

  "logging-facade-journald" = callPackage
    ({ mkDerivation, base, hspec, libsystemd-journal, logging-facade
     , text, unordered-containers
     }:
     mkDerivation {
       pname = "logging-facade-journald";
       version = "0.0.0";
       sha256 = "f4fc00ad2df10ef6ac6d2abd49b8fd719357eab394a8cea38dbda64d4e393794";
       libraryHaskellDepends = [
         base libsystemd-journal logging-facade text unordered-containers
       ];
       testHaskellDepends = [
         base hspec libsystemd-journal logging-facade text
         unordered-containers
       ];
       description = "Journald back-end for logging-facade";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "logic-TPTP" = callPackage
    ({ mkDerivation, alex, ansi-wl-pprint, array, base, containers
     , happy, mtl, pointed, QuickCheck, syb, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "logic-TPTP";
       version = "0.4.4.0";
       sha256 = "5aac97226f53f2be61c1aeb58e9fdd4b3f971aa74af10904944384fa849cbd27";
       libraryHaskellDepends = [
         ansi-wl-pprint array base containers mtl pointed QuickCheck syb
         transformers transformers-compat
       ];
       libraryToolDepends = [ alex happy ];
       description = "Import, export etc. for TPTP, a syntax for first-order logic";
       license = "GPL";
     }) {};

  "logic-classes" = callPackage
    ({ mkDerivation, applicative-extras, atp-haskell, base, containers
     , HUnit, mtl, parsec, pretty, PropLogic, safe, safecopy, set-extra
     , syb, template-haskell
     }:
     mkDerivation {
       pname = "logic-classes";
       version = "1.7";
       sha256 = "6af3404b06900e7e2f5a56b96182af2bf7764fe0ab680b9611cd34ff52a82f11";
       libraryHaskellDepends = [
         applicative-extras atp-haskell base containers HUnit mtl parsec
         pretty PropLogic safe safecopy set-extra syb template-haskell
       ];
       testHaskellDepends = [
         applicative-extras atp-haskell base containers HUnit mtl pretty
         PropLogic safe set-extra syb
       ];
       homepage = "https://github.com/seereason/logic-classes";
       description = "Framework for propositional and first order logic, theorem proving";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "logicst" = callPackage
    ({ mkDerivation, base, logict, transformers }:
     mkDerivation {
       pname = "logicst";
       version = "0.1.0.0";
       sha256 = "acad1f86fe98447f1e60efdd920a1dcd46b9584590b26ece11958c21d2333d18";
       libraryHaskellDepends = [ base logict transformers ];
       homepage = "http://github.com/sonyandy/logicst";
       description = "Backtracking mutable references in the ST and IO monads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "logict" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "logict";
       version = "0.6.0.2";
       sha256 = "1182b68e8d00279460c7fb9b8284bf129805c07754c678b2a8de5a6d768e161e";
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://code.haskell.org/~dolio/";
       description = "A backtracking logic-programming monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "logict-state" = callPackage
    ({ mkDerivation, base, logict, mtl, transformers }:
     mkDerivation {
       pname = "logict-state";
       version = "0.1.0.0";
       sha256 = "8b4ac063ffada947bfb853c5a4f9e144ad7aba0dbc1e3be3d662a83c19450ad8";
       libraryHaskellDepends = [ base logict mtl transformers ];
       homepage = "https://github.com/atzedijkstra/logict-state";
       description = "Library for logic programming based on haskell package logict";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "logplex-parse" = callPackage
    ({ mkDerivation, base, hspec, iso8601-time, parsec, text, time }:
     mkDerivation {
       pname = "logplex-parse";
       version = "0.1.0.2";
       sha256 = "e802251aa40c73f9dea2ebe0b7bd92450b94a513343f165cccb2e86489403604";
       libraryHaskellDepends = [ base iso8601-time parsec text time ];
       testHaskellDepends = [ base hspec time ];
       homepage = "https://github.com/keithduncan/logplex-parse";
       description = "Parse Heroku application/logplex documents";
       license = stdenv.lib.licenses.mit;
     }) {};

  "logsink" = callPackage
    ({ mkDerivation, base, hspec, hsyslog, logging-facade, time }:
     mkDerivation {
       pname = "logsink";
       version = "0.1.0";
       sha256 = "23f1bcac918698f5f7d6517135af658c217607f9d52f546503ff047048c7bffb";
       libraryHaskellDepends = [ base hsyslog logging-facade time ];
       testHaskellDepends = [ base hspec logging-facade ];
       description = "A logging framework for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "lojban" = callPackage
    ({ mkDerivation, base, containers, curl, directory, haskell98, HTTP
     , markov-chain, mtl, parsec, process, random, regex-compat, strict
     , tagsoup, xml
     }:
     mkDerivation {
       pname = "lojban";
       version = "0.3";
       sha256 = "a65b1d1dc98c073f228580f1db29bfab814c81c9c7579b6b801ead16c40ba35d";
       revision = "1";
       editedCabalFile = "9d30c9c8f1aa80aea24ca606d74ee1b3a9af0ecde15a0e65b1150d483d6b1cfc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers curl directory HTTP markov-chain mtl parsec process
         random regex-compat strict tagsoup xml
       ];
       executableHaskellDepends = [ haskell98 ];
       jailbreak = true;
       description = "Useful utilities for the Lojban language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lojbanParser" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "lojbanParser";
       version = "0.1.9.2";
       sha256 = "124dcd8bcdd28f83930cbdc22545a21e3b1d619440a9aaf4413369badb30b12b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       description = "lojban parser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lojbanXiragan" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "lojbanXiragan";
       version = "0.3";
       sha256 = "57b73e6afcb423a1621d5b1f220ce9f0f2262ad442484bb472d56c3434acf2c0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       description = "lojban to xiragan";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lojysamban" = callPackage
    ({ mkDerivation, base, lojbanParser, yjtools }:
     mkDerivation {
       pname = "lojysamban";
       version = "0.0.8.1";
       sha256 = "0dc2e4430073fbdd47f733955c045b652aae8a5ba715a4d6fd9afc79a60ba730";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base lojbanParser yjtools ];
       homepage = "http://homepage3.nifty.com/salamander/myblog/lojysamban.html";
       description = "Prolog with lojban";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lol" = callPackage
    ({ mkDerivation, arithmoi, base, binary, bytestring, constraints
     , containers, crypto-api, data-default, deepseq, DRBG, MonadRandom
     , mtl, numeric-prelude, QuickCheck, random, reflection, repa
     , singletons, storable-record, tagged-transformer, template-haskell
     , test-framework, test-framework-quickcheck2, th-desugar
     , transformers, vector, vector-th-unbox
     }:
     mkDerivation {
       pname = "lol";
       version = "0.2.0.0";
       sha256 = "8787dde0e356a8d436fc6dcea548098bb9e92237fc138701582e2f5eabbce564";
       libraryHaskellDepends = [
         arithmoi base binary bytestring constraints containers crypto-api
         data-default deepseq MonadRandom mtl numeric-prelude QuickCheck
         random reflection repa singletons storable-record
         tagged-transformer template-haskell th-desugar transformers vector
         vector-th-unbox
       ];
       testHaskellDepends = [
         base constraints deepseq DRBG MonadRandom mtl QuickCheck random
         repa singletons test-framework test-framework-quickcheck2 vector
       ];
       homepage = "https://github.com/cpeikert/Lol";
       description = "A library for lattice cryptography";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "lol-apps" = callPackage
    ({ mkDerivation, base, constraints, deepseq, DRBG, lol, MonadRandom
     , mtl, numeric-prelude, QuickCheck, random, repa, singletons
     , test-framework, test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "lol-apps";
       version = "0.0.0.1";
       sha256 = "988a006f77beb0fdf40ad446d1ae333b93bc60d818e3623f323eb1ff9349d149";
       revision = "1";
       editedCabalFile = "60383b773f8b931df96fac94a014194fcbc8f7f31025471e49e39ffc2b991907";
       libraryHaskellDepends = [
         base deepseq lol MonadRandom numeric-prelude
       ];
       testHaskellDepends = [
         base constraints deepseq DRBG lol MonadRandom mtl QuickCheck random
         repa singletons test-framework test-framework-quickcheck2 vector
       ];
       homepage = "https://github.com/cpeikert/Lol";
       description = "Lattice-based cryptographic applications using Lol";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "loli" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default, hack
     , hack-contrib, mps, mtl, template, utf8-string
     }:
     mkDerivation {
       pname = "loli";
       version = "2011.6.24";
       sha256 = "4a8e9160aa3fb6852bd5bf474926aa9ff1db7ee9f86675483b506d01fb6c43d4";
       libraryHaskellDepends = [
         base bytestring containers data-default hack hack-contrib mps mtl
         template utf8-string
       ];
       jailbreak = true;
       homepage = "http://github.com/nfjinjing/loli";
       description = "A minimum web dev DSL in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lookup-tables" = callPackage
    ({ mkDerivation, base, primitive, tasty, tasty-hunit
     , template-haskell
     }:
     mkDerivation {
       pname = "lookup-tables";
       version = "0.1.1.1";
       sha256 = "bb9ee2cea827e146d510804c6b26c6f1a62032215eba4da7eb5bb67f977c478e";
       libraryHaskellDepends = [ base primitive template-haskell ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       homepage = "http://hub.darcs.net/jmcarthur/lookup-tables/issues";
       description = "Statically generate lookup tables using Template Haskell";
       license = stdenv.lib.licenses.isc;
     }) {};

  "loop_0_2_0" = callPackage
    ({ mkDerivation, base, hspec, mtl }:
     mkDerivation {
       pname = "loop";
       version = "0.2.0";
       sha256 = "bd6c3cf86ab4b2ce801ec4eb069647dc2cb79dd7d08516e92c7ea647a1c22e86";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec mtl ];
       homepage = "https://github.com/nh2/loop";
       description = "Fast loops (for when GHC can't optimize forM_)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "loop" = callPackage
    ({ mkDerivation, base, hspec, mtl }:
     mkDerivation {
       pname = "loop";
       version = "0.3.0";
       sha256 = "92962010bdab28cc0092dd3fe42819d6f215c717dd10d9349626d92a0d0b3ecf";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec mtl ];
       homepage = "https://github.com/nh2/loop";
       description = "Fast loops (for when GHC can't optimize forM_)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "loop-effin" = callPackage
    ({ mkDerivation, base, effin }:
     mkDerivation {
       pname = "loop-effin";
       version = "0.1.1.0";
       sha256 = "a230f31bc8ae63af4b6d9264fb062a2f89ee75e58e632983433ea8895215a00b";
       libraryHaskellDepends = [ base effin ];
       jailbreak = true;
       homepage = "https://github.com/konn/loop-effin";
       description = "control-monad-loop port for effin";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "loop-while" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "loop-while";
       version = "1.0.0";
       sha256 = "6d916440ef5e7e0c00322c6c96e045f88eb5f2ffa510bcb238dcc7605f487cfb";
       libraryHaskellDepends = [ base mtl ];
       jailbreak = true;
       description = "A monad transformer supporting various styles of while loop";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "loops" = callPackage
    ({ mkDerivation, base, primitive, tasty, tasty-quickcheck
     , transformers, vector
     }:
     mkDerivation {
       pname = "loops";
       version = "0.2.0.2";
       sha256 = "47cfc98476c1a3267b27531825849978d3c0ccb5a2d6cd61132a7f719f10ddeb";
       revision = "1";
       editedCabalFile = "ef9ed99ec28140d39775a0b9c44333496d3ee754995219460d76cb137a9534ce";
       libraryHaskellDepends = [ base primitive transformers vector ];
       testHaskellDepends = [ base tasty tasty-quickcheck ];
       description = "Fast imperative-style loops";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "loopy" = callPackage
    ({ mkDerivation, base, cmdargs, containers, directory, filepath
     , GoogleChart, hmatrix, process, random
     }:
     mkDerivation {
       pname = "loopy";
       version = "0.0.1";
       sha256 = "c67b7ec86aa75af3a16951b064509103f7a621ffdc3becb93efbef11093dcd3f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs containers directory filepath GoogleChart hmatrix
         process random
       ];
       homepage = "http://www.esc.cam.ac.uk/people/research-students/emily-king";
       description = "Find all biological feedback loops within an ecosystem graph";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lord" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, attoparsec-conduit, base
     , bytestring, case-insensitive, conduit, conduit-extra, daemons
     , data-default, directory, fast-logger, hspec, html-conduit, HTTP
     , http-conduit, http-types, HUnit, libmpd, optparse-applicative
     , process, resourcet, text, transformers, unix
     , unordered-containers, utf8-string, wai-logger, xml-conduit, yaml
     }:
     mkDerivation {
       pname = "lord";
       version = "2.20150122";
       sha256 = "12a5f08f5d85a871e474592fc179a924dede3d26a8d6377f287f55100689fb4f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal attoparsec-conduit base bytestring
         case-insensitive conduit conduit-extra data-default directory
         fast-logger html-conduit HTTP http-conduit http-types libmpd
         process resourcet text transformers unix unordered-containers
         utf8-string wai-logger xml-conduit yaml
       ];
       executableHaskellDepends = [
         aeson ansi-terminal attoparsec-conduit base bytestring
         case-insensitive conduit conduit-extra daemons data-default
         directory fast-logger html-conduit HTTP http-conduit http-types
         libmpd optparse-applicative process resourcet text transformers
         unix unordered-containers utf8-string wai-logger xml-conduit yaml
       ];
       testHaskellDepends = [
         aeson ansi-terminal attoparsec-conduit base bytestring
         case-insensitive conduit daemons data-default directory fast-logger
         hspec html-conduit HTTP http-conduit http-types HUnit libmpd
         optparse-applicative process text transformers unix
         unordered-containers utf8-string wai-logger xml-conduit yaml
       ];
       homepage = "https://github.com/rnons/lord";
       description = "A command line interface to online radios";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lorem" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "lorem";
       version = "0.0.0.0";
       sha256 = "d1168732f55f9349d40792781471e831aa9b4a4065760f62cc22f83441faa7bb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/sfischer13/haskell-lorem";
       description = "Library for generating filler text";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "loris" = callPackage
    ({ mkDerivation, base, c2hs, loris, vector }:
     mkDerivation {
       pname = "loris";
       version = "0.3.1";
       sha256 = "f8890ad9edc96e2ff6552c73368a4e9be1c70941d7a32114f103f8aadf6081a7";
       libraryHaskellDepends = [ base vector ];
       librarySystemDepends = [ loris ];
       libraryToolDepends = [ c2hs ];
       jailbreak = true;
       homepage = "http://www.tiresiaspress.us/haskell/loris";
       description = "interface to Loris API";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {loris = null;};

  "loshadka" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, cryptohash
     , directory, hex, network, process, split
     }:
     mkDerivation {
       pname = "loshadka";
       version = "0.2";
       sha256 = "deb615d8d0f927032ae316072a18372fc33388f050f524cead03cefb1f5b5206";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base binary bytestring cryptohash directory hex network
         process split
       ];
       jailbreak = true;
       homepage = "https://github.com/tvorcesky/loshadka";
       description = "Minecraft 1.7 server proxy that answers to queries when the server is offline";
       license = stdenv.lib.licenses.mit;
     }) {};

  "lostcities" = callPackage
    ({ mkDerivation, array, base, containers, haskell98, mtl, wx
     , wxcore
     }:
     mkDerivation {
       pname = "lostcities";
       version = "0.2";
       sha256 = "37e921a1c7ee1e2a976f40b829c9bd9b96df23409cbb0b9a5d8e493091c074ab";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers haskell98 mtl wx wxcore
       ];
       jailbreak = true;
       homepage = "http://www.ncc.up.pt/~pbv/stuff/lostcities";
       description = "An implementation of an adictive two-player card game";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lowgl" = callPackage
    ({ mkDerivation, base, data-default, gl, linear, vector }:
     mkDerivation {
       pname = "lowgl";
       version = "0.3.1.1";
       sha256 = "85f5a954970634aa41bc77b6a2932ed935b1411be4ad7badab31dad45b2365b0";
       libraryHaskellDepends = [ base data-default gl linear vector ];
       jailbreak = true;
       description = "Basic gl wrapper and reference";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "lp-diagrams" = callPackage
    ({ mkDerivation, base, containers, glpk-hs, graphviz, labeled-tree
     , lens, mtl, polynomials-bernstein, text, typography-geometry
     , vector
     }:
     mkDerivation {
       pname = "lp-diagrams";
       version = "1.0";
       sha256 = "f10a4e0258fed5fde24a787d248a6e115c912374314f4091f11421500159b6a1";
       libraryHaskellDepends = [
         base containers glpk-hs graphviz labeled-tree lens mtl
         polynomials-bernstein text typography-geometry vector
       ];
       description = "An EDSL for diagrams based based on linear constraints";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "lp-diagrams-svg" = callPackage
    ({ mkDerivation, base, containers, FontyFruity, JuicyPixels, lens
     , linear, lp-diagrams, lucid-svg, mtl, optparse-applicative
     , svg-tree, text, vector
     }:
     mkDerivation {
       pname = "lp-diagrams-svg";
       version = "1.0";
       sha256 = "05b67150d7f4559f9b6aea62ffa9382551b1fb1ad56cfaf204ff2dc3c7db6325";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers FontyFruity JuicyPixels lens linear lp-diagrams
         lucid-svg mtl optparse-applicative svg-tree text vector
       ];
       executableHaskellDepends = [
         base containers FontyFruity lens lp-diagrams
       ];
       description = "SVG Backend for lp-diagrams";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lrucache" = callPackage
    ({ mkDerivation, base, containers, contravariant }:
     mkDerivation {
       pname = "lrucache";
       version = "1.2.0.0";
       sha256 = "5f17a9e026e198152d13830a0eae0df21be437c238a3f157f7c188fe27a37616";
       libraryHaskellDepends = [ base containers contravariant ];
       homepage = "http://github.com/chowells79/lrucache";
       description = "a simple, pure LRU cache";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ls-usb" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, base-unicode-symbols
     , cmdtheline, text, usb, usb-id-database, vector
     }:
     mkDerivation {
       pname = "ls-usb";
       version = "0.1.1";
       sha256 = "1323643388c09d5bff320219f2b7511e836d09df5f4af94e57bde5188f70aa23";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-wl-pprint base base-unicode-symbols cmdtheline text usb
         usb-id-database vector
       ];
       jailbreak = true;
       homepage = "https://github.com/roelvandijk/ls-usb";
       description = "List USB devices";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lscabal" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, directory
     , filepath, pretty, process
     }:
     mkDerivation {
       pname = "lscabal";
       version = "0.1.1";
       sha256 = "b23409ae7d13a3fda39b619935a9e973723e6440351e95d68616885e994c4192";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal containers directory filepath pretty process
       ];
       homepage = "http://code.haskell.org/~dons/code/lscabal";
       description = "List exported modules from a set of .cabal files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lss" = callPackage
    ({ mkDerivation, attoparsec, base, containers, directory, filepath
     , hspec2, language-css, language-css-attoparsec, text, xmlhtml
     }:
     mkDerivation {
       pname = "lss";
       version = "0.1.0.0";
       sha256 = "59b264243cfe1e6fea2c69e7482f9eb0946e3284af5496f4ee6035a0bc0609e5";
       libraryHaskellDepends = [
         attoparsec base containers directory filepath language-css
         language-css-attoparsec text xmlhtml
       ];
       testHaskellDepends = [
         attoparsec base containers hspec2 language-css
         language-css-attoparsec text
       ];
       jailbreak = true;
       homepage = "https://github.com/dbp/lss";
       description = "Lexical Style Sheets - a language for writing styles that is focused around lexical (ie, static) scoping and re-use of large components";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {language-css-attoparsec = null;};

  "lsystem" = callPackage
    ({ mkDerivation, base, haskell98, uu-parsinglib, wx, wxcore }:
     mkDerivation {
       pname = "lsystem";
       version = "1.2";
       sha256 = "afa344de784e26ee98e17eb8c857186da2ddc1ed8990c1d457e9de93350c64f2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base haskell98 uu-parsinglib wx wxcore
       ];
       description = "Paint an L-System Grammar";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ltext" = callPackage
    ({ mkDerivation, aeson, base, containers, data-default, deepseq
     , directory, hspec, mtl, mtl-compat, optparse-applicative, parsec
     , pretty, template-haskell, text, transformers, yaml
     }:
     mkDerivation {
       pname = "ltext";
       version = "0.0.2.1";
       sha256 = "2e0d10a71d59a59218f7e501fc53d6de05ee4e123c2e89bed2f12f4df34d2937";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers deepseq mtl mtl-compat parsec pretty
         template-haskell text transformers
       ];
       executableHaskellDepends = [
         aeson base containers data-default deepseq directory mtl mtl-compat
         optparse-applicative parsec pretty template-haskell text
         transformers yaml
       ];
       testHaskellDepends = [ base hspec mtl ];
       description = "Higher-order file applicator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ltk" = callPackage
    ({ mkDerivation, base, Cabal, containers, filepath, ghc, glib, gtk3
     , mtl, parsec, pretty, text, transformers
     }:
     mkDerivation {
       pname = "ltk";
       version = "0.15.0.4";
       sha256 = "6d39540a1aa73516d9390d8d49f1f9b8ec5f9cf15bede8cd51a25810ec345193";
       libraryHaskellDepends = [
         base Cabal containers filepath ghc glib gtk3 mtl parsec pretty text
         transformers
       ];
       homepage = "http://www.leksah.org";
       description = "Leksah tool kit";
       license = "GPL";
     }) {};

  "ltl" = callPackage
    ({ mkDerivation, base, vcd }:
     mkDerivation {
       pname = "ltl";
       version = "0.0.0";
       sha256 = "6f709c22880fbc4c626906cdde29211a6b39bd92fdaa5f466653d5a69fed7240";
       libraryHaskellDepends = [ base vcd ];
       homepage = "http://tomahawkins.org";
       description = "Using linear temporal logic (LTL) to verify embedded software and hardware";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lua-bytecode" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, containers
     , hashable, numeric-extras, vector
     }:
     mkDerivation {
       pname = "lua-bytecode";
       version = "0.1.0.0";
       sha256 = "f49b959109943221ace6025a8cf14270c093be401c31128e45cdcdde558f97b3";
       libraryHaskellDepends = [
         array base bytestring cereal containers hashable numeric-extras
         vector
       ];
       description = "Library for loading Lua bytecode";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "luachunk" = callPackage
    ({ mkDerivation, attoparsec, base, binary, bytestring
     , custom-prelude, ghc-prim, pretty, text
     }:
     mkDerivation {
       pname = "luachunk";
       version = "0.1.0.0";
       sha256 = "938d7cc1bfd99fc582745783a400442dc053585d58ef5c9de523d5f15553480d";
       libraryHaskellDepends = [
         attoparsec base binary bytestring custom-prelude ghc-prim pretty
         text
       ];
       jailbreak = true;
       description = "Library functions for reading and writing Lua chunks";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "luautils" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, hslua
     , monad-loops, QuickCheck, quickcheck-instances, test-framework
     , test-framework-quickcheck2, test-framework-th, text, text-binary
     }:
     mkDerivation {
       pname = "luautils";
       version = "0.1.4";
       sha256 = "0d88b97f2303b5ba706d4d7a138a3c88124764190294f8838db6f9f0b3fbda9c";
       libraryHaskellDepends = [
         base binary bytestring containers hslua monad-loops text
       ];
       testHaskellDepends = [
         base binary containers hslua QuickCheck quickcheck-instances
         test-framework test-framework-quickcheck2 test-framework-th text
         text-binary
       ];
       description = "Helpers for Haskell integration with Lua";
       license = stdenv.lib.licenses.mit;
     }) {};

  "lub" = callPackage
    ({ mkDerivation, base, unamb }:
     mkDerivation {
       pname = "lub";
       version = "0.1.7";
       sha256 = "3014d2b53a0fdc137763ec22326859e8023a97522115645bc960a4081e3b55b7";
       libraryHaskellDepends = [ base unamb ];
       homepage = "http://haskell.org/haskellwiki/lub";
       description = "information operators: least upper bound (lub) and greatest lower bound (glb)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lucid_2_5" = callPackage
    ({ mkDerivation, base, bifunctors, blaze-builder, bytestring
     , containers, hspec, HUnit, mtl, parsec, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "lucid";
       version = "2.5";
       sha256 = "f2237046b28b665f64273eb03f2c9313b680e3dcbeec26795b24cbcfc89fd260";
       revision = "1";
       editedCabalFile = "e029146dc37f2c4b867f6251ec6001261dc891ff564e020cd7fd89bf91eb2c18";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers mtl text transformers
         unordered-containers
       ];
       testHaskellDepends = [
         base bifunctors hspec HUnit mtl parsec text
       ];
       homepage = "https://github.com/chrisdone/lucid";
       description = "Clear to write, read and edit DSL for HTML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lucid_2_9_2" = callPackage
    ({ mkDerivation, base, bifunctors, blaze-builder, bytestring
     , containers, hashable, hspec, HUnit, mtl, parsec, text
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "lucid";
       version = "2.9.2";
       sha256 = "50c9b488abda1803fefeedab0b9dbfa227cb3493c480160b531ab37a13fc6b64";
       revision = "1";
       editedCabalFile = "62ded561d5846fbcbe77e7f491c5fed2f4beddbf5cda336685f3d980df525218";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers hashable mtl text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         base bifunctors hspec HUnit mtl parsec text
       ];
       homepage = "https://github.com/chrisdone/lucid";
       description = "Clear to write, read and edit DSL for HTML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lucid_2_9_3" = callPackage
    ({ mkDerivation, base, bifunctors, blaze-builder, bytestring
     , containers, hashable, hspec, HUnit, mtl, parsec, text
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "lucid";
       version = "2.9.3";
       sha256 = "c4279b1c12f4261de5e8405ceaf918055e76e492980e6cd84f12412538162353";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers hashable mtl text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         base bifunctors hspec HUnit mtl parsec text
       ];
       homepage = "https://github.com/chrisdone/lucid";
       description = "Clear to write, read and edit DSL for HTML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lucid" = callPackage
    ({ mkDerivation, base, bifunctors, blaze-builder, bytestring
     , containers, hashable, hspec, HUnit, mtl, parsec, text
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "lucid";
       version = "2.9.4";
       sha256 = "9e87cfc2591d9b79d5eb5351299e4110b50a9fa6b05f9912a65274e0ddfbb9cc";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers hashable mtl text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         base bifunctors hspec HUnit mtl parsec text
       ];
       homepage = "https://github.com/chrisdone/lucid";
       description = "Clear to write, read and edit DSL for HTML";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lucid-foundation" = callPackage
    ({ mkDerivation, base, hspec, lucid, QuickCheck
     , quickcheck-instances, text
     }:
     mkDerivation {
       pname = "lucid-foundation";
       version = "0.0.2.1";
       sha256 = "0dff6009ea6ff63601701b6524cdad79d4bbace5328a84755a72d639d6ee8682";
       libraryHaskellDepends = [ base lucid text ];
       testHaskellDepends = [
         base hspec QuickCheck quickcheck-instances
       ];
       description = "Basic Zurb Foundation API in Lucid";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lucid-svg_0_4_0_4" = callPackage
    ({ mkDerivation, base, blaze-builder, lucid, text, transformers }:
     mkDerivation {
       pname = "lucid-svg";
       version = "0.4.0.4";
       sha256 = "22e0262bfc8559b2a1e7a08064544d9d82020a1013d1d61247409fb8dbc09499";
       libraryHaskellDepends = [
         base blaze-builder lucid text transformers
       ];
       homepage = "http://github.com/jeffreyrosenbluth/lucid-svg.git";
       description = "DSL for SVG using lucid for HTML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lucid-svg_0_5_0_0" = callPackage
    ({ mkDerivation, base, blaze-builder, lucid, text, transformers }:
     mkDerivation {
       pname = "lucid-svg";
       version = "0.5.0.0";
       sha256 = "7257e01693a5d6810c24dc3ed1d23902f6d16c5941a10156780e570b7cbbf1dc";
       libraryHaskellDepends = [
         base blaze-builder lucid text transformers
       ];
       homepage = "http://github.com/jeffreyrosenbluth/lucid-svg.git";
       description = "DSL for SVG using lucid for HTML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lucid-svg" = callPackage
    ({ mkDerivation, base, blaze-builder, lucid, text, transformers }:
     mkDerivation {
       pname = "lucid-svg";
       version = "0.6.0.1";
       sha256 = "a8cff758914de95defca5640a1f6c3ddf995078063fb8553da02249510db67cc";
       libraryHaskellDepends = [
         base blaze-builder lucid text transformers
       ];
       homepage = "http://github.com/jeffreyrosenbluth/lucid-svg.git";
       description = "DSL for SVG using lucid for HTML";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lucienne" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-html, bson
     , bytestring, compact-string-fix, feed, happstack, happstack-server
     , HTTP, mongoDB, mtl, network, SHA, text, time
     }:
     mkDerivation {
       pname = "lucienne";
       version = "0.0.2";
       sha256 = "32f3a9c51e51e7e6d0ca825c1e1bdeef8dec346959e69ccdc31733534e579bb5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base base64-bytestring blaze-html bson bytestring
         compact-string-fix feed happstack happstack-server HTTP mongoDB mtl
         network SHA text time
       ];
       jailbreak = true;
       homepage = "http://www.imn.htwk-leipzig.de/~abau/lucienne";
       description = "Server side feed aggregator/reader";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "luhn" = callPackage
    ({ mkDerivation, base, digits, QuickCheck }:
     mkDerivation {
       pname = "luhn";
       version = "0.2";
       sha256 = "dffa4fcf53e893a2186202953d4dc70006021ade091cda7c5671b43a91e8a747";
       libraryHaskellDepends = [ base digits QuickCheck ];
       description = "An implementation of Luhn's check digit algorithm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lui" = callPackage
    ({ mkDerivation, base, containers, haskell98, haskgame, MaybeT, mtl
     , SDL
     }:
     mkDerivation {
       pname = "lui";
       version = "0.0.6";
       sha256 = "db34b8ee689b2a94add487a784cf0b86a81240f2b2063fe8471f887a5f282420";
       libraryHaskellDepends = [
         base containers haskell98 haskgame MaybeT mtl SDL
       ];
       description = "Purely FunctionaL User Interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "luka" = callPackage
    ({ mkDerivation, air, base, bytestring, libffi, objc }:
     mkDerivation {
       pname = "luka";
       version = "2012.8.29";
       sha256 = "3ae9b302080bfa7856aa6ef1c5d750d9a0432c0e0f5fd10d7f2b706a0152e701";
       libraryHaskellDepends = [ air base bytestring libffi ];
       librarySystemDepends = [ objc ];
       homepage = "https://github.com/nfjinjing/luka";
       description = "Simple ObjectiveC runtime binding";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {objc = null;};

  "luminance_0_9_1" = callPackage
    ({ mkDerivation, base, containers, contravariant, dlist, gl, linear
     , mtl, resourcet, semigroups, transformers, vector, void
     }:
     mkDerivation {
       pname = "luminance";
       version = "0.9.1";
       sha256 = "1b968fe815bf11c784474eead8f62ec1aefecfdc058fa99148867266669979dd";
       libraryHaskellDepends = [
         base containers contravariant dlist gl linear mtl resourcet
         semigroups transformers vector void
       ];
       jailbreak = true;
       homepage = "https://github.com/phaazon/luminance";
       description = "Type-safe, type-level and stateless graphics framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "luminance_0_9_1_2" = callPackage
    ({ mkDerivation, base, containers, contravariant, dlist, gl, linear
     , mtl, resourcet, semigroups, transformers, vector, void
     }:
     mkDerivation {
       pname = "luminance";
       version = "0.9.1.2";
       sha256 = "fd9d9b75c8bfff765eafc10023a709f10027928ea300932b82762e4543c10d5f";
       libraryHaskellDepends = [
         base containers contravariant dlist gl linear mtl resourcet
         semigroups transformers vector void
       ];
       homepage = "https://github.com/phaazon/luminance";
       description = "Type-safe, type-level and stateless graphics framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "luminance" = callPackage
    ({ mkDerivation, base, containers, contravariant, dlist, gl, linear
     , mtl, resourcet, semigroups, transformers, vector, void
     }:
     mkDerivation {
       pname = "luminance";
       version = "0.10.0.2";
       sha256 = "1892608cde96e81a748c608118f380e8b125f3653af1d743a9ee6ee9a8adb46e";
       libraryHaskellDepends = [
         base containers contravariant dlist gl linear mtl resourcet
         semigroups transformers vector void
       ];
       homepage = "https://github.com/phaazon/luminance";
       description = "Type-safe, type-level and stateless graphics framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "luminance-samples_0_9" = callPackage
    ({ mkDerivation, base, contravariant, GLFW-b, JuicyPixels, linear
     , luminance, mtl, resourcet, transformers
     }:
     mkDerivation {
       pname = "luminance-samples";
       version = "0.9";
       sha256 = "1ce2b8ff49c34bd529bcbe8e30f042f327a970b7a6d43dbdd3939b17cfa44bec";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base contravariant GLFW-b JuicyPixels linear luminance mtl
         resourcet transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/phaazon/luminance-samples";
       description = "Luminance samples";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "luminance-samples_0_9_1" = callPackage
    ({ mkDerivation, base, contravariant, GLFW-b, JuicyPixels, linear
     , luminance, mtl, resourcet, transformers
     }:
     mkDerivation {
       pname = "luminance-samples";
       version = "0.9.1";
       sha256 = "e3c67132470eb7e5f9b16c291dd686c5e281a25e66dd2e8ffc307230897895f7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base contravariant GLFW-b JuicyPixels linear luminance mtl
         resourcet transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/phaazon/luminance-samples";
       description = "Luminance samples";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "luminance-samples" = callPackage
    ({ mkDerivation, base, contravariant, GLFW-b, JuicyPixels, linear
     , luminance, mtl, resourcet, transformers
     }:
     mkDerivation {
       pname = "luminance-samples";
       version = "0.10";
       sha256 = "c3f0fec69567be8d32c7a913c4dd9241908666447bfc492cdd24810d4b245d2a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base contravariant GLFW-b JuicyPixels linear luminance mtl
         resourcet transformers
       ];
       homepage = "https://github.com/phaazon/luminance-samples";
       description = "Luminance samples";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "lushtags" = callPackage
    ({ mkDerivation, base, haskell-src-exts, text, vector }:
     mkDerivation {
       pname = "lushtags";
       version = "0.0.1";
       sha256 = "2c7143e5eacd177ca002494bbf6497c9d8d24f87acf17dd5f59f694b0c60450c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskell-src-exts text vector ];
       jailbreak = true;
       homepage = "https://github.com/bitc/lushtags";
       description = "Create ctags compatible tags files for Haskell programs";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "luthor" = callPackage
    ({ mkDerivation, base, mtl, parsec, transformers }:
     mkDerivation {
       pname = "luthor";
       version = "0.0.2";
       sha256 = "ca2f1f9689b17d1799c11a307f41a68ff023775cebb84b04b838936dd32dcde2";
       libraryHaskellDepends = [ base mtl parsec transformers ];
       testHaskellDepends = [ base mtl parsec ];
       homepage = "https://github.com/Zankoku-Okuno/luthor";
       description = "Tools for lexing and utilizing lexemes that integrate with Parsec";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lvish" = callPackage
    ({ mkDerivation, async, atomic-primops, base, bits-atomic
     , containers, deepseq, ghc-prim, HUnit, lattices, missing-foreign
     , QuickCheck, random, test-framework, test-framework-hunit
     , test-framework-quickcheck2, test-framework-th, text, time
     , transformers, vector
     }:
     mkDerivation {
       pname = "lvish";
       version = "1.1.4";
       sha256 = "844c627b369c6df9a0d9bb2af6c286ee716221f20d9866c9dcf154b3ba0cf1e8";
       revision = "2";
       editedCabalFile = "bb376e7ac0598a623c8222824a2ace2649a395be610f81912eb7193450aa3e7e";
       libraryHaskellDepends = [
         async atomic-primops base bits-atomic containers deepseq ghc-prim
         lattices missing-foreign random transformers vector
       ];
       testHaskellDepends = [
         async atomic-primops base bits-atomic containers deepseq ghc-prim
         HUnit lattices missing-foreign QuickCheck random test-framework
         test-framework-hunit test-framework-quickcheck2 test-framework-th
         text time transformers vector
       ];
       jailbreak = true;
       description = "Parallel scheduler, LVar data structures, and infrastructure to build more";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lvmlib" = callPackage
    ({ mkDerivation, array, base, containers, directory, filepath
     , parsec, wl-pprint
     }:
     mkDerivation {
       pname = "lvmlib";
       version = "1.1";
       sha256 = "6f99e1ed437d45ecdbb019185d24bc920f7965f279f3b1cec268d51350c622d3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers directory filepath parsec wl-pprint
       ];
       executableHaskellDepends = [
         array base containers directory filepath parsec wl-pprint
       ];
       homepage = "http://www.cs.uu.nl/wiki/bin/view/Helium/WebHome";
       description = "The Lazy Virtual Machine (LVM)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lvmrun" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "lvmrun";
       version = "1.0";
       sha256 = "ca2dce477ad4bc8f04ad6d40503a9834763c147bb686a2193e8bb8cdf24a8e71";
       isLibrary = false;
       isExecutable = true;
       homepage = "http://www.cs.uu.nl/wiki/bin/view/Helium/WebHome";
       description = "The Lazy Virtual Machine (LVM) Runtime System";
       license = "LGPL";
     }) {};

  "lxc" = callPackage
    ({ mkDerivation, base, bindings-lxc, mtl, transformers }:
     mkDerivation {
       pname = "lxc";
       version = "0.3.2";
       sha256 = "9ba3d9bff03cc213318124c279c216011f9b56ee8dd51f7a23edf2e5d8aabc5b";
       libraryHaskellDepends = [ base bindings-lxc mtl transformers ];
       homepage = "https://github.com/fizruk/lxc";
       description = "High level Haskell bindings to LXC (Linux containers)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "lye" = callPackage
    ({ mkDerivation, base, containers, free, HCodecs, lens, parsers
     , transformers, trifecta
     }:
     mkDerivation {
       pname = "lye";
       version = "0.1.0.0";
       sha256 = "35f5366ca8342b7a72c5b7a848cbf4764037950e53cd2c6f284b374eedeeb4de";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers free HCodecs lens parsers transformers trifecta
       ];
       description = "A Lilypond-compiling music box";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "lz4" = callPackage
    ({ mkDerivation, base, bytestring, cereal, hspec, HUnit, QuickCheck
     }:
     mkDerivation {
       pname = "lz4";
       version = "0.2.3.1";
       sha256 = "98cc62bea1a359201f9e39a7db2457272f996ede25d97a2dbee3a07aa80693f1";
       libraryHaskellDepends = [ base bytestring cereal ];
       testHaskellDepends = [ base bytestring hspec HUnit QuickCheck ];
       homepage = "http://github.com/mwotton/lz4hs";
       description = "LZ4 compression for ByteStrings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "lzma" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, lzma, QuickCheck, tasty
     , tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "lzma";
       version = "0.0.0.1";
       sha256 = "576583fa5ac2110ca62f24dea62a1bb6effeba51c31b9fe06862dcfa8f7a38ac";
       revision = "1";
       editedCabalFile = "8ceb5cde6e8f9769e12c1fdb1a5f5c25f1d1aaa045741c991c29659dc6c74fa1";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ lzma ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "https://github.com/hvr/lzma";
       description = "LZMA/XZ compression and decompression";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {inherit (pkgs) lzma;};

  "lzma-clib" = callPackage
    ({ mkDerivation, only-buildable-on-windows }:
     mkDerivation {
       pname = "lzma-clib";
       version = "5.2.2";
       sha256 = "0aed9cb8ef3a2b0e71c429b00161ee3fb342cce2603ccb934f507fb236a09fd5";
       libraryHaskellDepends = [ only-buildable-on-windows ];
       doHaddock = false;
       jailbreak = true;
       description = "liblzma C library and headers for use by LZMA bindings";
       license = stdenv.lib.licenses.publicDomain;
       broken = true;
     }) {only-buildable-on-windows = null;};

  "lzma-conduit_1_1_1" = callPackage
    ({ mkDerivation, base, bindings-DSL, bytestring, conduit, HUnit
     , lzma, QuickCheck, resourcet, test-framework, test-framework-hunit
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "lzma-conduit";
       version = "1.1.1";
       sha256 = "8f5f95c3f8d1f03897ec9f097a9deb9abfb5bd29069e0bdcb8b0a878fb8433c4";
       libraryHaskellDepends = [
         base bindings-DSL bytestring conduit resourcet transformers
       ];
       librarySystemDepends = [ lzma ];
       testHaskellDepends = [
         base bytestring conduit HUnit QuickCheck resourcet test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/alphaHeavy/lzma-conduit";
       description = "Conduit interface for lzma/xz compression";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) lzma;};

  "lzma-conduit_1_1_2" = callPackage
    ({ mkDerivation, base, bindings-DSL, bytestring, conduit, HUnit
     , lzma, QuickCheck, resourcet, test-framework, test-framework-hunit
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "lzma-conduit";
       version = "1.1.2";
       sha256 = "0c1c05ce7be4d82fc039a48c0fa266f4290454be295c9582ad7e8d60d39df408";
       libraryHaskellDepends = [
         base bindings-DSL bytestring conduit resourcet transformers
       ];
       librarySystemDepends = [ lzma ];
       testHaskellDepends = [
         base bytestring conduit HUnit QuickCheck resourcet test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "http://github.com/alphaHeavy/lzma-conduit";
       description = "Conduit interface for lzma/xz compression";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) lzma;};

  "lzma-conduit_1_1_3" = callPackage
    ({ mkDerivation, base, bindings-DSL, bytestring, conduit, HUnit
     , lzma, QuickCheck, resourcet, test-framework, test-framework-hunit
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "lzma-conduit";
       version = "1.1.3";
       sha256 = "24bb207c3cc6ccf4185e0168461a9c9bc276ccd98dbbc5f039a3126f0a3eee06";
       libraryHaskellDepends = [
         base bindings-DSL bytestring conduit resourcet transformers
       ];
       librarySystemDepends = [ lzma ];
       testHaskellDepends = [
         base bytestring conduit HUnit QuickCheck resourcet test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "http://github.com/alphaHeavy/lzma-conduit";
       description = "Conduit interface for lzma/xz compression";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) lzma;};

  "lzma-conduit" = callPackage
    ({ mkDerivation, base, bindings-DSL, bytestring, conduit, HUnit
     , lzma, QuickCheck, resourcet, test-framework, test-framework-hunit
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "lzma-conduit";
       version = "1.1.3.0";
       sha256 = "abf9e7a052a2bbd85923237a6fa7a73e7e077b20908ad3d68e6c24285aef390f";
       libraryHaskellDepends = [
         base bindings-DSL bytestring conduit resourcet transformers
       ];
       librarySystemDepends = [ lzma ];
       testHaskellDepends = [
         base bytestring conduit HUnit QuickCheck resourcet test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "http://github.com/alphaHeavy/lzma-conduit";
       description = "Conduit interface for lzma/xz compression";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) lzma;};

  "lzma-enumerator" = callPackage
    ({ mkDerivation, base, bindings-DSL, bytestring, enumerator, HUnit
     , lzma, mtl, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "lzma-enumerator";
       version = "0.1.3";
       sha256 = "61ca2349d45de89e38b8ffc849b7d31dacb8511c01285def10178461dc42ff5f";
       libraryHaskellDepends = [
         base bindings-DSL bytestring enumerator mtl
       ];
       librarySystemDepends = [ lzma ];
       testHaskellDepends = [
         base bytestring enumerator HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/alphaHeavy/lzma-enumerator";
       description = "Enumerator interface for lzma/xz compression";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) lzma;};

  "lzma-streams" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, io-streams, lzma
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "lzma-streams";
       version = "0.1.0.0";
       sha256 = "b6c90e493f6c367f79c1cee6c3ed978c3515139bf2c7174ed083a1cf76071af1";
       revision = "1";
       editedCabalFile = "7f2c0b8a7b6134789e1e2117ba70d536a050f3cc5cc6a438ab69ffd28785046c";
       libraryHaskellDepends = [ base bytestring io-streams lzma ];
       testHaskellDepends = [
         base bytestring HUnit io-streams QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/hvr/lzma-streams";
       description = "IO-Streams interface for lzma/xz compression";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "maam" = callPackage
    ({ mkDerivation, base, containers, template-haskell, text, vector
     }:
     mkDerivation {
       pname = "maam";
       version = "0.3.0.0";
       sha256 = "4e296086df29c682b848c7f618534e80b196e8544e197cd2b24ec4f7278999cf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers template-haskell text vector
       ];
       description = "Monadic Abstracting Abstract Machines (MAAM) built on Galois Transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mac" = callPackage
    ({ mkDerivation, base, network, transformers }:
     mkDerivation {
       pname = "mac";
       version = "0.1.2.0";
       sha256 = "8ac8188429cb9e20aefa83e3943f7b4f2713248160bcbeb9080784e637e5789d";
       libraryHaskellDepends = [ base network transformers ];
       description = "Static Mandatory Access Control in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "maccatcher" = callPackage
    ({ mkDerivation, base, binary, parsec, process }:
     mkDerivation {
       pname = "maccatcher";
       version = "2.1.5";
       sha256 = "cbafc38151d9c4c17c3055a7f8f0702bf5d7d5240db3369c84326e94ddcaa67c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base binary parsec process ];
       description = "Obtain the host MAC address on *NIX and Windows";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "machinecell" = callPackage
    ({ mkDerivation, arrows, base, free, hspec, mtl, profunctors
     , QuickCheck, semigroups
     }:
     mkDerivation {
       pname = "machinecell";
       version = "3.0.1";
       sha256 = "a018aa83f998b5c94daf1886269fe442566039c26060e4705095b40fa3639236";
       libraryHaskellDepends = [
         arrows base free mtl profunctors semigroups
       ];
       testHaskellDepends = [
         arrows base hspec mtl profunctors QuickCheck semigroups
       ];
       homepage = "http://github.com/as-capabl/machinecell";
       description = "Arrow based stream transducers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "machines_0_4_1" = callPackage
    ({ mkDerivation, base, comonad, containers, directory, doctest
     , filepath, free, mtl, pointed, profunctors, semigroups
     , transformers, void
     }:
     mkDerivation {
       pname = "machines";
       version = "0.4.1";
       sha256 = "eb1d29e2920b80633db71a0d53d6ccfa5c3606f4f27925e271b6b97fb7bd31f3";
       revision = "2";
       editedCabalFile = "d10058f6e32eabb6f1df264a6b0711227862fae22edbaf3d4fc226da7c47d429";
       libraryHaskellDepends = [
         base comonad containers free mtl pointed profunctors semigroups
         transformers void
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/machines/";
       description = "Networked stream transducers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "machines" = callPackage
    ({ mkDerivation, base, comonad, containers, directory, doctest
     , filepath, free, mtl, pointed, profunctors, semigroups
     , transformers, void
     }:
     mkDerivation {
       pname = "machines";
       version = "0.5.1";
       sha256 = "6229f4ff600fe2db87f43220d42089abd64dc0a0d959e15c5010a7ed81f7dbb7";
       revision = "1";
       editedCabalFile = "c50d5fcc8b1b5635539169a5da097a25c7a7b7e9b8cc582abba3703014ba2d1d";
       libraryHaskellDepends = [
         base comonad containers free mtl pointed profunctors semigroups
         transformers void
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/ekmett/machines/";
       description = "Networked stream transducers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "machines_0_6" = callPackage
    ({ mkDerivation, adjunctions, base, comonad, containers, directory
     , distributive, doctest, filepath, free, mtl, pointed, profunctors
     , semigroupoids, semigroups, transformers, transformers-compat
     , void
     }:
     mkDerivation {
       pname = "machines";
       version = "0.6";
       sha256 = "69a54f22a9788e4a7ef2691c49626cd1c22465da2b9f903839d7b20c41eb11f6";
       libraryHaskellDepends = [
         adjunctions base comonad containers distributive free mtl pointed
         profunctors semigroupoids semigroups transformers
         transformers-compat void
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/machines/";
       description = "Networked stream transducers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "machines-binary" = callPackage
    ({ mkDerivation, base, binary, bytestring, machines }:
     mkDerivation {
       pname = "machines-binary";
       version = "0.3.0.0";
       sha256 = "013b925cc53a804dcaf9d3b626c48c816513ed236940302c4274c3946141d58b";
       libraryHaskellDepends = [ base binary bytestring machines ];
       homepage = "http://github.com/aloiscochard/machines-binary";
       description = "Binary utilities for the machines library";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "machines-directory_0_2_0_0" = callPackage
    ({ mkDerivation, base, directory, filepath, machines, machines-io
     , transformers
     }:
     mkDerivation {
       pname = "machines-directory";
       version = "0.2.0.0";
       sha256 = "5b78b4b4d50fe4a5e480491bb92da1974c223e94cce6fe9e0da5421987d832ac";
       libraryHaskellDepends = [
         base directory filepath machines machines-io transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/aloiscochard/machines-io";
       description = "Directory (system) utilities for the machines library";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "machines-directory_0_2_0_2" = callPackage
    ({ mkDerivation, base, directory, filepath, machines, machines-io
     , transformers
     }:
     mkDerivation {
       pname = "machines-directory";
       version = "0.2.0.2";
       sha256 = "da9a373d71794677b8efa7e930af608602fba560b6d9962c71bd510f8ba427fc";
       libraryHaskellDepends = [
         base directory filepath machines machines-io transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/aloiscochard/machines-directory";
       description = "Directory (system) utilities for the machines library";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "machines-directory" = callPackage
    ({ mkDerivation, base, directory, filepath, machines, machines-io
     , transformers
     }:
     mkDerivation {
       pname = "machines-directory";
       version = "0.2.0.6";
       sha256 = "6a77cedb29baee22925ae84c4bbdfa537a8cb2c26071407e5e33f6f58b82ca0d";
       libraryHaskellDepends = [
         base directory filepath machines machines-io transformers
       ];
       homepage = "http://github.com/aloiscochard/machines-directory";
       description = "Directory (system) utilities for the machines library";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "machines-io_0_2_0_0" = callPackage
    ({ mkDerivation, base, bytestring, chunked-data, machines
     , transformers
     }:
     mkDerivation {
       pname = "machines-io";
       version = "0.2.0.0";
       sha256 = "03f482dce378a9b01b7902ab2036f97edc927b5a338123dd9255320d3d774b62";
       libraryHaskellDepends = [
         base bytestring chunked-data machines transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/aloiscochard/machines-io";
       description = "IO utilities for the machines library";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "machines-io_0_2_0_2" = callPackage
    ({ mkDerivation, base, bytestring, chunked-data, machines
     , transformers
     }:
     mkDerivation {
       pname = "machines-io";
       version = "0.2.0.2";
       sha256 = "a70472a80655e15f49f58747d488a32a1ec9b623474beff156635902e88bf26c";
       libraryHaskellDepends = [
         base bytestring chunked-data machines transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/aloiscochard/machines-io";
       description = "IO utilities for the machines library";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "machines-io_0_2_0_6" = callPackage
    ({ mkDerivation, base, bytestring, chunked-data, machines
     , transformers
     }:
     mkDerivation {
       pname = "machines-io";
       version = "0.2.0.6";
       sha256 = "c152e3bdb49e5cab4feb9850cdb82c6233c160a06461543ae6160527544cb1a7";
       libraryHaskellDepends = [
         base bytestring chunked-data machines transformers
       ];
       homepage = "http://github.com/aloiscochard/machines-io";
       description = "IO utilities for the machines library";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "machines-io" = callPackage
    ({ mkDerivation, base, bytestring, chunked-data, machines
     , transformers
     }:
     mkDerivation {
       pname = "machines-io";
       version = "0.2.0.8";
       sha256 = "a24e3c3acb84c53bf7d4c1257c3b1f9c65bdac40a1b27667b58422624a761c25";
       libraryHaskellDepends = [
         base bytestring chunked-data machines transformers
       ];
       homepage = "http://github.com/aloiscochard/machines-io";
       description = "IO utilities for the machines library";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "machines-process_0_2_0_0" = callPackage
    ({ mkDerivation, base, chunked-data, machines, machines-io, process
     }:
     mkDerivation {
       pname = "machines-process";
       version = "0.2.0.0";
       sha256 = "fefcdb5cb1d039b5f70a72259243ad587c01cbd82b543a8bb52f2f2523341409";
       libraryHaskellDepends = [
         base chunked-data machines machines-io process
       ];
       jailbreak = true;
       homepage = "http://github.com/aloiscochard/machines-io";
       description = "Process (system) utilities for the machines library";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "machines-process_0_2_0_2" = callPackage
    ({ mkDerivation, base, chunked-data, machines, machines-io, process
     }:
     mkDerivation {
       pname = "machines-process";
       version = "0.2.0.2";
       sha256 = "e26338a186c95ef80c4ad78fa38c6de53701b07b5c904b8539694b73666f70e8";
       libraryHaskellDepends = [
         base chunked-data machines machines-io process
       ];
       jailbreak = true;
       homepage = "http://github.com/aloiscochard/machines-process";
       description = "Process (system) utilities for the machines library";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "machines-process" = callPackage
    ({ mkDerivation, base, chunked-data, machines, machines-io, process
     }:
     mkDerivation {
       pname = "machines-process";
       version = "0.2.0.4";
       sha256 = "94604ac0954be93cb7c7a6ee0070a0c54b9da4235b1c134a6347878ad6d412ec";
       libraryHaskellDepends = [
         base chunked-data machines machines-io process
       ];
       homepage = "http://github.com/aloiscochard/machines-process";
       description = "Process (system) utilities for the machines library";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "machines-zlib" = callPackage
    ({ mkDerivation, base, basic-prelude, machines, streaming-commons
     }:
     mkDerivation {
       pname = "machines-zlib";
       version = "0.1.0";
       sha256 = "cdec0ca35953512e09727e7880f044f3db89ec475c35787fa9ea6f74d0614d2a";
       libraryHaskellDepends = [
         base basic-prelude machines streaming-commons
       ];
       jailbreak = true;
       homepage = "https://github.com/lshift/machines-zlib";
       description = "Decompression support for machines";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "macho" = callPackage
    ({ mkDerivation, base, binary, bytestring }:
     mkDerivation {
       pname = "macho";
       version = "0.22";
       sha256 = "628319b7c0249af073d2e372050c22ac4b14ba7b84cf540490484134ae5a288e";
       libraryHaskellDepends = [ base binary bytestring ];
       homepage = "http://github.com/erikcharlebois/macho";
       description = "Parser for Mach-O object format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "maclight" = callPackage
    ({ mkDerivation, base, filemanip, filepath, HUnit
     , optparse-applicative, parsec, strict, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "maclight";
       version = "0.1.0.0";
       sha256 = "63f73abc746d39aaeb8e0a27dc47a54435bb7a5bc089ae9d17782ba4be24c461";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base filemanip filepath parsec strict ];
       executableHaskellDepends = [
         base filemanip filepath optparse-applicative strict
       ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       homepage = "http://github.com/tych0/maclight";
       description = "Control screen and keyboard backlights on MACs under Linux";
       license = stdenv.lib.licenses.mit;
     }) {};

  "macosx-make-standalone" = callPackage
    ({ mkDerivation, base, containers, data-lens, data-lens-template
     , deepseq, directory, filepath, graph-visit, mtl, process
     , transformers, unix
     }:
     mkDerivation {
       pname = "macosx-make-standalone";
       version = "0.1.0.1";
       sha256 = "24e47204c92a63f42e586116032311ef22daccffc462a527a20b9543e4754512";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers data-lens data-lens-template deepseq directory
         filepath graph-visit mtl process transformers unix
       ];
       homepage = "https://github.com/atzedijkstra/macosx-make-standalone";
       description = "Make a macosx app standalone deployable";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mage" = callPackage
    ({ mkDerivation, array, base, containers, mtl, ncurses, random }:
     mkDerivation {
       pname = "mage";
       version = "1.1.0";
       sha256 = "9f4b161468e3099c0d478e17b560f02b5ea8b45cbcdff2f6c1db2a8d88df763a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base containers mtl random ];
       executableSystemDepends = [ ncurses ];
       homepage = "http://www.scannedinavian.com/~shae/mage-1.0pre35.tar.gz";
       description = "Rogue-like";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) ncurses;};

  "magic" = callPackage
    ({ mkDerivation, base, file }:
     mkDerivation {
       pname = "magic";
       version = "1.1";
       sha256 = "b21c3b69f57b64199c1d7be0ac8ea1d02d698be59943058f6a2d642ea57ce082";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ file ];
       description = "Interface to C file/magic library";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) file;};

  "magico" = callPackage
    ({ mkDerivation, base, hmatrix, transformers, utility-ht }:
     mkDerivation {
       pname = "magico";
       version = "0.0.1.1";
       sha256 = "149e482d11268d45fb6da03cfa45a0947ea7cacc259c27959314a029c06c2633";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base hmatrix transformers utility-ht
       ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/thielema/magico";
       description = "Compute solutions for Magico puzzle";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "magma" = callPackage
    ({ mkDerivation, base, deepseq, profunctors, semigroups }:
     mkDerivation {
       pname = "magma";
       version = "0.4.0.0";
       sha256 = "7fbef4ce5d50c30f6c386707e655c74626246f4bc8bb84a826a73182ae1a49a3";
       libraryHaskellDepends = [ base deepseq profunctors semigroups ];
       jailbreak = true;
       homepage = "https://github.com/cutsea110/magma";
       description = "magma is an algebraic structure consisting a set together with an binary operation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mahoro" = callPackage
    ({ mkDerivation, base, ConfigFile, containers, curl, directory
     , happstack-state, MissingH, mtl, network, old-time, regex-posix
     , tagsoup, utf8-string, XMPP
     }:
     mkDerivation {
       pname = "mahoro";
       version = "0.1.2";
       sha256 = "ee5caf86f92607a1c182ff3e81a514f008f70e91edc6344ae38a974080aeb03a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base ConfigFile containers curl directory happstack-state MissingH
         mtl network old-time regex-posix tagsoup utf8-string XMPP
       ];
       homepage = "http://kagami.touhou.ru/projects/show/mahoro";
       description = "ImageBoards to XMPP gate";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "maid" = callPackage
    ({ mkDerivation, air, air-th, base, bytestring, containers
     , data-default, directory, filepath, hack2, hack2-contrib
     , hack2-handler-snap-server, moe, process, text
     }:
     mkDerivation {
       pname = "maid";
       version = "2014.10.14";
       sha256 = "592788f2c3001df42ab83efd208af983f13cf5c7b4744f42ddfcdf6184415abf";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         air air-th base bytestring containers data-default directory
         filepath hack2 hack2-contrib hack2-handler-snap-server moe process
         text
       ];
       homepage = "https://github.com/nfjinjing/maid";
       description = "A simple static web server";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mailbox-count" = callPackage
    ({ mkDerivation, base, cmdargs, configurator, containers, directory
     , doctest, filemanip, filepath, HDBC, HDBC-postgresql, HDBC-sqlite3
     , MissingH, tasty, tasty-hunit
     }:
     mkDerivation {
       pname = "mailbox-count";
       version = "0.0.2";
       sha256 = "6eef4b2300a8a5a53bb44ec8c192324025ebddcdc81c2ba145f812a941dba3fd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs configurator containers directory filepath HDBC
         HDBC-postgresql HDBC-sqlite3 MissingH tasty tasty-hunit
       ];
       testHaskellDepends = [
         base cmdargs configurator containers directory doctest filemanip
         filepath HDBC HDBC-postgresql HDBC-sqlite3 MissingH tasty
         tasty-hunit
       ];
       description = "Count mailboxes in a SQL database";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "mailchimp-subscribe" = callPackage
    ({ mkDerivation, aeson, base, http-client, http-client-tls
     , http-types, reflection, scotty, text, transformers, wai-extra
     }:
     mkDerivation {
       pname = "mailchimp-subscribe";
       version = "1.0";
       sha256 = "717d9b1774be7da796eda1e3f65fa23277541c4214107eb38a02f17fd7b1da30";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base http-client http-client-tls http-types reflection scotty
         text transformers wai-extra
       ];
       jailbreak = true;
       homepage = "https://github.com/mietek/mailchimp-subscribe/";
       description = "MailChimp subscription request handler";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mailgun" = callPackage
    ({ mkDerivation, base, bytestring, conduit, exceptions, failure
     , http-client, http-client-multipart, http-conduit, monad-control
     , network, text, transformers
     }:
     mkDerivation {
       pname = "mailgun";
       version = "0.1.0.4";
       sha256 = "f8335b16a26d16f0bb070db96634d111a7d99c289e1430b7f2f9cec51bc8ac07";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring conduit exceptions failure http-client
         http-client-multipart http-conduit monad-control network text
         transformers
       ];
       executableHaskellDepends = [ base http-conduit text transformers ];
       jailbreak = true;
       homepage = "https://github.com/AndrewRademacher/mailgun";
       description = "Connector to Rackspace's Mailgun Service";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mainland-pretty_0_2_7_2" = callPackage
    ({ mkDerivation, base, containers, srcloc, text }:
     mkDerivation {
       pname = "mainland-pretty";
       version = "0.2.7.2";
       sha256 = "ad294e536de913258149a1cba1d854ded30d5e9d23503695e8ab00755549f66a";
       revision = "1";
       editedCabalFile = "e766e6766217250919472995c93de5f98496d1b03d73d498668400408f845ee6";
       libraryHaskellDepends = [ base containers srcloc text ];
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "Pretty printing designed for printing source code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mainland-pretty_0_4_1_0" = callPackage
    ({ mkDerivation, base, containers, srcloc, text }:
     mkDerivation {
       pname = "mainland-pretty";
       version = "0.4.1.0";
       sha256 = "f4874e662b70f32535f94ceb965c942291d3c8017fec56c0c0dc687e17851d65";
       libraryHaskellDepends = [ base containers srcloc text ];
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "Pretty printing designed for printing source code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mainland-pretty" = callPackage
    ({ mkDerivation, base, containers, srcloc, text }:
     mkDerivation {
       pname = "mainland-pretty";
       version = "0.4.1.2";
       sha256 = "8ca9e1df8cd6f5c8dc72d799971a7f9c363a36f5cc266a72b3443db653340941";
       libraryHaskellDepends = [ base containers srcloc text ];
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "Pretty printing designed for printing source code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "majordomo" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, monad-loops, old-locale
     , threads, time, unix, zeromq-haskell
     }:
     mkDerivation {
       pname = "majordomo";
       version = "0.1.6";
       sha256 = "61850b284d22ebad0d2853f20618410995c7a5d9236df91a4b38532cb9cb4ae6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring monad-loops old-locale time zeromq-haskell
       ];
       executableHaskellDepends = [
         base bytestring cmdargs threads unix
       ];
       jailbreak = true;
       description = "Majordomo protocol for ZeroMQ";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "majority" = callPackage
    ({ mkDerivation, haskell2010 }:
     mkDerivation {
       pname = "majority";
       version = "1.1";
       sha256 = "6afeabb09bd4be76bfefc34c7a461c34698c929e33e2ad301cf3c91411ef8290";
       libraryHaskellDepends = [ haskell2010 ];
       homepage = "https://github.com/niswegmann/majority";
       description = "Boyer-Moore Majority Vote Algorithm";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "make-hard-links" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , unix
     }:
     mkDerivation {
       pname = "make-hard-links";
       version = "0.2";
       sha256 = "02e7fb80d6e7cc75523dcbbb565bd6f207e17c895239c58d3edc5a776c5ed62f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory filepath unix
       ];
       description = "Change duplicated files into hard-links";
       license = "GPL";
     }) {};

  "make-package" = callPackage
    ({ mkDerivation, async, base, bytestring, configurator, containers
     , directory, filepath, github, haskeline, lens, lens-datetime, mtl
     , process, text, time
     }:
     mkDerivation {
       pname = "make-package";
       version = "1.2.0";
       sha256 = "c3463faf5fb73353e529bbea1d31f95d358f5766727ee88cd4953dc0debb0294";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async base bytestring configurator containers directory filepath
         github haskeline lens lens-datetime mtl process text time
       ];
       homepage = "https://github.com/Philonous/make-package";
       description = "Make a cabalized package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "makedo" = callPackage
    ({ mkDerivation, base, directory, filepath, HSH, process }:
     mkDerivation {
       pname = "makedo";
       version = "0.1";
       sha256 = "56d0590c8fa65216a5eaf00d63a42d0dcc1fd64b03fdd20ba786005588728269";
       libraryHaskellDepends = [ base directory filepath HSH process ];
       jailbreak = true;
       homepage = "http://darcsden.com/kowey/makedo";
       description = "Helper for writing redo scripts in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "managed_1_0_0" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "managed";
       version = "1.0.0";
       sha256 = "c5beb44a281e80d67cb2cbf8f116bce4b8d8f29ce56b4494a1a522d36e38cb1a";
       revision = "1";
       editedCabalFile = "e785d7abda6ca46246fcb4531202a68c71a17c0f1bfffe07bbcf7408bf0b1986";
       libraryHaskellDepends = [ base transformers ];
       description = "A monad for managed values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "managed_1_0_1" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "managed";
       version = "1.0.1";
       sha256 = "d2efbf081803303fb42b7bc105004a49be6f41719ad3e817400cba3a504dcb5f";
       revision = "1";
       editedCabalFile = "0baecb7e8c20aadcb65399e72b2db383cca207b7a3fafd22c637cff387e022ba";
       libraryHaskellDepends = [ base transformers ];
       description = "A monad for managed values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "managed" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "managed";
       version = "1.0.2";
       sha256 = "f2f562c1c9a1c5b2a73593fe9989c651fda86f67eee65be20861d151911a663c";
       libraryHaskellDepends = [ base transformers ];
       description = "A monad for managed values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "manatee" = callPackage
    ({ mkDerivation, base, binary, cairo, containers, dbus-client
     , dbus-core, derive, directory, filepath, gtk, gtk-serialized-event
     , manatee-core, mtl, stm, template-haskell, text, unix, utf8-string
     }:
     mkDerivation {
       pname = "manatee";
       version = "0.2.2";
       sha256 = "8385c95ee50e7c3816ac0b488c54e7ed5c6f3f00bd4a1b1734824491689d84ec";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [
         base binary cairo containers dbus-client dbus-core derive directory
         filepath gtk gtk-serialized-event manatee-core mtl stm
         template-haskell text unix utf8-string
       ];
       jailbreak = true;
       description = "The Haskell/Gtk+ Integrated Live Environment";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-all" = callPackage
    ({ mkDerivation, base, manatee, manatee-browser, manatee-core
     , manatee-curl, manatee-editor, manatee-filemanager
     , manatee-imageviewer, manatee-ircclient, manatee-mplayer
     , manatee-pdfviewer, manatee-processmanager, manatee-reader
     , manatee-terminal, manatee-welcome
     }:
     mkDerivation {
       pname = "manatee-all";
       version = "0.2.2";
       sha256 = "41645e09d0c4ccdd8c778be53d28659985c02e57da26e821c247e8b6b5107ad0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base manatee manatee-browser manatee-core manatee-curl
         manatee-editor manatee-filemanager manatee-imageviewer
         manatee-ircclient manatee-mplayer manatee-pdfviewer
         manatee-processmanager manatee-reader manatee-terminal
         manatee-welcome
       ];
       doHaddock = false;
       description = "Virtual package to install all Manatee packages";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-anything" = callPackage
    ({ mkDerivation, base, bytestring, containers, dataenc, dbus-client
     , dbus-core, filepath, gio, GoogleSuggest, gtk, manatee-core, mtl
     , network, proc, regex-tdfa, split, stm, text, unix, utf8-string
     }:
     mkDerivation {
       pname = "manatee-anything";
       version = "0.0.8";
       sha256 = "c80257c4539cf408c9658a8d5e13c60e4302f2f8308de24ff4009ccdc411e0a9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers dataenc dbus-client dbus-core filepath
         gio GoogleSuggest gtk manatee-core mtl network proc regex-tdfa
         split stm text unix utf8-string
       ];
       jailbreak = true;
       description = "Multithread interactive input/search framework for Manatee";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-browser" = callPackage
    ({ mkDerivation, base, binary, containers, dbus-client, derive
     , filepath, gtk, manatee-core, mtl, stm, text, utf8-string, webkit
     }:
     mkDerivation {
       pname = "manatee-browser";
       version = "0.1.1";
       sha256 = "7020100998980bb2d7b77852d88f1e06e82313b259919fed877a39eb1d737405";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary containers dbus-client derive filepath gtk manatee-core
         mtl stm text utf8-string webkit
       ];
       jailbreak = true;
       description = "Browser extension for Manatee";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-core" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, Cabal, cairo
     , containers, dataenc, dbus-client, dbus-core, derive, directory
     , filepath, gconf, ghc, ghc-paths, gio, glib, gtk
     , gtk-serialized-event, gtksourceview2, haskell-src-exts, mtl
     , network, old-locale, old-time, process, regex-tdfa, split, stm
     , template-haskell, text, time, unix, utf8-string
     }:
     mkDerivation {
       pname = "manatee-core";
       version = "0.1.1";
       sha256 = "bb94739dc5b6fc4b4df69cbabc53cf4941feffe7014402fd93250d3548634517";
       libraryHaskellDepends = [
         array base binary bytestring Cabal cairo containers dataenc
         dbus-client dbus-core derive directory filepath gconf ghc ghc-paths
         gio glib gtk gtk-serialized-event gtksourceview2 haskell-src-exts
         mtl network old-locale old-time process regex-tdfa split stm
         template-haskell text time unix utf8-string
       ];
       jailbreak = true;
       description = "The core of Manatee";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-curl" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, curl
     , dbus-client, dbus-core, derive, directory, filepath, gio, glib
     , gtk, manatee-core, mtl, network, old-locale, old-time, regex-tdfa
     , stm, template-haskell, text, utf8-string
     }:
     mkDerivation {
       pname = "manatee-curl";
       version = "0.1.1";
       sha256 = "764fb64d30214ce6104ef7a12fd819cd3e83fa4eb3abc5b2ab4833f3582ba26c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers curl dbus-client dbus-core derive
         directory filepath gio glib gtk manatee-core mtl network old-locale
         old-time regex-tdfa stm template-haskell text utf8-string
       ];
       jailbreak = true;
       description = "Download Manager extension for Manatee";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-editor" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, dbus-client
     , dbus-core, derive, filepath, gtk, gtksourceview2, manatee-core
     , regex-tdfa, stm, text
     }:
     mkDerivation {
       pname = "manatee-editor";
       version = "0.1.1";
       sha256 = "3ed15799d618a3234eb72fa01996d9e09ba13491510c2839646e571898eca665";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers dbus-client dbus-core derive
         filepath gtk gtksourceview2 manatee-core regex-tdfa stm text
       ];
       jailbreak = true;
       description = "Editor extension for Manatee";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-filemanager" = callPackage
    ({ mkDerivation, base, binary, containers, dbus-client, derive
     , filepath, gio, glib, gtk, manatee-core, mtl, old-locale, old-time
     , stm, text, utf8-string
     }:
     mkDerivation {
       pname = "manatee-filemanager";
       version = "0.1.1";
       sha256 = "e10aa801873ea7451ffb204002c06ead459c2936371ca04646d1597d9987f91b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary containers dbus-client derive filepath gio glib gtk
         manatee-core mtl old-locale old-time stm text utf8-string
       ];
       jailbreak = true;
       description = "File manager extension for Manatee";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-imageviewer" = callPackage
    ({ mkDerivation, base, binary, containers, dbus-client, derive
     , filepath, gio, glib, gtk, gtkimageview, manatee-core, regex-tdfa
     , stm, text, utf8-string
     }:
     mkDerivation {
       pname = "manatee-imageviewer";
       version = "0.1.1";
       sha256 = "0fe8d4380c4254769affd2f1090fa0ce65941e660fbaa9fb3489efc97417c37a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary containers dbus-client derive filepath gio glib gtk
         gtkimageview manatee-core regex-tdfa stm text utf8-string
       ];
       jailbreak = true;
       description = "Image viewer extension for Manatee";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-ircclient" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, Cabal, containers
     , curl, dbus-client, dbus-core, derive, fastirc, filepath, ghc
     , GoogleTranslate, groom, gtk, gtksourceview2, manatee-core
     , MorseCode, mtl, nano-md5, network, regex-posix, split, stm
     , template-haskell, text, unix, utf8-string
     }:
     mkDerivation {
       pname = "manatee-ircclient";
       version = "0.1.1";
       sha256 = "fe2d45163f230d4a12064b432efd739f8ad8f6b83a915af4979eafc22bc92450";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring Cabal containers curl dbus-client
         dbus-core derive fastirc filepath ghc GoogleTranslate groom gtk
         gtksourceview2 manatee-core MorseCode mtl nano-md5 network
         regex-posix split stm template-haskell text unix utf8-string
       ];
       jailbreak = true;
       description = "IRC client extension for Manatee";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-mplayer" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, dbus-client
     , dbus-core, derive, filepath, gio, gtk, libtagc, manatee-core
     , process, random, regex-tdfa, stm, text, time, unix, utf8-string
     }:
     mkDerivation {
       pname = "manatee-mplayer";
       version = "0.1.1";
       sha256 = "e4377af1eac3444ddf03f0f08f7c4e04b46631534584370ef6f2320df58ce9c9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers dbus-client dbus-core derive
         filepath gio gtk libtagc manatee-core process random regex-tdfa stm
         text time unix utf8-string
       ];
       jailbreak = true;
       description = "Mplayer client extension for Manatee";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-pdfviewer" = callPackage
    ({ mkDerivation, base, binary, cairo, containers, dbus-client
     , derive, filepath, gtk, manatee-core, mtl, poppler, stm, text
     , utf8-string
     }:
     mkDerivation {
       pname = "manatee-pdfviewer";
       version = "0.1.1";
       sha256 = "a690c5581550d8733b1381cd66504026b95e88e89fb3321562ebd633736e004c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary cairo containers dbus-client derive filepath gtk
         manatee-core mtl poppler stm text utf8-string
       ];
       jailbreak = true;
       description = "PDF viewer extension for Manatee";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-processmanager" = callPackage
    ({ mkDerivation, base, binary, containers, dbus-client, derive
     , filepath, gtk, manatee-core, proc, stm, text
     }:
     mkDerivation {
       pname = "manatee-processmanager";
       version = "0.1.1";
       sha256 = "949694dfb6d05e5ffb2808f5f599f0041d40dc3334f92992d9025a656874b3ff";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary containers dbus-client derive filepath gtk manatee-core
         proc stm text
       ];
       jailbreak = true;
       description = "Process manager extension for Manatee";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-reader" = callPackage
    ({ mkDerivation, base, binary, containers, curl, dbus-client
     , derive, download-curl, feed, filepath, gtk, manatee-core, stm
     , text, utf8-string, webkit
     }:
     mkDerivation {
       pname = "manatee-reader";
       version = "0.1.1";
       sha256 = "20cdfb51113450c3b499c8d1dd2b208720b8fd2d62807b038fb8bd81c393f31f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary containers curl dbus-client derive download-curl feed
         filepath gtk manatee-core stm text utf8-string webkit
       ];
       jailbreak = true;
       description = "Feed reader extension for Manatee";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-template" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, dbus-client
     , dbus-core, derive, filepath, gtk, gtksourceview2, manatee-core
     , regex-tdfa, stm, text
     }:
     mkDerivation {
       pname = "manatee-template";
       version = "0.1.1";
       sha256 = "9e2dd71827e8637b601045d1e6ec9391069c30988f87c26e27d48dfbce1b8d51";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers dbus-client dbus-core derive
         filepath gtk gtksourceview2 manatee-core regex-tdfa stm text
       ];
       jailbreak = true;
       description = "Template code to create Manatee application";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-terminal" = callPackage
    ({ mkDerivation, base, binary, containers, dbus-client, derive
     , filepath, gtk, manatee-core, stm, text, unix, vte
     }:
     mkDerivation {
       pname = "manatee-terminal";
       version = "0.1.1";
       sha256 = "6df2018e14b766f128a299b2a122f0cbdf0d9562c4251fd7a84d82a6e0bb41aa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary containers dbus-client derive filepath gtk manatee-core
         stm text unix vte
       ];
       jailbreak = true;
       description = "Terminal Emulator extension for Manatee";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manatee-welcome" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, dbus-client
     , dbus-core, derive, filepath, gtk, manatee-core, regex-tdfa, stm
     , text
     }:
     mkDerivation {
       pname = "manatee-welcome";
       version = "0.1.1";
       sha256 = "088c3b92097a47d04cdc489a8020291e675a59ad6213aa72c58fe702624892ef";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers dbus-client dbus-core derive
         filepath gtk manatee-core regex-tdfa stm text
       ];
       jailbreak = true;
       description = "Welcome module to help user play Manatee quickly";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mancala" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "mancala";
       version = "0.1";
       sha256 = "8658f85a7e2ebd11f1f5596d5ae572f042082264e9b9c2e97faa598893b959ef";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/julianalucena/mancala";
       description = "Simple mancala game";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "mandrill_0_1_1_0" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, blaze-html
     , bytestring, containers, email-validate, http-client
     , http-client-tls, http-types, lens, mtl, old-locale, QuickCheck
     , raw-strings-qq, tasty, tasty-hunit, tasty-quickcheck, text, time
     }:
     mkDerivation {
       pname = "mandrill";
       version = "0.1.1.0";
       sha256 = "09cb58cbfb9fa5d0d1b059ab769e9e0a6e330346dc477adf57c19693cb21278a";
       libraryHaskellDepends = [
         aeson base base64-bytestring blaze-html bytestring containers
         email-validate http-client http-client-tls http-types lens mtl
         old-locale QuickCheck text time
       ];
       testHaskellDepends = [
         aeson base bytestring QuickCheck raw-strings-qq tasty tasty-hunit
         tasty-quickcheck text
       ];
       jailbreak = true;
       description = "Library for interfacing with the Mandrill JSON API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mandrill_0_2_1_0" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, blaze-html
     , bytestring, containers, email-validate, http-client
     , http-client-tls, http-types, lens, mtl, old-locale, QuickCheck
     , raw-strings-qq, tasty, tasty-hunit, tasty-quickcheck, text, time
     }:
     mkDerivation {
       pname = "mandrill";
       version = "0.2.1.0";
       sha256 = "9f0e00e345d64657df25f348d3c28867e795b9f77a37726017b0250c4171b43e";
       libraryHaskellDepends = [
         aeson base base64-bytestring blaze-html bytestring containers
         email-validate http-client http-client-tls http-types lens mtl
         old-locale QuickCheck text time
       ];
       testHaskellDepends = [
         aeson base bytestring QuickCheck raw-strings-qq tasty tasty-hunit
         tasty-quickcheck text
       ];
       jailbreak = true;
       description = "Library for interfacing with the Mandrill JSON API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mandrill_0_2_2_0" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, blaze-html
     , bytestring, containers, email-validate, http-client
     , http-client-tls, http-types, lens, mtl, old-locale, QuickCheck
     , raw-strings-qq, tasty, tasty-hunit, tasty-quickcheck, text, time
     }:
     mkDerivation {
       pname = "mandrill";
       version = "0.2.2.0";
       sha256 = "d04769b4675bad4ba032f9c20c84fbbd3e7e1d5f65863d8bb8258f5489dfdaa0";
       libraryHaskellDepends = [
         aeson base base64-bytestring blaze-html bytestring containers
         email-validate http-client http-client-tls http-types lens mtl
         old-locale QuickCheck text time
       ];
       testHaskellDepends = [
         aeson base bytestring QuickCheck raw-strings-qq tasty tasty-hunit
         tasty-quickcheck text
       ];
       jailbreak = true;
       description = "Library for interfacing with the Mandrill JSON API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mandrill_0_2_2_1" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, blaze-html
     , bytestring, containers, email-validate, http-client
     , http-client-tls, http-types, lens, mtl, old-locale, QuickCheck
     , raw-strings-qq, tasty, tasty-hunit, tasty-quickcheck, text, time
     }:
     mkDerivation {
       pname = "mandrill";
       version = "0.2.2.1";
       sha256 = "13eee6bcdd1730d105ea2d6dd2dc2d82e037b1ec2394c84bb7eca0765a74493b";
       libraryHaskellDepends = [
         aeson base base64-bytestring blaze-html bytestring containers
         email-validate http-client http-client-tls http-types lens mtl
         old-locale QuickCheck text time
       ];
       testHaskellDepends = [
         aeson base bytestring QuickCheck raw-strings-qq tasty tasty-hunit
         tasty-quickcheck text
       ];
       description = "Library for interfacing with the Mandrill JSON API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mandrill_0_3_0_0" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, blaze-html
     , bytestring, containers, email-validate, http-client
     , http-client-tls, http-types, lens, mtl, old-locale, QuickCheck
     , raw-strings-qq, tasty, tasty-hunit, tasty-quickcheck, text, time
     }:
     mkDerivation {
       pname = "mandrill";
       version = "0.3.0.0";
       sha256 = "f497b16900ead8851bec4d8529dfa2a0ba77397a8e7f95ef39d68928d64ffc09";
       libraryHaskellDepends = [
         aeson base base64-bytestring blaze-html bytestring containers
         email-validate http-client http-client-tls http-types lens mtl
         old-locale QuickCheck text time
       ];
       testHaskellDepends = [
         aeson base bytestring QuickCheck raw-strings-qq tasty tasty-hunit
         tasty-quickcheck text
       ];
       description = "Library for interfacing with the Mandrill JSON API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mandrill_0_5_0_0" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, blaze-html
     , bytestring, containers, email-validate, http-client
     , http-client-tls, http-types, lens, mtl, old-locale, QuickCheck
     , raw-strings-qq, tasty, tasty-hunit, tasty-quickcheck, text, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "mandrill";
       version = "0.5.0.0";
       sha256 = "3e77f5fa5be866f32542eca4228cbd911b51b138773601b2f5f32eb84a7beb4b";
       libraryHaskellDepends = [
         aeson base base64-bytestring blaze-html bytestring containers
         email-validate http-client http-client-tls http-types lens mtl
         old-locale QuickCheck text time unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring QuickCheck raw-strings-qq tasty tasty-hunit
         tasty-quickcheck text
       ];
       description = "Library for interfacing with the Mandrill JSON API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mandrill" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, blaze-html
     , bytestring, containers, email-validate, http-client
     , http-client-tls, http-types, lens, mtl, old-locale, QuickCheck
     , raw-strings-qq, tasty, tasty-hunit, tasty-quickcheck, text, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "mandrill";
       version = "0.5.1.0";
       sha256 = "107ca6fe552fe86585fff7b31452073140be1df039a7baadd7e1efb880a063d1";
       libraryHaskellDepends = [
         aeson base base64-bytestring blaze-html bytestring containers
         email-validate http-client http-client-tls http-types lens mtl
         old-locale QuickCheck text time unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring QuickCheck raw-strings-qq tasty tasty-hunit
         tasty-quickcheck text
       ];
       description = "Library for interfacing with the Mandrill JSON API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mandulia" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , filepath, GLUT, hslua, time
     }:
     mkDerivation {
       pname = "mandulia";
       version = "0.7";
       sha256 = "1a8144f8175f08e6ed097839006e1c074013bf969529f7cf4b4c2032a2fa37f3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring containers directory filepath GLUT hslua time
       ];
       homepage = "http://gitorious.org/maximus/mandulia";
       description = "A zooming visualisation of the Mandelbrot Set as many Julia Sets";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mangopay_1_11_4" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, base16-bytestring
     , base64-bytestring, blaze-builder, bytestring, case-insensitive
     , conduit, conduit-extra, connection, country-codes, data-default
     , HTF, http-conduit, http-types, HUnit, lifted-base, monad-control
     , monad-logger, resourcet, template-haskell, text, time, tls
     , transformers, transformers-base, unordered-containers
     , utf8-string, vector, wai, warp, x509-system
     }:
     mkDerivation {
       pname = "mangopay";
       version = "1.11.4";
       sha256 = "6da483e85ce45bb220fd11e701527feed431b0384de589ff5bdc33184f8a6679";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async attoparsec base base16-bytestring base64-bytestring
         blaze-builder bytestring case-insensitive conduit conduit-extra
         connection country-codes data-default http-conduit http-types HUnit
         lifted-base monad-control monad-logger resourcet template-haskell
         text time tls transformers transformers-base unordered-containers
         utf8-string vector wai warp x509-system
       ];
       executableHaskellDepends = [
         aeson base bytestring http-conduit monad-logger text transformers
       ];
       testHaskellDepends = [
         aeson async attoparsec base base16-bytestring base64-bytestring
         blaze-builder bytestring case-insensitive conduit conduit-extra
         connection country-codes data-default HTF http-conduit http-types
         HUnit lifted-base monad-control monad-logger resourcet
         template-haskell text time tls transformers transformers-base
         unordered-containers utf8-string vector wai warp x509-system
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/prowdsponsor/mangopay";
       description = "Bindings to the MangoPay API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mangopay_1_11_5" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, base16-bytestring
     , base64-bytestring, blaze-builder, bytestring, case-insensitive
     , conduit, conduit-extra, connection, country-codes, data-default
     , HTF, http-conduit, http-types, HUnit, lifted-base, monad-control
     , monad-logger, resourcet, template-haskell, text, time, tls
     , transformers, transformers-base, unordered-containers
     , utf8-string, vector, wai, warp, x509-system
     }:
     mkDerivation {
       pname = "mangopay";
       version = "1.11.5";
       sha256 = "514d49768921da81657adbe8b790df25cb2d655c674a09606fa9c91047d4c1ac";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async attoparsec base base16-bytestring base64-bytestring
         blaze-builder bytestring case-insensitive conduit conduit-extra
         connection country-codes data-default http-conduit http-types HUnit
         lifted-base monad-control monad-logger resourcet template-haskell
         text time tls transformers transformers-base unordered-containers
         utf8-string vector wai warp x509-system
       ];
       executableHaskellDepends = [
         aeson base bytestring http-conduit monad-logger text transformers
       ];
       testHaskellDepends = [
         aeson async attoparsec base base16-bytestring base64-bytestring
         blaze-builder bytestring case-insensitive conduit conduit-extra
         connection country-codes data-default HTF http-conduit http-types
         HUnit lifted-base monad-control monad-logger resourcet
         template-haskell text time tls transformers transformers-base
         unordered-containers utf8-string vector wai warp x509-system
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/prowdsponsor/mangopay";
       description = "Bindings to the MangoPay API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mangopay" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, base16-bytestring
     , base64-bytestring, blaze-builder, bytestring, case-insensitive
     , conduit, conduit-extra, connection, country-codes, data-default
     , HTF, http-conduit, http-types, HUnit, lifted-base, monad-control
     , monad-logger, resourcet, template-haskell, text, time, tls
     , transformers, transformers-base, unordered-containers
     , utf8-string, vector, wai, warp, x509-system
     }:
     mkDerivation {
       pname = "mangopay";
       version = "1.12";
       sha256 = "859ea675506f505666857b1d694d57c0e34cc58cfd3b9da2c5216e78aff47f73";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async attoparsec base base16-bytestring base64-bytestring
         blaze-builder bytestring case-insensitive conduit conduit-extra
         connection country-codes data-default http-conduit http-types HUnit
         lifted-base monad-control monad-logger resourcet template-haskell
         text time tls transformers transformers-base unordered-containers
         utf8-string vector wai warp x509-system
       ];
       executableHaskellDepends = [
         aeson base bytestring http-conduit monad-logger text transformers
       ];
       testHaskellDepends = [
         aeson async attoparsec base base16-bytestring base64-bytestring
         blaze-builder bytestring case-insensitive conduit conduit-extra
         connection country-codes data-default HTF http-conduit http-types
         HUnit lifted-base monad-control monad-logger resourcet
         template-haskell text time tls transformers transformers-base
         unordered-containers utf8-string vector wai warp x509-system
       ];
       doCheck = false;
       homepage = "https://github.com/prowdsponsor/mangopay";
       description = "Bindings to the MangoPay API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "manifold-random" = callPackage
    ({ mkDerivation, base, manifolds, random-fu, vector-space }:
     mkDerivation {
       pname = "manifold-random";
       version = "0.1.1.0";
       sha256 = "9979681fcea7a314db619da04ffca77c93d5afe42ce0b819bd974ca70e74050c";
       libraryHaskellDepends = [ base manifolds random-fu vector-space ];
       homepage = "https://github.com/leftaroundabout/manifolds";
       description = "Sampling random points on general manifolds";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "manifolds" = callPackage
    ({ mkDerivation, base, comonad, constrained-categories, containers
     , deepseq, hmatrix, MemoTrie, semigroups, tagged, transformers
     , vector, vector-space, void
     }:
     mkDerivation {
       pname = "manifolds";
       version = "0.1.6.3";
       sha256 = "52b27094f18303664d91d5042f10d5ff0379de1104a21d14282b85efa954178a";
       libraryHaskellDepends = [
         base comonad constrained-categories containers deepseq hmatrix
         MemoTrie semigroups tagged transformers vector vector-space void
       ];
       homepage = "https://github.com/leftaroundabout/manifolds";
       description = "Coordinate-free hypersurfaces";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "map-syntax" = callPackage
    ({ mkDerivation, base, containers, deepseq, HUnit, mtl, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , transformers
     }:
     mkDerivation {
       pname = "map-syntax";
       version = "0.2";
       sha256 = "395cb1c7c4152252dea825ba54c02dca28a386f495a8bff872eb6383f06e610b";
       libraryHaskellDepends = [ base containers mtl ];
       testHaskellDepends = [
         base containers deepseq HUnit mtl QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 transformers
       ];
       description = "Syntax sugar for defining maps";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mappy" = callPackage
    ({ mkDerivation, ansi-terminal, base, containers, directory
     , haskeline, hspec, parsec, QuickCheck
     }:
     mkDerivation {
       pname = "mappy";
       version = "0.1.3.1";
       sha256 = "91ddbde2da1c972ec53a92f25d43e5db052b029a77f7b029b3389cae1b938645";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base containers directory haskeline parsec
       ];
       executableHaskellDepends = [
         ansi-terminal base directory haskeline parsec
       ];
       testHaskellDepends = [ base containers hspec parsec QuickCheck ];
       homepage = "https://github.com/PolyglotSymposium/mappy";
       description = "A functional programming language focused around maps";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "marionetta" = callPackage
    ({ mkDerivation, base, containers, gloss, mtl, splines, vector
     , vector-space
     }:
     mkDerivation {
       pname = "marionetta";
       version = "0.1.0.3";
       sha256 = "2fcd858c555ac3320314bd564664a6f4257246dd15282c5eee22958b70a9454c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers gloss mtl splines vector vector-space
       ];
       jailbreak = true;
       homepage = "https://github.com/paolino/marionetta";
       description = "A study of marionetta movements";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "markdown_0_1_13" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup
     , conduit, conduit-extra, containers, data-default, hspec
     , system-fileio, system-filepath, text, transformers, xss-sanitize
     }:
     mkDerivation {
       pname = "markdown";
       version = "0.1.13";
       sha256 = "6404005064312532e14276f4e9db3ef809f2d2cf3aa60211bac8a716888104e4";
       libraryHaskellDepends = [
         attoparsec base blaze-html blaze-markup conduit conduit-extra
         containers data-default text transformers xss-sanitize
       ];
       testHaskellDepends = [
         base blaze-html conduit conduit-extra containers hspec
         system-fileio system-filepath text transformers
       ];
       homepage = "https://github.com/snoyberg/markdown";
       description = "Convert Markdown to HTML, with XSS protection";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "markdown_0_1_13_1" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup
     , conduit, conduit-extra, containers, data-default, hspec
     , system-fileio, system-filepath, text, transformers, xss-sanitize
     }:
     mkDerivation {
       pname = "markdown";
       version = "0.1.13.1";
       sha256 = "d8b62ce0491e12cd3cb75c5607493f9eb2eee08c1748f1dccfdf675ffe66202c";
       libraryHaskellDepends = [
         attoparsec base blaze-html blaze-markup conduit conduit-extra
         containers data-default text transformers xss-sanitize
       ];
       testHaskellDepends = [
         base blaze-html conduit conduit-extra containers hspec
         system-fileio system-filepath text transformers
       ];
       homepage = "https://github.com/snoyberg/markdown";
       description = "Convert Markdown to HTML, with XSS protection";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "markdown" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup
     , conduit, conduit-extra, containers, data-default, directory
     , filepath, hspec, text, transformers, xss-sanitize
     }:
     mkDerivation {
       pname = "markdown";
       version = "0.1.13.2";
       sha256 = "1fad995dc757d4566196e75f0b13ad5d7176f3762f23c4a552e81900b4e45195";
       libraryHaskellDepends = [
         attoparsec base blaze-html blaze-markup conduit conduit-extra
         containers data-default text transformers xss-sanitize
       ];
       testHaskellDepends = [
         base blaze-html conduit conduit-extra containers directory filepath
         hspec text transformers
       ];
       homepage = "https://github.com/snoyberg/markdown";
       description = "Convert Markdown to HTML, with XSS protection";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "markdown-kate" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-conduit, base, blaze-html
     , conduit, containers, data-default, highlighting-kate, hspec
     , markdown, system-fileio, system-filepath, text, transformers
     , xss-sanitize
     }:
     mkDerivation {
       pname = "markdown-kate";
       version = "0.1.2.1";
       sha256 = "20122800d1d3e1d6d4d4ae22d6f471045c3c529041d83538f0f2f63c4cf0587e";
       libraryHaskellDepends = [
         attoparsec attoparsec-conduit base blaze-html conduit containers
         data-default highlighting-kate text transformers xss-sanitize
       ];
       testHaskellDepends = [
         base blaze-html conduit containers hspec markdown system-fileio
         system-filepath text transformers
       ];
       homepage = "https://github.com/joelteon/markdown-kate";
       description = "Convert Markdown to HTML, with XSS protection";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "markdown-pap" = callPackage
    ({ mkDerivation, base, monads-tf, papillon }:
     mkDerivation {
       pname = "markdown-pap";
       version = "0.0.1.10";
       sha256 = "986165951135fb83c1e681ca673059c032a1a2ec61c7a7e146e9cd1e7dd20033";
       libraryHaskellDepends = [ base monads-tf papillon ];
       description = "markdown parser with papillon";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "markdown-unlit_0_2_0_1" = callPackage
    ({ mkDerivation, base, directory, hspec, QuickCheck, silently
     , stringbuilder
     }:
     mkDerivation {
       pname = "markdown-unlit";
       version = "0.2.0.1";
       sha256 = "186e38a8cba9371293763708778bce59756d184003478a606bac8bed22db83ad";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base directory hspec QuickCheck silently stringbuilder
       ];
       description = "Literate Haskell support for Markdown";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "markdown-unlit" = callPackage
    ({ mkDerivation, base, base-compat, directory, hspec, QuickCheck
     , silently, stringbuilder, temporary
     }:
     mkDerivation {
       pname = "markdown-unlit";
       version = "0.4.0";
       sha256 = "7c650cae7326a687265274d9e73c74ab2f7e570d7928ce9f47add9439d5b42ce";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base base-compat ];
       executableHaskellDepends = [ base base-compat ];
       testHaskellDepends = [
         base base-compat directory hspec QuickCheck silently stringbuilder
         temporary
       ];
       homepage = "https://github.com/sol/markdown-unlit#readme";
       description = "Literate Haskell support for Markdown";
       license = stdenv.lib.licenses.mit;
     }) {};

  "markdown2svg" = callPackage
    ({ mkDerivation, base, binary-file, Cabal, directory, filepath
     , markdown-pap, monads-tf, papillon, png-file, yjsvg
     }:
     mkDerivation {
       pname = "markdown2svg";
       version = "0.0.1.27";
       sha256 = "250d806e8d7884c6207b23435f377cf826b5c0f2d7c5694a03d9e94450b0aa6a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary-file Cabal directory filepath markdown-pap monads-tf
         papillon png-file yjsvg
       ];
       description = "markdown to svg converter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "marked-pretty" = callPackage
    ({ mkDerivation, base, deepseq, ghc-prim }:
     mkDerivation {
       pname = "marked-pretty";
       version = "1.1.2.1";
       sha256 = "b4812c7ae1b5c9e563b061643c824043c8b74b915d675758f323d53c59c3ba05";
       libraryHaskellDepends = [ base deepseq ghc-prim ];
       testHaskellDepends = [ base ];
       homepage = "https://github.com/ku-fpg/marked-pretty";
       description = "Pretty-printing library, with scoping, based on pretty";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "markov" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "markov";
       version = "0.1";
       sha256 = "ae55c8aeb954699c32cb0a6ac9f102c728cb4e4a25cd2a17d4f7269a772644cd";
       libraryHaskellDepends = [ base ];
       description = "Simple interpreter for Markov's normal algorithms";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "markov-chain" = callPackage
    ({ mkDerivation, base, containers, random, transformers }:
     mkDerivation {
       pname = "markov-chain";
       version = "0.0.3.3";
       sha256 = "a8d32b259b4d5508c4c2fce44013c2d095f808fe5af072144ccabc669c962ef9";
       libraryHaskellDepends = [ base containers random transformers ];
       homepage = "http://code.haskell.org/~thielema/markov-chain/";
       description = "Markov Chains for generating random sequences with a user definable behaviour";
       license = "GPL";
     }) {};

  "markov-processes" = callPackage
    ({ mkDerivation, assertions, base, bifunctors, memoize, MonadRandom
     , random
     }:
     mkDerivation {
       pname = "markov-processes";
       version = "0.0.2";
       sha256 = "68385ba141e12ea66a27e0b09ba9f26d8b675a5c79b4766b6e8316e09b4ba0dd";
       libraryHaskellDepends = [
         base bifunctors memoize MonadRandom random
       ];
       testHaskellDepends = [ assertions base bifunctors memoize random ];
       description = "Hidden Markov processes";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "markup_1_1_0" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, comonad, hspec
     , lucid, mtl, text, transformers, urlpath
     }:
     mkDerivation {
       pname = "markup";
       version = "1.1.0";
       sha256 = "e8cfc6bee90478972480c50f5a29d00e25aab6a27dd824ecceab6d20b03d035c";
       libraryHaskellDepends = [
         base blaze-html blaze-markup comonad lucid mtl text transformers
         urlpath
       ];
       testHaskellDepends = [ base hspec ];
       description = "Abstraction for markup languages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "markup" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, clay, comonad
     , lucid, mmorph, monad-control, monad-logger, mtl, path-extra
     , resourcet, text, transformers-base, urlpath
     }:
     mkDerivation {
       pname = "markup";
       version = "3.1.0";
       sha256 = "c7510643483861dafc9c9a8c41ceaa2f02f85870930cf4563899c49307780d3d";
       revision = "1";
       editedCabalFile = "afb6565079dbae62dda5e69e61c9ef1d0617558ba6792c3e93f3788f8d05a3ab";
       libraryHaskellDepends = [
         base blaze-html blaze-markup clay comonad lucid mmorph
         monad-control monad-logger mtl path-extra resourcet text
         transformers-base urlpath
       ];
       description = "Abstraction for HTML-embedded content";
       license = stdenv.lib.licenses.mit;
     }) {};

  "markup-preview" = callPackage
    ({ mkDerivation, base, cmdargs, directory, glib, gtk
     , gtk2hs-buildtools, MissingH, mtl, pandoc, temporary, text
     , transformers, webkit
     }:
     mkDerivation {
       pname = "markup-preview";
       version = "0.2.2.1";
       sha256 = "415bf432f1896b0e1084300b62845ad5e5a4dc33aa40b1a78cd2ff0613acee25";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs directory glib gtk gtk2hs-buildtools MissingH mtl
         pandoc temporary text transformers webkit
       ];
       jailbreak = true;
       description = "A simple markup document preview (markdown, textile, reStructuredText)";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "marmalade-upload" = callPackage
    ({ mkDerivation, aeson, base, bytestring, Cabal, data-default
     , directory, exceptions, filepath, http-client, http-client-tls
     , http-types, keyring, mtl, network, optparse-applicative, process
     , shake, split, tasty, tasty-hunit, text, transformers, zip-archive
     }:
     mkDerivation {
       pname = "marmalade-upload";
       version = "0.10";
       sha256 = "c912fa4305f1459e8b3d8faebb333bdce2f387be01b4b5dc3738936a3ba08318";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring exceptions http-client http-client-tls
         http-types mtl network text transformers
       ];
       executableHaskellDepends = [
         aeson base bytestring Cabal data-default directory filepath keyring
         optparse-applicative process shake split text transformers
         zip-archive
       ];
       testHaskellDepends = [
         aeson base exceptions tasty tasty-hunit text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/lunaryorn/marmalade-upload";
       description = "Upload packages to Marmalade";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "marquise" = callPackage
    ({ mkDerivation, async, attoparsec, base, binary, bytestring
     , containers, cryptohash, data-binary-ieee754, directory, either
     , errors, fast-logger, filepath, hashable, hslogger, hspec
     , lifted-async, mmorph, monad-control, monad-logger, mtl
     , old-locale, optparse-applicative, packer, pipes, pipes-attoparsec
     , pipes-bytestring, pipes-group, semigroups, siphash, text, time
     , transformers, transformers-base, unix, unordered-containers
     , vaultaire-common, zeromq4-haskell
     }:
     mkDerivation {
       pname = "marquise";
       version = "4.0.0";
       sha256 = "eb4854a0719e880b2d2a9e045d8553a2617034389bb7aaa3ff0d0282b4dd54f0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async attoparsec base binary bytestring containers cryptohash
         directory either errors fast-logger filepath hashable hslogger
         lifted-async mmorph monad-control monad-logger mtl packer pipes
         pipes-attoparsec pipes-bytestring pipes-group semigroups siphash
         text time transformers transformers-base unix unordered-containers
         vaultaire-common zeromq4-haskell
       ];
       executableHaskellDepends = [
         async attoparsec base bytestring containers data-binary-ieee754
         hslogger old-locale optparse-applicative packer pipes text time
         unix unordered-containers vaultaire-common
       ];
       testHaskellDepends = [ base bytestring hspec ];
       description = "Client library for Vaultaire";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "marxup" = callPackage
    ({ mkDerivation, base, configurator, containers, cubicbezier
     , directory, dlist, filepath, glpk-hs, graphviz, labeled-tree, lens
     , mtl, parsek, polynomials-bernstein, pretty, process, text
     , typography-geometry, vector
     }:
     mkDerivation {
       pname = "marxup";
       version = "3.0.0.1";
       sha256 = "1675a378317ff0b1b3e2500ae8b4e62555dc85c4ab8d8f72c0d3cc227c4edf07";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers cubicbezier directory filepath glpk-hs graphviz
         labeled-tree lens mtl polynomials-bernstein process text
         typography-geometry vector
       ];
       executableHaskellDepends = [
         base configurator dlist parsek pretty
       ];
       jailbreak = true;
       description = "Markup language preprocessor for Haskell";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "masakazu-bot" = callPackage
    ({ mkDerivation, authenticate-oauth, base, bytestring, conduit
     , datetime, lens, monad-logger, parsers, persistent
     , persistent-sqlite, persistent-template, regex-posix, text
     , transformers, twitter-conduit, twitter-types
     }:
     mkDerivation {
       pname = "masakazu-bot";
       version = "0.4.0.0";
       sha256 = "e7457d9edc9809c30199d3ea7873a31060831071037ea6020fd01f36fc162ddd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         authenticate-oauth base bytestring conduit datetime lens
         monad-logger parsers persistent persistent-sqlite
         persistent-template regex-posix text transformers twitter-conduit
         twitter-types
       ];
       jailbreak = true;
       homepage = "https://github.com/minamiyama1994/chomado-bot-on-haskell/tree/minamiyama1994";
       description = "@minamiyama1994_bot on haskell";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mastermind" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "mastermind";
       version = "2010.7.25.1";
       sha256 = "be3a6cc65ec61c0cb2626b9eae3caa86e71ca0e93f43b143eb87099b8296bf2f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base random ];
       homepage = "http://wiki.github.com/paolino/mastermind";
       description = "console mastermind decypher";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "matchers" = callPackage
    ({ mkDerivation, base, bytestring, pcre, prednote, text }:
     mkDerivation {
       pname = "matchers";
       version = "0.24.0.0";
       sha256 = "c478bb1bd5cebcd1d64c8bb80745222b64a5b6b2e99a450df1dfa201d962369c";
       libraryHaskellDepends = [ base bytestring prednote text ];
       librarySystemDepends = [ pcre ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/matchers";
       description = "Text matchers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) pcre;};

  "math-functions" = callPackage
    ({ mkDerivation, base, deepseq, erf, HUnit, ieee754, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , vector, vector-th-unbox
     }:
     mkDerivation {
       pname = "math-functions";
       version = "0.1.5.2";
       sha256 = "9ec9b809d33c3b4deebc07d8e776cb3f81866e99906ed84f9c4145fe8eb39f89";
       libraryHaskellDepends = [
         base deepseq erf vector vector-th-unbox
       ];
       testHaskellDepends = [
         base HUnit ieee754 QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 vector
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/bos/math-functions";
       description = "Special functions and Chebyshev polynomials";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mathblog" = callPackage
    ({ mkDerivation, base, bytestring, ConfigFile, containers
     , data-default, deepseq, directory, either, filepath, fsnotify
     , HStringTemplate, HTTP, http-server, HUnit, JuicyPixels, mtl
     , network, old-locale, pandoc, pandoc-types, process, SHA
     , system-filepath, temporary, test-framework, test-framework-hunit
     , time, unix, url
     }:
     mkDerivation {
       pname = "mathblog";
       version = "0.6";
       sha256 = "bba53717751414c19467921f7c72a67eeb1898d75c1c0e019f2a2a491d706bd5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring ConfigFile containers data-default deepseq
         directory either filepath fsnotify HStringTemplate HTTP http-server
         HUnit JuicyPixels mtl network old-locale pandoc pandoc-types
         process SHA system-filepath temporary test-framework
         test-framework-hunit time unix url
       ];
       homepage = "http://jtdaugherty.github.io/mathblog/";
       description = "A program for creating and managing a static weblog with LaTeX math and diagrams";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mathgenealogy" = callPackage
    ({ mkDerivation, base, binary, bytestring, cmdargs, containers
     , directory, fgl, filepath, graphviz, HTTP, process, safe, tagsoup
     , text
     }:
     mkDerivation {
       pname = "mathgenealogy";
       version = "1.4.0";
       sha256 = "9491bb64d572248fab24ea1da7b88f2edc7251d00d98c9c3807bdede5b63b4f4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring cmdargs containers directory fgl filepath
         graphviz HTTP process safe tagsoup text
       ];
       description = "Discover your (academic) ancestors!";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "mathista" = callPackage
    ({ mkDerivation, base, filepath, hspec, MissingH, parsec
     , regex-compat, split
     }:
     mkDerivation {
       pname = "mathista";
       version = "0.0.1";
       sha256 = "89640f10b337e67d15ab2fc018f921ad7b158c4093b639be6defbbd745e90a2d";
       revision = "1";
       editedCabalFile = "57641a3bf376ea93c56ab3bb1cf06c41eb1e0fcbec3751d2a3507fe4974e818f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base MissingH parsec regex-compat split
       ];
       executableHaskellDepends = [
         base filepath MissingH parsec regex-compat split
       ];
       testHaskellDepends = [ base hspec parsec ];
       homepage = "https://github.com/nuta/mathista";
       description = "A small programming language for numerical computing";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "mathlink" = callPackage
    ({ mkDerivation, array, base, c2hs, containers, haskell98
     , ix-shapable, mtl
     }:
     mkDerivation {
       pname = "mathlink";
       version = "2.0.1.1";
       sha256 = "136317152f6158676036a4bccd13382a3198dc4edd53aab7e61a906c285cf8a9";
       libraryHaskellDepends = [
         array base containers haskell98 ix-shapable mtl
       ];
       libraryToolDepends = [ c2hs ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~TracyWadleigh/mathlink";
       description = "Write Mathematica packages in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "matlab" = callPackage
    ({ mkDerivation, array, base, Cabal, eng, filepath, mat, mx }:
     mkDerivation {
       pname = "matlab";
       version = "0.2.0.0";
       sha256 = "fd5022375f70d1d5d0bff5e7e4ea7981db04cd8725047968f11d7f1b29a36a22";
       libraryHaskellDepends = [ array base Cabal filepath ];
       librarySystemDepends = [ eng mat mx ];
       jailbreak = true;
       description = "Matlab bindings and interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {eng = null; mat = null; mx = null;};

  "matrices_0_4_2" = callPackage
    ({ mkDerivation, base, primitive, tasty, tasty-hunit
     , tasty-quickcheck, vector
     }:
     mkDerivation {
       pname = "matrices";
       version = "0.4.2";
       sha256 = "86a274a9a6d15eb786f4fda9f717af0ff230f67312a56aa28aab04a7601c9bd5";
       revision = "1";
       editedCabalFile = "6aabde42e016b428562ed0e983444308c23d79837f04453fe57f60a6cbc02fe4";
       libraryHaskellDepends = [ base primitive vector ];
       testHaskellDepends = [
         base tasty tasty-hunit tasty-quickcheck vector
       ];
       description = "native matrix based on vector";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "matrices" = callPackage
    ({ mkDerivation, base, primitive, tasty, tasty-hunit
     , tasty-quickcheck, vector
     }:
     mkDerivation {
       pname = "matrices";
       version = "0.4.3";
       sha256 = "7bc65e57db63146824e8b840f72ce0980251337b98819148439b1afe8d0d4039";
       libraryHaskellDepends = [ base primitive vector ];
       testHaskellDepends = [
         base tasty tasty-hunit tasty-quickcheck vector
       ];
       description = "native matrix based on vector";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "matrix_0_3_4_0" = callPackage
    ({ mkDerivation, base, deepseq, loop, primitive, QuickCheck, tasty
     , tasty-quickcheck, vector
     }:
     mkDerivation {
       pname = "matrix";
       version = "0.3.4.0";
       sha256 = "c12bb9770cc9d65d63160676e27dde09ead8348ac832913438d01e47e9184699";
       revision = "1";
       editedCabalFile = "962532eea266aaa5706e579133630a753e3fc5ff730f976c68bf8952fe98be22";
       libraryHaskellDepends = [ base deepseq loop primitive vector ];
       testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
       jailbreak = true;
       description = "A native implementation of matrix operations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "matrix_0_3_4_1" = callPackage
    ({ mkDerivation, base, deepseq, loop, primitive, QuickCheck, tasty
     , tasty-quickcheck, vector
     }:
     mkDerivation {
       pname = "matrix";
       version = "0.3.4.1";
       sha256 = "09c31a9734c04becc72482ce9c56c75dec1a6fe439389d4fce34ce77221cdc89";
       revision = "1";
       editedCabalFile = "fc5466038629e9dcf6e3a0a4d25eaad76f8d896f8a136da8ada9532bbb71837b";
       libraryHaskellDepends = [ base deepseq loop primitive vector ];
       testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
       jailbreak = true;
       description = "A native implementation of matrix operations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "matrix_0_3_4_2" = callPackage
    ({ mkDerivation, base, deepseq, loop, primitive, QuickCheck, tasty
     , tasty-quickcheck, vector
     }:
     mkDerivation {
       pname = "matrix";
       version = "0.3.4.2";
       sha256 = "f5e982fa0ba8409c0573b853c840955cb3f7868eafa5a5da200e924f44998544";
       revision = "1";
       editedCabalFile = "ffcd0e8752bf8780a721621858b01b93d928887386734a4fc7d957bd7c235834";
       libraryHaskellDepends = [ base deepseq loop primitive vector ];
       testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
       jailbreak = true;
       description = "A native implementation of matrix operations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "matrix_0_3_4_3" = callPackage
    ({ mkDerivation, base, deepseq, loop, primitive, QuickCheck, tasty
     , tasty-quickcheck, vector
     }:
     mkDerivation {
       pname = "matrix";
       version = "0.3.4.3";
       sha256 = "efa1d868c85775154ad5cdc0376860d4af72145f0f0b010fec040df5637f50db";
       revision = "1";
       editedCabalFile = "f586a9d89c7279218a0436d0b8a6adaabc22414caca30774904821bd40cc5ace";
       libraryHaskellDepends = [ base deepseq loop primitive vector ];
       testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
       jailbreak = true;
       description = "A native implementation of matrix operations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "matrix" = callPackage
    ({ mkDerivation, base, deepseq, loop, primitive, QuickCheck, tasty
     , tasty-quickcheck, vector
     }:
     mkDerivation {
       pname = "matrix";
       version = "0.3.4.4";
       sha256 = "fb66b6d62fd89c83bbc00edbae2cbacd283447031631ccb2ce8920d481e14a0d";
       libraryHaskellDepends = [ base deepseq loop primitive vector ];
       testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
       description = "A native implementation of matrix operations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "matrix-market" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "matrix-market";
       version = "1.2";
       sha256 = "487818040a2faf4ed3449defbacb02310f6147cf23c4e4ea388088cceb94f7c3";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://stat.stanford.edu/~patperry/code/matrix-market";
       description = "Read and write NIST Matrix Market files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "matrix-market-pure" = callPackage
    ({ mkDerivation, array, base, containers }:
     mkDerivation {
       pname = "matrix-market-pure";
       version = "0.2";
       sha256 = "c13e0f1b7f6915156f21f357219c5bc56bbf7ba6dfe1a058766ac16e79715216";
       libraryHaskellDepends = [ array base containers ];
       homepage = "http://bitbucket.org/jetxee/hs-matrix-market";
       description = "Pure and composable reader and writer of the Matrix Market format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "matsuri" = callPackage
    ({ mkDerivation, base, ConfigFile, containers, directory, MissingH
     , mtl, network, old-locale, split, time, vty, vty-ui, XMPP
     }:
     mkDerivation {
       pname = "matsuri";
       version = "0.0.4";
       sha256 = "0452336c5417793a165301ef7cb6d50138550b1c877ae5b6b02b699cbcc7f296";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base ConfigFile containers directory MissingH mtl network
         old-locale split time vty vty-ui XMPP
       ];
       homepage = "http://kagami.touhou.ru/projects/show/matsuri";
       description = "ncurses XMPP client";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "maude" = callPackage
    ({ mkDerivation, base, directory, filepath, process, process-extras
     , temporary, text, xml
     }:
     mkDerivation {
       pname = "maude";
       version = "0.6.1";
       sha256 = "14c33ae02a559d906bbf4d02dd92f10746e744dee626017125e8fd5de4c54d61";
       libraryHaskellDepends = [
         base directory filepath process process-extras temporary text xml
       ];
       homepage = "https://github.com/davidlazar/maude-hs";
       description = "An interface to the Maude rewriting system";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "maxent" = callPackage
    ({ mkDerivation, ad, base, hmatrix, lagrangian
     , nonlinear-optimization, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "maxent";
       version = "0.7";
       sha256 = "48ccee8ff48d1ed38fea567829d28ea92a26a93d5938c3e9ed0cd7cc36edae6f";
       libraryHaskellDepends = [
         ad base lagrangian nonlinear-optimization vector
       ];
       testHaskellDepends = [
         ad base hmatrix lagrangian nonlinear-optimization QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
         vector
       ];
       jailbreak = true;
       homepage = "https://github.com/jfischoff/maxent";
       description = "Compute Maximum Entropy Distributions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "maximal-cliques" = callPackage
    ({ mkDerivation, base, containers, vector }:
     mkDerivation {
       pname = "maximal-cliques";
       version = "0.1.1";
       sha256 = "709d05c753c7d2d7466ade515da0255fc79241432d0118b3182dd3b2def475e9";
       libraryHaskellDepends = [ base containers vector ];
       description = "Enumerate all maximal cliques of a graph";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "maxsharing" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, boxes, containers
     , containers-unicode-symbols, HaLeX, IndentParser, mtl, parsec
     , process, uuagc, uuagc-cabal
     }:
     mkDerivation {
       pname = "maxsharing";
       version = "1.0.3";
       sha256 = "4b9ae7230c590b7d9e6060d791e01d9bda953ae41d47c6e88912325b30e8a284";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base base-unicode-symbols boxes containers
         containers-unicode-symbols HaLeX IndentParser mtl parsec process
         uuagc uuagc-cabal
       ];
       jailbreak = true;
       homepage = "http://rochel.info/maxsharing/";
       description = "Maximal sharing of terms in the lambda calculus with letrec";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "maybe-justify" = callPackage
    ({ mkDerivation, base, tasty, tasty-hunit }:
     mkDerivation {
       pname = "maybe-justify";
       version = "0.1.0.0";
       sha256 = "6828b19d4b7439c5b6c9a0794a6b9cefc7dfaf23dac8cefa58e46ff0a31dec7d";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       description = "Simple higher order function for Maybe";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "maybench" = callPackage
    ({ mkDerivation, base, benchpress, Cabal, directory, filepath, mtl
     , old-time, process, time
     }:
     mkDerivation {
       pname = "maybench";
       version = "0.2.4.1";
       sha256 = "79856579a42b719d5a116281b5075330dfb05b90e019331f7140a99ae4ae0ec7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base benchpress old-time process ];
       executableHaskellDepends = [
         base benchpress Cabal directory filepath mtl process time
       ];
       jailbreak = true;
       homepage = "http://code.google.com/p/maybench/";
       description = "Automated benchmarking tool";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mbox_0_3" = callPackage
    ({ mkDerivation, base, old-locale, safe, text, time }:
     mkDerivation {
       pname = "mbox";
       version = "0.3";
       sha256 = "a0e83a87876a14ef3f49ae7ea2647813042af6f593b6e5e3cf44a8b12e01832c";
       libraryHaskellDepends = [ base old-locale safe text time ];
       jailbreak = true;
       description = "Read and write standard mailbox files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mbox" = callPackage
    ({ mkDerivation, base, safe, text, time, time-locale-compat }:
     mkDerivation {
       pname = "mbox";
       version = "0.3.1";
       sha256 = "d172b9d4c57b1138fb27931281deb7562e98312698b5bd784f6c71800434188e";
       revision = "1";
       editedCabalFile = "3d9d819d61351a5adfac1a1224ac81049fa7d809f101070477e28e58d488abb3";
       libraryHaskellDepends = [ base safe text time time-locale-compat ];
       description = "Read and write standard mailbox files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mbox-tools" = callPackage
    ({ mkDerivation, base, bytestring, codec-mbox, containers, fclabels
     , hsemail, mtl, parsec, process, pureMD5, random
     }:
     mkDerivation {
       pname = "mbox-tools";
       version = "0.2.0.4";
       sha256 = "7053c190f5bf46365530df916f780ddb8bd6f497868fc69ec07dbda94fa20dc8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring codec-mbox containers fclabels hsemail mtl parsec
         process pureMD5 random
       ];
       homepage = "https://github.com/np/mbox-tools";
       description = "A collection of tools to process mbox files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mcmaster-gloss-examples" = callPackage
    ({ mkDerivation, base, gloss }:
     mkDerivation {
       pname = "mcmaster-gloss-examples";
       version = "2013";
       sha256 = "588cb21e84d186bc6b5bd0457660fafb33e030d5185bf8a7fd92d49385150e9d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base gloss ];
       jailbreak = true;
       homepage = "http://www.cas.mcmaster.ca/~anand/";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "mcmc-samplers" = callPackage
    ({ mkDerivation, base, containers, hakaru, hmatrix, mwc-random
     , primitive, statistics
     }:
     mkDerivation {
       pname = "mcmc-samplers";
       version = "0.1.1.1";
       sha256 = "91e240bbc1c2bac3d556e6aba3cfd18eb5d3c10442f491b8836d976550340c5f";
       libraryHaskellDepends = [
         base containers hakaru hmatrix mwc-random primitive statistics
       ];
       jailbreak = true;
       description = "Combinators for MCMC sampling";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mcmc-synthesis" = callPackage
    ({ mkDerivation, base, MonadRandom }:
     mkDerivation {
       pname = "mcmc-synthesis";
       version = "0.1.2.2";
       sha256 = "781714d8cc3ba1362a98cfcdc3b21a10fb83904efa599a6d48434a8b5beae193";
       libraryHaskellDepends = [ base MonadRandom ];
       jailbreak = true;
       description = "MCMC applied to probabilistic program synthesis";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "mcmc-types" = callPackage
    ({ mkDerivation, base, containers, mwc-probability, transformers }:
     mkDerivation {
       pname = "mcmc-types";
       version = "1.0.1";
       sha256 = "04e11474719161813da8ce505a7052853a26a237d5ddee99ed198a3326b246e0";
       libraryHaskellDepends = [
         base containers mwc-probability transformers
       ];
       homepage = "http://github.com/jtobin/mcmc-types";
       description = "Common types for sampling";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mcpi" = callPackage
    ({ mkDerivation, base, network, pipes, split, transformers }:
     mkDerivation {
       pname = "mcpi";
       version = "0.0.1.2";
       sha256 = "86ba6e6a066361809acda148e2f2fafd2c07ef73e5f344304a03db44a8234b95";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base network split transformers ];
       executableHaskellDepends = [ base network pipes transformers ];
       jailbreak = true;
       homepage = "https://github.com/DougBurke/hmcpi";
       description = "Connect to MineCraft running on a Raspberry PI";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "mdapi" = callPackage
    ({ mkDerivation, aeson, base, bytestring, data-default, lens
     , lens-aeson, text, transformers, wreq
     }:
     mkDerivation {
       pname = "mdapi";
       version = "1";
       sha256 = "0f0c90b50b439519ce86d721023e06478358b94c5339f8e3dfdf930ad6b16721";
       revision = "1";
       editedCabalFile = "23b50bbb40d56c56dd89e5d0d36b62c7c31e9c0046362a56dfcab3c81a753139";
       libraryHaskellDepends = [
         aeson base bytestring data-default lens lens-aeson text
         transformers wreq
       ];
       homepage = "https://github.com/relrod/mdapi-hs";
       description = "Haskell interface to Fedora's mdapi";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "mdcat" = callPackage
    ({ mkDerivation, ansi-terminal, base, directory, pandoc, terminfo
     }:
     mkDerivation {
       pname = "mdcat";
       version = "0.1.0.4";
       sha256 = "3405cd2ffeb4a9d2de1df140a453d75a5c9d4b48e36fbe5c379bf7cc15abd64b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base directory pandoc terminfo
       ];
       executableHaskellDepends = [
         ansi-terminal base directory pandoc terminfo
       ];
       jailbreak = true;
       homepage = "https://github.com/dorafmon/mdcat";
       description = "Markdown viewer in your terminal";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mdo" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "mdo";
       version = "0.0.1";
       sha256 = "bb96f03358e70e1858bea568070cabfcab061fc70de03c643433994acea2248e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base process ];
       description = "Command-line tool to run a command on each of the items";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mdp" = callPackage
    ({ mkDerivation, base, containers, HTF, HUnit, QuickCheck, vector
     }:
     mkDerivation {
       pname = "mdp";
       version = "0.1.0.0";
       sha256 = "816474886b59ab0f0cd5c4779f2702e9b7484fe94179a426894f561828f86711";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers vector ];
       executableHaskellDepends = [ base containers vector ];
       testHaskellDepends = [
         base containers HTF HUnit QuickCheck vector
       ];
       description = "Tools for solving Markov Decision Processes";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mecab" = callPackage
    ({ mkDerivation, base, bytestring, mecab, text }:
     mkDerivation {
       pname = "mecab";
       version = "0.4.0";
       sha256 = "e30f55b6a0d0ed13de5d4ecd9fedbbac918097ec0ae912c1ac2477eb8807c57c";
       libraryHaskellDepends = [ base bytestring text ];
       librarySystemDepends = [ mecab ];
       jailbreak = true;
       homepage = "http://github.com/tanakh/hsmecab";
       description = "A Haskell binding to MeCab";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {mecab = null;};

  "mecha" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "mecha";
       version = "0.1.1";
       sha256 = "413413fd61b38820a38e538019893fc2f5c5a840a325676b57721e635cfc7978";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       homepage = "http://tomahawkins.org";
       description = "A constructive solid geometry (CSG) modeling language";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mediawiki" = callPackage
    ({ mkDerivation, base, HTTP, mime, network, pretty, utf8-string
     , xml
     }:
     mkDerivation {
       pname = "mediawiki";
       version = "0.2.6";
       sha256 = "393c7ebd450eb93d5b3ec09236c9882d46fa130464a9a96b363ce37f6284d9f1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base HTTP mime network utf8-string xml ];
       executableHaskellDepends = [
         base HTTP mime network pretty utf8-string xml
       ];
       description = "Interfacing with the MediaWiki API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mediawiki2latex" = callPackage
    ({ mkDerivation, array, base, blaze-html, bytestring, containers
     , directory, directory-tree, file-embed, filepath, happstack-server
     , highlighting-kate, HTTP, http-conduit, hxt, hxt-http, mtl
     , network, parsec, process, split, temporary, text, transformers
     , url, utf8-string, utility-ht
     }:
     mkDerivation {
       pname = "mediawiki2latex";
       version = "7.9.0.1";
       sha256 = "7c64d1419342a1138107494746efd777e3a3be1db00667272c1320512044e060";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base blaze-html bytestring containers directory
         directory-tree file-embed filepath happstack-server
         highlighting-kate HTTP http-conduit hxt hxt-http mtl network parsec
         process split temporary text transformers url utf8-string
         utility-ht
       ];
       homepage = "http://sourceforge.net/projects/wb2pdf/";
       description = "Convert MediaWiki text to LaTeX";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "medium-sdk-haskell" = callPackage
    ({ mkDerivation, aeson, base, bytestring, data-default-class
     , either, http-client, servant-client, servant-server, text, time
     }:
     mkDerivation {
       pname = "medium-sdk-haskell";
       version = "0.1.0.0";
       sha256 = "4dbe2ba6d20729a3cd7bb3af8ff881dec791a01485e1a010881dea0f1fb9e00a";
       libraryHaskellDepends = [
         aeson base bytestring data-default-class either http-client
         servant-client servant-server text time
       ];
       jailbreak = true;
       description = "Haskell SDK for communicating with the Medium API";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "meep" = callPackage
    ({ mkDerivation, base, bifunctors, doctest, hspec
     , hspec-expectations-lens, lens, QuickCheck, semigroupoids
     , semigroups
     }:
     mkDerivation {
       pname = "meep";
       version = "0.1.2.0";
       sha256 = "b94562ef31dc24f051738e2e4e81f3c769c85dd75886f8bc5480d4a1e4fb23cb";
       libraryHaskellDepends = [
         base bifunctors lens semigroupoids semigroups
       ];
       testHaskellDepends = [
         base bifunctors doctest hspec hspec-expectations-lens lens
         QuickCheck semigroupoids semigroups
       ];
       description = "A silly container";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mega-sdist" = callPackage
    ({ mkDerivation, base, bytestring, conduit, containers, directory
     , http-conduit, http-types, network, shelly, system-fileio
     , system-filepath, tar, text, transformers, zlib-conduit
     }:
     mkDerivation {
       pname = "mega-sdist";
       version = "0.2.10.4";
       sha256 = "8f5e7a5edb1c21a8a219867ec670b7def9b764ce0326caea0bf1ff84cfa10575";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring conduit containers directory http-conduit
         http-types network shelly system-fileio system-filepath tar text
         transformers zlib-conduit
       ];
       homepage = "https://github.com/snoyberg/mega-sdist";
       description = "Handles uploading to Hackage from mega repos (deprecated)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "megaparsec_4_2_0" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, mtl, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, transformers
     }:
     mkDerivation {
       pname = "megaparsec";
       version = "4.2.0";
       sha256 = "de76c7e946cc73fcdafc4c78697e4312b1c68a052332d2b34859a176f115a493";
       libraryHaskellDepends = [ base bytestring mtl text transformers ];
       testHaskellDepends = [
         base HUnit mtl QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 transformers
       ];
       homepage = "https://github.com/mrkkrp/megaparsec";
       description = "Monadic parser combinators";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "megaparsec" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, mtl, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, transformers
     }:
     mkDerivation {
       pname = "megaparsec";
       version = "4.3.0";
       sha256 = "2298f02815b1ebbf200817c68c5e7414ef558c70fe64b2ee01fbbe1142d78680";
       revision = "2";
       editedCabalFile = "937110189d9bc4843e11cfdf80b4a215845a8c9ecca0fea40a13ad00f6c6c1bc";
       libraryHaskellDepends = [ base bytestring mtl text transformers ];
       testHaskellDepends = [
         base HUnit mtl QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 transformers
       ];
       homepage = "https://github.com/mrkkrp/megaparsec";
       description = "Monadic parser combinators";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "megaparsec_4_4_0" = callPackage
    ({ mkDerivation, base, bytestring, fail, HUnit, mtl, QuickCheck
     , semigroups, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, transformers
     }:
     mkDerivation {
       pname = "megaparsec";
       version = "4.4.0";
       sha256 = "93addf2a1cf14cb88fd67ea9951d8dd76bcb75960936a517b13787ed0e26f310";
       libraryHaskellDepends = [
         base bytestring fail mtl semigroups text transformers
       ];
       testHaskellDepends = [
         base HUnit mtl QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/mrkkrp/megaparsec";
       description = "Monadic parser combinators";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "meldable-heap" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "meldable-heap";
       version = "2.0.3";
       sha256 = "63b66e2d102fc419fe355a099d82736da6556f2d891f5569681a0d4da9fce5dc";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.google.com/p/priority-queues/";
       description = "Asymptotically optimal, Coq-verified meldable heaps, AKA priority queues";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "melody" = callPackage
    ({ mkDerivation, base, containers, either, HUnit, lens, mtl, parsec
     , ParsecTools, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "melody";
       version = "0.2";
       sha256 = "d73ce3379e43971e7f1883866ce1ad6252a5b464569dda07a524c1577b687ce9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers either lens mtl parsec ParsecTools
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base containers HUnit mtl test-framework test-framework-hunit
       ];
       jailbreak = true;
       description = "A functional scripting language";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "memcache" = callPackage
    ({ mkDerivation, base, binary, blaze-builder, bytestring, hashable
     , network, resource-pool, time, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "memcache";
       version = "0.1.0.0";
       sha256 = "a592a3c154c8d64fb0e4335d13e8362e75a53fe3bbea8cc44f57802a00e254f4";
       revision = "1";
       editedCabalFile = "6e2508fa18aae99fee1c0aa41cc86e97d73ff504647b5265e54adf3566ca81e7";
       libraryHaskellDepends = [
         base binary blaze-builder bytestring hashable network resource-pool
         time vector vector-algorithms
       ];
       testHaskellDepends = [ base bytestring ];
       homepage = "https://github.com/dterei/memcache-hs";
       description = "A memcached client library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "memcache-conduit" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-binary, base, bytestring
     , conduit, conduit-extra, containers, hashtables, memcache-haskell
     , monad-control, mtl, network, resourcet, split, stm, transformers
     }:
     mkDerivation {
       pname = "memcache-conduit";
       version = "0.0.3";
       sha256 = "f28e89dcbf1329dec98d67ce055a3eef12bc8c4ef9afeaf3c8adf10db5f632f8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec attoparsec-binary base bytestring conduit conduit-extra
         memcache-haskell mtl network resourcet split
       ];
       executableHaskellDepends = [
         base bytestring conduit conduit-extra containers hashtables
         memcache-haskell monad-control mtl network resourcet stm
         transformers
       ];
       description = "Conduit library for memcache procotol";
       license = stdenv.lib.licenses.mit;
     }) {};

  "memcache-haskell" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, conduit-extra
     , containers, hashable, hashtables, HUnit, mtl, network, QuickCheck
     , resourcet, split, stm, test-framework, test-framework-hunit
     , test-framework-quickcheck2, test-framework-th, transformers
     }:
     mkDerivation {
       pname = "memcache-haskell";
       version = "0.0.10.1";
       sha256 = "4c1b7d9c5d12a4ae24ea73ace9489232831bb15b1d8e0d2bb53e926f53b16e48";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring hashable network split transformers
       ];
       executableHaskellDepends = [
         base bytestring conduit-extra containers hashtables mtl resourcet
         stm transformers
       ];
       testHaskellDepends = [
         base bytestring HUnit network QuickCheck split test-framework
         test-framework-hunit test-framework-quickcheck2 test-framework-th
       ];
       description = "Memcache procotol library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "memcached" = callPackage
    ({ mkDerivation, base, bytestring, network, utf8-light }:
     mkDerivation {
       pname = "memcached";
       version = "0.2.1";
       sha256 = "cd8bd88caf906b004307176cd468f415b536f52a4e663e3c6006fc0bedffdca8";
       libraryHaskellDepends = [ base bytestring network utf8-light ];
       jailbreak = true;
       homepage = "http://github.com/olegkat/haskell-memcached";
       description = "haskell bindings for memcached";
       license = "unknown";
     }) {};

  "memcached-binary" = callPackage
    ({ mkDerivation, base, bytestring, data-default-class, hspec, HUnit
     , network, process, resource-pool, storable-endian, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "memcached-binary";
       version = "0.2.0";
       sha256 = "4d895459998bfd2fb80337cfc2363a905dfd7dc62adfad0696841c570c58fb8c";
       revision = "3";
       editedCabalFile = "3314b765ef10f959862577e55809bc181d16dfd3ff9443b62499b5b393eea6b3";
       libraryHaskellDepends = [
         base bytestring data-default-class network resource-pool
         storable-endian time unordered-containers
       ];
       testHaskellDepends = [
         base bytestring data-default-class hspec HUnit network process
       ];
       doCheck = false;
       homepage = "https://github.com/philopon/memcached-binary";
       description = "memcached client using binary protocol";
       license = stdenv.lib.licenses.mit;
     }) {};

  "memexml" = callPackage
    ({ mkDerivation, base, hxt }:
     mkDerivation {
       pname = "memexml";
       version = "0.0.3";
       sha256 = "e85e83e70d4c2ed6b56a047ea5df836b4ba37a13666d438088fdfbd048896ff4";
       libraryHaskellDepends = [ base hxt ];
       homepage = "https://github.com/eggzilla/memexml";
       description = "Library for reading Meme XML output";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "memo-ptr" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "memo-ptr";
       version = "0.1.0.0";
       sha256 = "29b84899c725d87518cb4cb2313d9a29c775a229116e8286ce0cb8ddc631c3ef";
       libraryHaskellDepends = [ base containers ];
       description = "Pointer equality memoization";
       license = stdenv.lib.licenses.mit;
     }) {};

  "memo-sqlite" = callPackage
    ({ mkDerivation, base, direct-sqlite }:
     mkDerivation {
       pname = "memo-sqlite";
       version = "0.1";
       sha256 = "c3ef7f29b5707af12a4cd5321d9cbf4b637b307c953cf7199ae9489e84fa32be";
       libraryHaskellDepends = [ base direct-sqlite ];
       jailbreak = true;
       homepage = "https://gitorious.org/memo-sqlite";
       description = "memoize functions using SQLite3 database";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "memoization-utils" = callPackage
    ({ mkDerivation, base, containers, hspec, lrucache, time
     , time-units
     }:
     mkDerivation {
       pname = "memoization-utils";
       version = "0.1.0.1";
       sha256 = "32a495df7ca1a24ed303393f821d33ce873683a4b398ee07e4c79dc88dc72ab6";
       libraryHaskellDepends = [
         base containers lrucache time time-units
       ];
       testHaskellDepends = [ base hspec time time-units ];
       homepage = "http://github.com/yamadapc/haskell-memoization-utils";
       description = "Utilities for memoizing functions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "memoize" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "memoize";
       version = "0.7";
       sha256 = "04dbd6e367132c477342a3a7271438a9d2ec55cd433e1d01807a6091934d11eb";
       revision = "1";
       editedCabalFile = "4dccaf9fbeff4ff6207a78541ec3a6592db9c732fc65aa8bef1c5d8ff9c1f9f2";
       libraryHaskellDepends = [ base template-haskell ];
       description = "A memoization library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "memory_0_6" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, ghc-prim, tasty
     , tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "memory";
       version = "0.6";
       sha256 = "7c09b84114044e9183785a6db7bef74fbfdcb710620f1185fd4a972ea0cd20a3";
       revision = "1";
       editedCabalFile = "380f7409f7c1bf0d287aefe77267e7d18858f556672519348b26d351f9538f23";
       libraryHaskellDepends = [ base bytestring deepseq ghc-prim ];
       testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ];
       homepage = "https://github.com/vincenthz/hs-memory";
       description = "memory and related abtraction stuff";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "memory_0_7" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, ghc-prim, tasty
     , tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "memory";
       version = "0.7";
       sha256 = "e123c8851a0f9bc3d442a462324bb828f6571d0d90fe1c6cb671f8913bd941fa";
       revision = "1";
       editedCabalFile = "f45af2b5e7abcf5f66673d053d3531a62cd6417b3830c0ae375ee704c4c539c8";
       libraryHaskellDepends = [ base bytestring deepseq ghc-prim ];
       testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ];
       homepage = "https://github.com/vincenthz/hs-memory";
       description = "memory and related abtraction stuff";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "memory_0_10" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, ghc-prim, tasty
     , tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "memory";
       version = "0.10";
       sha256 = "4fbd6b86424c9513c4315b0e3649d4545400b07045cce5de5930ca25eb4f1af7";
       revision = "1";
       editedCabalFile = "077f03d446f54b00ecc4b9b3af646532f6e9d0a455b911ddfaf2484507c48433";
       libraryHaskellDepends = [ base bytestring deepseq ghc-prim ];
       testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ];
       homepage = "https://github.com/vincenthz/hs-memory";
       description = "memory and related abstraction stuff";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "memory" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, ghc-prim, tasty
     , tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "memory";
       version = "0.11";
       sha256 = "7b7fa325def957f4cc0a884f7c1e0d549c9329a8d1aa9e1456e37e5aff4e3fa6";
       libraryHaskellDepends = [ base bytestring deepseq ghc-prim ];
       testHaskellDepends = [ base tasty tasty-hunit tasty-quickcheck ];
       homepage = "https://github.com/vincenthz/hs-memory";
       description = "memory and related abstraction stuff";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "memscript" = callPackage
    ({ mkDerivation, base, haskeline, transformers }:
     mkDerivation {
       pname = "memscript";
       version = "0.1.0.0";
       sha256 = "b9003c8b8ac493ecae2ec104800b825e5ce50a8a76b7786069ae70ed9ed591f5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskeline transformers ];
       homepage = "http://hackage.haskell.org/cgi-bin/hackage-scripts/package/memscript";
       description = "Command line utility for memorizing scriptures or any other text";
       license = "GPL";
     }) {};

  "mersenne-random" = callPackage
    ({ mkDerivation, base, old-time }:
     mkDerivation {
       pname = "mersenne-random";
       version = "1.0.0.1";
       sha256 = "bcee8af246b6967b0c4326f3eec57611818dacc729b7c6bd42e1d363f9f878a4";
       libraryHaskellDepends = [ base old-time ];
       homepage = "http://code.haskell.org/~dons/code/mersenne-random";
       description = "Generate high quality pseudorandom numbers using a SIMD Fast Mersenne Twister";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mersenne-random-pure64" = callPackage
    ({ mkDerivation, base, old-time, random }:
     mkDerivation {
       pname = "mersenne-random-pure64";
       version = "0.2.0.4";
       sha256 = "302534036199a7835841f1a52668ec9ea71e9c51fab78ec1616486e7ac170762";
       libraryHaskellDepends = [ base old-time random ];
       homepage = "http://code.haskell.org/~dons/code/mersenne-random-pure64/";
       description = "Generate high quality pseudorandom numbers purely using a Mersenne Twister";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "messagepack_0_3_0" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, cereal, containers
     , QuickCheck, test-framework, test-framework-quickcheck2
     , test-framework-th, text
     }:
     mkDerivation {
       pname = "messagepack";
       version = "0.3.0";
       sha256 = "405d6bc70ee548ca2752b13d8d44e1df2efbc24943415540c89fbe041d2094c5";
       libraryHaskellDepends = [
         attoparsec base bytestring cereal containers text
       ];
       testHaskellDepends = [
         base bytestring cereal containers QuickCheck test-framework
         test-framework-quickcheck2 test-framework-th text
       ];
       jailbreak = true;
       homepage = "https://github.com/rodrigosetti/messagepack";
       description = "Serialize instance for Message Pack Object";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "messagepack_0_4_0" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, QuickCheck
     , test-framework, test-framework-quickcheck2, test-framework-th
     }:
     mkDerivation {
       pname = "messagepack";
       version = "0.4.0";
       sha256 = "11684ac166c7023c6cb31fbe27205ef532497f9fe3d787c87dfaa7e47d6a19a5";
       libraryHaskellDepends = [ base bytestring cereal containers ];
       testHaskellDepends = [
         base bytestring cereal containers QuickCheck test-framework
         test-framework-quickcheck2 test-framework-th
       ];
       jailbreak = true;
       homepage = "https://github.com/rodrigosetti/messagepack";
       description = "Serialize instance for Message Pack Object";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "messagepack" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, QuickCheck
     , test-framework, test-framework-quickcheck2, test-framework-th
     }:
     mkDerivation {
       pname = "messagepack";
       version = "0.5.1";
       sha256 = "e12c22991bd4265e3a52642d0e5970182ecd931afdf8552088d49a524c49625d";
       libraryHaskellDepends = [ base bytestring cereal containers ];
       testHaskellDepends = [
         base bytestring cereal containers QuickCheck test-framework
         test-framework-quickcheck2 test-framework-th
       ];
       doCheck = false;
       homepage = "https://github.com/rodrigosetti/messagepack";
       description = "Serialize instance for Message Pack Object";
       license = stdenv.lib.licenses.mit;
     }) {};

  "messagepack-rpc_0_1_0_3" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, messagepack
     , network-simple, text
     }:
     mkDerivation {
       pname = "messagepack-rpc";
       version = "0.1.0.3";
       sha256 = "a11a89b6f50c5e871a66f03f8f9b84e3fcb793e233b649fe78f605b4dc90343d";
       libraryHaskellDepends = [
         base bytestring cereal containers messagepack network-simple text
       ];
       jailbreak = true;
       homepage = "http://github.com/rodrigosetti/messagepack-rpc";
       description = "Message Pack RPC over TCP";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "messagepack-rpc_0_2_0_0" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, messagepack
     , network-simple
     }:
     mkDerivation {
       pname = "messagepack-rpc";
       version = "0.2.0.0";
       sha256 = "a82366e59578f2971214ad2d9d2881f11ec031e1fb0354c45fd4df40b6c7a053";
       libraryHaskellDepends = [
         base bytestring cereal containers messagepack network-simple
       ];
       jailbreak = true;
       homepage = "http://github.com/rodrigosetti/messagepack-rpc";
       description = "Message Pack RPC over TCP";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "messagepack-rpc" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, messagepack
     , network-simple
     }:
     mkDerivation {
       pname = "messagepack-rpc";
       version = "0.5.1";
       sha256 = "aa7960644668284e6add36e5c305af2c6d3ebf0a9a2c3fcd62529554a049a0bc";
       libraryHaskellDepends = [
         base bytestring cereal containers messagepack network-simple
       ];
       homepage = "http://github.com/rodrigosetti/messagepack-rpc";
       description = "Message Pack RPC over TCP";
       license = stdenv.lib.licenses.mit;
     }) {};

  "messente" = callPackage
    ({ mkDerivation, base, bytestring, HTTP, http-conduit, network }:
     mkDerivation {
       pname = "messente";
       version = "0.1.0.1";
       sha256 = "8549a33d224cb0b43dac520b0d063729cb6765540930f483719e0c3baf6e62fb";
       libraryHaskellDepends = [
         base bytestring HTTP http-conduit network
       ];
       jailbreak = true;
       homepage = "http://github.com/kaiko/messente-haskell";
       description = "Messente SMS Gateway";
       license = stdenv.lib.licenses.mit;
     }) {};

  "meta-misc" = callPackage
    ({ mkDerivation, base, loch-th, template-haskell }:
     mkDerivation {
       pname = "meta-misc";
       version = "0.1.0.3";
       sha256 = "0c40967864839cf2c360533ede7d8f0bc4489bd5285594fb4f0e7c918f79ba5f";
       libraryHaskellDepends = [ base loch-th template-haskell ];
       homepage = "https://github.com/bairyn/meta-misc";
       description = "Utility library providing miscellaneous meta-programming utilities";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "meta-par" = callPackage
    ({ mkDerivation, abstract-deque, abstract-par, base, bytestring
     , containers, deepseq, mtl, mwc-random, transformers, vector
     }:
     mkDerivation {
       pname = "meta-par";
       version = "0.3";
       sha256 = "56d221c2e8ec37b43f5b63bca1393706b9b388d272371f67e482a9ce17a74b04";
       libraryHaskellDepends = [
         abstract-deque abstract-par base bytestring containers deepseq mtl
         mwc-random transformers vector
       ];
       homepage = "https://github.com/simonmar/monad-par";
       description = "Provides the monad-par interface, but based on modular scheduler \"mix-ins\"";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "meta-par-accelerate" = callPackage
    ({ mkDerivation, abstract-deque, abstract-par
     , abstract-par-accelerate, accelerate, array, base, meta-par
     , QuickCheck, transformers, vector
     }:
     mkDerivation {
       pname = "meta-par-accelerate";
       version = "0.3.5";
       sha256 = "985310b7673b38433e3e0606a0e05a0005f3d2f8083d46e83ec9382c055c863e";
       libraryHaskellDepends = [
         abstract-deque abstract-par abstract-par-accelerate accelerate
         array base meta-par QuickCheck transformers vector
       ];
       homepage = "https://github.com/simonmar/monad-par";
       description = "Support for integrated Accelerate computations within Meta-par";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "metadata" = callPackage
    ({ mkDerivation, base, text, time }:
     mkDerivation {
       pname = "metadata";
       version = "0.4.2.0";
       sha256 = "1b33c343e12766fb329345a2f687c4348bb8fc36792adc88e41b0510e6ed456a";
       libraryHaskellDepends = [ base text time ];
       homepage = "https://github.com/cutsea110/metadata";
       description = "metadata library for semantic web";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "metamorphic" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "metamorphic";
       version = "0.1.2.3";
       sha256 = "e88092983adac6dbe36cdfea4c8db256dc7d9e83e02dd355230f51dda6e05f5d";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/technogeeky/metamorphic";
       description = "metamorphisms: ana . cata or understanding folds and unfolds";
       license = "unknown";
     }) {};

  "metaplug" = callPackage
    ({ mkDerivation, base, Cabal, filepath, ghc, haskell98 }:
     mkDerivation {
       pname = "metaplug";
       version = "0.1.1";
       sha256 = "96c8487a51065561292cb11e7707df0faa6132a8d43f19469c588ae8f14cd620";
       libraryHaskellDepends = [ base Cabal filepath ghc haskell98 ];
       description = "a tiny ghc api wrapper";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "metric" = callPackage
    ({ mkDerivation, base, data-default, edit-distance, hmatrix
     , QuickCheck, test-framework, test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "metric";
       version = "0.2.0";
       sha256 = "4d1492d729878fe568384269ddc5d6b548474384f04aa1e6f6d8978baccb4d9c";
       libraryHaskellDepends = [
         base data-default edit-distance hmatrix vector
       ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2 vector
       ];
       description = "Metric spaces";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "metrics" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
     , lens, mtl, mwc-random, primitive, QuickCheck, text, time, unix
     , unordered-containers, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "metrics";
       version = "0.3.0.2";
       sha256 = "0df2801b630fcfe5c4a1968ccc1571016fb4c9408dfc881c599ba6f872543c02";
       libraryHaskellDepends = [
         ansi-terminal base bytestring containers lens mtl mwc-random
         primitive text time unix unordered-containers vector
         vector-algorithms
       ];
       testHaskellDepends = [
         async base lens mwc-random primitive QuickCheck unix
       ];
       doHaddock = false;
       description = "High-performance application metric tracking";
       license = stdenv.lib.licenses.mit;
     }) {};

  "metricsd-client" = callPackage
    ({ mkDerivation, base, network }:
     mkDerivation {
       pname = "metricsd-client";
       version = "0.1";
       sha256 = "09171debb866a05de5e4a9a928af37547121010446ca534401060759373f00e1";
       libraryHaskellDepends = [ base network ];
       jailbreak = true;
       description = "Client for the metrics aggregator Metricsd";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "metronome" = callPackage
    ({ mkDerivation, base, data-lens, data-lens-template, hosc, stm }:
     mkDerivation {
       pname = "metronome";
       version = "0.1";
       sha256 = "8ccb6dba705ab70f14f415adf022744346d8069033ec70e38635255e347aa03f";
       libraryHaskellDepends = [
         base data-lens data-lens-template hosc stm
       ];
       description = "Time Synchronized execution";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mezzolens" = callPackage
    ({ mkDerivation, base, containers, mtl, transformers }:
     mkDerivation {
       pname = "mezzolens";
       version = "0.0.0";
       sha256 = "8252be7d73700b7401c87248e6eb5cb23873d0ce092f9b15583c4fd59b46df2b";
       libraryHaskellDepends = [ base containers mtl transformers ];
       description = "Pure Profunctor Functional Lenses";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "mfsolve" = callPackage
    ({ mkDerivation, base, hashable, mtl, mtl-compat, tasty
     , tasty-hunit, unordered-containers
     }:
     mkDerivation {
       pname = "mfsolve";
       version = "0.3.2.0";
       sha256 = "232167442f9c0f326b7514b362d4521b3937b716fd4155c65060d34430aa42f1";
       libraryHaskellDepends = [
         base hashable mtl mtl-compat unordered-containers
       ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       description = "Equation solver and calculator à la metafont";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mgeneric" = callPackage
    ({ mkDerivation, base, containers, lens, mtl, template-haskell }:
     mkDerivation {
       pname = "mgeneric";
       version = "0.0.0.2";
       sha256 = "831bd77866d50d692518f09e15fc96c71b2aa3ec95ee4d7eda1650edb57ef5dd";
       libraryHaskellDepends = [
         base containers lens mtl template-haskell
       ];
       homepage = "http://github.com/RafaelBocquet/haskell-mgeneric/";
       description = "Generics with multiple parameters";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mi" = callPackage
    ({ mkDerivation, base, haskell-src-meta, parsec, split
     , template-haskell
     }:
     mkDerivation {
       pname = "mi";
       version = "0.0.1";
       sha256 = "4bc4f1c226067e380bf308dcc213ce41ef1cbc03e611dcc118bef703cecb710f";
       libraryHaskellDepends = [
         base haskell-src-meta parsec split template-haskell
       ];
       jailbreak = true;
       homepage = "https://github.com/matt76k/mi";
       description = "Multiple Instance for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "microbench" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "microbench";
       version = "0.1";
       sha256 = "6fee3c592c9afb72bd7b5574872119464055b717491c612ffee7f57c8e85d717";
       libraryHaskellDepends = [ base time ];
       homepage = "http://neugierig.org/software/darcs/browse/?r=microbench;a=summary";
       description = "Microbenchmark Haskell code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "microformats2-parser" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, aeson-qq, attoparsec, base
     , blaze-html, blaze-markup, bytestring, containers, data-default
     , either, errors, hspec, hspec-expectations-pretty-diff
     , html-conduit, lens-aeson, mtl, network, network-uri, options
     , pcre-heavy, raw-strings-qq, safe, scotty, streaming-commons
     , stringable, template-haskell, text, time, transformers
     , unordered-containers, vector, wai-extra, warp, xml-lens
     , xss-sanitize
     }:
     mkDerivation {
       pname = "microformats2-parser";
       version = "1.0.1.3";
       sha256 = "68f0da066f3c891ab15a4336eede0558f5f43dd74a70f178886e517a1fdd604f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-qq attoparsec base blaze-markup bytestring containers
         data-default either errors html-conduit lens-aeson network-uri
         pcre-heavy safe text time transformers unordered-containers vector
         xml-lens xss-sanitize
       ];
       executableHaskellDepends = [
         aeson aeson-pretty base blaze-html blaze-markup data-default
         network network-uri options scotty streaming-commons stringable
         text wai-extra warp
       ];
       testHaskellDepends = [
         aeson-qq base bytestring data-default hspec
         hspec-expectations-pretty-diff html-conduit mtl network-uri
         raw-strings-qq template-haskell text time xml-lens
       ];
       homepage = "https://github.com/myfreeweb/microformats2-parser";
       description = "A Microformats 2 parser";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "microformats2-types" = callPackage
    ({ mkDerivation, aeson, base, data-default-class, pandoc-types
     , setters, text, time
     }:
     mkDerivation {
       pname = "microformats2-types";
       version = "0.4.1";
       sha256 = "eb6ceacf393b5887455bfae0c39493dddbf26f081d70ce81630bdb85ce135adc";
       libraryHaskellDepends = [
         aeson base data-default-class pandoc-types setters text time
       ];
       homepage = "https://github.com/myfreeweb/microformats2-types";
       description = "Microformats 2 types (with Aeson instances)";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "microlens_0_2_0_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "microlens";
       version = "0.2.0.0";
       sha256 = "6f7585848d6ec9e1163672141d00c3eb108efe80a241330307c9e0af34c3a022";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/aelve/microlens";
       description = "A tiny part of the lens library which you can depend upon";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens_0_3_5_1" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "microlens";
       version = "0.3.5.1";
       sha256 = "dcdda73757640dc9b72da6730269debfb318794a94dd9bd6ecfa0ab89107aaa0";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/aelve/microlens";
       description = "A tiny part of the lens library with no dependencies";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens_0_4_1_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "microlens";
       version = "0.4.1.0";
       sha256 = "bce08742930f858a6fc4d122ecc7849c3087c7bdacdcdb0cb2638493fe605905";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/aelve/microlens";
       description = "A tiny part of the lens library with no dependencies";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "microlens";
       version = "0.4.2.0";
       sha256 = "db38765f93e58074475ed50b1e8e941d1fe3396566fd69f809ae954b5d43640c";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/aelve/microlens";
       description = "A tiny part of the lens library with no dependencies";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "microlens-aeson_2_1_0" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, directory
     , doctest, filepath, generic-deriving, microlens, scientific
     , semigroups, simple-reflect, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "microlens-aeson";
       version = "2.1.0";
       sha256 = "e0a5471df7e70aa6b79ce29830be8beeae10ce137ee8a358d4928285aff4b561";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring microlens scientific text
         unordered-containers vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       homepage = "http://github.com/fosskers/microlens-aeson/";
       description = "Law-abiding lenses for Aeson, using microlens";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens-aeson" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, directory
     , doctest, filepath, generic-deriving, microlens, scientific
     , semigroups, simple-reflect, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "microlens-aeson";
       version = "2.1.1";
       sha256 = "5b43bcdc52d4b86b8c74040f754209efa95f5983d5d114d2af6709949614acda";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring microlens scientific text
         unordered-containers vector
       ];
       testHaskellDepends = [
         base directory doctest filepath generic-deriving semigroups
         simple-reflect
       ];
       homepage = "http://github.com/fosskers/microlens-aeson/";
       description = "Law-abiding lenses for Aeson, using microlens";
       license = stdenv.lib.licenses.mit;
     }) {};

  "microlens-contra" = callPackage
    ({ mkDerivation, base, contravariant, microlens }:
     mkDerivation {
       pname = "microlens-contra";
       version = "0.1.0.0";
       sha256 = "27d58e82c94efa174507d30b3cd98cbb30591eed8f37fb772ba6915e66fd2567";
       libraryHaskellDepends = [ base contravariant microlens ];
       homepage = "http://github.com/aelve/microlens";
       description = "True folds and getters for microlens";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens-each" = callPackage
    ({ mkDerivation, base, microlens }:
     mkDerivation {
       pname = "microlens-each";
       version = "0.1.0.0";
       sha256 = "b27354ca9d7fb054db493c0aa39cd616607709e2e2156b98900a411ef3167301";
       libraryHaskellDepends = [ base microlens ];
       jailbreak = true;
       homepage = "http://github.com/aelve/microlens";
       description = "'each' for microlens";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "microlens-ghc_0_1_0_1" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, microlens }:
     mkDerivation {
       pname = "microlens-ghc";
       version = "0.1.0.1";
       sha256 = "a53c082be481560e349e644ad95944a6e5e2818a85529b549022c36e9b81739e";
       libraryHaskellDepends = [
         array base bytestring containers microlens
       ];
       jailbreak = true;
       homepage = "http://github.com/aelve/microlens";
       description = "Orphan instances of microlens classes for packages coming with GHC (array, bytestring, containers)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens-ghc_0_3_1_0" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, microlens }:
     mkDerivation {
       pname = "microlens-ghc";
       version = "0.3.1.0";
       sha256 = "cf9e78ca5abb459d4402a279c80ef07198d56ee4b0d51d7792dc0840e7217ef9";
       libraryHaskellDepends = [
         array base bytestring containers microlens
       ];
       jailbreak = true;
       homepage = "http://github.com/aelve/microlens";
       description = "microlens + all features depending on packages coming with GHC (array, bytestring, containers)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens-ghc_0_4_1_0" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, microlens
     , transformers
     }:
     mkDerivation {
       pname = "microlens-ghc";
       version = "0.4.1.0";
       sha256 = "e461fd96383d0edb198fb7e2ca650fbfd089e4601a1a19537a44918a455aea7d";
       libraryHaskellDepends = [
         array base bytestring containers microlens transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/aelve/microlens";
       description = "microlens + array, bytestring, containers, transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens-ghc" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, microlens
     , transformers
     }:
     mkDerivation {
       pname = "microlens-ghc";
       version = "0.4.2.0";
       sha256 = "65c98674708c55de5a0b9c0913b903f906e4313184b798652817a4205f25b35e";
       libraryHaskellDepends = [
         array base bytestring containers microlens transformers
       ];
       homepage = "http://github.com/aelve/microlens";
       description = "microlens + array, bytestring, containers, transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "microlens-mtl_0_1_3_1" = callPackage
    ({ mkDerivation, base, microlens, mtl, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "microlens-mtl";
       version = "0.1.3.1";
       sha256 = "ecef24ec6aa0d4817977d41139fe44df2ec2f8fa33c212d0a36219166ca91e85";
       libraryHaskellDepends = [
         base microlens mtl transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://github.com/aelve/microlens";
       description = "microlens support for Reader/Writer/State from mtl";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens-mtl_0_1_4_0" = callPackage
    ({ mkDerivation, base, microlens, mtl, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "microlens-mtl";
       version = "0.1.4.0";
       sha256 = "99fb9facb90cece06a5b4d1e108b9b4a917bbf6832383d0d08eadc76684173b9";
       libraryHaskellDepends = [
         base microlens mtl transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://github.com/aelve/microlens";
       description = "microlens support for Reader/Writer/State from mtl";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens-mtl_0_1_6_0" = callPackage
    ({ mkDerivation, base, microlens, mtl, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "microlens-mtl";
       version = "0.1.6.0";
       sha256 = "8594cf0eb10ad1a247c87f16b1afd860e55d91dca999bd3fcfb4b4af062b8362";
       libraryHaskellDepends = [
         base microlens mtl transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://github.com/aelve/microlens";
       description = "microlens support for Reader/Writer/State from mtl";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens-mtl" = callPackage
    ({ mkDerivation, base, microlens, mtl, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "microlens-mtl";
       version = "0.1.7.0";
       sha256 = "521f641ad6f051b13cbb0ee7c418bcba8169f6714a270c28a08fbe1ef75ae34f";
       libraryHaskellDepends = [
         base microlens mtl transformers transformers-compat
       ];
       homepage = "http://github.com/aelve/microlens";
       description = "microlens support for Reader/Writer/State from mtl";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "microlens-platform_0_1_7_0" = callPackage
    ({ mkDerivation, base, hashable, microlens, microlens-ghc
     , microlens-mtl, microlens-th, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "microlens-platform";
       version = "0.1.7.0";
       sha256 = "db74b98d8a8a0486c9f93e48ca7d9252b8f806a9bbbe9737457eeb91bb9555cd";
       libraryHaskellDepends = [
         base hashable microlens microlens-ghc microlens-mtl microlens-th
         text unordered-containers vector
       ];
       jailbreak = true;
       homepage = "http://github.com/aelve/microlens";
       description = "Feature-complete microlens";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens-platform_0_2_2_0" = callPackage
    ({ mkDerivation, base, hashable, microlens, microlens-ghc
     , microlens-mtl, microlens-th, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "microlens-platform";
       version = "0.2.2.0";
       sha256 = "35fcf4295733a3ca800dd1bd012c0835fa7b4698e5917e72e0cfbaa86f5b6ea9";
       libraryHaskellDepends = [
         base hashable microlens microlens-ghc microlens-mtl microlens-th
         text unordered-containers vector
       ];
       jailbreak = true;
       homepage = "http://github.com/aelve/microlens";
       description = "Feature-complete microlens";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens-platform" = callPackage
    ({ mkDerivation, base, hashable, microlens, microlens-ghc
     , microlens-mtl, microlens-th, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "microlens-platform";
       version = "0.2.3.0";
       sha256 = "94ad65919ed029a46884a941ba854a836047d059aee6372f6f3915b0d2c86799";
       libraryHaskellDepends = [
         base hashable microlens microlens-ghc microlens-mtl microlens-th
         text unordered-containers vector
       ];
       homepage = "http://github.com/aelve/microlens";
       description = "Feature-complete microlens";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "microlens-th_0_2_1_0" = callPackage
    ({ mkDerivation, base, containers, microlens, template-haskell }:
     mkDerivation {
       pname = "microlens-th";
       version = "0.2.1.0";
       sha256 = "74f397a2aba294e965963deca940e660bce2bfa57291d2e8be06a28ff0ec90d0";
       libraryHaskellDepends = [
         base containers microlens template-haskell
       ];
       jailbreak = true;
       homepage = "http://github.com/aelve/microlens";
       description = "Automatic generation of record lenses for microlens";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens-th_0_2_1_1" = callPackage
    ({ mkDerivation, base, containers, microlens, template-haskell }:
     mkDerivation {
       pname = "microlens-th";
       version = "0.2.1.1";
       sha256 = "e38ef1cc80a44aadb9e6ffbea6647eceb84971b05a00f64bdd3fde4e2a4a7277";
       libraryHaskellDepends = [
         base containers microlens template-haskell
       ];
       jailbreak = true;
       homepage = "http://github.com/aelve/microlens";
       description = "Automatic generation of record lenses for microlens";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens-th_0_2_2_0" = callPackage
    ({ mkDerivation, base, containers, microlens, template-haskell }:
     mkDerivation {
       pname = "microlens-th";
       version = "0.2.2.0";
       sha256 = "bf52318c0898294ab356ba75f72b880b9453cbc9df809b71aeac8081105596f9";
       revision = "1";
       editedCabalFile = "838249b8311e60d02769f4d6f106be52451179d3656842d43e11d866c46b2a8e";
       libraryHaskellDepends = [
         base containers microlens template-haskell
       ];
       jailbreak = true;
       homepage = "http://github.com/aelve/microlens";
       description = "Automatic generation of record lenses for microlens";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens-th_0_3_0_0" = callPackage
    ({ mkDerivation, base, containers, microlens, template-haskell }:
     mkDerivation {
       pname = "microlens-th";
       version = "0.3.0.0";
       sha256 = "951eaf33daf3b648082f754a6c091a8401bad39f5d5f659bad22252fe214d866";
       revision = "1";
       editedCabalFile = "9c75b584e225de81b1114a1bf81fad5f7b7c44d5d9271b09235b24ed6d17d02b";
       libraryHaskellDepends = [
         base containers microlens template-haskell
       ];
       homepage = "http://github.com/aelve/microlens";
       description = "Automatic generation of record lenses for microlens";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "microlens-th" = callPackage
    ({ mkDerivation, base, containers, microlens, template-haskell }:
     mkDerivation {
       pname = "microlens-th";
       version = "0.3.0.1";
       sha256 = "05576f60d3cafc2f4554164330e864d965f2de8912cd29c802c2c11d719eba52";
       libraryHaskellDepends = [
         base containers microlens template-haskell
       ];
       homepage = "http://github.com/aelve/microlens";
       description = "Automatic generation of record lenses for microlens";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "microtimer" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "microtimer";
       version = "0.0.1.2";
       sha256 = "574d1063abb7ae8b1c17ac364537825eed3ac6feb94125aefe033bf48c958827";
       libraryHaskellDepends = [ base time ];
       homepage = "http://thoughtpolice.github.com/hs-microtimer";
       description = "A tiny library for benchmarking IO actions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mida" = callPackage
    ({ mkDerivation, aeson, base, containers, data-default, exceptions
     , filepath, formatting, haskeline, HCodecs, megaparsec, mtl
     , optparse-applicative, path, path-io, process, QuickCheck, random
     , test-framework, test-framework-quickcheck2, text, tf-random
     , transformers, yaml
     }:
     mkDerivation {
       pname = "mida";
       version = "1.0.0";
       sha256 = "3fff0b1ce7fcbe948b7ec3f20868cdd7f8737c7eec1355355e0a13bb2fb340e4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers exceptions haskeline HCodecs megaparsec mtl random
         text tf-random transformers
       ];
       executableHaskellDepends = [
         aeson base containers data-default exceptions filepath formatting
         haskeline HCodecs megaparsec mtl optparse-applicative path path-io
         process random text tf-random transformers yaml
       ];
       testHaskellDepends = [
         base containers HCodecs megaparsec mtl QuickCheck random
         test-framework test-framework-quickcheck2 text tf-random
         transformers
       ];
       homepage = "https://github.com/mrkkrp/mida";
       description = "Language for algorithmic generation of MIDI files";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "midi" = callPackage
    ({ mkDerivation, base, binary, bytestring, event-list
     , explicit-exception, monoid-transformer, non-negative, QuickCheck
     , random, transformers, utility-ht
     }:
     mkDerivation {
       pname = "midi";
       version = "0.2.2";
       sha256 = "e0f32499afddb6f0e790a8cabecd53e6cefdf87a64a789ad1d15a2d862a0fb6d";
       libraryHaskellDepends = [
         base binary bytestring event-list explicit-exception
         monoid-transformer non-negative QuickCheck random transformers
         utility-ht
       ];
       testHaskellDepends = [
         base bytestring event-list explicit-exception non-negative
         QuickCheck transformers utility-ht
       ];
       homepage = "http://www.haskell.org/haskellwiki/MIDI";
       description = "Handling of MIDI messages and files";
       license = "GPL";
     }) {};

  "midi-alsa" = callPackage
    ({ mkDerivation, alsa-seq, base, data-accessor, midi, utility-ht }:
     mkDerivation {
       pname = "midi-alsa";
       version = "0.2.1";
       sha256 = "ecbe392b796041c42c9e63950ffbe0186c6603bde7fe1d28cd5614d15212ac8d";
       libraryHaskellDepends = [
         alsa-seq base data-accessor midi utility-ht
       ];
       homepage = "http://www.haskell.org/haskellwiki/MIDI";
       description = "Convert between datatypes of the midi and the alsa packages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "midi-music-box" = callPackage
    ({ mkDerivation, base, containers, diagrams-lib
     , diagrams-postscript, event-list, midi, non-empty
     , optparse-applicative, utility-ht
     }:
     mkDerivation {
       pname = "midi-music-box";
       version = "0.0";
       sha256 = "ae5ae1f9db61d56ee17035a04e8d1d9a8c68f4bfdb213f619e159d619fb4d442";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers diagrams-lib diagrams-postscript event-list midi
         non-empty optparse-applicative utility-ht
       ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/thielema/midi-music-box";
       description = "Convert MIDI file to music box punch tape";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "midi-util" = callPackage
    ({ mkDerivation, base, containers, event-list, midi, non-negative
     }:
     mkDerivation {
       pname = "midi-util";
       version = "0.1.1.1";
       sha256 = "d3c93d2112b5fbbff2fc2da10e18372f9f6d57a87166d313891e6663438719bd";
       revision = "1";
       editedCabalFile = "2c42b8e0940125f6354a9174ad5cb19da6fc0122b4947576e28abb753a7cff14";
       libraryHaskellDepends = [
         base containers event-list midi non-negative
       ];
       homepage = "http://github.com/mtolly/midi-util";
       description = "Utility functions for processing MIDI files";
       license = "GPL";
     }) {};

  "midimory" = callPackage
    ({ mkDerivation, alsa-core, alsa-seq, base, containers, random
     , transformers, wx, wxcore
     }:
     mkDerivation {
       pname = "midimory";
       version = "0.0.0.2";
       sha256 = "dfb750af588a19e8b64bf53919c9655b33b16c29fb08826bbd7a2f6fb4586e8d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         alsa-core alsa-seq base containers random transformers wx wxcore
       ];
       jailbreak = true;
       homepage = "http://www.youtube.com/watch?v=cOlR73h2uII";
       description = "A Memory-like (Concentration, Pairs, ...) game for tones";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "midisurface" = callPackage
    ({ mkDerivation, alsa-core, alsa-seq, base, containers, gtk, mtl
     , stm
     }:
     mkDerivation {
       pname = "midisurface";
       version = "0.1.0.0";
       sha256 = "df05b1fd6e12af0ad1171eff19d457a6b2527f8ae03e3773b652ca90310c2f44";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         alsa-core alsa-seq base containers gtk mtl stm
       ];
       jailbreak = true;
       description = "A control midi surface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mighttpd" = callPackage
    ({ mkDerivation, base, bytestring, c10k, directory, filepath
     , haskell98, hdaemonize, hslogger, network, parsec, time, unix
     , webserver
     }:
     mkDerivation {
       pname = "mighttpd";
       version = "0.4.3";
       sha256 = "ce83085798ceed0415f335acb2c9820727614baee33afca2f81af5520ee98676";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring c10k directory filepath haskell98 hdaemonize
         hslogger network parsec time unix webserver
       ];
       homepage = "http://www.mew.org/~kazu/proj/mighttpd/";
       description = "Simple Web Server in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mighttpd2" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , byteorder, bytestring, case-insensitive, conduit, conduit-extra
     , directory, filepath, hspec, http-client, http-date, http-types
     , io-choice, network, old-locale, parsec, resourcet
     , streaming-commons, time, transformers, unix, unix-time
     , unordered-containers, wai, wai-app-file-cgi, wai-logger, warp
     }:
     mkDerivation {
       pname = "mighttpd2";
       version = "3.3.0";
       sha256 = "cc39bcd4a08a4ea71c9bfb11f5ab70a7aee91e927885cc88f7e71104fdc71966";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array async auto-update base blaze-builder byteorder bytestring
         case-insensitive conduit conduit-extra directory filepath http-date
         http-types io-choice network parsec resourcet streaming-commons
         unix unix-time unordered-containers wai wai-app-file-cgi warp
       ];
       executableHaskellDepends = [
         base bytestring conduit-extra directory filepath http-client
         http-date http-types network old-locale streaming-commons time
         transformers unix wai wai-app-file-cgi wai-logger warp
       ];
       testHaskellDepends = [ base hspec http-client ];
       homepage = "http://www.mew.org/~kazu/proj/mighttpd/";
       description = "High performance web server on WAI/warp";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mighty-metropolis" = callPackage
    ({ mkDerivation, base, containers, mcmc-types, mwc-probability
     , pipes, primitive, transformers
     }:
     mkDerivation {
       pname = "mighty-metropolis";
       version = "1.0.2";
       sha256 = "639c560cdb6d4f1d793cf9baf02dca60ca290a6d1831e463f6c92458bd83c0f2";
       libraryHaskellDepends = [
         base mcmc-types mwc-probability pipes primitive transformers
       ];
       testHaskellDepends = [ base containers mwc-probability ];
       homepage = "http://github.com/jtobin/mighty-metropolis";
       description = "The Metropolis algorithm";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mikmod" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "mikmod";
       version = "0.2.0.1";
       sha256 = "b7d2b0aa2288f5874aad326043676f667bc61e930d0a5e9c5a90243807e023ed";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "https://github.com/evanrinehart/mikmod";
       description = "MikMod bindings";
       license = "LGPL";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "miku" = callPackage
    ({ mkDerivation, air, air-th, base, bytestring, containers
     , data-default, hack2, hack2-contrib, mtl
     }:
     mkDerivation {
       pname = "miku";
       version = "2014.11.17";
       sha256 = "76682bc6d3db2fb07e9a749a40a752917afc2787bdf3dc1849b7b102f689dbfd";
       libraryHaskellDepends = [
         air air-th base bytestring containers data-default hack2
         hack2-contrib mtl
       ];
       homepage = "https://github.com/nfjinjing/miku";
       description = "A minimum web dev DSL in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "milena" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, digest, lens
     , lifted-base, mtl, murmur-hash, network, QuickCheck, random
     , resource-pool, semigroups, tasty, tasty-hspec, tasty-quickcheck
     , transformers
     }:
     mkDerivation {
       pname = "milena";
       version = "0.5.0.0";
       sha256 = "fbae487cc6e61fa6cde0ba79b4d0df28c75e1af9c0d75970b7685a7beb18b63a";
       libraryHaskellDepends = [
         base bytestring cereal containers digest lens lifted-base mtl
         murmur-hash network random resource-pool semigroups transformers
       ];
       testHaskellDepends = [
         base bytestring lens mtl network QuickCheck semigroups tasty
         tasty-hspec tasty-quickcheck
       ];
       jailbreak = true;
       description = "A Kafka client for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mime" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "mime";
       version = "0.4.0.2";
       sha256 = "e7fa283e5caa6371d5b3978e152412a2dd2489eec43aee722caca9dc14ea3875";
       libraryHaskellDepends = [ base text ];
       homepage = "https://github.com/GaloisInc/mime";
       description = "Working with MIME types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mime-directory" = callPackage
    ({ mkDerivation, base, base64-string, bytestring, containers
     , old-locale, regex-pcre, time
     }:
     mkDerivation {
       pname = "mime-directory";
       version = "0.5.2";
       sha256 = "a3f337e2bcd3cbb27f92cea6b9fa65cd6c79832367d3e3bcd45989b53930077a";
       libraryHaskellDepends = [
         base base64-string bytestring containers old-locale regex-pcre time
       ];
       homepage = "http://github.com/mboes/mime-directory";
       description = "A library for parsing/printing the text/directory mime type";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mime-mail_0_4_6" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring
     , filepath, hspec, process, random, text
     }:
     mkDerivation {
       pname = "mime-mail";
       version = "0.4.6";
       sha256 = "862b54c2653506ca2fc8e3501d323237613be82d6761035a3699bcebffc53514";
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder bytestring filepath process
         random text
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec text ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/mime-mail";
       description = "Compose MIME email messages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mime-mail_0_4_6_2" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring
     , filepath, hspec, process, random, text
     }:
     mkDerivation {
       pname = "mime-mail";
       version = "0.4.6.2";
       sha256 = "cbed597142ae0e7dec7eb568af13e3c1c1271262a255af1dd710ff6c1aa2ba9e";
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder bytestring filepath process
         random text
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec text ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/mime-mail";
       description = "Compose MIME email messages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mime-mail_0_4_7" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring
     , filepath, hspec, process, random, text
     }:
     mkDerivation {
       pname = "mime-mail";
       version = "0.4.7";
       sha256 = "a4b3737a1c87ab6d49dd63a0c7edcfbd9d66b957b944e19f0aa439d6adaa76d1";
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder bytestring filepath process
         random text
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec text ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/mime-mail";
       description = "Compose MIME email messages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mime-mail_0_4_8_1" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring
     , filepath, hspec, process, random, text
     }:
     mkDerivation {
       pname = "mime-mail";
       version = "0.4.8.1";
       sha256 = "05aeb67961581180c78fd4b684fe1ee92e3b346a538a0feb5a3bf7b2dbd1aa05";
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder bytestring filepath process
         random text
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec text ];
       homepage = "http://github.com/snoyberg/mime-mail";
       description = "Compose MIME email messages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mime-mail_0_4_8_2" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring
     , filepath, hspec, process, random, text
     }:
     mkDerivation {
       pname = "mime-mail";
       version = "0.4.8.2";
       sha256 = "2a6e5bc9a5e5202508973f38e80fd0f23dafdda0bb7b1ffc613a85853ac1c2a5";
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder bytestring filepath process
         random text
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec text ];
       homepage = "http://github.com/snoyberg/mime-mail";
       description = "Compose MIME email messages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mime-mail_0_4_9" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring
     , filepath, hspec, process, random, text
     }:
     mkDerivation {
       pname = "mime-mail";
       version = "0.4.9";
       sha256 = "641420aa8b1d2c7f8ebf82fdb0e6000443ffba89a420f4ea11828474b244c3d0";
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder bytestring filepath process
         random text
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec text ];
       homepage = "http://github.com/snoyberg/mime-mail";
       description = "Compose MIME email messages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mime-mail_0_4_10" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring
     , filepath, hspec, process, random, text
     }:
     mkDerivation {
       pname = "mime-mail";
       version = "0.4.10";
       sha256 = "4930f9c6a906e73452a891d93b1cf545b64613ccb079fe625fa4c98c01b25677";
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder bytestring filepath process
         random text
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec text ];
       homepage = "http://github.com/snoyberg/mime-mail";
       description = "Compose MIME email messages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mime-mail" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring
     , filepath, hspec, process, random, text
     }:
     mkDerivation {
       pname = "mime-mail";
       version = "0.4.11";
       sha256 = "84fa24f83206cb88377128395c2d6db2d08bbe9b568ba6ab8eeb76952abedfee";
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder bytestring filepath process
         random text
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec text ];
       homepage = "http://github.com/snoyberg/mime-mail";
       description = "Compose MIME email messages";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mime-mail-ses_0_3_2" = callPackage
    ({ mkDerivation, base, base64-bytestring, byteable, bytestring
     , conduit, cryptohash, http-client, http-conduit, http-types
     , mime-mail, old-locale, text, time, transformers, xml-conduit
     , xml-types
     }:
     mkDerivation {
       pname = "mime-mail-ses";
       version = "0.3.2";
       sha256 = "bf5183e722bd0fd63fa2dc78b1483248e790985045ad570ed7a04c45b9ab4da6";
       libraryHaskellDepends = [
         base base64-bytestring byteable bytestring conduit cryptohash
         http-client http-conduit http-types mime-mail old-locale text time
         transformers xml-conduit xml-types
       ];
       homepage = "http://github.com/snoyberg/mime-mail";
       description = "Send mime-mail messages via Amazon SES";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mime-mail-ses_0_3_2_1" = callPackage
    ({ mkDerivation, base, base64-bytestring, byteable, bytestring
     , conduit, cryptohash, http-client, http-conduit, http-types
     , mime-mail, old-locale, text, time, transformers, xml-conduit
     , xml-types
     }:
     mkDerivation {
       pname = "mime-mail-ses";
       version = "0.3.2.1";
       sha256 = "77900d797d7b5d37432b186adaf37feba4a31f7c522339a26e66119ce2b066b4";
       libraryHaskellDepends = [
         base base64-bytestring byteable bytestring conduit cryptohash
         http-client http-conduit http-types mime-mail old-locale text time
         transformers xml-conduit xml-types
       ];
       homepage = "http://github.com/snoyberg/mime-mail";
       description = "Send mime-mail messages via Amazon SES";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mime-mail-ses" = callPackage
    ({ mkDerivation, base, base64-bytestring, byteable, bytestring
     , conduit, cryptohash, http-client, http-conduit, http-types
     , mime-mail, old-locale, text, time, transformers, xml-conduit
     , xml-types
     }:
     mkDerivation {
       pname = "mime-mail-ses";
       version = "0.3.2.2";
       sha256 = "c10bbf88ca04119c060f74b7bc1f139ba23bbf122596fbf8c46d0d8e6f76f4b7";
       libraryHaskellDepends = [
         base base64-bytestring byteable bytestring conduit cryptohash
         http-client http-conduit http-types mime-mail old-locale text time
         transformers xml-conduit xml-types
       ];
       homepage = "http://github.com/snoyberg/mime-mail";
       description = "Send mime-mail messages via Amazon SES";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mime-string" = callPackage
    ({ mkDerivation, base, base64-string, bytestring, iconv, mtl
     , network, old-time
     }:
     mkDerivation {
       pname = "mime-string";
       version = "0.4";
       sha256 = "c1e4a17e7e0171ec7d0c75efcdc4dab69d47bff2b524a5da4721518a1f43026c";
       libraryHaskellDepends = [
         base base64-string bytestring iconv mtl network old-time
       ];
       description = "MIME implementation for String's";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mime-types_0_1_0_4" = callPackage
    ({ mkDerivation, base, bytestring, containers, text }:
     mkDerivation {
       pname = "mime-types";
       version = "0.1.0.4";
       sha256 = "5dc87de5461d217f003259fe5b3260179449ea2fecaeab6779b09e8b3e9fb02f";
       libraryHaskellDepends = [ base bytestring containers text ];
       homepage = "https://github.com/yesodweb/wai";
       description = "Basic mime-type handling types and functions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mime-types_0_1_0_5" = callPackage
    ({ mkDerivation, base, bytestring, containers, text }:
     mkDerivation {
       pname = "mime-types";
       version = "0.1.0.5";
       sha256 = "215ff0e67c81b4b23175c4bae897b254fcc3c6ffa11e06fe863dba1f41865211";
       libraryHaskellDepends = [ base bytestring containers text ];
       homepage = "https://github.com/yesodweb/wai";
       description = "Basic mime-type handling types and functions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mime-types" = callPackage
    ({ mkDerivation, base, bytestring, containers, text }:
     mkDerivation {
       pname = "mime-types";
       version = "0.1.0.6";
       sha256 = "fc8a933f75970dc90d4623f834f35d028a994178481b66ab1a4420916e1b1f24";
       libraryHaskellDepends = [ base bytestring containers text ];
       homepage = "https://github.com/yesodweb/wai";
       description = "Basic mime-type handling types and functions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mines" = callPackage
    ({ mkDerivation, base, directory, mtl, random }:
     mkDerivation {
       pname = "mines";
       version = "0.1";
       sha256 = "1369e26dd2e931ead084071909611f18710477b44bd8b0f11294f9a93944499b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory mtl random ];
       homepage = "http://finder.homelinux.org/haskell/Mines";
       description = "Minesweeper simulation using neural networks";
       license = "unknown";
     }) {};

  "minesweeper" = callPackage
    ({ mkDerivation, base, binary, binary-generic, bytestring, cairo
     , containers, directory, filepath, glade, gtk, random, time
     }:
     mkDerivation {
       pname = "minesweeper";
       version = "0.9.2.1";
       sha256 = "423ff2a8f8ee0fe330e07cfd0732c463f01a7889e9afb509652d27cacd087cb1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary binary-generic bytestring cairo containers directory
         filepath glade gtk random time
       ];
       jailbreak = true;
       description = "Minesweeper game which is always solvable without guessing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "miniball" = callPackage
    ({ mkDerivation, base, vector }:
     mkDerivation {
       pname = "miniball";
       version = "0.1.0.2";
       sha256 = "e28438054d792fee36364320517f9adbaa62802dc23eb30f0411f7abddfacd99";
       libraryHaskellDepends = [ base vector ];
       homepage = "http://nonempty.org/software/haskell-miniball";
       description = "Bindings to Miniball, a smallest enclosing ball library";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "miniforth" = callPackage
    ({ mkDerivation, base, containers, lens, MonadRandom, mtl
     , mtl-compat, parsec, parsec3-numbers, readline
     }:
     mkDerivation {
       pname = "miniforth";
       version = "0.1.0.1";
       sha256 = "0fcc6fce2d3a5cedb738bae294c9b43426a2d1ea700a6c2476f11b795e675ab8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers lens MonadRandom mtl mtl-compat parsec
         parsec3-numbers
       ];
       executableHaskellDepends = [
         base containers lens mtl parsec readline
       ];
       jailbreak = true;
       description = "Miniature FORTH-like interpreter";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "minilens" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, mtl
     , semigroups, text, transformers
     }:
     mkDerivation {
       pname = "minilens";
       version = "1.0.0.1";
       sha256 = "581cd335de2ff83e384c7e250db208b884ac7c44163afacc731f855e2e8d06ce";
       libraryHaskellDepends = [
         array base bytestring containers mtl semigroups text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/RaminHAL9001/minilens";
       description = "A minimalistic lens library, providing only the simplest, most basic lens functionality";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "minimal-configuration" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, tconfig }:
     mkDerivation {
       pname = "minimal-configuration";
       version = "0.1.2";
       sha256 = "7debae44339df6a1c35e99be9807df430fac30d6c27b606f36fe23deed4d928e";
       libraryHaskellDepends = [
         base containers directory filepath tconfig
       ];
       description = "Minimal ini like configuration library with a few extras";
       license = "unknown";
     }) {};

  "minimorph" = callPackage
    ({ mkDerivation, base, HUnit, test-framework, test-framework-hunit
     , text
     }:
     mkDerivation {
       pname = "minimorph";
       version = "0.1.6.0";
       sha256 = "7faeea373e316aefc8bb8fcf7e3265263be94d8f985a7bb07ef67c7fe502ba9d";
       libraryHaskellDepends = [ base text ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit text
       ];
       homepage = "https://github.com/Mikolaj/minimorph";
       description = "English spelling functions with an emphasis on simplicity";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "minimung" = callPackage
    ({ mkDerivation, base, GLUT, haskell98, unix }:
     mkDerivation {
       pname = "minimung";
       version = "0.1";
       sha256 = "8ee2194658f1400c27c66806144d90b23f2a9348ec4d2a84744d8572da2a0245";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base GLUT haskell98 unix ];
       description = "Shows how to run grabber on Mac OS X";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "minions" = callPackage
    ({ mkDerivation, ansi-terminal, base, MissingH, process, time }:
     mkDerivation {
       pname = "minions";
       version = "0.2.0.0";
       sha256 = "74935247e64e2e93f3defb30ee26729a282333cdfdd5e0c58027d3a4ee01ece4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base MissingH process time
       ];
       jailbreak = true;
       homepage = "http://github.com/jhickner/minions";
       description = "A fast parallel ssh tool";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "minioperational" = callPackage
    ({ mkDerivation, base, containers, elevator, extensible, mtl
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "minioperational";
       version = "0.4.9";
       sha256 = "b524899037135247e114849df6d318e9942e58e3ea38e92741b1ff77df986e4d";
       libraryHaskellDepends = [
         base containers elevator extensible mtl template-haskell
         transformers
       ];
       homepage = "https://github.com/fumieval/minioperational";
       description = "fast and simple operational monad";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "miniplex" = callPackage
    ({ mkDerivation, base, colock, directory, mtl, network, stm, unix
     }:
     mkDerivation {
       pname = "miniplex";
       version = "0.3.4";
       sha256 = "e4317ac51ab9d31d44b7e692acb6c426c9fc3d2c6d5ee1c06208567e82793a97";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base colock directory mtl network stm unix
       ];
       jailbreak = true;
       description = "simple 1-to-N interprocess communication";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "minirotate" = callPackage
    ({ mkDerivation, base, data-accessor, data-accessor-template
     , directory, filepath, mtl, old-locale, old-time, process, safe
     , split, template-haskell
     }:
     mkDerivation {
       pname = "minirotate";
       version = "0.1.2.2";
       sha256 = "1e91d0ae5035c89a4751d5ce063f0b3159bdce4f059ca568acda7090c3530f96";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base data-accessor data-accessor-template directory filepath mtl
         old-locale old-time process safe split template-haskell
       ];
       jailbreak = true;
       homepage = "http://tener.github.com/haskell-minirotate/";
       description = "Minimalistic file rotation utility";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "minisat" = callPackage
    ({ mkDerivation, async, base }:
     mkDerivation {
       pname = "minisat";
       version = "0.1.2";
       sha256 = "ad9528401dad68e9e778961e629e76b7ae373f813cada74da8c4f1c544553221";
       libraryHaskellDepends = [ async base ];
       description = "A Haskell bundle of the Minisat SAT solver";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "ministg" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, monads-tf
     , parsec, pretty, transformers, xhtml
     }:
     mkDerivation {
       pname = "ministg";
       version = "0.3";
       sha256 = "b50ad03e32f9aae25df718dffbc1bbea4ddaa57b1c70f6a4071eaf0b4a86ad15";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath monads-tf parsec pretty
         transformers xhtml
       ];
       homepage = "http://www.haskell.org/haskellwiki/Ministg";
       description = "an interpreter for an operational semantics for the STG machine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "miniutter" = callPackage
    ({ mkDerivation, base, binary, containers, ghc-prim, HUnit
     , minimorph, test-framework, test-framework-hunit, text
     }:
     mkDerivation {
       pname = "miniutter";
       version = "0.4.4.2";
       sha256 = "3a08fc860e92aa22e83b07a0aa136530f60e675d24ef8e75009c676c2a4320db";
       libraryHaskellDepends = [
         base binary containers ghc-prim minimorph text
       ];
       testHaskellDepends = [
         base containers HUnit test-framework test-framework-hunit text
       ];
       homepage = "https://github.com/Mikolaj/miniutter";
       description = "Simple English clause creation from arbitrary words";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "minst-idx" = callPackage
    ({ mkDerivation, base, binary, bytestring, directory, hspec, vector
     }:
     mkDerivation {
       pname = "minst-idx";
       version = "0.1.2.2";
       sha256 = "3be63590a01f8504f372fe7565a318eef8d6de31e6e251bdac01965297793d1a";
       libraryHaskellDepends = [ base binary bytestring vector ];
       testHaskellDepends = [ base binary directory hspec vector ];
       jailbreak = true;
       homepage = "https://github.com/kryoxide/minst-idx/";
       description = "Read and write IDX data that is used in e.g. the MINST database.";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "mirror-tweet" = callPackage
    ({ mkDerivation, authenticate-oauth, base, bytestring, conduit
     , lens, monad-logger, text, transformers, twitter-conduit
     }:
     mkDerivation {
       pname = "mirror-tweet";
       version = "0.1.0.0";
       sha256 = "eac658afd7980b4c1c94d50aea97c6792454dea8c7af2cf29b67cd5e0c03bf1d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         authenticate-oauth base bytestring conduit lens monad-logger text
         transformers twitter-conduit
       ];
       jailbreak = true;
       homepage = "https://github.com/minamiyama1994/mirror-tweet";
       description = "Tweet mirror";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "misfortune" = callPackage
    ({ mkDerivation, base, bytestring, cereal, directory, filepath
     , knob, monad-loops, random-fu, regex-base, regex-pcre, semigroups
     , text, utf8-string, vector
     }:
     mkDerivation {
       pname = "misfortune";
       version = "0.1.1.2";
       sha256 = "ae4b44215f811e7af6af756c813b9bd6e4161be555f30dd817324f8d1ffe2349";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal directory filepath knob random-fu semigroups
         text utf8-string vector
       ];
       executableHaskellDepends = [ monad-loops regex-base regex-pcre ];
       homepage = "https://github.com/mokus0/misfortune";
       description = "fortune-mod clone";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "missing-foreign" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "missing-foreign";
       version = "0.1.1";
       sha256 = "9e1b36cdb8626d848386c1c4d54f3b9f80b3458398aa6a4d499266b5ecbcc885";
       libraryHaskellDepends = [ base ];
       description = "Convenience functions for FFI work";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "missing-py2" = callPackage
    ({ mkDerivation, anydbm, base, Cabal, directory, HUnit, MissingH }:
     mkDerivation {
       pname = "missing-py2";
       version = "1.0.1";
       sha256 = "b266a628cfdb903da0e05fde8a40df0f1c6df170b261e248068956a640184a35";
       libraryHaskellDepends = [ anydbm base MissingH ];
       testHaskellDepends = [
         anydbm base Cabal directory HUnit MissingH
       ];
       homepage = "https://github.com/domdere/missing-py2";
       description = "Haskell interface to Python";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mix-arrows" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "mix-arrows";
       version = "1.2";
       sha256 = "61242240e78294039ec855d9adb3c8aab11cdb26ffe6835a490be5ba12a0e054";
       libraryHaskellDepends = [ base ];
       description = "Mixing effects of one arrow into another one";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mixed-strategies" = callPackage
    ({ mkDerivation, array, base, containers, simple-tabular }:
     mkDerivation {
       pname = "mixed-strategies";
       version = "0.1.0.0";
       sha256 = "6ce6f0df567853bed9ba5b4b929be771084f5cf38b8acf1c4a722b21056e546f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base containers simple-tabular ];
       executableHaskellDepends = [
         array base containers simple-tabular
       ];
       jailbreak = true;
       homepage = "http://wiki.cs.pdx.edu/bartforge/oms";
       description = "Find optimal mixed strategies for two-player games";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mkbndl" = callPackage
    ({ mkDerivation, base, directory, filepath, haskell98 }:
     mkDerivation {
       pname = "mkbndl";
       version = "0.2.1";
       sha256 = "2dab465aafde67886a713f9a7163f66a226f54b014e2dc65c1bb742d92abeee3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath haskell98 ];
       description = "Makes an OS X .app bundle from a binary.";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mkcabal" = callPackage
    ({ mkDerivation, base, directory, extensible-exceptions, mtl
     , old-locale, old-time, pcre-light, pretty, readline
     }:
     mkDerivation {
       pname = "mkcabal";
       version = "1.0.0";
       sha256 = "cc67bbbad36aaa2a2c2cda6418077330c2a48d8dec18f7feee3d809848e5aab2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory extensible-exceptions mtl old-locale old-time
         pcre-light pretty readline
       ];
       homepage = "http://code.haskell.org/~dons/code/mkcabal";
       description = "Generate cabal files for a Haskell project";
       license = "GPL";
     }) {};

  "ml-w" = callPackage
    ({ mkDerivation, base, mtl, parsec, pretty }:
     mkDerivation {
       pname = "ml-w";
       version = "0.1.1";
       sha256 = "815ae613c0612c51570b0e7797490fdaa2ab0533320fed8c2f077ce5716ea011";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl parsec pretty ];
       executableHaskellDepends = [ base mtl parsec pretty ];
       description = "Minimal ML language to to demonstrate the W type infererence algorithm";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mlist" = callPackage
    ({ mkDerivation, base, haskell98 }:
     mkDerivation {
       pname = "mlist";
       version = "0.0.2";
       sha256 = "338cbb8509a0f9d070f461229aef9c7297c3cf9f22a82d5fe4019deba1aabc1a";
       libraryHaskellDepends = [ base haskell98 ];
       homepage = "http://haskell.org/haskellwiki/mlist";
       description = "Monadic List alternative to lazy I/O";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mmap" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "mmap";
       version = "0.5.9";
       sha256 = "58fcbb04e1cb8e7c36c05823b02dce2faaa989c53d745a7f36192de2fc98b5f8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring ];
       description = "Memory mapped files for POSIX and Windows";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mmorph_1_0_4" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "mmorph";
       version = "1.0.4";
       sha256 = "22e3665b4c86bf28cb4e836da91f586294d74d1cf1c18db364dcf568eba7bf4c";
       libraryHaskellDepends = [ base transformers ];
       description = "Monad morphisms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mmorph_1_0_5" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "mmorph";
       version = "1.0.5";
       sha256 = "6ae92f8c9e0aa767ecce520833ac46d3cf293931050650dc8896be16fb16da9d";
       libraryHaskellDepends = [ base transformers ];
       description = "Monad morphisms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mmorph" = callPackage
    ({ mkDerivation, base, mtl, transformers, transformers-compat }:
     mkDerivation {
       pname = "mmorph";
       version = "1.0.6";
       sha256 = "14c391b111af4cc10917a9340897ae2a5718f5b0b7e6bc13f379445c58fe0dc5";
       libraryHaskellDepends = [
         base mtl transformers transformers-compat
       ];
       description = "Monad morphisms";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mmtl" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "mmtl";
       version = "0.1";
       sha256 = "f4485b92193e90e10c0d8ca5d7448c078d4355e3724fed7913de142d0a4d612d";
       libraryHaskellDepends = [ base ];
       description = "Modular Monad transformer library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mmtl-base" = callPackage
    ({ mkDerivation, base, mmtl }:
     mkDerivation {
       pname = "mmtl-base";
       version = "15321.1";
       sha256 = "d806708dfbb000cbf520ace5cbf5f68114232030f40e2a981fbafdb46e570d8e";
       libraryHaskellDepends = [ base mmtl ];
       description = "MonadBase type-class for mmtl";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "moan" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, dawg
     , regex-tdfa, regex-tdfa-text, tagset-positional, text, zlib
     }:
     mkDerivation {
       pname = "moan";
       version = "0.2.0.2";
       sha256 = "60c444b8a192197cfe0c071c45d3f76cdfcf66eb47cb4e3aa76b2245f6f86039";
       libraryHaskellDepends = [
         base binary bytestring containers dawg regex-tdfa regex-tdfa-text
         tagset-positional text zlib
       ];
       jailbreak = true;
       homepage = "https://github.com/vjeranc/moan";
       description = "Language-agnostic analyzer for positional morphosyntactic tags";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mockery_0_3_0" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, hspec
     , logging-facade, temporary
     }:
     mkDerivation {
       pname = "mockery";
       version = "0.3.0";
       sha256 = "dd2885072c3c5971602e35b27493c436e8b82eae327b72b7452cd05655e33ecd";
       libraryHaskellDepends = [
         base bytestring directory filepath logging-facade temporary
       ];
       testHaskellDepends = [
         base bytestring directory filepath hspec logging-facade temporary
       ];
       description = "Support functions for automated testing";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mockery" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, hspec
     , logging-facade, temporary
     }:
     mkDerivation {
       pname = "mockery";
       version = "0.3.2";
       sha256 = "6f8577fc23392612d6c2f6405cc0b9335b58f2281285513ef5f3e961beb81454";
       libraryHaskellDepends = [
         base bytestring directory filepath logging-facade temporary
       ];
       testHaskellDepends = [
         base bytestring directory filepath hspec logging-facade temporary
       ];
       description = "Support functions for automated testing";
       license = stdenv.lib.licenses.mit;
     }) {};

  "modbus-tcp" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, bytestring, cereal
     , network
     }:
     mkDerivation {
       pname = "modbus-tcp";
       version = "0.1";
       sha256 = "996aa62fc7d5ac0112d128fc3209c4bf1c9a55bc0bd5c636f8cdefbc0d9b0fc8";
       libraryHaskellDepends = [
         base base-unicode-symbols bytestring cereal network
       ];
       jailbreak = true;
       homepage = "https://github.com/roelvandijk/modbus-tcp";
       description = "Communicate with Modbus devices over TCP";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "modelicaparser" = callPackage
    ({ mkDerivation, ansi-terminal, base, containers, filepath, parsec
     , QuickCheck
     }:
     mkDerivation {
       pname = "modelicaparser";
       version = "0.1.0.0";
       sha256 = "d461b3926381d73b8c1e59653c751b50b501a1309dcaabfbf9e68c11717bda45";
       libraryHaskellDepends = [ base containers parsec ];
       testHaskellDepends = [
         ansi-terminal base containers filepath parsec QuickCheck
       ];
       jailbreak = true;
       description = "A parser for the modelica language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "modify-fasta_0_8_0_4" = callPackage
    ({ mkDerivation, base, containers, fasta, mtl, optparse-applicative
     , pipes, pipes-text, regex-tdfa, regex-tdfa-text, split, text
     , text-show
     }:
     mkDerivation {
       pname = "modify-fasta";
       version = "0.8.0.4";
       sha256 = "bab0205c7075337179b098b9445735033ec7b3d3e9a36730a2a085798c2eb543";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers fasta regex-tdfa regex-tdfa-text split text
         text-show
       ];
       executableHaskellDepends = [
         base containers fasta mtl optparse-applicative pipes pipes-text
         split text
       ];
       homepage = "https://github.com/GregorySchwartz/modify-fasta";
       description = "Modify fasta (and CLIP) files in several optional ways";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "modify-fasta" = callPackage
    ({ mkDerivation, base, containers, fasta, mtl, optparse-applicative
     , pipes, pipes-text, regex-tdfa, regex-tdfa-text, split, text
     , text-show
     }:
     mkDerivation {
       pname = "modify-fasta";
       version = "0.8.1.3";
       sha256 = "362c99eb19428ed9d8f950ef5a8a377d4d9a4a8feaca229bf3aabb9ee0908585";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers fasta regex-tdfa regex-tdfa-text split text
         text-show
       ];
       executableHaskellDepends = [
         base containers fasta mtl optparse-applicative pipes pipes-text
         split text
       ];
       homepage = "https://github.com/GregorySchwartz/modify-fasta";
       description = "Modify fasta (and CLIP) files in several optional ways";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "modsplit" = callPackage
    ({ mkDerivation, base, directory, filepath, haskell98, mtl
     , utf8-string
     }:
     mkDerivation {
       pname = "modsplit";
       version = "0.2.1";
       sha256 = "b714c6c4f90586169a206bcee55afde5e189a813f531ad92f65c51868edca976";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory filepath haskell98 mtl utf8-string
       ];
       executableHaskellDepends = [
         base directory filepath haskell98 mtl utf8-string
       ];
       description = "Haskell source splitter driven by special comments";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "modular-arithmetic" = callPackage
    ({ mkDerivation, base, doctest, Glob }:
     mkDerivation {
       pname = "modular-arithmetic";
       version = "1.2.1.1";
       sha256 = "5b1592ef852596e8c4e1ac5e8f213ee0272a8e0bf6c3d431a86bbeaff35cb700";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base doctest Glob ];
       jailbreak = true;
       homepage = "https://github.com/TikhonJelvis/modular-arithmetic";
       description = "A type for integers modulo some constant";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "modular-prelude" = callPackage
    ({ mkDerivation, base, basic-prelude, bytestring, containers
     , data-default, hashable, system-filepath, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "modular-prelude";
       version = "0.3.0.0";
       sha256 = "6ee621088d17d175968878c0715237eac24534a892661b3e2ec559d753ed9542";
       libraryHaskellDepends = [
         base basic-prelude bytestring containers data-default hashable
         system-filepath text transformers unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/DanBurton/modular-prelude#readme";
       description = "A new Prelude featuring first class modules";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "modular-prelude-classy" = callPackage
    ({ mkDerivation, base, classy-prelude, modular-prelude }:
     mkDerivation {
       pname = "modular-prelude-classy";
       version = "0.1.0.0";
       sha256 = "dd76f45afabff8476079dbd0ce30ffac45c9897e123d1d4fa9daa8d45eb6f1c7";
       libraryHaskellDepends = [ base classy-prelude modular-prelude ];
       jailbreak = true;
       homepage = "https://github.com/DanBurton/modular-prelude#readme";
       description = "Reifying ClassyPrelude a la ModularPrelude";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "module-management" = callPackage
    ({ mkDerivation, applicative-extras, base, bytestring, Cabal
     , cmdargs, containers, data-default, directory, filepath, haskeline
     , haskell-src-exts, HUnit, lens, lifted-base, monad-control, mtl
     , pretty, process, pureMD5, regex-compat, set-extra, syb
     , system-fileio, template-haskell, temporary, transformers-base
     }:
     mkDerivation {
       pname = "module-management";
       version = "0.20.4";
       sha256 = "f85be205a423d8fb2251a432ec4492a4d11cfa41aaa7005a3e958108809fbba0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         applicative-extras base bytestring Cabal containers data-default
         directory filepath haskell-src-exts HUnit lifted-base monad-control
         mtl pretty process pureMD5 set-extra syb system-fileio temporary
       ];
       executableHaskellDepends = [
         base Cabal cmdargs containers directory haskeline haskell-src-exts
         lens monad-control mtl regex-compat set-extra template-haskell
         transformers-base
       ];
       testHaskellDepends = [
         base containers filepath haskell-src-exts HUnit process
       ];
       jailbreak = true;
       homepage = "https://github.com/seereason/module-management";
       description = "Clean up module imports, split and merge modules";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "modulespection" = callPackage
    ({ mkDerivation, base, exceptions, filepath, ghc, ghc-paths
     , template-haskell, temporary, transformers
     }:
     mkDerivation {
       pname = "modulespection";
       version = "0.1.2.2";
       sha256 = "8e4abf685a1a4cab8244eb2c71378a99fd53c71696ee8a1cc14320b293162700";
       libraryHaskellDepends = [
         base exceptions filepath ghc ghc-paths template-haskell temporary
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/jfischoff/modulespection";
       description = "Template Haskell for introspecting a module's declarations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "modulo" = callPackage
    ({ mkDerivation, atto-lisp, base, data-default, directory
     , haskell-src, language-c, mtl, nats, pandoc-types, parsec
     , prettify, process, semigroups, text
     }:
     mkDerivation {
       pname = "modulo";
       version = "1.9.1";
       sha256 = "ec98a1f9a9107fb5d480c018042b841399135938ad1598ea1fa4ffe35073bbb7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         atto-lisp base data-default directory haskell-src language-c mtl
         nats pandoc-types parsec prettify process semigroups text
       ];
       jailbreak = true;
       description = "Modular C code generator";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "moe" = callPackage
    ({ mkDerivation, air, base, bytestring, data-default, dlist, mtl
     , text
     }:
     mkDerivation {
       pname = "moe";
       version = "2015.5.4";
       sha256 = "298fde0c83cea1ae7dbe78d05920e9435a99dc1450652f1163bcf0052cca3e7a";
       libraryHaskellDepends = [
         air base bytestring data-default dlist mtl text
       ];
       homepage = "https://github.com/nfjinjing/moe";
       description = "html with style";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "moesocks_1_0_0_40" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , containers, cryptohash, hslogger, HsOpenSSL, iproute, lens
     , lens-aeson, mtl, network, optparse-applicative, random, stm
     , strict, text, time, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "moesocks";
       version = "1.0.0.40";
       sha256 = "29ee09f715fb00707f036d4ba8708bf309c1e581a83b6e8b53006899376cc2b7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson async attoparsec base binary bytestring containers cryptohash
         hslogger HsOpenSSL iproute lens lens-aeson mtl network
         optparse-applicative random stm strict text time transformers
         unordered-containers
       ];
       homepage = "https://github.com/nfjinjing/moesocks";
       description = "A functional firewall killer";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "moesocks" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, binary, bytestring
     , containers, cryptohash, hslogger, HsOpenSSL, iproute, lens
     , lens-aeson, mtl, network, optparse-applicative, random, stm
     , strict, text, time, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "moesocks";
       version = "1.0.0.41";
       sha256 = "85905960363cb617541b0f9ec3a93e73a9b9cd761acdf37174864da865c5cb95";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson async attoparsec base binary bytestring containers cryptohash
         hslogger HsOpenSSL iproute lens lens-aeson mtl network
         optparse-applicative random stm strict text time transformers
         unordered-containers
       ];
       homepage = "https://github.com/nfjinjing/moesocks";
       description = "A functional firewall killer";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "mohws" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-accessor
     , directory, explicit-exception, filepath, html, HTTP, network
     , old-locale, old-time, parsec, process, transformers, unix
     , utility-ht
     }:
     mkDerivation {
       pname = "mohws";
       version = "0.2.1.3";
       sha256 = "8e631823f6cda806c8c54f63ba928803304c398a254f84707c439bc06c4145d9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers data-accessor directory
         explicit-exception filepath html HTTP network old-locale old-time
         parsec process transformers unix utility-ht
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/mohws/";
       description = "Modular Haskell Web Server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mole" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, bytestring
     , containers, cryptohash, css-syntax, directory, filemanip
     , filepath, fsnotify, hspec, hspec-smallcheck, kraken, mtl
     , network-uri, optparse-applicative, process, smallcheck, snap
     , snap-server, stm, tagsoup, text, time, transformers, unix
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "mole";
       version = "0.0.3";
       sha256 = "dd9dd149f4c5ce0e9e9bec0c75277b9a4fad51ff6a1545f0231ba94e0b51469e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base64-bytestring bytestring containers cryptohash
         css-syntax directory filemanip filepath fsnotify kraken mtl
         network-uri optparse-applicative process snap snap-server stm
         tagsoup text time transformers unix
       ];
       testHaskellDepends = [
         attoparsec base bytestring containers hspec hspec-smallcheck kraken
         smallcheck stm text time unordered-containers vector
       ];
       description = "A glorified string replacement tool";
       license = stdenv.lib.licenses.mit;
     }) {};

  "monad-abort-fd" = callPackage
    ({ mkDerivation, base, data-default, monad-control, mtl
     , transformers, transformers-abort, transformers-base
     }:
     mkDerivation {
       pname = "monad-abort-fd";
       version = "0.4";
       sha256 = "f98fe481b4dd57e1fdb5a30899b53eb0183265fcb02212151faa3263f04dde06";
       libraryHaskellDepends = [
         base data-default monad-control mtl transformers transformers-abort
         transformers-base
       ];
       homepage = "https://github.com/mvv/monad-abort-fd";
       description = "A better error monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-atom" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, mtl }:
     mkDerivation {
       pname = "monad-atom";
       version = "0.4.1";
       sha256 = "783042863f498e9737be43911afe160b1ec2ca66a59a894a7da668f0b9b9b699";
       libraryHaskellDepends = [ base containers ghc-prim mtl ];
       homepage = "https://bitbucket.org/gchrupala/lingo";
       description = "Monadically convert object to unique integers and back";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-atom-simple" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, mtl }:
     mkDerivation {
       pname = "monad-atom-simple";
       version = "0.0.2";
       sha256 = "528c99bb0708b0d54ca184008e19dcd146b1ea03972f6d6bbaa268295b6699cc";
       libraryHaskellDepends = [ base containers ghc-prim mtl ];
       description = "Monadically map objects to unique ints";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-bool" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "monad-bool";
       version = "0.2.0";
       sha256 = "9010424e301c5773a75a517ee81514865f9500243d396db5b87ad1d1161776b8";
       libraryHaskellDepends = [ base ];
       doHaddock = false;
       description = "This package has been removed";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-classes" = callPackage
    ({ mkDerivation, base, conduit, data-lens-light, ghc-prim, mmorph
     , monad-control, peano, reflection, tasty, tasty-hunit
     , transformers, transformers-base, transformers-compat
     }:
     mkDerivation {
       pname = "monad-classes";
       version = "0.3.1.1";
       sha256 = "0c906dc616414c84250c79dba279fd29a963de56aeb98e55d4096e80e9f119d8";
       libraryHaskellDepends = [
         base ghc-prim mmorph monad-control peano reflection transformers
         transformers-base transformers-compat
       ];
       testHaskellDepends = [
         base conduit data-lens-light ghc-prim mmorph tasty tasty-hunit
         transformers
       ];
       homepage = "https://github.com/strake/monad-classes.hs";
       description = "more flexible mtl";
       license = stdenv.lib.licenses.mit;
     }) {};

  "monad-codec" = callPackage
    ({ mkDerivation, base, binary, containers, data-lens, mtl }:
     mkDerivation {
       pname = "monad-codec";
       version = "0.2.0";
       sha256 = "b41c1238fad41320644300d1271375a84a610499c119c89ef04b86842634354a";
       libraryHaskellDepends = [ base binary containers data-lens mtl ];
       homepage = "https://github.com/kawu/monad-codec";
       description = "Monadic conversion between complex data structures and unique integers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-control_0_3_3_0" = callPackage
    ({ mkDerivation, base, transformers, transformers-base }:
     mkDerivation {
       pname = "monad-control";
       version = "0.3.3.0";
       sha256 = "ef44c9943760f2120eb450182852d6150390daa2de4b87e9dda9591e89714e6e";
       libraryHaskellDepends = [ base transformers transformers-base ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/basvandijk/monad-control";
       description = "Lift control operations, like exception catching, through monad transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-control_0_3_3_1" = callPackage
    ({ mkDerivation, base, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-control";
       version = "0.3.3.1";
       sha256 = "5f3c41454b1e394f28f1ceb2f0307676d1a02dacff205c28523f64913e90640b";
       libraryHaskellDepends = [
         base transformers transformers-base transformers-compat
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/monad-control";
       description = "Lift control operations, like exception catching, through monad transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-control_1_0_0_4" = callPackage
    ({ mkDerivation, base, stm, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-control";
       version = "1.0.0.4";
       sha256 = "e984b7346af6d31b7ce918e1a0263075af8cbcf5440bc3df698d0354c90df61e";
       revision = "1";
       editedCabalFile = "2df3fbea3354b0d5e0faefe0c441b7d5485a5669caec28a5d9643c15c47c7e76";
       libraryHaskellDepends = [
         base stm transformers transformers-base transformers-compat
       ];
       homepage = "https://github.com/basvandijk/monad-control";
       description = "Lift control operations, like exception catching, through monad transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-control" = callPackage
    ({ mkDerivation, base, stm, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-control";
       version = "1.0.0.5";
       sha256 = "055f715701c82e2c238282e363807d5bd6300e82cb38eaf37283987bfa8943f9";
       libraryHaskellDepends = [
         base stm transformers transformers-base transformers-compat
       ];
       homepage = "https://github.com/basvandijk/monad-control";
       description = "Lift control operations, like exception catching, through monad transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-coroutine_0_8" = callPackage
    ({ mkDerivation, base, monad-parallel, transformers }:
     mkDerivation {
       pname = "monad-coroutine";
       version = "0.8";
       sha256 = "fdc3b95528f02065366423de1b13303549106412fa0b12ae4aa2c43d58b9395a";
       libraryHaskellDepends = [ base monad-parallel transformers ];
       jailbreak = true;
       homepage = "http://trac.haskell.org/SCC/wiki/monad-coroutine";
       description = "Coroutine monad transformer for suspending and resuming monadic computations";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-coroutine_0_8_0_1" = callPackage
    ({ mkDerivation, base, monad-parallel, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-coroutine";
       version = "0.8.0.1";
       sha256 = "1eea76148afae3e01d52abeb497b99cd57e37d771345167076ec403e5b36fe4b";
       libraryHaskellDepends = [
         base monad-parallel transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://trac.haskell.org/SCC/wiki/monad-coroutine";
       description = "Coroutine monad transformer for suspending and resuming monadic computations";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-coroutine_0_9_0_1" = callPackage
    ({ mkDerivation, base, monad-parallel, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-coroutine";
       version = "0.9.0.1";
       sha256 = "32f231f64a6d0192734bbb7649ef7c74eecbd6c478a4efb8b20b9edc01476981";
       libraryHaskellDepends = [
         base monad-parallel transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://trac.haskell.org/SCC/wiki/monad-coroutine";
       description = "Coroutine monad transformer for suspending and resuming monadic computations";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-coroutine" = callPackage
    ({ mkDerivation, base, monad-parallel, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-coroutine";
       version = "0.9.0.2";
       sha256 = "c648272e0578f8d590bdf834aaf2866ebe94474517c34d8e34b4c821469b4da4";
       libraryHaskellDepends = [
         base monad-parallel transformers transformers-compat
       ];
       homepage = "http://trac.haskell.org/SCC/wiki/monad-coroutine";
       description = "Coroutine monad transformer for suspending and resuming monadic computations";
       license = "GPL";
     }) {};

  "monad-exception" = callPackage
    ({ mkDerivation, base, monad-control, mtl-evil-instances
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "monad-exception";
       version = "0.1";
       sha256 = "084efc952e9479fc7a3ffb48e58b35d3b61a5b6d52ee8140db9356137b4d01d6";
       libraryHaskellDepends = [
         base monad-control mtl-evil-instances transformers
         transformers-base
       ];
       jailbreak = true;
       description = "Exstensible monadic exceptions";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-extras_0_5_9" = callPackage
    ({ mkDerivation, base, mmorph, monad-control, stm, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "monad-extras";
       version = "0.5.9";
       sha256 = "1a6828e30ba11c1a6f813f027cc1e2b1a3462c5d35a8f8bca334af32ccf744f8";
       libraryHaskellDepends = [
         base mmorph monad-control stm transformers transformers-base
       ];
       homepage = "http://github.com/jwiegley/monad-extras";
       description = "Extra utility functions for working with monads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-extras" = callPackage
    ({ mkDerivation, base, mmorph, monad-control, stm, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "monad-extras";
       version = "0.5.11";
       sha256 = "76972ce47148f8a60498a878394135cd4079bef79f79f12c9cd86d1766230467";
       libraryHaskellDepends = [
         base mmorph monad-control stm transformers transformers-base
       ];
       homepage = "http://github.com/jwiegley/monad-extras";
       description = "Extra utility functions for working with monads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-fork" = callPackage
    ({ mkDerivation, base, monad-control }:
     mkDerivation {
       pname = "monad-fork";
       version = "0.1";
       sha256 = "8cdfc6c868b5599d12cc238a5def812bc084414d50ea485c747d304ff056bc97";
       libraryHaskellDepends = [ base monad-control ];
       jailbreak = true;
       description = "Type class for monads which support a fork operation";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "monad-gen" = callPackage
    ({ mkDerivation, base, mtl, transformers }:
     mkDerivation {
       pname = "monad-gen";
       version = "0.3.0.1";
       sha256 = "be8485023fce236b5b915f2f6074f7b0470a2040f84cdd137c5227f1b4c98465";
       libraryHaskellDepends = [ base mtl transformers ];
       description = "A simple monad for generating fresh integers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "monad-http" = callPackage
    ({ mkDerivation, base, base-compat, bytestring, exceptions
     , http-client, http-client-tls, http-types, monad-logger
     , monadcryptorandom, MonadRandom, mtl, text, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-http";
       version = "0.1.0.0";
       sha256 = "a333b087835aa4902d0814e76fe4f32a523092fd7b13526aad415160a8317192";
       revision = "2";
       editedCabalFile = "7f2d5927cf21949017fce8d2c46c3f768e1be144e57ae4c845b409707d11313a";
       libraryHaskellDepends = [
         base base-compat bytestring exceptions http-client http-client-tls
         http-types monad-logger monadcryptorandom MonadRandom mtl text
         transformers transformers-compat
       ];
       homepage = "https://github.com/futurice/haskell-monad-http#readme";
       description = "A class of monads which can do http requests";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-interleave" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "monad-interleave";
       version = "0.1";
       sha256 = "e7ba24f3f9ca37c57f49d4c879fae544069b4468264dda49cf7ac702d5a11726";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/patperry/monad-interleave";
       description = "Monads with an unsaveInterleaveIO-like operation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-journal_0_5_0_1" = callPackage
    ({ mkDerivation, base, either, monad-control, mtl, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "monad-journal";
       version = "0.5.0.1";
       sha256 = "00c1aee1abcecb88a5d6f8b8f8973c4a3db867bf93c09308d7084ed4a1f9b5e7";
       libraryHaskellDepends = [
         base either monad-control mtl transformers transformers-base
       ];
       jailbreak = true;
       homepage = "http://github.com/phaazon/monad-journal";
       description = "Pure logger typeclass and monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-journal_0_6_0_2" = callPackage
    ({ mkDerivation, base, either, monad-control, mtl, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "monad-journal";
       version = "0.6.0.2";
       sha256 = "a5fb3c17d992310d6907c8d60eb6b1f1c9afd1dfab56a33eb35b8a1402ab7bd1";
       libraryHaskellDepends = [
         base either monad-control mtl transformers transformers-base
       ];
       jailbreak = true;
       homepage = "http://github.com/phaazon/monad-journal";
       description = "Pure logger typeclass and monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-journal_0_7" = callPackage
    ({ mkDerivation, base, either, monad-control, mtl, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "monad-journal";
       version = "0.7";
       sha256 = "e2d3a44abce5e7adc3a093af4bb614b20068c03f449b2ad26fc8ed23c02dd5ad";
       libraryHaskellDepends = [
         base either monad-control mtl transformers transformers-base
       ];
       jailbreak = true;
       homepage = "http://github.com/phaazon/monad-journal";
       description = "Pure logger typeclass and monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-journal" = callPackage
    ({ mkDerivation, base, either, monad-control, mtl, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "monad-journal";
       version = "0.7.1";
       sha256 = "79afa46b66530b7877a1860352ad3696a6ce65f3ad2f17468c3d4e78bc4fd2ad";
       libraryHaskellDepends = [
         base either monad-control mtl transformers transformers-base
       ];
       homepage = "http://github.com/phaazon/monad-journal";
       description = "Pure logger typeclass and monad transformer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-levels" = callPackage
    ({ mkDerivation, base, constraints, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-levels";
       version = "0.1.0.1";
       sha256 = "5651701e394dd9b00e3e05007cb9451fe6cf58b7890935d2f7081d46a00871ec";
       libraryHaskellDepends = [
         base constraints transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "https://github.com/ivan-m/monad-levels";
       description = "Specific levels of monad transformers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-logger_0_3_11" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, conduit
     , conduit-extra, exceptions, fast-logger, lifted-base
     , monad-control, monad-loops, mtl, resourcet, stm, stm-chans
     , template-haskell, text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "monad-logger";
       version = "0.3.11";
       sha256 = "b8d53d9193151b2a1165bbac290c3b10ba291f2d4dd7c6066cc018dc2ed9bd79";
       revision = "1";
       editedCabalFile = "f928c2c755c64ff6c7f0ff7364c3b3868a08f06181ec1300e2f12d7bf5cc20b8";
       libraryHaskellDepends = [
         base blaze-builder bytestring conduit conduit-extra exceptions
         fast-logger lifted-base monad-control monad-loops mtl resourcet stm
         stm-chans template-haskell text transformers transformers-base
       ];
       jailbreak = true;
       homepage = "https://github.com/kazu-yamamoto/logger";
       description = "A class of monads which can log messages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-logger_0_3_11_1" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, conduit
     , conduit-extra, exceptions, fast-logger, lifted-base
     , monad-control, monad-loops, mtl, resourcet, stm, stm-chans
     , template-haskell, text, transformers, transformers-base
     }:
     mkDerivation {
       pname = "monad-logger";
       version = "0.3.11.1";
       sha256 = "e78692823e3e691ef6a468af58fbb195fd322aa357254f35100b56bfe32108ee";
       libraryHaskellDepends = [
         base blaze-builder bytestring conduit conduit-extra exceptions
         fast-logger lifted-base monad-control monad-loops mtl resourcet stm
         stm-chans template-haskell text transformers transformers-base
       ];
       jailbreak = true;
       homepage = "https://github.com/kazu-yamamoto/logger";
       description = "A class of monads which can log messages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-logger_0_3_12" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, conduit
     , conduit-extra, exceptions, fast-logger, lifted-base
     , monad-control, monad-loops, mtl, resourcet, stm, stm-chans
     , template-haskell, text, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-logger";
       version = "0.3.12";
       sha256 = "e1f49b7664dc9d4f4a69c2b4eebf15b13af47ef6266ecbbe5697a8765816be58";
       libraryHaskellDepends = [
         base blaze-builder bytestring conduit conduit-extra exceptions
         fast-logger lifted-base monad-control monad-loops mtl resourcet stm
         stm-chans template-haskell text transformers transformers-base
         transformers-compat
       ];
       jailbreak = true;
       homepage = "https://github.com/kazu-yamamoto/logger";
       description = "A class of monads which can log messages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-logger_0_3_13_1" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, conduit
     , conduit-extra, exceptions, fast-logger, lifted-base
     , monad-control, monad-loops, mtl, resourcet, stm, stm-chans
     , template-haskell, text, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-logger";
       version = "0.3.13.1";
       sha256 = "268b4a6493e86d7a6a4ab18de3bfa9d97bb1d40fe4bca465ee4a084f3b8c8d57";
       libraryHaskellDepends = [
         base blaze-builder bytestring conduit conduit-extra exceptions
         fast-logger lifted-base monad-control monad-loops mtl resourcet stm
         stm-chans template-haskell text transformers transformers-base
         transformers-compat
       ];
       jailbreak = true;
       homepage = "https://github.com/kazu-yamamoto/logger";
       description = "A class of monads which can log messages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-logger_0_3_13_2" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, conduit
     , conduit-extra, exceptions, fast-logger, lifted-base
     , monad-control, monad-loops, mtl, resourcet, stm, stm-chans
     , template-haskell, text, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-logger";
       version = "0.3.13.2";
       sha256 = "c1383c4d32e1f276e3437db39418d5a4c3c3670c25c416b4f6c3fe5ad4b5e2b2";
       libraryHaskellDepends = [
         base blaze-builder bytestring conduit conduit-extra exceptions
         fast-logger lifted-base monad-control monad-loops mtl resourcet stm
         stm-chans template-haskell text transformers transformers-base
         transformers-compat
       ];
       homepage = "https://github.com/kazu-yamamoto/logger";
       description = "A class of monads which can log messages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-logger_0_3_14" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, conduit
     , conduit-extra, exceptions, fast-logger, lifted-base
     , monad-control, monad-loops, mtl, resourcet, stm, stm-chans
     , template-haskell, text, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-logger";
       version = "0.3.14";
       sha256 = "dc748f55363f0af6e52a4711c73fb54b5579845eb091395a23377afd28c70052";
       libraryHaskellDepends = [
         base blaze-builder bytestring conduit conduit-extra exceptions
         fast-logger lifted-base monad-control monad-loops mtl resourcet stm
         stm-chans template-haskell text transformers transformers-base
         transformers-compat
       ];
       homepage = "https://github.com/kazu-yamamoto/logger";
       description = "A class of monads which can log messages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-logger_0_3_15" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, conduit
     , conduit-extra, exceptions, fast-logger, lifted-base
     , monad-control, monad-loops, mtl, resourcet, stm, stm-chans
     , template-haskell, text, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-logger";
       version = "0.3.15";
       sha256 = "33a5bb9d91be1068201ae8764f0a325ab2f4436a6b3bace2e58fb38db872a86e";
       libraryHaskellDepends = [
         base blaze-builder bytestring conduit conduit-extra exceptions
         fast-logger lifted-base monad-control monad-loops mtl resourcet stm
         stm-chans template-haskell text transformers transformers-base
         transformers-compat
       ];
       homepage = "https://github.com/kazu-yamamoto/logger";
       description = "A class of monads which can log messages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-logger_0_3_16" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, conduit
     , conduit-extra, exceptions, fast-logger, lifted-base
     , monad-control, monad-loops, mtl, resourcet, stm, stm-chans
     , template-haskell, text, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-logger";
       version = "0.3.16";
       sha256 = "1ee1b69e5732dab1cd833e8f0ea8092dc4c82b6548e7a46669192f0c0c641622";
       libraryHaskellDepends = [
         base blaze-builder bytestring conduit conduit-extra exceptions
         fast-logger lifted-base monad-control monad-loops mtl resourcet stm
         stm-chans template-haskell text transformers transformers-base
         transformers-compat
       ];
       homepage = "https://github.com/kazu-yamamoto/logger";
       description = "A class of monads which can log messages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-logger_0_3_17" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, conduit
     , conduit-extra, exceptions, fast-logger, lifted-base
     , monad-control, monad-loops, mtl, resourcet, stm, stm-chans
     , template-haskell, text, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-logger";
       version = "0.3.17";
       sha256 = "25dd1e420c1bbc83b968cac738a08ebc6d708581a6e190f5e61c8de5e698e1ea";
       libraryHaskellDepends = [
         base blaze-builder bytestring conduit conduit-extra exceptions
         fast-logger lifted-base monad-control monad-loops mtl resourcet stm
         stm-chans template-haskell text transformers transformers-base
         transformers-compat
       ];
       homepage = "https://github.com/kazu-yamamoto/logger";
       description = "A class of monads which can log messages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-logger" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, conduit
     , conduit-extra, exceptions, fast-logger, lifted-base
     , monad-control, monad-loops, mtl, resourcet, stm, stm-chans
     , template-haskell, text, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "monad-logger";
       version = "0.3.18";
       sha256 = "81497c19d08df93e6de5914f3adf0feecf4fcd9412e3004d2b19b4bfba05497e";
       libraryHaskellDepends = [
         base blaze-builder bytestring conduit conduit-extra exceptions
         fast-logger lifted-base monad-control monad-loops mtl resourcet stm
         stm-chans template-haskell text transformers transformers-base
         transformers-compat
       ];
       homepage = "https://github.com/kazu-yamamoto/logger";
       description = "A class of monads which can log messages";
       license = stdenv.lib.licenses.mit;
     }) {};

  "monad-logger-json" = callPackage
    ({ mkDerivation, aeson, base, monad-logger, template-haskell, text
     }:
     mkDerivation {
       pname = "monad-logger-json";
       version = "0.1.0.0";
       sha256 = "10871c4aef838c01c8fdd7586161367b4d66907a53cbd9737efb717a1041e9aa";
       libraryHaskellDepends = [
         aeson base monad-logger template-haskell text
       ];
       homepage = "http://github.com/fpco/monad-logger-json";
       description = "JSON-friendly Logging APIs";
       license = stdenv.lib.licenses.mit;
     }) {};

  "monad-logger-syslog" = callPackage
    ({ mkDerivation, base, bytestring, fast-logger, hsyslog
     , monad-logger, text, transformers
     }:
     mkDerivation {
       pname = "monad-logger-syslog";
       version = "0.1.1.1";
       sha256 = "6e1bc3833c3768c354ea269b95a8c566036ba606b769dacda1b9653b4b22b541";
       libraryHaskellDepends = [
         base bytestring fast-logger hsyslog monad-logger text transformers
       ];
       homepage = "https://github.com/fpco/monad-logger-syslog";
       description = "syslog output for monad-logger";
       license = stdenv.lib.licenses.mit;
     }) {};

  "monad-loops_0_4_2_1" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "monad-loops";
       version = "0.4.2.1";
       sha256 = "a6e888a462aff46297527e90a7bf0171bc2cff4cab073973bdbf2fc09ae5f9b6";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/mokus0/monad-loops";
       description = "Monadic loops";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-loops" = callPackage
    ({ mkDerivation, base, tasty, tasty-hunit }:
     mkDerivation {
       pname = "monad-loops";
       version = "0.4.3";
       sha256 = "7eaaaf6bc43661e9e86e310ff8c56fbea16eb6bf13c31a2e28103138ac164c18";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       homepage = "https://github.com/mokus0/monad-loops";
       description = "Monadic loops";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "monad-loops-stm" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "monad-loops-stm";
       version = "0.4";
       sha256 = "5a9d5c9a70eb8a0957bc8ad98b1386ddeaa7682debee3d2a7fefe8906f17f278";
       libraryHaskellDepends = [ base stm ];
       homepage = "https://github.com/mokus0/monad-loops-stm";
       description = "Monadic loops for STM";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "monad-lrs" = callPackage
    ({ mkDerivation, base, containers, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "monad-lrs";
       version = "0.0.2.1";
       sha256 = "8f557940e9c17085e282936d687ab8232f93e932896a9547468e8e0cca872806";
       revision = "1";
       editedCabalFile = "dd714797826911e564a0e418307530fa99a8ba9ea91400517be2bb78b4e695c1";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [
         base containers QuickCheck test-framework
         test-framework-quickcheck2
       ];
       homepage = "https://github.com/bjin/monad-lrs";
       description = "a monad to calculate linear recursive sequence";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-memo" = callPackage
    ({ mkDerivation, array, base, containers, mtl, primitive
     , QuickCheck, random, test-framework, test-framework-quickcheck2
     , transformers, vector
     }:
     mkDerivation {
       pname = "monad-memo";
       version = "0.4.1";
       sha256 = "4c00c4aff00c85bfcce0a9a7d96a2a7d08f1efe64b3326e67e47499d5168f11d";
       libraryHaskellDepends = [
         array base containers mtl primitive transformers vector
       ];
       testHaskellDepends = [
         array base containers mtl primitive QuickCheck random
         test-framework test-framework-quickcheck2 transformers vector
       ];
       homepage = "https://github.com/EduardSergeev/monad-memo";
       description = "Memoization monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-mersenne-random" = callPackage
    ({ mkDerivation, base, mersenne-random-pure64 }:
     mkDerivation {
       pname = "monad-mersenne-random";
       version = "0.1";
       sha256 = "065373647071e2149019d8f845b516664de44fb8644a90ec77ff5ab2dfc26b0e";
       libraryHaskellDepends = [ base mersenne-random-pure64 ];
       homepage = "http://code.haskell.org/~dons/code/monad-mersenne-random";
       description = "An efficient random generator monad, based on the Mersenne Twister";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-open" = callPackage
    ({ mkDerivation, base, exceptions, mtl, transformers }:
     mkDerivation {
       pname = "monad-open";
       version = "0.1.0.0";
       sha256 = "7d0b1777eed3cb67c7ac7ad65b8ca7e80394a7820a13d845e6d6b9b5db2702a2";
       libraryHaskellDepends = [ base exceptions mtl transformers ];
       jailbreak = true;
       description = "Open recursion for when you need it";
       license = stdenv.lib.licenses.mit;
     }) {};

  "monad-ox" = callPackage
    ({ mkDerivation, base, containers, mtl, text, vector }:
     mkDerivation {
       pname = "monad-ox";
       version = "0.3.0";
       sha256 = "88f2eb3abbf982d73eb9ca66ce2fa96a20fa9df61be926bc49429980e096c5f4";
       libraryHaskellDepends = [ base containers mtl text vector ];
       homepage = "https://github.com/kawu/monad-ox";
       description = "Monad for observation extraction";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-par" = callPackage
    ({ mkDerivation, abstract-deque, abstract-par, array, base
     , containers, deepseq, HUnit, monad-par-extras, mtl, mwc-random
     , parallel, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, test-framework-th, time
     }:
     mkDerivation {
       pname = "monad-par";
       version = "0.3.4.7";
       sha256 = "23b8a68719b4c5848ce9a3381ce9efdc1c96677ba043a3ee74d99223343cc28a";
       libraryHaskellDepends = [
         abstract-deque abstract-par array base containers deepseq
         monad-par-extras mtl mwc-random parallel
       ];
       testHaskellDepends = [
         abstract-deque abstract-par array base containers deepseq HUnit
         monad-par-extras mtl mwc-random QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 test-framework-th
         time
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/simonmar/monad-par";
       description = "A library for parallel programming based on a monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-par-extras" = callPackage
    ({ mkDerivation, abstract-par, base, cereal, deepseq, mtl, random
     , transformers
     }:
     mkDerivation {
       pname = "monad-par-extras";
       version = "0.3.3";
       sha256 = "e21e33190bc248afa4ae467287ac37d24037ef3de6050c44fd85b52f4d5b842e";
       libraryHaskellDepends = [
         abstract-par base cereal deepseq mtl random transformers
       ];
       homepage = "https://github.com/simonmar/monad-par";
       description = "Combinators and extra features for Par monads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-parallel_0_7_1_3" = callPackage
    ({ mkDerivation, base, parallel, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "monad-parallel";
       version = "0.7.1.3";
       sha256 = "7dd605c9cb8f838515806be46790c5faa36a4f8af9340df76ebcdeef12641194";
       libraryHaskellDepends = [
         base parallel transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://trac.haskell.org/SCC/wiki/monad-parallel";
       description = "Parallel execution of monadic computations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-parallel_0_7_1_4" = callPackage
    ({ mkDerivation, base, parallel, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "monad-parallel";
       version = "0.7.1.4";
       sha256 = "0b25754c33622960ff0b072426b94aebc02eac39cb815443d7efec39286c4a07";
       libraryHaskellDepends = [
         base parallel transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://trac.haskell.org/SCC/wiki/monad-parallel";
       description = "Parallel execution of monadic computations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-parallel_0_7_2_0" = callPackage
    ({ mkDerivation, base, parallel, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "monad-parallel";
       version = "0.7.2.0";
       sha256 = "9993e6590abe8cc69db34d8b11dec3ab2e13179cf3d162f2b79b86462c5becdd";
       libraryHaskellDepends = [
         base parallel transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://trac.haskell.org/SCC/wiki/monad-parallel";
       description = "Parallel execution of monadic computations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-parallel" = callPackage
    ({ mkDerivation, base, parallel, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "monad-parallel";
       version = "0.7.2.1";
       sha256 = "8bd8e90bcf9b71375bea031703551c09a51137c05377876dde2616e375782065";
       libraryHaskellDepends = [
         base parallel transformers transformers-compat
       ];
       homepage = "http://trac.haskell.org/SCC/wiki/monad-parallel";
       description = "Parallel execution of monadic computations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-parallel-progressbar" = callPackage
    ({ mkDerivation, base, monad-parallel, monadIO
     , terminal-progress-bar
     }:
     mkDerivation {
       pname = "monad-parallel-progressbar";
       version = "0.1.0.1";
       sha256 = "04cd5a99fdb3dd46f5ee98de607a04e549905ea18cdce78be7d4e9eda91211df";
       libraryHaskellDepends = [
         base monad-parallel monadIO terminal-progress-bar
       ];
       homepage = "https://github.com/mnacamura/monad-parallel-progressbar";
       description = "Parallel execution of monadic computations with a progress bar";
       license = stdenv.lib.licenses.mit;
     }) {};

  "monad-param" = callPackage
    ({ mkDerivation, base, mtl, stm }:
     mkDerivation {
       pname = "monad-param";
       version = "0.0.4";
       sha256 = "0cce76237aeb979b20341b2b59fa825f037735d6593a1503c457513605483523";
       libraryHaskellDepends = [ base mtl stm ];
       homepage = "http://hackage.haskell.org/package/monad-param";
       description = "Parameterized monads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-peel" = callPackage
    ({ mkDerivation, base, extensible-exceptions, transformers }:
     mkDerivation {
       pname = "monad-peel";
       version = "0.2";
       sha256 = "3d4667b49c53cfd7b44f3da7b3d9a70a83f24ee9bc197388f5990408b190e6b1";
       libraryHaskellDepends = [
         base extensible-exceptions transformers
       ];
       homepage = "http://andersk.mit.edu/haskell/monad-peel/";
       description = "Lift control operations like exception catching through monad transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-primitive" = callPackage
    ({ mkDerivation, base, primitive, transformers }:
     mkDerivation {
       pname = "monad-primitive";
       version = "0.1";
       sha256 = "3dc032536e87ca77d9e802d581f036ebbf2e29064fb98a0ede05fb068b7926ee";
       libraryHaskellDepends = [ base primitive transformers ];
       homepage = "http://bitbucket.org/Shimuuar/monad-primitive";
       description = "Type class for monad transformers stack with pirimitive base monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-products_4_0_0_1" = callPackage
    ({ mkDerivation, base, semigroupoids }:
     mkDerivation {
       pname = "monad-products";
       version = "4.0.0.1";
       sha256 = "a36420f08d798010dced3914d92abd3428bad5a8a681ac117080bbbe55ecec04";
       revision = "1";
       editedCabalFile = "fb4d07af0ad3081f3f2a252c99b777fafa6b3ece61ca81642f8a889ef370710e";
       libraryHaskellDepends = [ base semigroupoids ];
       homepage = "http://github.com/ekmett/monad-products";
       description = "Monad products";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-products" = callPackage
    ({ mkDerivation, base, semigroupoids }:
     mkDerivation {
       pname = "monad-products";
       version = "4.0.1";
       sha256 = "02bfe1db2ae1a5cff19f73736a219605b1f0649f6af44ca848d09160a7946cea";
       libraryHaskellDepends = [ base semigroupoids ];
       homepage = "http://github.com/ekmett/monad-products";
       description = "Monad products";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-ran" = callPackage
    ({ mkDerivation, base, ghc-prim, mtl }:
     mkDerivation {
       pname = "monad-ran";
       version = "0.1.0";
       sha256 = "5d51cc345f244414f48803f4a34d425b50e380efc26090e1444e7c4896d0c913";
       libraryHaskellDepends = [ base ghc-prim mtl ];
       jailbreak = true;
       description = "Fast monads and monad transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-resumption" = callPackage
    ({ mkDerivation, base, mmorph, mtl, transformers }:
     mkDerivation {
       pname = "monad-resumption";
       version = "0.1.2.0";
       sha256 = "79b678b13259b679438f3f7befb3ef5294dfee7bbda922326db852b9172bdf27";
       libraryHaskellDepends = [ base mmorph mtl transformers ];
       homepage = "https://github.com/igraves/resumption_monads";
       description = "Resumption and reactive resumption monads for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-skeleton_0_1_2_1" = callPackage
    ({ mkDerivation, base, containers, ghc-prim }:
     mkDerivation {
       pname = "monad-skeleton";
       version = "0.1.2.1";
       sha256 = "e6446fb5c281bf903b583aad22a4627ae8956401ec42debc114c9dcb88f4e169";
       libraryHaskellDepends = [ base containers ghc-prim ];
       homepage = "https://github.com/fumieval/monad-skeleton";
       description = "An undead monad";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-skeleton" = callPackage
    ({ mkDerivation, base, containers, ghc-prim }:
     mkDerivation {
       pname = "monad-skeleton";
       version = "0.1.2.2";
       sha256 = "b1cc4f0b9e308374c76902942b8381e0af869b0915735d380f792bb11e362de3";
       libraryHaskellDepends = [ base containers ghc-prim ];
       homepage = "https://github.com/fumieval/monad-skeleton";
       description = "An undead monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-st" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "monad-st";
       version = "0.2.4";
       sha256 = "718d5ae878306e0527e3b6ce32d5ad59fd83432b90012a594059d3720fd0c7c8";
       libraryHaskellDepends = [ base transformers ];
       homepage = "http://github.com/ekmett/monad-st";
       description = "Provides a MonadST class";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-state" = callPackage
    ({ mkDerivation, AbortT-transformers, base, fclabels, monads-tf
     , transformers
     }:
     mkDerivation {
       pname = "monad-state";
       version = "0.2.0.3";
       sha256 = "bbe3dee445b41b1ad0e66a0ca0a0ff01f5f40487007f3279412ba7610f6f01b6";
       libraryHaskellDepends = [
         AbortT-transformers base fclabels monads-tf transformers
       ];
       homepage = "https://github.com/bairyn/monad-state";
       description = "Utility library for monads, particularly those involving state";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-statevar" = callPackage
    ({ mkDerivation, base, stm, transformers }:
     mkDerivation {
       pname = "monad-statevar";
       version = "0.1";
       sha256 = "dd857c551f02f2fb38238e987efd1a9797e4f46538b25094c46e0a9071125923";
       libraryHaskellDepends = [ base transformers ];
       testHaskellDepends = [ base stm ];
       homepage = "http://github.com/joeyadams/hs-monad-statevar";
       description = "Concise, overloaded accessors for IORef, STRef, TVar";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-stlike-io" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, monads-tf
     }:
     mkDerivation {
       pname = "monad-stlike-io";
       version = "0.2.2";
       sha256 = "a529d285ecf039a9c88b22f84649445f231a92658e116270070aa21686e33fd2";
       libraryHaskellDepends = [
         base bytestring containers deepseq monads-tf
       ];
       homepage = "http://github.com/taruti/monad-stlike-io";
       description = "ST-like monad capturing variables to regions and supporting IO";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-stlike-stm" = callPackage
    ({ mkDerivation, base, monad-stlike-io, stm }:
     mkDerivation {
       pname = "monad-stlike-stm";
       version = "0.1.1";
       sha256 = "a6f0d4b4b3c628b4c23287553c4cffb19730d1060bbf1a63ed0837d013d6f900";
       libraryHaskellDepends = [ base monad-stlike-io stm ];
       homepage = "http://github.com/taruti/monad-stlike-stm";
       description = "ST-like monad capturing variables to regions and supporting STM";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-stm" = callPackage
    ({ mkDerivation, base, stm, transformers }:
     mkDerivation {
       pname = "monad-stm";
       version = "0.1.0.2";
       sha256 = "b7a71a1cc50a04a461768e03b9813e2c708876d67d6fdb864422bd9fe4826b25";
       libraryHaskellDepends = [ base stm transformers ];
       description = "MonadSTM class analogous to MonadIO";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-supply" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "monad-supply";
       version = "0.6";
       sha256 = "398e01431c3bf7f7202465e3a3d7ed26e0316b00e35ff429504e60c5ddc9e4bd";
       libraryHaskellDepends = [ base mtl ];
       description = "Stateful supply monad";
       license = "unknown";
     }) {};

  "monad-task" = callPackage
    ({ mkDerivation, base, mtl, transformers }:
     mkDerivation {
       pname = "monad-task";
       version = "0.1.0";
       sha256 = "287a355aa82cbbfe971984a2d3c1b1f28b0a9f773cb6eba6493c51a72be68307";
       libraryHaskellDepends = [ base mtl transformers ];
       jailbreak = true;
       homepage = "http://github.com/ninegua/monad-task";
       description = "A monad transformer that turns event processing into co-routine programming";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-time" = callPackage
    ({ mkDerivation, base, mtl, time }:
     mkDerivation {
       pname = "monad-time";
       version = "0.1";
       sha256 = "d23a08ea5c5fd02012d2a299384a67b1ada90af7bd47d646be8de3cab9c36dbc";
       libraryHaskellDepends = [ base mtl time ];
       homepage = "https://github.com/scrive/monad-time";
       description = "Type class for monads which carry the notion of the current time";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monad-tx" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "monad-tx";
       version = "0.0.1";
       sha256 = "6936efc75c6bc8a4973fed15595c8f5741d606059164080581778dba2abb634b";
       libraryHaskellDepends = [ base ];
       description = "A transactional state monad";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-unify" = callPackage
    ({ mkDerivation, base, mtl, unordered-containers }:
     mkDerivation {
       pname = "monad-unify";
       version = "0.2.2";
       sha256 = "97bfdadd6c3f427dc5d310c7af4eef6221b7e5269b9b5acea2846da2942494c5";
       revision = "1";
       editedCabalFile = "7d585b29bfa558cf59d169421d1ec3363b6ef56b88cf6a9a082192d609676ce2";
       libraryHaskellDepends = [ base mtl unordered-containers ];
       jailbreak = true;
       description = "Generic first-order unification";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monad-unlift" = callPackage
    ({ mkDerivation, base, constraints, exceptions, monad-control, mtl
     , mutable-containers, resourcet, stm, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "monad-unlift";
       version = "0.1.1.0";
       sha256 = "c21f482f2533c8b4b4bccd4a41c8f273b9e17a1241081f54cb27dd1cdfed06f5";
       libraryHaskellDepends = [
         base constraints exceptions monad-control mtl mutable-containers
         resourcet stm transformers transformers-base
       ];
       homepage = "https://github.com/fpco/monad-unlift";
       description = "Typeclasses for representing monad transformer unlifting";
       license = stdenv.lib.licenses.mit;
     }) {};

  "monad-wrap" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "monad-wrap";
       version = "0.1";
       sha256 = "6e048bc3e6ae49c2b3a65282c1c6c322e080f4b05c7ca08ddb4de7c5c07bb1c2";
       libraryHaskellDepends = [ base transformers ];
       description = "Wrap functions such as catch around different monads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monadIO" = callPackage
    ({ mkDerivation, base, mtl, stm }:
     mkDerivation {
       pname = "monadIO";
       version = "0.10.1.4";
       sha256 = "342b67effad053d1216a07d20289e0104a6d0ada7ff66f979dc9407492442520";
       libraryHaskellDepends = [ base mtl stm ];
       description = "Overloading of concurrency variables";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monadLib" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "monadLib";
       version = "3.7.3";
       sha256 = "1834a77560d9df7ab0bc43ce24c77ffc660fc84573730ea94cb6e4ab8dcca99e";
       libraryHaskellDepends = [ base ];
       homepage = "http://wiki.github.com/yav/monadlib";
       description = "A collection of monad transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monadLib-compose" = callPackage
    ({ mkDerivation, base, monadLib }:
     mkDerivation {
       pname = "monadLib-compose";
       version = "0.2";
       sha256 = "c16ffae593e47f185b73369fe96c4728974fafd59eae59dfc52401bf58837e91";
       libraryHaskellDepends = [ base monadLib ];
       jailbreak = true;
       homepage = "http://github.com/aristidb/monadLib-compose";
       description = "Arrow-like monad composition for monadLib";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monadacme" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "monadacme";
       version = "0.0.2";
       sha256 = "27799390bb992349fd821aa7388e47bd4e3bf5aa0203b77e725374f5c63455e1";
       libraryHaskellDepends = [ base ];
       description = "The Acme and AcmeT monads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monadbi" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "monadbi";
       version = "0.1";
       sha256 = "07bbb8bf47946c76fc69533a1a87194de720d384358b4e18dd902a4b8692b064";
       libraryHaskellDepends = [ base mtl ];
       homepage = "https://github.com/ajnsit/monadbi";
       description = "Extract underlying monads from monad transformers";
       license = "GPL";
     }) {};

  "monadcryptorandom_0_6_1" = callPackage
    ({ mkDerivation, base, bytestring, crypto-api, mtl, tagged
     , transformers
     }:
     mkDerivation {
       pname = "monadcryptorandom";
       version = "0.6.1";
       sha256 = "42be5bde4f4d5b2eadbbc9c4a1556b1ac60e366d9aeae76aa41a722c1c902949";
       libraryHaskellDepends = [
         base bytestring crypto-api mtl tagged transformers
       ];
       homepage = "https://github.com/TomMD/monadcryptorandom";
       description = "A monad for using CryptoRandomGen";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monadcryptorandom" = callPackage
    ({ mkDerivation, base, bytestring, crypto-api, mtl, tagged
     , transformers
     }:
     mkDerivation {
       pname = "monadcryptorandom";
       version = "0.7.0";
       sha256 = "67011973932bc58d5f1d0eedbbe8dca3c3160ea1dac04e82cf96bd6687515623";
       libraryHaskellDepends = [
         base bytestring crypto-api mtl tagged transformers
       ];
       homepage = "https://github.com/TomMD/monadcryptorandom";
       description = "A monad for using CryptoRandomGen";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monadfibre" = callPackage
    ({ mkDerivation, base, monadbi }:
     mkDerivation {
       pname = "monadfibre";
       version = "0.1.2.1";
       sha256 = "46b7914f21c85b5c8313a60bc29a110e30438dd2224c4afe1d204de0cb23486e";
       libraryHaskellDepends = [ base monadbi ];
       homepage = "https://github.com/ajnsit/monadfibre";
       description = "Monadic functions which provide Choice and Parallelism";
       license = "GPL";
     }) {};

  "monadic-arrays_0_2_1_3" = callPackage
    ({ mkDerivation, array, base, stm, transformers }:
     mkDerivation {
       pname = "monadic-arrays";
       version = "0.2.1.3";
       sha256 = "45807cdbfe0fa14e10fa5b9c8f18d3e3b71cdb25e5df1a16b08decff01310e63";
       libraryHaskellDepends = [ array base stm transformers ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/monadic-arrays/";
       description = "Boxed and unboxed arrays for monad transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monadic-arrays_0_2_1_4" = callPackage
    ({ mkDerivation, array, base, stm, transformers }:
     mkDerivation {
       pname = "monadic-arrays";
       version = "0.2.1.4";
       sha256 = "10aa697b8b039be06abdfde02afda25cf5b312e1b450d80e71e14d872b8098ee";
       libraryHaskellDepends = [ array base stm transformers ];
       homepage = "http://github.com/ekmett/monadic-arrays/";
       description = "Boxed and unboxed arrays for monad transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monadic-arrays" = callPackage
    ({ mkDerivation, array, base, stm, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "monadic-arrays";
       version = "0.2.2";
       sha256 = "667714c6100272b48c4377cf2e2984b67a4445521a2a2e9c37539128c7e276a0";
       libraryHaskellDepends = [
         array base stm transformers transformers-compat
       ];
       homepage = "http://github.com/ekmett/monadic-arrays/";
       description = "Boxed and unboxed arrays for monad transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monadiccp" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec, pretty, random }:
     mkDerivation {
       pname = "monadiccp";
       version = "0.7.6";
       sha256 = "ac53f2d24ac25476f9514a8c1fdf3092aad7b9d3cf36bb7cc90531354abe7720";
       libraryHaskellDepends = [
         base containers mtl parsec pretty random
       ];
       homepage = "http://users.ugent.be/~tschrijv/MCP/";
       description = "Constraint Programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monadiccp-gecode" = callPackage
    ({ mkDerivation, base, containers, gecodeint, gecodekernel
     , gecodesearch, gecodeset, gecodesupport, monadiccp, mtl
     }:
     mkDerivation {
       pname = "monadiccp-gecode";
       version = "0.1.2";
       sha256 = "e0f1c060a0670f51c1219b9d7661b64169d03cfd2e04857086f38cc5e8fc9efa";
       libraryHaskellDepends = [ base containers monadiccp mtl ];
       librarySystemDepends = [
         gecodeint gecodekernel gecodesearch gecodeset gecodesupport
       ];
       homepage = "http://users.ugent.be/~tschrijv/MCP/";
       description = "Constraint Programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gecodeint = null; gecodekernel = null; gecodesearch = null; 
         gecodeset = null; gecodesupport = null;};

  "monadio-unwrappable" = callPackage
    ({ mkDerivation, base, monads-tf, transformers }:
     mkDerivation {
       pname = "monadio-unwrappable";
       version = "0.3";
       sha256 = "b0fb82eefcfe3261baccf50380b7ea536b8fd0d227ac1014658e26d937890ba2";
       libraryHaskellDepends = [ base monads-tf transformers ];
       description = "Reversibly allow monad transformer stacks to run in IO";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monadlist" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "monadlist";
       version = "0.0.2";
       sha256 = "06bbe82c9fc2a35048788367da74bb5f79c7e6be2ae38eca20f332f8cbc5fdfe";
       libraryHaskellDepends = [ base ];
       description = "Monadic versions of list functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monadloc" = callPackage
    ({ mkDerivation, base, template-haskell, transformers }:
     mkDerivation {
       pname = "monadloc";
       version = "0.7.1";
       sha256 = "b25a0f6b3ebb051e58e2a58f2f5d588ff67622584cb575d40c46eaacbd1de7a8";
       libraryHaskellDepends = [ base template-haskell transformers ];
       homepage = "http://github.com/pepeiborra/monadloc";
       description = "A class for monads which can keep a monadic call trace";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "monadloc-pp" = callPackage
    ({ mkDerivation, base, filepath, haskell-src-exts, monadloc, pretty
     , syb
     }:
     mkDerivation {
       pname = "monadloc-pp";
       version = "0.3.1";
       sha256 = "ec56d05f9ee3b66d3908e90f0d90800e0a242a5c5856d3b88db00ff3d92c0232";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base filepath haskell-src-exts monadloc pretty syb
       ];
       jailbreak = true;
       homepage = "http://github.com/pepeiborra/monadloc-pp";
       description = "A preprocessor for generating monadic call traces";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "monadplus" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "monadplus";
       version = "1.4.2";
       sha256 = "366ed520db1eaf2ec56d8508fee2804cc24c7a6016de4b75b9addec681186595";
       libraryHaskellDepends = [ base ];
       description = "Haskell98 partial maps and filters over MonadPlus";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monads-fd" = callPackage
    ({ mkDerivation, base, mtl, transformers }:
     mkDerivation {
       pname = "monads-fd";
       version = "0.2.0.0";
       sha256 = "8c74b3fdd916187655b9c9feec99b44592c2b2161ff3e6f7ad5d17b5c72d19c7";
       libraryHaskellDepends = [ base mtl transformers ];
       jailbreak = true;
       description = "Monad classes, using functional dependencies";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monads-tf" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "monads-tf";
       version = "0.1.0.2";
       sha256 = "cb6f495443f526b00b3d06535aa29e393473244acd410cba1b898eeaa8f8077c";
       libraryHaskellDepends = [ base transformers ];
       description = "Monad classes, using type families";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monadtransform" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "monadtransform";
       version = "0.0.2";
       sha256 = "db87a9feaef9874e338f49e6180e0bdf1f8215904774c16775f21061e037a844";
       libraryHaskellDepends = [ base transformers ];
       homepage = "https://github.com/tonymorris/monadtransform";
       description = "A type-class for transforming monads (homomorphism) in a transformer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monarch" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, doctest
     , hspec, lifted-base, monad-control, mtl, network, pool-conduit
     , stm, transformers, transformers-base
     }:
     mkDerivation {
       pname = "monarch";
       version = "0.10.0.0";
       sha256 = "3bea109f2e3d4d3481f3f6807ea5898707fcd6c81965adc91c35535a298487a8";
       libraryHaskellDepends = [
         base binary bytestring containers lifted-base monad-control mtl
         network pool-conduit stm transformers transformers-base
       ];
       testHaskellDepends = [
         base bytestring doctest hspec transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/notogawa/monarch";
       description = "Monadic interface for TokyoTyrant";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mongoDB_2_0_3" = callPackage
    ({ mkDerivation, array, base, binary, bson, bytestring, containers
     , cryptohash, hashtables, lifted-base, monad-control, mtl, network
     , parsec, random, random-shuffle, text, transformers-base
     }:
     mkDerivation {
       pname = "mongoDB";
       version = "2.0.3";
       sha256 = "732924ea013d9b4b103228b525a55f89ea4bbe3af61fe08241d4255ec16898ae";
       libraryHaskellDepends = [
         array base binary bson bytestring containers cryptohash hashtables
         lifted-base monad-control mtl network parsec random random-shuffle
         text transformers-base
       ];
       homepage = "https://github.com/mongodb-haskell/mongodb";
       description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mongoDB_2_0_4" = callPackage
    ({ mkDerivation, array, base, binary, bson, bytestring, containers
     , cryptohash, hashtables, hspec, lifted-base, monad-control, mtl
     , network, old-locale, parsec, random, random-shuffle, text, time
     , transformers-base
     }:
     mkDerivation {
       pname = "mongoDB";
       version = "2.0.4";
       sha256 = "fe5dd0695cab47880e7d84824b7ea31c67e22a9fee5f44efa6749b57ff169bbd";
       libraryHaskellDepends = [
         array base binary bson bytestring containers cryptohash hashtables
         lifted-base monad-control mtl network parsec random random-shuffle
         text transformers-base
       ];
       testHaskellDepends = [ base hspec mtl old-locale time ];
       homepage = "https://github.com/mongodb-haskell/mongodb";
       description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mongoDB_2_0_5" = callPackage
    ({ mkDerivation, array, base, binary, bson, bytestring, containers
     , cryptohash, hashtables, hspec, lifted-base, monad-control, mtl
     , network, old-locale, parsec, random, random-shuffle, text, time
     , transformers-base
     }:
     mkDerivation {
       pname = "mongoDB";
       version = "2.0.5";
       sha256 = "705c30dd2240eb7842e8e9a53dfb6580a2ca07760f0729b5f317f57375e1da27";
       libraryHaskellDepends = [
         array base binary bson bytestring containers cryptohash hashtables
         lifted-base monad-control mtl network parsec random random-shuffle
         text transformers-base
       ];
       testHaskellDepends = [ base hspec mtl old-locale time ];
       homepage = "https://github.com/mongodb-haskell/mongodb";
       description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mongoDB_2_0_6" = callPackage
    ({ mkDerivation, array, base, binary, bson, bytestring, containers
     , cryptohash, hashtables, hspec, lifted-base, monad-control, mtl
     , network, old-locale, parsec, random, random-shuffle, text, time
     , transformers-base
     }:
     mkDerivation {
       pname = "mongoDB";
       version = "2.0.6";
       sha256 = "d6b7699d98a9349b2711be23fce0c61fbf91b66e4625e937ca1b65c6b6f988c5";
       libraryHaskellDepends = [
         array base binary bson bytestring containers cryptohash hashtables
         lifted-base monad-control mtl network parsec random random-shuffle
         text transformers-base
       ];
       testHaskellDepends = [ base hspec mtl old-locale text time ];
       homepage = "https://github.com/mongodb-haskell/mongodb";
       description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mongoDB_2_0_7" = callPackage
    ({ mkDerivation, array, base, binary, bson, bytestring, containers
     , cryptohash, hashtables, hspec, lifted-base, monad-control, mtl
     , network, old-locale, parsec, random, random-shuffle, text, time
     , transformers-base
     }:
     mkDerivation {
       pname = "mongoDB";
       version = "2.0.7";
       sha256 = "ca0653656949b882f47e0b77fd8bc04b8437c94f114ebdf60544191ea6f9826d";
       libraryHaskellDepends = [
         array base binary bson bytestring containers cryptohash hashtables
         lifted-base monad-control mtl network parsec random random-shuffle
         text transformers-base
       ];
       testHaskellDepends = [ base hspec mtl old-locale text time ];
       homepage = "https://github.com/mongodb-haskell/mongodb";
       description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mongoDB_2_0_8" = callPackage
    ({ mkDerivation, array, base, binary, bson, bytestring, containers
     , cryptohash, hashtables, hspec, lifted-base, monad-control, mtl
     , network, old-locale, parsec, random, random-shuffle, text, time
     , transformers-base
     }:
     mkDerivation {
       pname = "mongoDB";
       version = "2.0.8";
       sha256 = "d515ad855fb008848c62bea117925ef6cf48f62c9dfe94c9efbca4a65a1ac5d9";
       libraryHaskellDepends = [
         array base binary bson bytestring containers cryptohash hashtables
         lifted-base monad-control mtl network parsec random random-shuffle
         text transformers-base
       ];
       testHaskellDepends = [ base hspec mtl old-locale text time ];
       homepage = "https://github.com/mongodb-haskell/mongodb";
       description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mongoDB_2_0_9" = callPackage
    ({ mkDerivation, array, base, base16-bytestring, base64-bytestring
     , binary, bson, bytestring, containers, cryptohash, hashtables
     , hspec, lifted-base, monad-control, mtl, network, nonce
     , old-locale, parsec, random, random-shuffle, text, time
     , transformers-base
     }:
     mkDerivation {
       pname = "mongoDB";
       version = "2.0.9";
       sha256 = "aae433636448e8b0b118a74b2110c622a4127ae6184d8c6e9bfba8d67e082237";
       libraryHaskellDepends = [
         array base base16-bytestring base64-bytestring binary bson
         bytestring containers cryptohash hashtables lifted-base
         monad-control mtl network nonce parsec random random-shuffle text
         transformers-base
       ];
       testHaskellDepends = [ base hspec mtl old-locale text time ];
       doHaddock = false;
       homepage = "https://github.com/mongodb-haskell/mongodb";
       description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mongoDB" = callPackage
    ({ mkDerivation, array, base, base16-bytestring, base64-bytestring
     , binary, bson, bytestring, containers, cryptohash, hashtables
     , hspec, lifted-base, monad-control, mtl, network, nonce
     , old-locale, parsec, random, random-shuffle, text, time
     , transformers-base
     }:
     mkDerivation {
       pname = "mongoDB";
       version = "2.0.10";
       sha256 = "8986956648874ce70c0bc4682d7856ea20c1477895405c532e6de34573f5b0df";
       libraryHaskellDepends = [
         array base base16-bytestring base64-bytestring binary bson
         bytestring containers cryptohash hashtables lifted-base
         monad-control mtl network nonce parsec random random-shuffle text
         transformers-base
       ];
       testHaskellDepends = [ base hspec mtl old-locale text time ];
       doHaddock = false;
       homepage = "https://github.com/mongodb-haskell/mongodb";
       description = "Driver (client) for MongoDB, a free, scalable, fast, document DBMS";
       license = "unknown";
     }) {};

  "mongodb-queue" = callPackage
    ({ mkDerivation, base, data-default, hspec, lifted-base
     , monad-control, mongoDB, network, text, transformers
     }:
     mkDerivation {
       pname = "mongodb-queue";
       version = "0.4.0.1";
       sha256 = "5a884889ffbc3a5e2c7ac45719f64664685a1b6057450347542595e39a2f6cf8";
       libraryHaskellDepends = [
         base data-default lifted-base monad-control mongoDB network text
         transformers
       ];
       testHaskellDepends = [
         base data-default hspec lifted-base monad-control mongoDB network
         text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/docmunch/haskell-mongodb-queue";
       description = "message queue using MongoDB";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mongrel2-handler" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-textual
     , bytestring, case-insensitive, containers, http-types, text
     , zeromq-haskell
     }:
     mkDerivation {
       pname = "mongrel2-handler";
       version = "0.3.2";
       sha256 = "ae4992edaab6a1283b67cdf2ea7d0c9ae5f2ac1170107ae8c9a0ac0b968869af";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-textual bytestring
         case-insensitive containers http-types text zeromq-haskell
       ];
       jailbreak = true;
       description = "Mongrel2 Handler Library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monitor" = callPackage
    ({ mkDerivation, base, filepath, hinotify, process }:
     mkDerivation {
       pname = "monitor";
       version = "0.1.1";
       sha256 = "7a6d7d1ed57f560e6bd5c49988a0525b304f2af9d8a953288384f6e18bece91a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base filepath hinotify process ];
       description = "Do things when files change";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "mono-foldable" = callPackage
    ({ mkDerivation, base, bytestring, text, vector }:
     mkDerivation {
       pname = "mono-foldable";
       version = "0.1.0.2";
       sha256 = "b5d3def13119b4d1deb456d271876848aef35e6c52b32ea4e79f19d06ee2cbe2";
       libraryHaskellDepends = [ base bytestring text vector ];
       jailbreak = true;
       homepage = "http://github.com/JohnLato/mono-foldable";
       description = "Folds for monomorphic containers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mono-traversable_0_6_3" = callPackage
    ({ mkDerivation, base, bytestring, comonad, containers, dlist
     , dlist-instances, foldl, hashable, hspec, QuickCheck
     , semigroupoids, semigroups, text, transformers
     , unordered-containers, vector, vector-algorithms, vector-instances
     }:
     mkDerivation {
       pname = "mono-traversable";
       version = "0.6.3";
       sha256 = "79d2d0e50a71b0be4455b29a37f5416ee7e5ff7c88a6b5e1d6145113458cd808";
       revision = "2";
       editedCabalFile = "b6d1d0b8f48138ce8d38b01862c556fa30e72198061f689bd020f8f1fe71d96e";
       libraryHaskellDepends = [
         base bytestring comonad containers dlist dlist-instances hashable
         semigroupoids semigroups text transformers unordered-containers
         vector vector-algorithms vector-instances
       ];
       testHaskellDepends = [
         base bytestring containers foldl hspec QuickCheck semigroups text
         transformers unordered-containers vector
       ];
       homepage = "https://github.com/snoyberg/mono-traversable";
       description = "Type classes for mapping, folding, and traversing monomorphic containers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mono-traversable_0_7_0" = callPackage
    ({ mkDerivation, base, bytestring, comonad, containers, dlist
     , dlist-instances, foldl, hashable, hspec, QuickCheck
     , semigroupoids, semigroups, text, transformers
     , unordered-containers, vector, vector-algorithms, vector-instances
     }:
     mkDerivation {
       pname = "mono-traversable";
       version = "0.7.0";
       sha256 = "2402b614158f72c2c7aff654d64036cebb223d2cb261813104064ce4f1d5a404";
       revision = "2";
       editedCabalFile = "e5ecd3bfd2c391001beaa042d93002c06b0e2ba676ee93cacd3de9143edd025c";
       libraryHaskellDepends = [
         base bytestring comonad containers dlist dlist-instances hashable
         semigroupoids semigroups text transformers unordered-containers
         vector vector-algorithms vector-instances
       ];
       testHaskellDepends = [
         base bytestring containers foldl hspec QuickCheck semigroups text
         transformers unordered-containers vector
       ];
       homepage = "https://github.com/snoyberg/mono-traversable";
       description = "Type classes for mapping, folding, and traversing monomorphic containers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mono-traversable_0_9_1" = callPackage
    ({ mkDerivation, base, bytestring, comonad, containers, dlist
     , dlist-instances, foldl, hashable, hspec, HUnit, QuickCheck
     , semigroupoids, semigroups, text, transformers
     , unordered-containers, vector, vector-algorithms, vector-instances
     }:
     mkDerivation {
       pname = "mono-traversable";
       version = "0.9.1";
       sha256 = "ec7700a38f9838daa19a2828673620b6a57bffe4d5cf3b70ae6e4e1a1ba5f843";
       revision = "2";
       editedCabalFile = "94220a010929ffa4b669d797531cbd5b67ae4bbb7432a5b1b3b02f09065bc0c3";
       libraryHaskellDepends = [
         base bytestring comonad containers dlist dlist-instances hashable
         semigroupoids semigroups text transformers unordered-containers
         vector vector-algorithms vector-instances
       ];
       testHaskellDepends = [
         base bytestring containers foldl hspec HUnit QuickCheck semigroups
         text transformers unordered-containers vector
       ];
       homepage = "https://github.com/snoyberg/mono-traversable";
       description = "Type classes for mapping, folding, and traversing monomorphic containers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mono-traversable_0_9_2_1" = callPackage
    ({ mkDerivation, base, bytestring, comonad, containers, dlist
     , dlist-instances, foldl, hashable, hspec, HUnit, QuickCheck
     , semigroupoids, semigroups, text, transformers
     , unordered-containers, vector, vector-algorithms, vector-instances
     }:
     mkDerivation {
       pname = "mono-traversable";
       version = "0.9.2.1";
       sha256 = "34c3827b49e47e83bdbed647ae6ca27e049be8887904007b57b03dc006b542ef";
       revision = "2";
       editedCabalFile = "4c2e3ae2b7520b1128c6c467a29bf4113f5e5d966a588a52179190df6637ce40";
       libraryHaskellDepends = [
         base bytestring comonad containers dlist dlist-instances hashable
         semigroupoids semigroups text transformers unordered-containers
         vector vector-algorithms vector-instances
       ];
       testHaskellDepends = [
         base bytestring containers foldl hspec HUnit QuickCheck semigroups
         text transformers unordered-containers vector
       ];
       homepage = "https://github.com/snoyberg/mono-traversable";
       description = "Type classes for mapping, folding, and traversing monomorphic containers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mono-traversable_0_9_3" = callPackage
    ({ mkDerivation, base, bytestring, comonad, containers, dlist
     , dlist-instances, foldl, hashable, hspec, HUnit, QuickCheck
     , semigroupoids, semigroups, split, text, transformers
     , unordered-containers, vector, vector-algorithms, vector-instances
     }:
     mkDerivation {
       pname = "mono-traversable";
       version = "0.9.3";
       sha256 = "d73b495b65cdc3951e2407d07e46b3cb5b3ab074b474c0742687b616f4e7e4db";
       revision = "2";
       editedCabalFile = "b9de7890b4bb32d2e6e41c6ef1d69e45b721a528350bf8d46acea645d627c9f5";
       libraryHaskellDepends = [
         base bytestring comonad containers dlist dlist-instances hashable
         semigroupoids semigroups split text transformers
         unordered-containers vector vector-algorithms vector-instances
       ];
       testHaskellDepends = [
         base bytestring containers foldl hspec HUnit QuickCheck semigroups
         text transformers unordered-containers vector
       ];
       homepage = "https://github.com/snoyberg/mono-traversable";
       description = "Type classes for mapping, folding, and traversing monomorphic containers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mono-traversable_0_10_0_1" = callPackage
    ({ mkDerivation, base, bytestring, comonad, containers, dlist
     , dlist-instances, foldl, hashable, hspec, HUnit, QuickCheck
     , semigroupoids, semigroups, split, text, transformers
     , unordered-containers, vector, vector-algorithms, vector-instances
     }:
     mkDerivation {
       pname = "mono-traversable";
       version = "0.10.0.1";
       sha256 = "2e25c24ed3cf644cd4818cfb6d4e122cffcac2a375f0edb544b6814f871af45d";
       revision = "2";
       editedCabalFile = "00a92bc7f9dc2205d1a467ed3b9752787bc45793800eaf77a91f6bd9eee50584";
       libraryHaskellDepends = [
         base bytestring comonad containers dlist dlist-instances hashable
         semigroupoids semigroups split text transformers
         unordered-containers vector vector-algorithms vector-instances
       ];
       testHaskellDepends = [
         base bytestring containers foldl hspec HUnit QuickCheck semigroups
         text transformers unordered-containers vector
       ];
       homepage = "https://github.com/snoyberg/mono-traversable";
       description = "Type classes for mapping, folding, and traversing monomorphic containers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mono-traversable_0_10_1" = callPackage
    ({ mkDerivation, base, bytestring, comonad, containers, dlist
     , dlist-instances, foldl, hashable, hspec, HUnit, QuickCheck
     , semigroupoids, semigroups, split, text, transformers
     , unordered-containers, vector, vector-algorithms, vector-instances
     }:
     mkDerivation {
       pname = "mono-traversable";
       version = "0.10.1";
       sha256 = "a82e63352ed854319bca7d33e3aa13a42a18648e47d01109f8c306ee54b9418b";
       revision = "1";
       editedCabalFile = "9e3d9071851b695eeaa944b8ccecc3f0cad59961a4edb05fa15b4e37eed75235";
       libraryHaskellDepends = [
         base bytestring comonad containers dlist dlist-instances hashable
         semigroupoids semigroups split text transformers
         unordered-containers vector vector-algorithms vector-instances
       ];
       testHaskellDepends = [
         base bytestring containers foldl hspec HUnit QuickCheck semigroups
         text transformers unordered-containers vector
       ];
       homepage = "https://github.com/snoyberg/mono-traversable";
       description = "Type classes for mapping, folding, and traversing monomorphic containers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mono-traversable" = callPackage
    ({ mkDerivation, base, bytestring, comonad, containers, dlist
     , dlist-instances, foldl, hashable, hspec, HUnit, QuickCheck
     , semigroupoids, semigroups, split, text, transformers
     , unordered-containers, vector, vector-algorithms, vector-instances
     }:
     mkDerivation {
       pname = "mono-traversable";
       version = "0.10.1.1";
       sha256 = "a15fe3e4c92a6293a8959f77a6054ae85f5a1be049b2f7b07997245d6e6b574b";
       libraryHaskellDepends = [
         base bytestring comonad containers dlist dlist-instances hashable
         semigroupoids semigroups split text transformers
         unordered-containers vector vector-algorithms vector-instances
       ];
       testHaskellDepends = [
         base bytestring containers foldl hspec HUnit QuickCheck semigroups
         text transformers unordered-containers vector
       ];
       homepage = "https://github.com/snoyberg/mono-traversable";
       description = "Type classes for mapping, folding, and traversing monomorphic containers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "monoid-absorbing" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "monoid-absorbing";
       version = "0.1.0.4";
       sha256 = "3b7f739fe8cd242d225c427f24b3bd27c8b2a9fccf78d61e58dd0da606a502eb";
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://github.com/maciejpirog/monoid-absorbing";
       description = "A library for (left, right) zero monoids and backtracking with cut";
       license = stdenv.lib.licenses.mit;
     }) {};

  "monoid-extras_0_3_3_5" = callPackage
    ({ mkDerivation, base, groups, semigroupoids, semigroups }:
     mkDerivation {
       pname = "monoid-extras";
       version = "0.3.3.5";
       sha256 = "00096ef3f26a6c093ab53a98aa61314ea848c35f40835f8eec5246f02fa1b41f";
       libraryHaskellDepends = [ base groups semigroupoids semigroups ];
       jailbreak = true;
       description = "Various extra monoid-related definitions and utilities";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monoid-extras_0_4_0_1" = callPackage
    ({ mkDerivation, base, groups, semigroupoids, semigroups }:
     mkDerivation {
       pname = "monoid-extras";
       version = "0.4.0.1";
       sha256 = "ce1f99bda388567af08e9a9f816c89bdd4837c5d71eb880b90c468322b969e49";
       libraryHaskellDepends = [ base groups semigroupoids semigroups ];
       jailbreak = true;
       description = "Various extra monoid-related definitions and utilities";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monoid-extras_0_4_0_2" = callPackage
    ({ mkDerivation, base, groups, semigroupoids, semigroups }:
     mkDerivation {
       pname = "monoid-extras";
       version = "0.4.0.2";
       sha256 = "ccf05d44831dad32d52da1d4176fc77f05f4a5f7f71719e4452fd5069b80ba32";
       libraryHaskellDepends = [ base groups semigroupoids semigroups ];
       jailbreak = true;
       description = "Various extra monoid-related definitions and utilities";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monoid-extras_0_4_0_3" = callPackage
    ({ mkDerivation, base, groups, semigroupoids, semigroups }:
     mkDerivation {
       pname = "monoid-extras";
       version = "0.4.0.3";
       sha256 = "ad2949f8f76d0716d5a7890d767c5af58b1419586aa47dd081d20b370080c30a";
       libraryHaskellDepends = [ base groups semigroupoids semigroups ];
       description = "Various extra monoid-related definitions and utilities";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monoid-extras" = callPackage
    ({ mkDerivation, base, groups, semigroupoids, semigroups }:
     mkDerivation {
       pname = "monoid-extras";
       version = "0.4.0.4";
       sha256 = "0032553ec9f06f62adc55d46a3b422497769e127cf74a427193bea1626c3b1e9";
       libraryHaskellDepends = [ base groups semigroupoids semigroups ];
       description = "Various extra monoid-related definitions and utilities";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monoid-owns" = callPackage
    ({ mkDerivation, base, bytestring, containers }:
     mkDerivation {
       pname = "monoid-owns";
       version = "2010.5.29";
       sha256 = "d351a6aed74e11dd02b9b6b74e63249a6a1aa641a653dbf2b9d258e84b7205d8";
       libraryHaskellDepends = [ base bytestring containers ];
       homepage = "http://github.com/nfjinjing/monoid-owns";
       description = "a practical monoid implementation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monoid-record" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "monoid-record";
       version = "0.1";
       sha256 = "250ac227627b07e111fa260dd07f2a41431bd5c01f4e1bb724fd59e0b60dba93";
       libraryHaskellDepends = [ base ];
       description = "Support for modifying record fields of monoidal type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monoid-statistics" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "monoid-statistics";
       version = "0.3.1";
       sha256 = "c363fb99785aff69b64955edb2c24916b53f1d7a7703c22840259f427a95cd3d";
       libraryHaskellDepends = [ base ];
       homepage = "https://bitbucket.org/Shimuuar/monoid-statistics";
       description = "Monoids for calculation of statistics of sample";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monoid-subclasses_0_3_6_2" = callPackage
    ({ mkDerivation, base, bytestring, containers, primes, QuickCheck
     , quickcheck-instances, test-framework, test-framework-quickcheck2
     , text, vector
     }:
     mkDerivation {
       pname = "monoid-subclasses";
       version = "0.3.6.2";
       sha256 = "127c8a45302f991512a8aef4fe668b985e25aaa30e747ca68d08038e285435ed";
       revision = "1";
       editedCabalFile = "42338a48c472bdd02e95619f73be7358121274f14f717e59b7dfa7404517ad33";
       libraryHaskellDepends = [
         base bytestring containers primes text vector
       ];
       testHaskellDepends = [
         base bytestring containers primes QuickCheck quickcheck-instances
         test-framework test-framework-quickcheck2 text vector
       ];
       jailbreak = true;
       homepage = "https://github.com/blamario/monoid-subclasses/";
       description = "Subclasses of Monoid";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monoid-subclasses_0_4_0_4" = callPackage
    ({ mkDerivation, base, bytestring, containers, primes, QuickCheck
     , quickcheck-instances, tasty, tasty-quickcheck, text, vector
     }:
     mkDerivation {
       pname = "monoid-subclasses";
       version = "0.4.0.4";
       sha256 = "309bd69f55b63d27ea799a314620e4177340f01db78ecc3a4c12f59748f7e5f1";
       revision = "1";
       editedCabalFile = "4e619788e858e492cbc511b5316a7fb8b383b3f25cfeff6afe6f325f0c33eccc";
       libraryHaskellDepends = [
         base bytestring containers primes text vector
       ];
       testHaskellDepends = [
         base bytestring containers primes QuickCheck quickcheck-instances
         tasty tasty-quickcheck text vector
       ];
       jailbreak = true;
       homepage = "https://github.com/blamario/monoid-subclasses/";
       description = "Subclasses of Monoid";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monoid-subclasses_0_4_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, primes, QuickCheck
     , quickcheck-instances, tasty, tasty-quickcheck, text, vector
     }:
     mkDerivation {
       pname = "monoid-subclasses";
       version = "0.4.1";
       sha256 = "7f134500b445492930890f3998cd12312e233f5f8ef7a583ed2274113103fe71";
       libraryHaskellDepends = [
         base bytestring containers primes text vector
       ];
       testHaskellDepends = [
         base bytestring containers primes QuickCheck quickcheck-instances
         tasty tasty-quickcheck text vector
       ];
       jailbreak = true;
       homepage = "https://github.com/blamario/monoid-subclasses/";
       description = "Subclasses of Monoid";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monoid-subclasses_0_4_1_2" = callPackage
    ({ mkDerivation, base, bytestring, containers, primes, QuickCheck
     , quickcheck-instances, tasty, tasty-quickcheck, text, vector
     }:
     mkDerivation {
       pname = "monoid-subclasses";
       version = "0.4.1.2";
       sha256 = "3dc5a549d39d5f8a76124728f9535150bc190064134f8dbe14e0b5817fb02a49";
       libraryHaskellDepends = [
         base bytestring containers primes text vector
       ];
       testHaskellDepends = [
         base bytestring containers primes QuickCheck quickcheck-instances
         tasty tasty-quickcheck text vector
       ];
       homepage = "https://github.com/blamario/monoid-subclasses/";
       description = "Subclasses of Monoid";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monoid-subclasses" = callPackage
    ({ mkDerivation, base, bytestring, containers, primes, QuickCheck
     , quickcheck-instances, tasty, tasty-quickcheck, text, vector
     }:
     mkDerivation {
       pname = "monoid-subclasses";
       version = "0.4.2";
       sha256 = "38257132ebd3dca4d1d95252a928ca183171ae0ba3aefd133f3c564fa3bfee2b";
       libraryHaskellDepends = [
         base bytestring containers primes text vector
       ];
       testHaskellDepends = [
         base bytestring containers primes QuickCheck quickcheck-instances
         tasty tasty-quickcheck text vector
       ];
       homepage = "https://github.com/blamario/monoid-subclasses/";
       description = "Subclasses of Monoid";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monoid-transformer" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "monoid-transformer";
       version = "0.0.3";
       sha256 = "94c8661eac0cdd85bbf9a2adc78c3030363ff94f482f5299ba8583b2f7bd06b8";
       libraryHaskellDepends = [ base ];
       description = "Monoid counterparts to some ubiquitous monad transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monoidal-containers_0_1_2_2" = callPackage
    ({ mkDerivation, base, containers, deepseq, hashable, lens, newtype
     , unordered-containers
     }:
     mkDerivation {
       pname = "monoidal-containers";
       version = "0.1.2.2";
       sha256 = "cbf3777ea3856052652742bbe129b0d542d23f7ad333a6641695922b29a9ca1b";
       libraryHaskellDepends = [
         base containers deepseq hashable lens newtype unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/bgamari/monoidal-containers";
       description = "Containers with monoidal accumulation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monoidal-containers" = callPackage
    ({ mkDerivation, base, containers, deepseq, hashable, lens, newtype
     , unordered-containers
     }:
     mkDerivation {
       pname = "monoidal-containers";
       version = "0.1.2.3";
       sha256 = "755d1dd29281b7537ef32882b20a29baeb42c19c653318bca78fbec9cd89a149";
       libraryHaskellDepends = [
         base containers deepseq hashable lens newtype unordered-containers
       ];
       homepage = "http://github.com/bgamari/monoidal-containers";
       description = "Containers with monoidal accumulation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "monoidplus" = callPackage
    ({ mkDerivation, base, contravariant, semigroups, transformers }:
     mkDerivation {
       pname = "monoidplus";
       version = "0.1.0.1";
       sha256 = "490b666011252870a3edcabbb012ad9ccd502cbd3e9f12e4c5f5a7a6c7e68fce";
       libraryHaskellDepends = [
         base contravariant semigroups transformers
       ];
       jailbreak = true;
       description = "Extra classes/functions about monoids";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monoids" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, fingertree
     , parallel, text
     }:
     mkDerivation {
       pname = "monoids";
       version = "0.3.2";
       sha256 = "8a4d74604249c4bd38bd1c561d036ceeb71dd66a9eafc681a8ad2653002ec17a";
       libraryHaskellDepends = [
         array base bytestring containers fingertree parallel text
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/monoids";
       description = "Deprecated: Use 'reducers'";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "monomorphic" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "monomorphic";
       version = "0.0.3.3";
       sha256 = "96b282a06bcb70097337128a33c4ee210b3d0285ef1044a08a18175dc98bee74";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/konn/monomorphic";
       description = "Library to convert polymorphic datatypes to/from its monomorphic represetation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "montage" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, ListLike
     , old-locale, pool-conduit, protocol-buffers
     , protocol-buffers-descriptor, riak-bump, safe, stats-web, stm
     , system-uuid, text, time, unordered-containers, zeromq-haskell
     }:
     mkDerivation {
       pname = "montage";
       version = "0.1.1";
       sha256 = "87ea3f424a9f57233161963fd0faeba14e1c55018aaf1bb94cfac9ee9e52a2fb";
       libraryHaskellDepends = [
         aeson base bytestring containers ListLike old-locale pool-conduit
         protocol-buffers protocol-buffers-descriptor riak-bump safe
         stats-web stm system-uuid text time unordered-containers
         zeromq-haskell
       ];
       jailbreak = true;
       homepage = "http://github.com/bumptech/montage";
       description = "Riak Resolution Proxy";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {riak-bump = null; stats-web = null;};

  "montage-client" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, ListLike, mtl
     , old-locale, pool-conduit, protocol-buffers
     , protocol-buffers-descriptor, riak-bump, safe, stats-web, stm
     , system-uuid, text, text-format, time, unordered-containers
     , zeromq-haskell
     }:
     mkDerivation {
       pname = "montage-client";
       version = "0.1.1";
       sha256 = "ee1ef7cd3650c6461e42f655a7fbeb433d8c1a36d7688ff05294fe1301576fa1";
       libraryHaskellDepends = [
         aeson base bytestring containers ListLike mtl old-locale
         pool-conduit protocol-buffers protocol-buffers-descriptor riak-bump
         safe stats-web stm system-uuid text text-format time
         unordered-containers zeromq-haskell
       ];
       jailbreak = true;
       homepage = "http://github.com/bumptech/montage-haskell-client";
       description = "Riak Resolution Proxy Client";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {riak-bump = null; stats-web = null;};

  "monte-carlo" = callPackage
    ({ mkDerivation, base, gsl-random, ieee754, primitive, QuickCheck
     , random, test-framework, test-framework-quickcheck2, transformers
     , vector
     }:
     mkDerivation {
       pname = "monte-carlo";
       version = "0.6.1";
       sha256 = "1d38a457dc408e10f04be2d01bb0d3e82cad7d6c4625d8f5b659fd959ce768fe";
       libraryHaskellDepends = [
         base gsl-random primitive transformers vector
       ];
       testHaskellDepends = [
         base gsl-random ieee754 primitive QuickCheck random test-framework
         test-framework-quickcheck2 transformers vector
       ];
       jailbreak = true;
       homepage = "http://github.com/patperry/hs-monte-carlo";
       description = "A monad and transformer for Monte Carlo calculations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "moo" = callPackage
    ({ mkDerivation, array, base, containers, gray-code, HUnit
     , mersenne-random-pure64, monad-mersenne-random, mtl, random
     , random-shuffle, time
     }:
     mkDerivation {
       pname = "moo";
       version = "1.0";
       sha256 = "dcd879d80b31f71b40cde58a44b1f936a9ec41cf569af3276ada2a02cd4e5009";
       libraryHaskellDepends = [
         array base gray-code mersenne-random-pure64 monad-mersenne-random
         mtl random random-shuffle time
       ];
       testHaskellDepends = [
         array base containers gray-code HUnit mersenne-random-pure64
         monad-mersenne-random mtl random random-shuffle time
       ];
       homepage = "http://www.github.com/astanin/moo/";
       description = "Genetic algorithm library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "moonshine" = callPackage
    ({ mkDerivation, aeson, base, bytestring, canteven-config, ekg
     , ekg-core, hslogger, snap, text, time, transformers, yaml
     }:
     mkDerivation {
       pname = "moonshine";
       version = "2.0.0.0";
       sha256 = "1a1bed5a06a3eb16393e94f40dfb32c34695033ee5695f709adf9669133c0bad";
       libraryHaskellDepends = [
         aeson base bytestring canteven-config ekg ekg-core hslogger snap
         text time transformers yaml
       ];
       homepage = "https://github.com/SumAll/moonshine";
       description = "A web service framework for Haskell, similar in purpose to dropwizard";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "morfette" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, filepath, mtl, pretty, QuickCheck, text, utf8-string
     , vector
     }:
     mkDerivation {
       pname = "morfette";
       version = "0.4.3";
       sha256 = "5e6dab28515a626a7d3a785ae3384fa5aabd3146065dbae31740695b34b83291";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base binary bytestring containers directory filepath mtl
         pretty QuickCheck text utf8-string vector
       ];
       jailbreak = true;
       homepage = "http://sites.google.com/site/morfetteweb/";
       description = "A tool for supervised learning of morphology";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "morfeusz" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, morfeusz
     , mtl, text
     }:
     mkDerivation {
       pname = "morfeusz";
       version = "0.4.2";
       sha256 = "a06b0014b3f20d752cb63e67a6611a5ccc2ab6b31c78a3dc8a3df47bf42cf4d3";
       libraryHaskellDepends = [
         base bytestring containers directory mtl text
       ];
       librarySystemDepends = [ morfeusz ];
       homepage = "https://github.com/kawu/morfeusz";
       description = "Bindings to the morphological analyser Morfeusz";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {morfeusz = null;};

  "morte" = callPackage
    ({ mkDerivation, alex, array, base, binary, containers, deepseq
     , Earley, http-client, http-client-tls, managed, microlens
     , microlens-mtl, optparse-applicative, pipes, system-fileio
     , system-filepath, text, text-format, transformers
     }:
     mkDerivation {
       pname = "morte";
       version = "1.4.2";
       sha256 = "766814c920fac0fa03a64ffe155ab46c291942d6c9652da6874e8893d6b96148";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary containers deepseq Earley http-client
         http-client-tls managed microlens microlens-mtl pipes system-fileio
         system-filepath text text-format transformers
       ];
       libraryToolDepends = [ alex ];
       executableHaskellDepends = [ base optparse-applicative text ];
       description = "A bare-bones calculus of constructions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mosaico-lib" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, colour, diagrams-cairo
     , diagrams-core, diagrams-gtk, diagrams-lib, glib, gtk, JuicyPixels
     , mtl, split, stm, stm-chans, transformers
     }:
     mkDerivation {
       pname = "mosaico-lib";
       version = "0.1.1.0";
       sha256 = "0be45e9af3ff7076c5ac2666b878ca794373116b83102344814e08a2021d99e1";
       libraryHaskellDepends = [
         base base-unicode-symbols colour diagrams-cairo diagrams-core
         diagrams-gtk diagrams-lib glib gtk JuicyPixels mtl split stm
         stm-chans transformers
       ];
       jailbreak = true;
       homepage = "http://ldc.usb.ve/~05-38235/cursos/CI3661/2015AJ/";
       description = "Generación interactiva de mosaicos";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mount" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "mount";
       version = "0.2.1";
       sha256 = "e313277fe0ea2f6f85c566af17a0b11a32df1ecfee79a4d2a1b19ad9c1b7b465";
       libraryHaskellDepends = [ base bytestring ];
       description = "Mounts and umounts filesystems";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mountpoints" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "mountpoints";
       version = "1.0.1";
       sha256 = "744abbbda305c0765e15500f9ebf0ad2185fdea1733f43525488acb21b871c80";
       libraryHaskellDepends = [ base ];
       description = "list mount points";
       license = "LGPL";
     }) {};

  "mp" = callPackage
    ({ mkDerivation, base, binary, bytestring, ConfigFile, daemons
     , directory, filepath, glib, gstreamer, hgettext, MissingH, mtl
     , network, random, setlocale, text, unix, unordered-containers
     , utf8-string, vty, vty-ui
     }:
     mkDerivation {
       pname = "mp";
       version = "0.2.2";
       sha256 = "398ec4f8adec8a6791792234e2017e65b3d297642a16698cee7b3efaa6179fce";
       revision = "1";
       editedCabalFile = "8c578611352448e5aea9a082fb0696e7bb890397214631a009351925db2f88b1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring ConfigFile daemons directory filepath glib
         gstreamer hgettext MissingH mtl network random setlocale text unix
         unordered-containers utf8-string vty vty-ui
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/borekpiotr/linux-music-player";
       description = "Music player for linux";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mp3decoder" = callPackage
    ({ mkDerivation, base, binary-strict, bytestring, haskell98, mtl }:
     mkDerivation {
       pname = "mp3decoder";
       version = "0.0.1";
       sha256 = "bbe6709b3c95bda7af5b551217ec686264259a35c7bd3a3e2f2a5d5af3b2924f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary-strict bytestring haskell98 mtl
       ];
       homepage = "http://www.bjrn.se/mp3dec";
       description = "MP3 decoder for teaching";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mpdmate" = callPackage
    ({ mkDerivation, base, directory, network, powermate, unix }:
     mkDerivation {
       pname = "mpdmate";
       version = "0.1";
       sha256 = "c251ba70e4e585a7f1f42e033034204c9cf4740d72ed6cdba0fdd7fa387ae60a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory network powermate unix
       ];
       homepage = "http://neugierig.org/software/darcs/powermate/";
       description = "MPD/PowerMate executable";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mpppc" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, split, text }:
     mkDerivation {
       pname = "mpppc";
       version = "0.1.3";
       sha256 = "b12b8ade452fe1d912848c93a49863778e4b7c5e7ca9cb57f6f8527da7a691fd";
       libraryHaskellDepends = [
         ansi-terminal base bytestring split text
       ];
       jailbreak = true;
       description = "Multi-dimensional parametric pretty-printer with color";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mpretty" = callPackage
    ({ mkDerivation, ansi-terminal, base, containers, data-lens-fd
     , data-lens-template, mtl, orders, text, transformers
     }:
     mkDerivation {
       pname = "mpretty";
       version = "0.1.0.0";
       sha256 = "5660e929da60b0cf308f16356a8ee352a702490a87393331db6bb856e5898e60";
       libraryHaskellDepends = [
         ansi-terminal base containers data-lens-fd data-lens-template mtl
         orders text transformers
       ];
       jailbreak = true;
       description = "a monadic, extensible pretty printing library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mpris" = callPackage
    ({ mkDerivation, base, containers, dbus, mtl }:
     mkDerivation {
       pname = "mpris";
       version = "0.1.0.0";
       sha256 = "3ee98b2f922e746982a46c8bd71058c1b9882c05db3eb21d21573d9b42158685";
       libraryHaskellDepends = [ base containers dbus mtl ];
       jailbreak = true;
       homepage = "http://github.com/Fuco1/mpris";
       description = "Interface for MPRIS";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "mprover" = callPackage
    ({ mkDerivation, base, containers, haskell98, mtl, parsec, pretty
     , transformers, unbound
     }:
     mkDerivation {
       pname = "mprover";
       version = "0.0.0.0";
       sha256 = "5a4f2cd9f6ce95b8b296000ce0222cfb431cca540daebf00ebd7ca6217fcbbac";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers haskell98 mtl parsec pretty transformers unbound
       ];
       description = "Simple equational reasoning for a Haskell-ish language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mps" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , filepath, monoid-owns, old-locale, old-time, parallel, parsec
     , regexpr, template-haskell, time, utf8-string
     }:
     mkDerivation {
       pname = "mps";
       version = "2010.11.28";
       sha256 = "8f120efc1842337b80763fff6042c28789016922c1b664163ef2cbccdfa60ef6";
       libraryHaskellDepends = [
         array base bytestring containers directory filepath monoid-owns
         old-locale old-time parallel parsec regexpr template-haskell time
         utf8-string
       ];
       homepage = "http://github.com/nfjinjing/mps/";
       description = "simply oo";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mpvguihs" = callPackage
    ({ mkDerivation, base, directory, filepath, gtk, mtl, process
     , template-haskell, unix
     }:
     mkDerivation {
       pname = "mpvguihs";
       version = "0.1.1";
       sha256 = "ddfffe9e15cc3fc3c295520b6c63e62403fc59b48a432fd5ae700e88f400acda";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath gtk mtl process template-haskell unix
       ];
       jailbreak = true;
       homepage = "https://github.com/sebadoom/mpvguihs";
       description = "A minimalist mpv GUI written in I/O heavy Haskell";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mqtt-hs" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, monad-loops, mtl
     , network, singletons, text
     }:
     mkDerivation {
       pname = "mqtt-hs";
       version = "0.2.0";
       sha256 = "4f56d06f2ff3ba9fd416f0894a4b1ad5b5879f56cb72876408b4b7bab0c97f4b";
       revision = "1";
       editedCabalFile = "aa0a2e9ea99cfbed4646ac02625b66361f8175ae2d70efc041dc517119706439";
       libraryHaskellDepends = [
         attoparsec base bytestring monad-loops mtl network singletons text
       ];
       jailbreak = true;
       homepage = "http://github.com/k00mi/mqtt-hs";
       description = "A MQTT client library";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "ms" = callPackage
    ({ mkDerivation, base, contravariant, doctest, edit-distance, lens
     , profunctors, semigroupoids, semigroups, tasty, tasty-quickcheck
     , vector
     }:
     mkDerivation {
       pname = "ms";
       version = "0.2.1";
       sha256 = "d766fd486c8e62d227b23425ff03366a04d7fc5eb827af10a9722dffdf6ce040";
       libraryHaskellDepends = [
         base contravariant edit-distance lens profunctors semigroupoids
         semigroups vector
       ];
       testHaskellDepends = [
         base doctest profunctors tasty tasty-quickcheck vector
       ];
       jailbreak = true;
       homepage = "https://github.com/relrod/ms";
       description = "metric spaces";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "msgpack" = callPackage
    ({ mkDerivation, base, binary, blaze-builder, bytestring
     , containers, data-binary-ieee754, deepseq, hashable, mtl
     , QuickCheck, tasty, tasty-quickcheck, text, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "msgpack";
       version = "1.0.0";
       sha256 = "08f600b8428b27ee53f8f8cbd6c772603ecc80668c3e0801055083242cb6664e";
       libraryHaskellDepends = [
         base binary blaze-builder bytestring containers data-binary-ieee754
         deepseq hashable mtl text unordered-containers vector
       ];
       testHaskellDepends = [
         base bytestring QuickCheck tasty tasty-quickcheck
       ];
       homepage = "http://msgpack.org/";
       description = "A Haskell implementation of MessagePack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "msgpack-aeson" = callPackage
    ({ mkDerivation, aeson, base, bytestring, deepseq, msgpack
     , scientific, tasty, tasty-hunit, text, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "msgpack-aeson";
       version = "0.1.0.0";
       sha256 = "72605d87d66c25cfce95e361fe6eba526fb2ed23ccea727c28c948564a9cf6f9";
       libraryHaskellDepends = [
         aeson base bytestring deepseq msgpack scientific text
         unordered-containers vector
       ];
       testHaskellDepends = [ aeson base msgpack tasty tasty-hunit ];
       homepage = "http://msgpack.org/";
       description = "Aeson adapter for MessagePack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "msgpack-idl" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, cmdargs
     , containers, directory, filepath, hspec, msgpack, peggy
     , shakespeare-text, template-haskell, text
     }:
     mkDerivation {
       pname = "msgpack-idl";
       version = "0.2.1";
       sha256 = "dfcd473e1efb39282a3c2fbb3c6477982e51a91ce11d947b92d36dc766c4487c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring containers directory filepath msgpack
         peggy shakespeare-text template-haskell text
       ];
       executableHaskellDepends = [ base cmdargs directory peggy ];
       testHaskellDepends = [ base hspec ];
       jailbreak = true;
       homepage = "http://msgpack.org/";
       description = "An IDL Compiler for MessagePack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "msgpack-rpc" = callPackage
    ({ mkDerivation, async, base, binary, binary-conduit, bytestring
     , conduit, conduit-extra, exceptions, monad-control, msgpack, mtl
     , network, random, tasty, tasty-hunit, text
     }:
     mkDerivation {
       pname = "msgpack-rpc";
       version = "1.0.0";
       sha256 = "76ca6b5fe702456d84c622fed0819abbdfa555225ce92f870ca23456e485a502";
       libraryHaskellDepends = [
         base binary binary-conduit bytestring conduit conduit-extra
         exceptions monad-control msgpack mtl network random text
       ];
       testHaskellDepends = [ async base mtl network tasty tasty-hunit ];
       homepage = "http://msgpack.org/";
       description = "A MessagePack-RPC Implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "msh" = callPackage
    ({ mkDerivation, base, containers, haskell-src-exts
     , haskell-src-meta, lens, mtl, parsec, template-haskell, text
     }:
     mkDerivation {
       pname = "msh";
       version = "0.1.0.2";
       sha256 = "841959f17db990cf8894feb2ead08d758dcff502e1cd1b88f9bb2a9145e3a9f8";
       libraryHaskellDepends = [
         base containers haskell-src-exts haskell-src-meta lens mtl parsec
         template-haskell text
       ];
       homepage = "http://www.cl.cam.ac.uk/~mbg28/";
       description = "Object-Oriented Programming in Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "msi-kb-backlit" = callPackage
    ({ mkDerivation, base, bytestring, hid, split }:
     mkDerivation {
       pname = "msi-kb-backlit";
       version = "0.1.0.1";
       sha256 = "8437ed623ae07c5350d24b5b8f96ac82fdade7afe9cd6a6085b39103475001d3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bytestring hid split ];
       description = "A command line tool to change backlit colors of your MSI keyboards";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "mstate" = callPackage
    ({ mkDerivation, base, monad-peel, mtl, stm }:
     mkDerivation {
       pname = "mstate";
       version = "0.2.7";
       sha256 = "4508e3e7cc2dec5a0e75ba7dd085c73fdd4f886ac6d1a74cf071816795bb2c17";
       libraryHaskellDepends = [ base monad-peel mtl stm ];
       description = "MState: A consistent State monad for concurrent applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "msu" = callPackage
    ({ mkDerivation, base, directory, filepath, mtl, parsec, process
     , xdg-basedir
     }:
     mkDerivation {
       pname = "msu";
       version = "0.0.2";
       sha256 = "acf4ddf7122571b0d5bec3e0c576d65f969230956cd82e400646b6e1cffc1f2f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath mtl parsec process xdg-basedir
       ];
       homepage = "http://github.com/pbrisbin/msu";
       description = "Monitor Setup Utility";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mtgoxapi" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, bytestring, curl, either, errors, hashable
     , HTTP, HUnit, ixset, network, QuickCheck, SHA, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , transformers, unordered-containers, vector, watchdog
     }:
     mkDerivation {
       pname = "mtgoxapi";
       version = "0.5.0.2";
       sha256 = "51fec86d45e44ae197d275e298b0a16567aed02948af0aaf288962077015d6c7";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         bytestring curl either errors hashable HTTP ixset network SHA text
         time transformers unordered-containers vector watchdog
       ];
       testHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         bytestring curl errors hashable HTTP HUnit ixset network QuickCheck
         SHA test-framework test-framework-hunit test-framework-quickcheck2
         text time transformers unordered-containers vector watchdog
       ];
       jailbreak = true;
       description = "Library to communicate with Mt.Gox";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mtl_2_1_3_1" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "mtl";
       version = "2.1.3.1";
       sha256 = "77af766957fb49361fe63446f272a698bddb13398669edc363022e5c2517f6f6";
       libraryHaskellDepends = [ base transformers ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/mtl";
       description = "Monad classes, using functional dependencies";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mtl" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "mtl";
       version = "2.2.1";
       sha256 = "cae59d79f3a16f8e9f3c9adc1010c7c6cdddc73e8a97ff4305f6439d855c8dc5";
       revision = "1";
       editedCabalFile = "4b5a800fe9edf168fc7ae48c7a3fc2aab6b418ac15be2f1dad43c0f48a494a3b";
       libraryHaskellDepends = [ base transformers ];
       homepage = "http://github.com/ekmett/mtl";
       description = "Monad classes, using functional dependencies";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mtl-c" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "mtl-c";
       version = "0.1";
       sha256 = "eb852379c1710af26179c148114b5269f568e3b8317b1a5716f2a07d00942159";
       libraryHaskellDepends = [ base mtl ];
       homepage = "https://github.com/fumieval/mtl-c";
       description = "Very strict CPS'd transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mtl-compat_0_2_1_1" = callPackage
    ({ mkDerivation, base, mtl, transformers-compat }:
     mkDerivation {
       pname = "mtl-compat";
       version = "0.2.1.1";
       sha256 = "ac06e0ad010045e8bb1fc894303d6060fffc9d14bf6e8d90c83d1c7eb23b95e9";
       revision = "3";
       editedCabalFile = "1847f7f92b4878613f0f7b0062f3a3744bbd5c6aed0eb1cfd5c2ddfc5e41689b";
       libraryHaskellDepends = [ base mtl transformers-compat ];
       jailbreak = true;
       homepage = "https://github.com/haskell-compat/mtl-compat";
       description = "Backported Control.Monad.Except module from mtl";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mtl-compat" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "mtl-compat";
       version = "0.2.1.3";
       sha256 = "6458ca53593a31ebce1d94ef8dd4f6a06d050dd7ed32335f6cc6b6e5d3456894";
       revision = "3";
       editedCabalFile = "6c94536cf0a7415c1fb740d1a98a109928e77ac0bc1fc2f77b460c7c58d6ee45";
       libraryHaskellDepends = [ base mtl ];
       doHaddock = false;
       homepage = "https://github.com/haskell-compat/mtl-compat";
       description = "Backported Control.Monad.Except module from mtl";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mtl-evil-instances" = callPackage
    ({ mkDerivation, base, monad-control, mtl, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "mtl-evil-instances";
       version = "0.1";
       sha256 = "a47ad8b59de5277e7d74235ae1dc49004cc722f67f5a43986ccacb5d1bb820fc";
       libraryHaskellDepends = [
         base monad-control mtl transformers transformers-base
       ];
       jailbreak = true;
       description = "Instances for the mtl classes for all monad transformers";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "mtl-prelude_1_0_1" = callPackage
    ({ mkDerivation, mtl, transformers }:
     mkDerivation {
       pname = "mtl-prelude";
       version = "1.0.1";
       sha256 = "128a44cbce4527429a4a630357bb6f5a68bfc96fc11e82286465114fe0d3ed27";
       libraryHaskellDepends = [ mtl transformers ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/mtl-prelude";
       description = "Reexports of most definitions from \"mtl\" and \"transformers\"";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mtl-prelude_1_0_2" = callPackage
    ({ mkDerivation, mtl, transformers }:
     mkDerivation {
       pname = "mtl-prelude";
       version = "1.0.2";
       sha256 = "dedd1e54e8d433140f485e187de448e96270ca2e4a873cacbd034fda51f68067";
       libraryHaskellDepends = [ mtl transformers ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/mtl-prelude";
       description = "Reexports of most definitions from \"mtl\" and \"transformers\"";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mtl-prelude_1_0_3" = callPackage
    ({ mkDerivation, base, mtl, transformers }:
     mkDerivation {
       pname = "mtl-prelude";
       version = "1.0.3";
       sha256 = "1d811002b816c7afabf06eae1895a20862837432294abbde2892e6f4185f20e3";
       libraryHaskellDepends = [ base mtl transformers ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/mtl-prelude";
       description = "Reexports of most definitions from \"mtl\" and \"transformers\"";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mtl-prelude" = callPackage
    ({ mkDerivation, base, mtl, transformers }:
     mkDerivation {
       pname = "mtl-prelude";
       version = "2.0.2";
       sha256 = "5b549441d41f1b542fe14b514098e60d4501f972f7d5d7626d53e21867bb82c8";
       libraryHaskellDepends = [ base mtl transformers ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/mtl-prelude";
       description = "Reexports of most definitions from \"mtl\" and \"transformers\"";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mtl-tf" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "mtl-tf";
       version = "0.1";
       sha256 = "4e086ab1d2647f1f1337b3104e7da6b86b2e008010b138b981ab24391bd7d561";
       libraryHaskellDepends = [ base ];
       description = "Monad transformer library using type families";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mtl-unleashed" = callPackage
    ({ mkDerivation, base, contravariant, hspec, hspec-core, lens, mtl
     , profunctors, tagged, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "mtl-unleashed";
       version = "0.6.1";
       sha256 = "330d0193940de75b851d55d2b2e92e9a3b62fd3396e37a093610320545fa0a44";
       libraryHaskellDepends = [
         base contravariant lens mtl profunctors tagged transformers
         transformers-compat
       ];
       testHaskellDepends = [
         base contravariant hspec hspec-core lens mtl profunctors
       ];
       homepage = "https://github.com/seereason/mtl-unleashed";
       description = "MTL classes without the functional dependency";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mtlparse_0_1_2" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "mtlparse";
       version = "0.1.2";
       sha256 = "cd85d985e4eff842b1c053a2ff507094a20995c5757acc06ea34ff07d9edd142";
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://homepage3.nifty.com/salamander/second/projects/mtlparse/";
       description = "parse library using mtl package";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mtlparse" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "mtlparse";
       version = "0.1.4.0";
       sha256 = "ec79238fe6f19ee7b3d2ab4fe5490419ba0b10e4820dfde5c3eb8cf9eace85ba";
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://homepage3.nifty.com/salamander/second/projects/mtlparse/";
       description = "parse library using mtl package";
       license = "LGPL";
     }) {};

  "mtlx" = callPackage
    ({ mkDerivation, base, mtl, QuickCheck }:
     mkDerivation {
       pname = "mtlx";
       version = "0.1.6";
       sha256 = "b69139f7d0cce8d6b57e99071864b3b7cf3feb81920f4e02ce67b96071b40c68";
       libraryHaskellDepends = [ base mtl QuickCheck ];
       description = "Monad transformer library with type indexes, providing 'free' copies";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mtp" = callPackage
    ({ mkDerivation, base, filepath, mtp, unix }:
     mkDerivation {
       pname = "mtp";
       version = "0.1.1.1";
       sha256 = "9c2f5d3d16cbb7c9d682ee5c2fb4b36a01fb3249d35d7c0727561516d03d9898";
       libraryHaskellDepends = [ base filepath unix ];
       librarySystemDepends = [ mtp ];
       jailbreak = true;
       description = "Bindings to libmtp";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {mtp = null;};

  "mtree" = callPackage
    ({ mkDerivation, base, bifunctors }:
     mkDerivation {
       pname = "mtree";
       version = "0.1";
       sha256 = "9b3ecc824097f71cf0f4baf47183706aeb4c9ba91e70441c9c17ed926b9693d0";
       libraryHaskellDepends = [ base bifunctors ];
       description = "Tree with Meta and Content parameters";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "mucipher" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "mucipher";
       version = "0.6.0";
       sha256 = "1e3c0ec3f33cf662c57c06503422637af625d39cbb57f29f843c45bb48ccad2e";
       libraryHaskellDepends = [ base ];
       description = "A library to produce simple ciphers for use with lambdabot";
       license = "GPL";
     }) {};

  "mudbath" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cryptohash, directory
     , github-types, http-conduit, http-types, process, random
     , snap-core, snap-server, stm, text, transformers
     }:
     mkDerivation {
       pname = "mudbath";
       version = "0.0.3";
       sha256 = "785893adc915cd925503f25eae2fca8c2132e41f465fa990ea52a904a87edaad";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring cryptohash directory github-types
         http-conduit http-types process random snap-core snap-server stm
         text transformers
       ];
       jailbreak = true;
       description = "Continuous deployment server for use with GitHub";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "muesli" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, directory
     , filepath, hashable, mtl, psqueues, time
     }:
     mkDerivation {
       pname = "muesli";
       version = "0.1.1.0";
       sha256 = "bc88e08c5534dc4f31ea18c2dd8ca8d3c66126be94db97e45ffbfdf486c7da33";
       libraryHaskellDepends = [
         base bytestring cereal containers directory filepath hashable mtl
         psqueues time
       ];
       homepage = "https://github.com/clnx/muesli";
       description = "A simple document-oriented database";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mueval" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory
     , extensible-exceptions, filepath, hint, mtl, process, QuickCheck
     , show, simple-reflect, unix
     }:
     mkDerivation {
       pname = "mueval";
       version = "0.9.1.1.2";
       sha256 = "e04c3b754695cc8f71c072c6398b8a567c112c69d48355b5bca9bfbb1c050ac1";
       revision = "1";
       editedCabalFile = "5c6cf1e221928e15536f1dfa46942293acf7b470a442c619ef66529b78c59596";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers directory extensible-exceptions filepath hint
         mtl process QuickCheck show simple-reflect unix
       ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/gwern/mueval";
       description = "Safely evaluate pure Haskell expressions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mulang" = callPackage
    ({ mkDerivation, aeson, base, bytestring, haskell-src, hspec }:
     mkDerivation {
       pname = "mulang";
       version = "0.1.0.0";
       sha256 = "5df2829d85ceb46086011c96ecaf396aa78d92dda293ba728d0ad8e3efcaaddf";
       libraryHaskellDepends = [ aeson base bytestring haskell-src ];
       testHaskellDepends = [ aeson base bytestring haskell-src hspec ];
       jailbreak = true;
       description = "The Mu Language, a non-computable extended Lambda Calculus";
       license = stdenv.lib.licenses.mit;
     }) {};

  "multext-east-msd" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "multext-east-msd";
       version = "0.1.0.4";
       sha256 = "86b6b715d3ab239aa292ff37368976f91b72098bc442ed274d851f2fc48dc1c5";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://github.com/jsnajder/multex-east-msd";
       description = "MULTEXT-East morphosyntactic descriptors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "multi-cabal" = callPackage
    ({ mkDerivation, AAI, aeson, base, bytestring, directory, filepath
     , HUnit, mtl, process, strict, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "multi-cabal";
       version = "0.1.0.0";
       sha256 = "6ffcb526ae61ef9004684ff9b6f3eee59c3fdc8dc04b9db655b8e57a0984f763";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ aeson base filepath mtl ];
       executableHaskellDepends = [
         AAI aeson base bytestring directory filepath process strict
       ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       homepage = "https://github.com/aka-bash0r/multi-cabal";
       description = "A tool supporting multi cabal project builds";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "multiaddr" = callPackage
    ({ mkDerivation, attoparsec, base, base58-bytestring, bytestring
     , cereal, errors, hashable, tasty, tasty-hunit, tasty-quickcheck
     , text
     }:
     mkDerivation {
       pname = "multiaddr";
       version = "0.2.0";
       sha256 = "fd8537d3598b92cd662efe6a41554aa88e8bb8f74fff6c1be1df65745d66c46d";
       libraryHaskellDepends = [
         attoparsec base base58-bytestring bytestring cereal errors hashable
         text
       ];
       testHaskellDepends = [
         base tasty tasty-hunit tasty-quickcheck text
       ];
       homepage = "http://github.com/micxjo/hs-multiaddr";
       description = "A network address format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "multiarg_0_30_0_8" = callPackage
    ({ mkDerivation, base, QuickCheck, tasty, tasty-quickcheck
     , tasty-th
     }:
     mkDerivation {
       pname = "multiarg";
       version = "0.30.0.8";
       sha256 = "5a97d7fac38ce176809f93fa8d3634bd3db1d850bc678e442e7d13650e0698a2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base QuickCheck tasty tasty-quickcheck tasty-th
       ];
       jailbreak = true;
       homepage = "https://github.com/massysett/multiarg";
       description = "Command lines for options that take multiple arguments";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "multiarg" = callPackage
    ({ mkDerivation, base, QuickCheck, tasty, tasty-quickcheck
     , tasty-th
     }:
     mkDerivation {
       pname = "multiarg";
       version = "0.30.0.10";
       sha256 = "c9fa623a8e06d62addc2b7ad5102ceac3a6f0db6a67afbc8e693d0d0aec417a1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base QuickCheck tasty tasty-quickcheck tasty-th
       ];
       homepage = "https://github.com/massysett/multiarg";
       description = "Command lines for options that take multiple arguments";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "multifocal" = callPackage
    ({ mkDerivation, array, base, containers, haskell-src-exts, HaXml
     , hxt, hxt-xpath, mtl, parsec, pointless-haskell, pointless-lenses
     , pointless-rewrite, pretty, process, syb
     }:
     mkDerivation {
       pname = "multifocal";
       version = "0.0.1";
       sha256 = "d5312ef6ab560d110841f930252660cfad444d885cf65986121c2287ba738770";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers haskell-src-exts HaXml hxt hxt-xpath mtl
         parsec pointless-haskell pointless-lenses pointless-rewrite pretty
         process syb
       ];
       executableHaskellDepends = [
         array base containers haskell-src-exts HaXml hxt hxt-xpath mtl
         parsec pointless-haskell pointless-lenses pointless-rewrite pretty
         process syb
       ];
       description = "Bidirectional Two-level Transformation of XML Schemas";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "multihash" = callPackage
    ({ mkDerivation, attoparsec, base, base58-bytestring
     , base64-bytestring, byteable, bytestring, cryptohash, hex
     , io-streams, optparse-applicative
     }:
     mkDerivation {
       pname = "multihash";
       version = "0.1.2";
       sha256 = "dd2b0511c900d83794dec151008b0bec07be676dc0cbb073ce11d5b754c47538";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base base58-bytestring base64-bytestring bytestring
         cryptohash hex io-streams
       ];
       executableHaskellDepends = [
         base base58-bytestring base64-bytestring byteable bytestring
         cryptohash hex io-streams optparse-applicative
       ];
       jailbreak = true;
       homepage = "https://github.com/LukeHoersten/multihash";
       description = "Multihash library and CLI executable";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "multimap" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "multimap";
       version = "1.2.1";
       sha256 = "6332c529475177b9e08d762d5701804dc2edc0ff26dd98a2a1dcd7ed092e7434";
       libraryHaskellDepends = [ base containers ];
       homepage = "http://hub.darcs.net/scravy/multimap";
       description = "A multimap";
       license = stdenv.lib.licenses.mit;
     }) {};

  "multipart" = callPackage
    ({ mkDerivation, base, bytestring, parsec }:
     mkDerivation {
       pname = "multipart";
       version = "0.1.2";
       sha256 = "e543fb307beb14fc366171d7767a6a18244bacf78db295d8d161c5c03d94043c";
       libraryHaskellDepends = [ base bytestring parsec ];
       homepage = "http://www.github.com/silkapp/multipart";
       description = "HTTP multipart split out of the cgi package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "multipart-names" = callPackage
    ({ mkDerivation, base, case-insensitive, HUnit, lens, parsec
     , test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "multipart-names";
       version = "0.0.1";
       sha256 = "ac63f71fe90bfdb613f97000c01e69343fb0e6337604e8d1a879441c1e4d9c9d";
       libraryHaskellDepends = [ base case-insensitive lens parsec ];
       testHaskellDepends = [
         base HUnit lens test-framework test-framework-hunit
       ];
       homepage = "http://github.com/nedervold/multipart-names";
       description = "Handling of multipart names in various casing styles";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "multipass" = callPackage
    ({ mkDerivation, base, binary, containers, ghc-prim, hashable, keys
     , math-functions, newtype, unordered-containers
     }:
     mkDerivation {
       pname = "multipass";
       version = "0.1.0.2";
       sha256 = "d54585c28cb2cc8104581b09c5428691c3b8358631db99c44d0fe55213d7457f";
       libraryHaskellDepends = [
         base binary containers ghc-prim hashable keys math-functions
         newtype unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/multipass/";
       description = "Folding data with multiple named passes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "multiplate" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "multiplate";
       version = "0.0.3";
       sha256 = "2c0016847dcedc8ba0054211256a3ef6c7f142e605668c7b64beebdf0eaf4ebf";
       libraryHaskellDepends = [ base transformers ];
       homepage = "http://haskell.org/haskellwiki/Multiplate";
       description = "Lightweight generic library for mutually recursive data types";
       license = stdenv.lib.licenses.mit;
     }) {};

  "multiplate-simplified" = callPackage
    ({ mkDerivation, base, multiplate, transformers }:
     mkDerivation {
       pname = "multiplate-simplified";
       version = "0.0.0.2";
       sha256 = "59ec1287196833863baa45be42b1a1864728935bc0ca6c1a5e8f9baaeda0f277";
       libraryHaskellDepends = [ base multiplate transformers ];
       jailbreak = true;
       description = "Shorter, more generic functions for Multiplate";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "multiplicity" = callPackage
    ({ mkDerivation, base, containers, fez-conf, mtl, process }:
     mkDerivation {
       pname = "multiplicity";
       version = "0.1.0";
       sha256 = "cc2926997f59861dbba1d9a376d4a889309f84269108ae80d248d96bb1011bf8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers fez-conf mtl process
       ];
       homepage = "http://ui3.info/d/proj/multiplicity.html";
       description = "Wrapper program for duplicity, adding config files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "multirec" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "multirec";
       version = "0.7.5";
       sha256 = "bf795f603d72b23d3307e1c5ea27a70df8fc810ce10a0ada6906183557068a98";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/Multirec";
       description = "Generic programming for families of recursive datatypes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "multirec-alt-deriver" = callPackage
    ({ mkDerivation, base, containers, mtl, multirec, syb
     , template-haskell, th-expand-syns
     }:
     mkDerivation {
       pname = "multirec-alt-deriver";
       version = "0.1.3";
       sha256 = "cc351b1fd24e7dc5d0e70beed4729a9354419007e247be1b41c707f9eacf3f43";
       libraryHaskellDepends = [
         base containers mtl multirec syb template-haskell th-expand-syns
       ];
       jailbreak = true;
       description = "Alternative multirec instances deriver";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "multirec-binary" = callPackage
    ({ mkDerivation, base, binary, multirec }:
     mkDerivation {
       pname = "multirec-binary";
       version = "0.0.1";
       sha256 = "fa57bbf7fd5159713520772307af960e2c79d9c24e045ef23680f18ea5cb41b2";
       libraryHaskellDepends = [ base binary multirec ];
       jailbreak = true;
       description = "Generic Data.Binary instances using MultiRec.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "multiset_0_3_0" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "multiset";
       version = "0.3.0";
       sha256 = "8bc156ac6de136d8417e81ee28b8422acd465a2f5d4c6ac1b1fc195cca16ec72";
       libraryHaskellDepends = [ base containers ];
       description = "The Data.MultiSet container type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "multiset" = callPackage
    ({ mkDerivation, base, containers, doctest, Glob }:
     mkDerivation {
       pname = "multiset";
       version = "0.3.2";
       sha256 = "e576efc992d808585a40baeb22dd83e0b42001d79ed13e2085b6eb6d6008a6bb";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [ base doctest Glob ];
       description = "The Data.MultiSet container type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "multiset-comb" = callPackage
    ({ mkDerivation, base, containers, transformers }:
     mkDerivation {
       pname = "multiset-comb";
       version = "0.2.4";
       sha256 = "297d7a2ec9ecae0deb83e8ff8685b81221a4a4127dcf56e96f4773754cedfb48";
       revision = "1";
       editedCabalFile = "b6ecbed315e0578b665644b8a73ed1e348968e5a93bb1d491fb5a6faf79d7545";
       libraryHaskellDepends = [ base containers transformers ];
       description = "Combinatorial algorithms over multisets";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "multisetrewrite" = callPackage
    ({ mkDerivation, base, haskell98, stm }:
     mkDerivation {
       pname = "multisetrewrite";
       version = "0.6";
       sha256 = "5e95b7428d004e7a06f546e05d0659bb4873443c9e8f29f89f199cfb666c0fb2";
       libraryHaskellDepends = [ base haskell98 stm ];
       homepage = "http://sulzmann.blogspot.com/2008/10/multi-set-rewrite-rules-with-guards-and.html";
       description = "Multi-set rewrite rules with guards and a parallel execution scheme";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "multistate" = callPackage
    ({ mkDerivation, base, hspec, monad-control, mtl, tagged
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "multistate";
       version = "0.7.0.0";
       sha256 = "012cefe6afa33be2285c47538e6d79ba54bcb15328865751209cadbea2a38b75";
       revision = "1";
       editedCabalFile = "c0546d74f2bc0c476714677432693161d63956a2a23fc88a30f7c61239672a9b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base monad-control mtl tagged transformers transformers-base
       ];
       testHaskellDepends = [ base hspec transformers ];
       homepage = "https://github.com/lspitzner/multistate";
       description = "like mtl's ReaderT / WriterT / StateT, but more than one contained value/type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "muon" = callPackage
    ({ mkDerivation, base, blaze-html, ConfigFile, directory, Glob
     , happstack-server, HStringTemplate, markdown, MissingH, process
     , text
     }:
     mkDerivation {
       pname = "muon";
       version = "0.1.0.8";
       sha256 = "3fcddac69c00da46cbf822252b82be92d7e80c06174ee0c2c82c73aee0ee2168";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-html ConfigFile directory Glob happstack-server
         HStringTemplate markdown MissingH process text
       ];
       jailbreak = true;
       homepage = "http://github.com/kaashif-hymabaccus/muon";
       description = "Static blog generator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "murder" = callPackage
    ({ mkDerivation, AspectAG, base, containers, HList, ListLike
     , template-haskell, TTTAS, uu-parsinglib, uulib
     }:
     mkDerivation {
       pname = "murder";
       version = "1.3.4";
       sha256 = "25eccca6076443accc1e313e69d6127d99033c344adb198d9876a2bc863c275f";
       libraryHaskellDepends = [
         AspectAG base containers HList ListLike template-haskell TTTAS
         uu-parsinglib uulib
       ];
       jailbreak = true;
       homepage = "http://www.cs.uu.nl/wiki/Center/CoCoCo";
       description = "MUtually Recursive Definitions Explicitly Represented";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "murmur-hash" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "murmur-hash";
       version = "0.1.0.8";
       sha256 = "6cb9f4dc4a7d5b35e843bb8767d2e2c9745bcfbdacb5daf4fce5f4e05f983a06";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://github.com/nominolo/murmur-hash";
       description = "MurmurHash2 implementation for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "murmur3" = callPackage
    ({ mkDerivation, base, base16-bytestring, bytestring, cereal, HUnit
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "murmur3";
       version = "1.0.1";
       sha256 = "5bac92e0d72d5858bdc390c5c5e234e3c3d4191d717e3d5b972d6fd3401500c3";
       libraryHaskellDepends = [ base bytestring cereal ];
       testHaskellDepends = [
         base base16-bytestring bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/plaprade/murmur3";
       description = "Pure Haskell implementation of the MurmurHash3 x86_32 algorithm";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "murmurhash3" = callPackage
    ({ mkDerivation, haskell2010 }:
     mkDerivation {
       pname = "murmurhash3";
       version = "1.0";
       sha256 = "6235ee5432a5dfd12c7eab60992d0f663979c0b530d99542eff1fd8c83cbe6c3";
       libraryHaskellDepends = [ haskell2010 ];
       homepage = "https://github.com/niswegmann/murmurhash3";
       description = "32-bit non-cryptographic hashing";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "music-articulation" = callPackage
    ({ mkDerivation, average, base, semigroups }:
     mkDerivation {
       pname = "music-articulation";
       version = "1.9.0";
       sha256 = "ef0a45c2eeeefd2c361d74c4f1d534d1fb011ccb0b40b3eabc70d859c484ab33";
       libraryHaskellDepends = [ average base semigroups ];
       description = "Abstract representation of musical articulation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "music-diatonic" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "music-diatonic";
       version = "0.1.1";
       sha256 = "7af1534a0647af75d4440ed61aebc89cde76057b4c792e316554e3b280a44ea7";
       libraryHaskellDepends = [ base ];
       description = "Implementation of basic western musical theory objects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "music-dynamics" = callPackage
    ({ mkDerivation, average, base, music-dynamics-literal, semigroups
     }:
     mkDerivation {
       pname = "music-dynamics";
       version = "1.9.0";
       sha256 = "44236f34eb62454da5722efd82a17bb571c2b147f78b773f5be012df320e4189";
       libraryHaskellDepends = [
         average base music-dynamics-literal semigroups
       ];
       description = "Abstract representation of musical dynamics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "music-dynamics-literal" = callPackage
    ({ mkDerivation, base, semigroups }:
     mkDerivation {
       pname = "music-dynamics-literal";
       version = "1.9.0";
       sha256 = "a519d48536faf25cb60fd99864477abf868b98666e2f37ef86d349ac0aa178a5";
       libraryHaskellDepends = [ base semigroups ];
       description = "Overloaded dynamics literals";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "music-graphics" = callPackage
    ({ mkDerivation, aeson, base, blaze-svg, bytestring, lens
     , music-pitch, music-preludes, music-score, process
     }:
     mkDerivation {
       pname = "music-graphics";
       version = "1.8.1";
       sha256 = "5539c2f05d7234d47134b6459314df3cc58b572cf4954c996ecda98b56c5c49c";
       libraryHaskellDepends = [
         aeson base blaze-svg bytestring lens music-pitch music-preludes
         music-score process
       ];
       jailbreak = true;
       description = "Diagrams-based visualization of musical data structures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "music-parts" = callPackage
    ({ mkDerivation, adjunctions, aeson, base, bytestring, cassava
     , containers, data-default, lens, monadplus, music-dynamics
     , music-pitch, roman-numerals, semigroups, vector-space
     , vector-space-points
     }:
     mkDerivation {
       pname = "music-parts";
       version = "1.9.0";
       sha256 = "a4c5c475cda42e642e9a0a447ca841763ebe0e0384bef2fa679e713691493fce";
       libraryHaskellDepends = [
         adjunctions aeson base bytestring cassava containers data-default
         lens monadplus music-dynamics music-pitch roman-numerals semigroups
         vector-space vector-space-points
       ];
       description = "Musical instruments, parts and playing techniques";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "music-pitch" = callPackage
    ({ mkDerivation, aeson, base, containers, data-interval, lens
     , music-pitch-literal, nats, positive, semigroups, type-unary
     , vector-space, vector-space-points
     }:
     mkDerivation {
       pname = "music-pitch";
       version = "1.9.0";
       sha256 = "7f01e76e6549343811bf7ca9099c35e5bae99b4d7d373dd421015940a330abf0";
       libraryHaskellDepends = [
         aeson base containers data-interval lens music-pitch-literal nats
         positive semigroups type-unary vector-space vector-space-points
       ];
       description = "Musical pitch representation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "music-pitch-literal" = callPackage
    ({ mkDerivation, base, semigroups }:
     mkDerivation {
       pname = "music-pitch-literal";
       version = "1.9.0";
       sha256 = "14632d91807a61c0e5a17406bd4b9355aabb12fe5ff8977e3271e324d8e15b6f";
       libraryHaskellDepends = [ base semigroups ];
       description = "Overloaded pitch literals";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "music-preludes" = callPackage
    ({ mkDerivation, async, average, base, containers, filepath, lens
     , lilypond, monadplus, music-articulation, music-dynamics
     , music-dynamics-literal, music-parts, music-pitch
     , music-pitch-literal, music-score, musicxml2, optparse-applicative
     , process, semigroups, split, tasty, tasty-golden, temporary, unix
     , vector-space, vector-space-points
     }:
     mkDerivation {
       pname = "music-preludes";
       version = "1.9.0";
       sha256 = "38802472317600f8f2dcc06586eb2738766cda022b0d43812a8ae70f7e1e1cbb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async average base containers filepath lens lilypond monadplus
         music-articulation music-dynamics music-dynamics-literal
         music-parts music-pitch music-pitch-literal music-score musicxml2
         optparse-applicative process semigroups split temporary unix
         vector-space vector-space-points
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base process tasty tasty-golden ];
       description = "Some useful preludes for the Music Suite";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "music-score" = callPackage
    ({ mkDerivation, adjunctions, aeson, average, base, base-orphans
     , bifunctors, colour, comonad, containers, contravariant
     , distributive, HCodecs, lens, lilypond, monadplus, mtl
     , music-dynamics-literal, music-pitch-literal, musicxml2, nats
     , NumInstances, parsec, prettify, process, semigroups, transformers
     , transformers-compat, vector-space, vector-space-points
     }:
     mkDerivation {
       pname = "music-score";
       version = "1.9.0";
       sha256 = "2028c8b61e9b088996e57b0ecdbadbcc8764a5e68e848e4193595a0262d49e81";
       libraryHaskellDepends = [
         adjunctions aeson average base base-orphans bifunctors colour
         comonad containers contravariant distributive HCodecs lens lilypond
         monadplus mtl music-dynamics-literal music-pitch-literal musicxml2
         nats NumInstances parsec prettify process semigroups transformers
         transformers-compat vector-space vector-space-points
       ];
       jailbreak = true;
       description = "Musical score and part representation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "music-sibelius" = callPackage
    ({ mkDerivation, aeson, base, bytestring, lens, monadplus
     , music-articulation, music-dynamics, music-parts, music-pitch
     , music-pitch-literal, music-preludes, music-score, semigroups
     , unordered-containers
     }:
     mkDerivation {
       pname = "music-sibelius";
       version = "1.9.0";
       sha256 = "7f96238c3978969c907443e3ff7f6d0877bd8cfb5e8b38c078ecbd803efa50f9";
       libraryHaskellDepends = [
         aeson base bytestring lens monadplus music-articulation
         music-dynamics music-parts music-pitch music-pitch-literal
         music-preludes music-score semigroups unordered-containers
       ];
       description = "Interaction with Sibelius";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "music-suite" = callPackage
    ({ mkDerivation, abcnotation, lilypond, music-articulation
     , music-dynamics, music-dynamics-literal, music-parts, music-pitch
     , music-pitch-literal, music-preludes, music-score, musicxml2
     }:
     mkDerivation {
       pname = "music-suite";
       version = "1.9.0";
       sha256 = "c65afdfb1b517d0185b316a86f2f613c0e9343d67d960fb9c0728ba698085adb";
       libraryHaskellDepends = [
         abcnotation lilypond music-articulation music-dynamics
         music-dynamics-literal music-parts music-pitch music-pitch-literal
         music-preludes music-score musicxml2
       ];
       doHaddock = false;
       description = "A set of libraries for composition, analysis and manipulation of music";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "music-util" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, fgl, process
     , shelly, split, text, unix
     }:
     mkDerivation {
       pname = "music-util";
       version = "0.17";
       sha256 = "0eaf610377d3838ae5c2b5159b093704b28fcc60538e8c321d7f8a991baf665f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers directory fgl process shelly split text unix
       ];
       description = "Utility for developing the Music Suite";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "musicbrainz-email" = callPackage
    ({ mkDerivation, aeson, amqp, base, blaze-builder, bytestring
     , configurator, errors, ghc-prim, heist, HTTP, HUnit, mime-mail
     , mtl, network, network-metrics, optparse-applicative
     , postgresql-simple, smallcheck, stm, test-framework
     , test-framework-hunit, test-framework-smallcheck, text, time
     , transformers, xmlhtml
     }:
     mkDerivation {
       pname = "musicbrainz-email";
       version = "1.0.0.0";
       sha256 = "6267d60a681a739f30b2659f64fc459d9add268ac41423faf0cd6d425ba64a83";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson amqp base ghc-prim mime-mail optparse-applicative text
       ];
       executableHaskellDepends = [
         aeson amqp base blaze-builder errors heist HTTP mime-mail mtl
         network network-metrics optparse-applicative postgresql-simple text
         time transformers xmlhtml
       ];
       testHaskellDepends = [
         aeson amqp base blaze-builder bytestring configurator errors
         ghc-prim heist HTTP HUnit mime-mail mtl postgresql-simple
         smallcheck stm test-framework test-framework-hunit
         test-framework-smallcheck text time transformers xmlhtml
       ];
       jailbreak = true;
       homepage = "http://github.com/metabrainz/mass-mail";
       description = "Send an email to all MusicBrainz editors";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "musicxml" = callPackage
    ({ mkDerivation, base, containers, directory, HaXml, old-time
     , pretty
     }:
     mkDerivation {
       pname = "musicxml";
       version = "0.1.2";
       sha256 = "e8bee2b5cd8f261020cb807b9800157a46e1c9f25decd3f46cb71b57fd7fc86a";
       libraryHaskellDepends = [
         base containers directory HaXml old-time pretty
       ];
       jailbreak = true;
       homepage = "https://troglodita.di.uminho.pt/svn/musica/work/MusicXML";
       description = "MusicXML format encoded as Haskell type and functions of reading and writting";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "musicxml2" = callPackage
    ({ mkDerivation, base, data-default, music-dynamics-literal
     , music-pitch-literal, nats, reverse-apply, semigroups, type-unary
     , xml
     }:
     mkDerivation {
       pname = "musicxml2";
       version = "1.9.0";
       sha256 = "c8bb51501284ff80400706ea16dbf1823d9f04eac22cd72d660d383c5da45d1d";
       libraryHaskellDepends = [
         base data-default music-dynamics-literal music-pitch-literal nats
         reverse-apply semigroups type-unary xml
       ];
       description = "A representation of the MusicXML format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mustache" = callPackage
    ({ mkDerivation, aeson, base, base-unicode-symbols, bytestring
     , cmdargs, containers, directory, either, filepath, hspec, mtl
     , parsec, process, scientific, temporary, text
     , unordered-containers, vector, yaml
     }:
     mkDerivation {
       pname = "mustache";
       version = "1.0";
       sha256 = "a928ff0f3430af57c0ce22b45d85d85a64bca7f0ba48de93cfb3271a0a6042af";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base-unicode-symbols bytestring containers directory
         either filepath mtl parsec scientific text unordered-containers
         vector
       ];
       executableHaskellDepends = [
         aeson base base-unicode-symbols bytestring cmdargs filepath text
         yaml
       ];
       testHaskellDepends = [
         aeson base base-unicode-symbols directory filepath hspec process
         temporary text unordered-containers yaml
       ];
       doCheck = false;
       homepage = "https://github.com/JustusAdam/mustache";
       description = "A mustache template parser library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mustache-haskell" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory
     , optparse-applicative, parsec, pretty-show, scientific, text
     , transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "mustache-haskell";
       version = "0.1.0.5";
       sha256 = "62a7735900cfa7a2e3e3f7def84b1e69aa3f26c302c73e7922a9d2c59e2d7256";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring directory parsec pretty-show scientific text
         transformers unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson base bytestring directory optparse-applicative parsec
         pretty-show scientific text transformers unordered-containers
         vector
       ];
       jailbreak = true;
       homepage = "https://github.com/danchoi/mustache-haskell";
       description = "Straight implementation of mustache templates";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mustache2hs" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, filepath
     , haskell-src, parsec, text, transformers, utf8-string
     }:
     mkDerivation {
       pname = "mustache2hs";
       version = "0.3";
       sha256 = "3a42f503e2112ff4b8f26df19bbeabc275fb851ffc093070716bc1e19bc125d4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-builder bytestring filepath haskell-src parsec text
         transformers utf8-string
       ];
       homepage = "http://github.com/singpolyma/mustache2hs";
       description = "Utility to generate Haskell code from Mustache templates";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mutable-containers_0_2_1_2" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, hspec
     , mono-traversable, primitive, QuickCheck, vector
     }:
     mkDerivation {
       pname = "mutable-containers";
       version = "0.2.1.2";
       sha256 = "c89ff0d7fd37153d9cf259ca48282c273425e7beb3d92c6f5603471b51ff2dc8";
       libraryHaskellDepends = [
         base containers ghc-prim mono-traversable primitive vector
       ];
       testHaskellDepends = [
         base containers hspec primitive QuickCheck vector
       ];
       homepage = "https://github.com/fpco/mutable-containers";
       description = "Abstactions and concrete implementations of mutable containers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mutable-containers_0_3_0" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, hspec
     , mono-traversable, primitive, QuickCheck, vector
     }:
     mkDerivation {
       pname = "mutable-containers";
       version = "0.3.0";
       sha256 = "ccec3cc85fa5a4facd65e7ab39220d0b41bd4ec2fe15df0bcd38fcf249105ff7";
       libraryHaskellDepends = [
         base containers ghc-prim mono-traversable primitive vector
       ];
       testHaskellDepends = [
         base containers hspec primitive QuickCheck vector
       ];
       homepage = "https://github.com/fpco/mutable-containers";
       description = "Abstactions and concrete implementations of mutable containers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mutable-containers" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, hspec
     , mono-traversable, primitive, QuickCheck, vector
     }:
     mkDerivation {
       pname = "mutable-containers";
       version = "0.3.2";
       sha256 = "781388cf52faa5f9c4c8a825eef11bec430e323c6913d25b5f4e63d8ce02017e";
       libraryHaskellDepends = [
         base containers ghc-prim mono-traversable primitive vector
       ];
       testHaskellDepends = [
         base containers hspec primitive QuickCheck vector
       ];
       homepage = "https://github.com/fpco/mutable-containers";
       description = "Abstactions and concrete implementations of mutable containers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mutable-iter" = callPackage
    ({ mkDerivation, base, iteratee, MonadCatchIO-transformers
     , transformers, vector
     }:
     mkDerivation {
       pname = "mutable-iter";
       version = "0.6.1";
       sha256 = "4e9c92be749ec9aacdbb84ca039b7a906850d98b9cb9e9dcff172cb3fe74d821";
       libraryHaskellDepends = [
         base iteratee MonadCatchIO-transformers transformers vector
       ];
       jailbreak = true;
       homepage = "http://jwlato.webfactional.com/haskell/mutable-iter";
       description = "iteratees based upon mutable buffers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mute-unmute" = callPackage
    ({ mkDerivation, base, directory, filepath, hslogger
     , hslogger-template, mtl, network-dbus, process
     }:
     mkDerivation {
       pname = "mute-unmute";
       version = "0.2.0.0";
       sha256 = "4e25207bce5d21010eebcfdfe76b92525077a15a6b9d0f9fa56e9d2f2861a159";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath hslogger hslogger-template mtl network-dbus
         process
       ];
       jailbreak = true;
       homepage = "http://github.com/Tener/mute-unmute";
       description = "Watches your screensaver and (un)mutes music when you (un)lock the screen";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "mvc" = callPackage
    ({ mkDerivation, async, base, contravariant, foldl, managed, mmorph
     , pipes, pipes-concurrency, transformers
     }:
     mkDerivation {
       pname = "mvc";
       version = "1.1.1";
       sha256 = "b97122c1df6b5eb569e75cbc2a4c84a06e8ab942f68110a2f56b9cdac1bd34f5";
       libraryHaskellDepends = [
         async base contravariant foldl managed mmorph pipes
         pipes-concurrency transformers
       ];
       jailbreak = true;
       description = "Model-view-controller";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mvc-updates" = callPackage
    ({ mkDerivation, async, base, foldl, mvc }:
     mkDerivation {
       pname = "mvc-updates";
       version = "1.2.0";
       sha256 = "c60603c0b97949219361c674097fe37b38bc68cf137b641b5abc329c0ee3ab88";
       libraryHaskellDepends = [ async base foldl mvc ];
       jailbreak = true;
       description = "Concurrent and combinable updates";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mvclient" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, binary, bytestring
     , containers, control-event, Crypto, data-binary-ieee754, hexpat
     , http-enumerator, maccatcher, mtl, network, parsec, time, uuid
     }:
     mkDerivation {
       pname = "mvclient";
       version = "0.4";
       sha256 = "a37cf0ff183a2f43552d4b8148d5202e415efbe1df761d8b4143716e96fb9389";
       libraryHaskellDepends = [
         base base-unicode-symbols binary bytestring containers
         control-event Crypto data-binary-ieee754 hexpat http-enumerator
         maccatcher mtl network parsec time uuid
       ];
       jailbreak = true;
       description = "Client library for metaverse systems like Second Life";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mwc-probability_1_0_2" = callPackage
    ({ mkDerivation, base, mwc-random, primitive, transformers }:
     mkDerivation {
       pname = "mwc-probability";
       version = "1.0.2";
       sha256 = "226dc423bef96665a354757e0d74cb77667a587a14d40173a39451f3242b16e0";
       libraryHaskellDepends = [ base mwc-random primitive transformers ];
       homepage = "http://github.com/jtobin/mwc-probability";
       description = "Sampling function-based probability distributions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mwc-probability_1_0_3" = callPackage
    ({ mkDerivation, base, mwc-random, primitive, transformers }:
     mkDerivation {
       pname = "mwc-probability";
       version = "1.0.3";
       sha256 = "38386c522e96768ffe4f71c4eedbe0e3418472eb8d78c8c509183fb19175c47f";
       libraryHaskellDepends = [ base mwc-random primitive transformers ];
       homepage = "http://github.com/jtobin/mwc-probability";
       description = "Sampling function-based probability distributions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mwc-probability" = callPackage
    ({ mkDerivation, base, mwc-random, primitive, transformers }:
     mkDerivation {
       pname = "mwc-probability";
       version = "1.1.3";
       sha256 = "a7190d8f2b12d5aff0344a1bdc5a85386cb12960fe31e346b14806e615773363";
       libraryHaskellDepends = [ base mwc-random primitive transformers ];
       homepage = "http://github.com/jtobin/mwc-probability";
       description = "Sampling function-based probability distributions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mwc-random_0_13_2_2" = callPackage
    ({ mkDerivation, base, HUnit, primitive, QuickCheck, statistics
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , time, vector
     }:
     mkDerivation {
       pname = "mwc-random";
       version = "0.13.2.2";
       sha256 = "977545fece98a619699ddfca148dbcfcbc6272de6ea2fc91edc6c0a89ada59e7";
       revision = "1";
       editedCabalFile = "22b940db1257c69484e123d2bb733fa416f3bc75befe3da5e2ba743ae70083ae";
       libraryHaskellDepends = [ base primitive time vector ];
       testHaskellDepends = [
         base HUnit QuickCheck statistics test-framework
         test-framework-hunit test-framework-quickcheck2 vector
       ];
       jailbreak = true;
       homepage = "https://github.com/bos/mwc-random";
       description = "Fast, high quality pseudo random number generation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mwc-random_0_13_3_0" = callPackage
    ({ mkDerivation, base, HUnit, primitive, QuickCheck, statistics
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , time, vector
     }:
     mkDerivation {
       pname = "mwc-random";
       version = "0.13.3.0";
       sha256 = "4ddaeccb593c1e0ee8a50cf0cbcad45eda6ac5a4a01ffd891df5071ff8fb5b59";
       revision = "1";
       editedCabalFile = "1e4c368970dfef4c3ab4666c0917c2627292c7d1cd69b84a00ab8e46da311c9d";
       libraryHaskellDepends = [ base primitive time vector ];
       testHaskellDepends = [
         base HUnit QuickCheck statistics test-framework
         test-framework-hunit test-framework-quickcheck2 vector
       ];
       jailbreak = true;
       homepage = "https://github.com/bos/mwc-random";
       description = "Fast, high quality pseudo random number generation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mwc-random" = callPackage
    ({ mkDerivation, base, HUnit, primitive, QuickCheck, statistics
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , time, vector
     }:
     mkDerivation {
       pname = "mwc-random";
       version = "0.13.3.2";
       sha256 = "2cb1e354ec8b31400d14716920f38eedd5161003249deedfd49cda290aae5806";
       libraryHaskellDepends = [ base primitive time vector ];
       testHaskellDepends = [
         base HUnit QuickCheck statistics test-framework
         test-framework-hunit test-framework-quickcheck2 vector
       ];
       homepage = "https://github.com/bos/mwc-random";
       description = "Fast, high quality pseudo random number generation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mwc-random_0_13_4_0" = callPackage
    ({ mkDerivation, base, HUnit, primitive, QuickCheck, statistics
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , time, vector
     }:
     mkDerivation {
       pname = "mwc-random";
       version = "0.13.4.0";
       sha256 = "c52cfdeab2fe6cae3e2b0de382757372df571b7c25a6712ab205fb784b5a8aea";
       libraryHaskellDepends = [ base primitive time vector ];
       testHaskellDepends = [
         base HUnit QuickCheck statistics test-framework
         test-framework-hunit test-framework-quickcheck2 vector
       ];
       homepage = "https://github.com/bos/mwc-random";
       description = "Fast, high quality pseudo random number generation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mwc-random-monad" = callPackage
    ({ mkDerivation, base, monad-primitive, mwc-random, primitive
     , transformers, vector
     }:
     mkDerivation {
       pname = "mwc-random-monad";
       version = "0.7.3.1";
       sha256 = "d0f37917e646c9610dcbee4173c4ac50e054418f62623a42f19e3c0c39979440";
       libraryHaskellDepends = [
         base monad-primitive mwc-random primitive transformers vector
       ];
       description = "Monadic interface for mwc-random";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "myTestlll" = callPackage
    ({ mkDerivation, ansi-terminal, array, arrows, base, bytestring
     , Cabal, CCA, containers, deepseq, Euterpea, ghc-prim, HCodecs
     , heap, markov-chain, monadIO, mtl, PortMidi, pure-fft, QuickCheck
     , random, stm, syb, template-haskell, UISF
     }:
     mkDerivation {
       pname = "myTestlll";
       version = "1.0.0";
       sha256 = "c0c32a45c22ddc8f9ee324d6bfd1b848cf9a8a7f7eb284811c8b772058bfa3e5";
       revision = "4";
       editedCabalFile = "e554b67c3f8efd73e028328341e3b535dc4898b3d476524a40c236c4c2871e43";
       libraryHaskellDepends = [
         array arrows base bytestring CCA containers deepseq ghc-prim
         HCodecs heap markov-chain monadIO mtl PortMidi pure-fft random stm
         syb template-haskell UISF
       ];
       testHaskellDepends = [
         ansi-terminal base Cabal Euterpea QuickCheck
       ];
       jailbreak = true;
       homepage = "http://haskell.cs.yale.edu/";
       description = "None";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mybitcoin-sci" = callPackage
    ({ mkDerivation, base, cgi, curl, directory, mtl, process, split }:
     mkDerivation {
       pname = "mybitcoin-sci";
       version = "0.3";
       sha256 = "d8cab7659453b7956006c1b3dbfb70df07818417d71fabea5c1ca538c227c8c7";
       libraryHaskellDepends = [
         base cgi curl directory mtl process split
       ];
       description = "Binding to mybitcoin.com's Shopping Cart Interface.";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "myo" = callPackage
    ({ mkDerivation, aeson, base, containers, lens-family
     , lens-family-th, scientific, string-conv, tasty, tasty-hunit, text
     , unordered-containers, vector, websockets
     }:
     mkDerivation {
       pname = "myo";
       version = "0.2.0.0";
       sha256 = "a606c19c6bfc4ea1044f5b6447dd3f060372a89cbd5d2cfebe2492c93cfd4c74";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base containers lens-family lens-family-th scientific text
         unordered-containers vector websockets
       ];
       executableHaskellDepends = [
         aeson base lens-family string-conv websockets
       ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       homepage = "http://github.com/adinapoli/myo";
       description = "Haskell binding to the Myo armband";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mysnapsession" = callPackage
    ({ mkDerivation, base, bytestring, cereal, clientsession
     , containers, mtl, random, regex-posix, snap, snap-core, time
     }:
     mkDerivation {
       pname = "mysnapsession";
       version = "0.4.1";
       sha256 = "35fdb09c0998d519938f7ec623a55261de0db98ebc51374bb4545f6813b6e120";
       libraryHaskellDepends = [
         base bytestring cereal clientsession containers mtl random
         regex-posix snap snap-core time
       ];
       jailbreak = true;
       description = "Sessions and continuations for Snap web apps";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mysnapsession-example" = callPackage
    ({ mkDerivation, base, bytestring, clientsession, heist, mtl
     , mysnapsession, snap, snap-core, snap-server, text, time
     }:
     mkDerivation {
       pname = "mysnapsession-example";
       version = "0.4";
       sha256 = "9f26f6843159c75e4e4e8512c4433dbc086f4235c49dd4dd90c19d641db2bf53";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring clientsession heist mtl mysnapsession snap
         snap-core snap-server text time
       ];
       jailbreak = true;
       description = "Example projects using mysnapsession";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mysql_0_1_1_7" = callPackage
    ({ mkDerivation, base, bytestring, containers, mysql }:
     mkDerivation {
       pname = "mysql";
       version = "0.1.1.7";
       sha256 = "a025c2bc948c12808c1ebb1284646b38a6b244575966f588857b37653dfa8842";
       libraryHaskellDepends = [ base bytestring containers ];
       librarySystemDepends = [ mysql ];
       homepage = "https://github.com/bos/mysql";
       description = "A low-level MySQL client library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) mysql;};

  "mysql" = callPackage
    ({ mkDerivation, base, bytestring, containers, mysql }:
     mkDerivation {
       pname = "mysql";
       version = "0.1.1.8";
       sha256 = "90f02af1c81e2189f65dcef0f78327eba4b0ef40bea5bde5cb74920727f9bd84";
       libraryHaskellDepends = [ base bytestring containers ];
       librarySystemDepends = [ mysql ];
       homepage = "https://github.com/bos/mysql";
       description = "A low-level MySQL client library";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) mysql;};

  "mysql-effect" = callPackage
    ({ mkDerivation, base, bytestring, extensible-effects, mysql
     , mysql-simple
     }:
     mkDerivation {
       pname = "mysql-effect";
       version = "0.2.0.3";
       sha256 = "a3f62cb2d32aa95bbd2349bf185ebaa42f76cd11cbea32216e987ec109d4d785";
       revision = "1";
       editedCabalFile = "d4474591079b806b8e26d102824d46c7e4c239afb3479ea8d1e8cbd39f015718";
       libraryHaskellDepends = [
         base bytestring extensible-effects mysql mysql-simple
       ];
       jailbreak = true;
       homepage = "https://github.com/ibotty/mysql-effect";
       description = "An extensible mysql effect using extensible-effects and mysql-simple";
       license = stdenv.lib.licenses.mit;
     }) {};

  "mysql-simple_0_2_2_4" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, blaze-builder
     , blaze-textual, bytestring, mysql, old-locale, pcre-light, text
     , time
     }:
     mkDerivation {
       pname = "mysql-simple";
       version = "0.2.2.4";
       sha256 = "064acc6d6f3fbc00e41cd3334bc23ece91a0ae8831bb25d47ad9bfe0a9cc8f10";
       libraryHaskellDepends = [
         attoparsec base base16-bytestring blaze-builder blaze-textual
         bytestring mysql old-locale pcre-light text time
       ];
       homepage = "https://github.com/bos/mysql-simple";
       description = "A mid-level MySQL client library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mysql-simple" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, blaze-builder
     , blaze-textual, bytestring, mysql, old-locale, pcre-light, text
     , time
     }:
     mkDerivation {
       pname = "mysql-simple";
       version = "0.2.2.5";
       sha256 = "86a30893c6e0eb0316b52780d6ca0464c7a1e048a50d03d203ecce975f7d518c";
       libraryHaskellDepends = [
         attoparsec base base16-bytestring blaze-builder blaze-textual
         bytestring mysql old-locale pcre-light text time
       ];
       homepage = "https://github.com/bos/mysql-simple";
       description = "A mid-level MySQL client library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "mysql-simple-quasi" = callPackage
    ({ mkDerivation, base, haskell-src-meta, mysql-simple
     , template-haskell
     }:
     mkDerivation {
       pname = "mysql-simple-quasi";
       version = "1.0.0.2";
       sha256 = "c85eee4597391ff1af6887ba5e508415caac827c2c7f7a261ea2e781acc4f8bd";
       libraryHaskellDepends = [
         base haskell-src-meta mysql-simple template-haskell
       ];
       description = "Quasi-quoter for use with mysql-simple";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mysql-simple-typed" = callPackage
    ({ mkDerivation, base, mysql, mysql-simple, template-haskell
     , typedquery, utf8-string
     }:
     mkDerivation {
       pname = "mysql-simple-typed";
       version = "0.1.1.2";
       sha256 = "250199742b36b6157c3867367e91ee406786d9f5335d5668477688b272dd96a7";
       libraryHaskellDepends = [
         base mysql mysql-simple template-haskell typedquery utf8-string
       ];
       homepage = "https://github.com/tolysz/mysql-simple-typed";
       description = "Typed extension to mysql simple";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "mzv" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "mzv";
       version = "0.1.0.2";
       sha256 = "54a86a422f4949f9d63a0c7e68a011fb01ca1eb315e871af2d4f63ffe5419d10";
       libraryHaskellDepends = [ base transformers ];
       jailbreak = true;
       homepage = "http://github.com/ifigueroap/mzv";
       description = "Implementation of the \"Monads, Zippers and Views\" (Schrijvers and Oliveira, ICFP'11)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "n-m" = callPackage
    ({ mkDerivation, base, HSH, mtl, process }:
     mkDerivation {
       pname = "n-m";
       version = "0.0.1";
       sha256 = "f5aca5c66dcbeed7637a743215bf7019eaf9f2ab4c5af889700c9ce5105d3ea1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base HSH mtl process ];
       description = "Utility to call iwconfig";
       license = "unknown";
     }) {};

  "nagios-check" = callPackage
    ({ mkDerivation, base, bifunctors, exceptions, hspec, mtl
     , QuickCheck, text
     }:
     mkDerivation {
       pname = "nagios-check";
       version = "0.3.2";
       sha256 = "1bc9b85cb10c396943d53c44e2701c5bc2a02ecdf3e8f46da238981f8b7860b7";
       libraryHaskellDepends = [ base bifunctors exceptions mtl text ];
       testHaskellDepends = [ base hspec QuickCheck text ];
       homepage = "https://github.com/olorin/haskell-nagios-check";
       description = "Package for writing monitoring plugins";
       license = stdenv.lib.licenses.mit;
     }) {};

  "nagios-perfdata" = callPackage
    ({ mkDerivation, attoparsec, base, bifunctors, bytestring
     , containers, hspec, HUnit, MissingH, mtl, transformers
     }:
     mkDerivation {
       pname = "nagios-perfdata";
       version = "0.2.2";
       sha256 = "42b4be9382c3c6a02c662c33a7443ac30790c4ab7311610f5caabdbe5d213595";
       libraryHaskellDepends = [
         attoparsec base bifunctors bytestring containers mtl
       ];
       testHaskellDepends = [
         base bytestring hspec HUnit MissingH transformers
       ];
       homepage = "https://github.com/anchor/nagios-perfdata";
       description = "Parse Nagios performance data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nagios-plugin-ekg" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, hspec, HUnit
     , lens, nagios-check, optparse-applicative, text, transformers
     , unordered-containers, wreq
     }:
     mkDerivation {
       pname = "nagios-plugin-ekg";
       version = "0.1.1.0";
       sha256 = "30cffe4a1a2ced95299c0ef22b115f0f521a9e41c3032dbdaa7324dbe1d566e6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers lens nagios-check
         optparse-applicative text transformers unordered-containers wreq
       ];
       executableHaskellDepends = [ base nagios-check text ];
       testHaskellDepends = [
         base bytestring hspec HUnit nagios-check text transformers
       ];
       homepage = "https://github.com/fractalcat/nagios-plugin-ekg";
       description = "Monitor ekg metrics via Nagios";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "named-formlet" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, containers, mtl
     , text, transformers
     }:
     mkDerivation {
       pname = "named-formlet";
       version = "0.2";
       sha256 = "c72349ff730a709c765081ce1d6e7a4984d012f5cb80137ab1b65b3680edf272";
       libraryHaskellDepends = [
         base blaze-html bytestring containers mtl text transformers
       ];
       description = "A simple formlet library with named formlets";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "named-lock" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "named-lock";
       version = "0.1";
       sha256 = "9188040373f6d97d14df3b34f491419ab809b058f695cfaf99bea481851361b5";
       libraryHaskellDepends = [ base containers ];
       jailbreak = true;
       homepage = "http://github.com/nominolo/named-lock";
       description = "A named lock that is created on demand";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "named-records" = callPackage
    ({ mkDerivation, base, binary, names, template-haskell }:
     mkDerivation {
       pname = "named-records";
       version = "0.5";
       sha256 = "99e7b831d8291f4b6c9cbdacc2924d818ec10249a94d009a937f186d6dad6c7a";
       libraryHaskellDepends = [ base binary names template-haskell ];
       description = "Flexible records with named fields";
       license = stdenv.lib.licenses.mit;
     }) {};

  "namelist" = callPackage
    ({ mkDerivation, base, case-insensitive, data-default-class, parsec
     , QuickCheck, tasty, tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "namelist";
       version = "0.1.0";
       sha256 = "9a1c59077ee5e6af15dbdc238ef365a554f43880d2918f2dffd90dd842c3d169";
       libraryHaskellDepends = [
         base case-insensitive data-default-class parsec
       ];
       testHaskellDepends = [
         base case-insensitive QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "https://github.com/philopon/namelist-hs";
       description = "fortran90 namelist parser/pretty printer";
       license = stdenv.lib.licenses.mit;
     }) {};

  "names" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "names";
       version = "0.3.1";
       sha256 = "afe4cf6115492d794893ea38b4f7ace2b4c4b665da6387e4567266f741ba526a";
       libraryHaskellDepends = [ base template-haskell ];
       description = "Type level names";
       license = stdenv.lib.licenses.mit;
     }) {};

  "names-th" = callPackage
    ({ mkDerivation, base, containers, template-haskell }:
     mkDerivation {
       pname = "names-th";
       version = "0.2.0.1";
       sha256 = "704a06e72c4bd3a15a8dc58f47d9b4e61728d7117ff6e3b905494344a3251821";
       libraryHaskellDepends = [ base containers template-haskell ];
       homepage = "http://khibino.github.io/haskell-relational-record/";
       description = "Manipulate name strings for TH";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nano-cryptr" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "nano-cryptr";
       version = "0.1.1.3";
       sha256 = "c8b923b74f2f4e34e6d8d33041a3028af3399a0c414a2807c284214211fd1cdf";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://github.com/chowells79/nano-cryptr";
       description = "A threadsafe binding to glibc's crypt_r function";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nano-erl" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "nano-erl";
       version = "0.1.0.1";
       sha256 = "370a60682b38ca77b793ee7326c54d5e74dd688f316f31fdd5cf999ad498ee12";
       libraryHaskellDepends = [ base stm ];
       description = "Small library for Erlang-style actor semantics";
       license = stdenv.lib.licenses.mit;
     }) {};

  "nano-hmac" = callPackage
    ({ mkDerivation, base, bytestring, openssl }:
     mkDerivation {
       pname = "nano-hmac";
       version = "0.2.0";
       sha256 = "d8ba32a4538dd5c84688160aa3bc8b2b923077e81e474daa0c54ed3a58503c67";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ openssl ];
       homepage = "http://www.jasani.org/search/label/nano-hmac";
       description = "Bindings to OpenSSL HMAC";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openssl;};

  "nano-md5" = callPackage
    ({ mkDerivation, base, bytestring, openssl }:
     mkDerivation {
       pname = "nano-md5";
       version = "0.1.2";
       sha256 = "73a93b3b0f1542f346080049b152288751f214eb38d3014f157b026e8e1faba1";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ openssl ];
       homepage = "http://code.haskell.org/~dons/code/nano-md5";
       description = "Efficient, ByteString bindings to OpenSSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openssl;};

  "nanoAgda" = callPackage
    ({ mkDerivation, base, BNFC-meta, cmdargs, containers, mtl, parsec
     , pretty, transformers
     }:
     mkDerivation {
       pname = "nanoAgda";
       version = "1.0.0";
       sha256 = "55a7a87f992d2042062d5c971da4e52bec9ca8db580f11e4b1dd2421b5e6950c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base BNFC-meta cmdargs containers mtl parsec pretty transformers
       ];
       jailbreak = true;
       description = "A toy dependently-typed language";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nanocurses" = callPackage
    ({ mkDerivation, base, bytestring, ncurses, unix }:
     mkDerivation {
       pname = "nanocurses";
       version = "1.5.2";
       sha256 = "35bc629de613a20f7f885ea5222378f40bd28befe07e575d68a637b9f7706f12";
       libraryHaskellDepends = [ base bytestring unix ];
       librarySystemDepends = [ ncurses ];
       homepage = "http://www.cse.unsw.edu.au/~dons/hmp3.html";
       description = "Simple Curses binding";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) ncurses;};

  "nanomsg" = callPackage
    ({ mkDerivation, base, bytestring, nanomsg }:
     mkDerivation {
       pname = "nanomsg";
       version = "0.1.1";
       sha256 = "e3364e1c9c00931fc8d750d7804b16ce9c86fb18bd23db4c3e3fca2e87464b1a";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ nanomsg ];
       jailbreak = true;
       description = "nanomsg - scalability protocols library";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) nanomsg;};

  "nanomsg-haskell" = callPackage
    ({ mkDerivation, base, binary, bytestring, nanomsg, QuickCheck
     , test-framework, test-framework-quickcheck2, test-framework-th
     }:
     mkDerivation {
       pname = "nanomsg-haskell";
       version = "0.2.3";
       sha256 = "1d535d846c7fd4ca54d1235a25f0b887c301a1af0cf23a551b994a4bbc923f61";
       libraryHaskellDepends = [ base binary bytestring ];
       librarySystemDepends = [ nanomsg ];
       testHaskellDepends = [
         base binary bytestring QuickCheck test-framework
         test-framework-quickcheck2 test-framework-th
       ];
       homepage = "https://github.com/ivarnymoen/nanomsg-haskell";
       description = "Bindings to the nanomsg library";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) nanomsg;};

  "nanoparsec" = callPackage
    ({ mkDerivation, base, bytestring, ListLike }:
     mkDerivation {
       pname = "nanoparsec";
       version = "0.1.1";
       sha256 = "75d8c57ffca0dbd65b2092ea79e54658f706f03f180ab2cf236242fde76ff001";
       libraryHaskellDepends = [ base bytestring ListLike ];
       jailbreak = true;
       description = "An implementation of attoparsec-like parser around list-like";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nanospec_0_2_0" = callPackage
    ({ mkDerivation, base, hspec, silently }:
     mkDerivation {
       pname = "nanospec";
       version = "0.2.0";
       sha256 = "1b0bae00eb01e9f4b04c167ebe0c7a27025429ce7709db3f2a798ccd0ca2203c";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec silently ];
       description = "A lightweight implementation of a subset of Hspec's API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nanospec" = callPackage
    ({ mkDerivation, base, hspec, silently }:
     mkDerivation {
       pname = "nanospec";
       version = "0.2.1";
       sha256 = "dbcbd9baa57fc9aa573cc2e291bb93c787dc0d7aac9793b2a10c125f69a0024b";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec silently ];
       description = "A lightweight implementation of a subset of Hspec's API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "nanq" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, containers
     , extensible-effects, kanji, microlens, microlens-aeson
     , optparse-applicative, text
     }:
     mkDerivation {
       pname = "nanq";
       version = "3.0.0";
       sha256 = "fd0ce6e40e6995521a97c0cbe13bd0260adfa21a76230f07cc17e299ca9c131c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson aeson-pretty base bytestring containers extensible-effects
         kanji microlens microlens-aeson optparse-applicative text
       ];
       homepage = "https://github.com/fosskers/nanq";
       description = "Performs 漢字検定 (National Kanji Exam) level analysis on given Kanji";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "narc" = callPackage
    ({ mkDerivation, base, HDBC, HUnit, mtl, QuickCheck, random }:
     mkDerivation {
       pname = "narc";
       version = "0.1.3";
       sha256 = "4c3b30fd459cd12d90e55118596e166732bb0af8faa179c74bd0381ae4cfe1d9";
       libraryHaskellDepends = [ base HDBC HUnit mtl QuickCheck random ];
       homepage = "http://ezrakilty.net/projects/narc";
       description = "Query SQL databases using Nested Relational Calculus embedded in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nat" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "nat";
       version = "0.3";
       sha256 = "c5d58fc25be8a3bd1e996700a66057b2638dac3298715b7d45168b935b6083ec";
       libraryHaskellDepends = [ base ];
       description = "Lazy binary natural numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nationstates_0_2_0_0" = callPackage
    ({ mkDerivation, base, bytestring, clock, containers, http-client
     , http-client-tls, http-types, multiset, transformers, xml
     }:
     mkDerivation {
       pname = "nationstates";
       version = "0.2.0.0";
       sha256 = "88e00660570f45c3ff709a659707b5967db54730f3dff25844dde07d0b3b3a1f";
       libraryHaskellDepends = [
         base bytestring clock containers http-client http-client-tls
         http-types multiset transformers xml
       ];
       homepage = "https://github.com/lfairy/nationstates";
       description = "NationStates API client";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nationstates_0_2_0_1" = callPackage
    ({ mkDerivation, base, bytestring, clock, containers, http-client
     , http-client-tls, http-types, multiset, transformers, xml
     }:
     mkDerivation {
       pname = "nationstates";
       version = "0.2.0.1";
       sha256 = "091ddee83ea21b6b8505ef5053c8b6ce58b08a578f8cd51bfe1c32745af0426c";
       libraryHaskellDepends = [
         base bytestring clock containers http-client http-client-tls
         http-types multiset transformers xml
       ];
       homepage = "https://github.com/lfairy/nationstates";
       description = "NationStates API client";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nationstates_0_2_0_2" = callPackage
    ({ mkDerivation, base, bytestring, clock, containers, http-client
     , http-client-tls, http-types, multiset, transformers, xml
     }:
     mkDerivation {
       pname = "nationstates";
       version = "0.2.0.2";
       sha256 = "232e71acca03866bc47c8d9d49179f83c45b95734ccf8dd683345d2fe9ecbbbc";
       libraryHaskellDepends = [
         base bytestring clock containers http-client http-client-tls
         http-types multiset transformers xml
       ];
       homepage = "https://github.com/lfairy/nationstates";
       description = "NationStates API client";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nationstates_0_2_0_3" = callPackage
    ({ mkDerivation, base, bytestring, clock, containers, http-client
     , http-client-tls, http-types, multiset, transformers, xml
     }:
     mkDerivation {
       pname = "nationstates";
       version = "0.2.0.3";
       sha256 = "169a20cc4de3c68cb22f792410cf39379199895787b4d587cd67aa8a8a57f4fa";
       libraryHaskellDepends = [
         base bytestring clock containers http-client http-client-tls
         http-types multiset transformers xml
       ];
       homepage = "https://github.com/lfairy/nationstates";
       description = "NationStates API client";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nationstates" = callPackage
    ({ mkDerivation, base, bytestring, clock, containers, http-client
     , http-client-tls, http-types, multiset, tls, transformers, xml
     }:
     mkDerivation {
       pname = "nationstates";
       version = "0.5.0.0";
       sha256 = "020efcdc1b16ae77ce2488180c02e398db45745adc96da2e9b406f27d7f75692";
       libraryHaskellDepends = [
         base bytestring clock containers http-client http-client-tls
         http-types multiset tls transformers xml
       ];
       homepage = "https://github.com/lfairy/nationstates";
       description = "NationStates API client";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "nats_1" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "nats";
       version = "1";
       sha256 = "8045e8348bc166832d443b65addc537504a63e5a60cf9c99e8037ba00945da64";
       revision = "1";
       editedCabalFile = "ea2e93e879296eb63130ebd89562d0e7e6d74748c6c8b029c07708d2ffd44b72";
       doHaddock = false;
       homepage = "http://github.com/ekmett/nats/";
       description = "Natural numbers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nats" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "nats";
       version = "1.1";
       sha256 = "ce64e24dcd62d3e93ca9023c9bda43101298d1161a16de84cb3800f5535a09c4";
       doHaddock = false;
       homepage = "http://github.com/ekmett/nats/";
       description = "Natural numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nats-queue" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, containers
     , dequeue, hspec, network, network-uri, random, text
     }:
     mkDerivation {
       pname = "nats-queue";
       version = "0.1.2.1";
       sha256 = "278abe19802ac26b2a720ad9bab84c9ce74f348eabff55ee96e67286f5453ca3";
       libraryHaskellDepends = [
         aeson async base bytestring containers dequeue network network-uri
         random text
       ];
       testHaskellDepends = [
         aeson base bytestring containers dequeue hspec network network-uri
         random text
       ];
       description = "Haskell API for NATS messaging system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "natural-number" = callPackage
    ({ mkDerivation, base, type-equality, type-level-natural-number
     , type-level-natural-number-induction
     }:
     mkDerivation {
       pname = "natural-number";
       version = "1.0";
       sha256 = "bddc37b81d39d34ac0c4b99d220090fc52d3ba5c44796a3dbfa03012977c18d9";
       libraryHaskellDepends = [
         base type-equality type-level-natural-number
         type-level-natural-number-induction
       ];
       jailbreak = true;
       description = "Natural numbers tagged with a type-level representation of the number";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "natural-numbers" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "natural-numbers";
       version = "0.1.2.0";
       sha256 = "965fdd3763555123f3ed1a335edbf1b0a755a04b1bf7385711c4e74dada54932";
       libraryHaskellDepends = [ base ];
       homepage = "http://darcs.wolfgang.jeltsch.info/haskell/natural-numbers";
       description = "Natural numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "natural-sort" = callPackage
    ({ mkDerivation, base, bytestring, parsec, text }:
     mkDerivation {
       pname = "natural-sort";
       version = "0.1.2";
       sha256 = "7b72b734680827ab07df38a004d4f523540055389d62fcd587edd2fcf19a6b50";
       libraryHaskellDepends = [ base bytestring parsec text ];
       homepage = "https://john-millikin.com/software/natural-sort/";
       description = "User-friendly text collation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "natural-transformation" = callPackage
    ({ mkDerivation, base, containers, quickcheck-instances, tasty
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "natural-transformation";
       version = "0.3.1";
       sha256 = "9b5a39f18790f33807298d47dc7098e2863ca874e8b3d2b419bf696f2ad09702";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base containers quickcheck-instances tasty tasty-quickcheck
       ];
       homepage = "https://github.com/ku-fpg/natural-transformation";
       description = "A natural transformation package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "naturalcomp" = callPackage
    ({ mkDerivation, base, text, utf8-string }:
     mkDerivation {
       pname = "naturalcomp";
       version = "0.0.3";
       sha256 = "5d105e8d34ad36015e9598d52b189bfc5339e67e5e6500211565f9d12625a9d0";
       libraryHaskellDepends = [ base text utf8-string ];
       homepage = "not yet available";
       description = "Natural-order string comparison";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "naturals" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "naturals";
       version = "0.2.0.2";
       sha256 = "2654d9083a478706c82fcb524947e8882b1a252679b01f02818ab5315048c2ab";
       libraryHaskellDepends = [ base ];
       homepage = "frigidcode.com";
       description = "Constructors and related functions for natural numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "naver-translate" = callPackage
    ({ mkDerivation, aeson, base, iso639, lens, lens-aeson, network-uri
     , random, text, wreq
     }:
     mkDerivation {
       pname = "naver-translate";
       version = "0.1.0.2";
       sha256 = "ea4bd9f0eb8eef5f89d9715ab893238db39cdc186617ec8ec93b8c9fce817542";
       libraryHaskellDepends = [
         aeson base iso639 lens lens-aeson network-uri random text wreq
       ];
       jailbreak = true;
       homepage = "https://github.com/dahlia/naver-translate";
       description = "Interface to Naver Translate";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "nbt" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, zlib
     }:
     mkDerivation {
       pname = "nbt";
       version = "0.6";
       sha256 = "4db207844f21a0073d6346613d61cf00b02a7da7c32ba501413c3b0624ed9651";
       libraryHaskellDepends = [ array base bytestring cereal text ];
       testHaskellDepends = [
         array base bytestring cereal HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 text zlib
       ];
       homepage = "https://github.com/acfoltzer/nbt";
       description = "A parser/serializer for Minecraft's Named Binary Tag (NBT) data format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nc-indicators" = callPackage
    ({ mkDerivation, array, attoparsec, base, bytestring, containers
     , gtk, hflags, lens, pipes, stm, unix
     }:
     mkDerivation {
       pname = "nc-indicators";
       version = "0.3";
       sha256 = "75588f72d294101a4a8f879faf5e7aaa86d7de4a56dd66d2df69459d636bb670";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array attoparsec base bytestring containers gtk hflags lens pipes
         stm unix
       ];
       homepage = "https://github.com/nilcons/nc-indicators";
       description = "CPU load and memory usage indicators for i3bar";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "ncurses" = callPackage
    ({ mkDerivation, base, c2hs, containers, ncurses, text
     , transformers
     }:
     mkDerivation {
       pname = "ncurses";
       version = "0.2.15";
       sha256 = "d66088846d7b82ac7921a81e6456492277f1d81c0b115afe1a35b23e0ec0b198";
       libraryHaskellDepends = [ base containers text transformers ];
       librarySystemDepends = [ ncurses ];
       libraryToolDepends = [ c2hs ];
       homepage = "https://john-millikin.com/software/haskell-ncurses/";
       description = "Modernised bindings to GNU ncurses";
       license = stdenv.lib.licenses.gpl3;
     }) {inherit (pkgs) ncurses;};

  "ndjson-conduit_0_1_0_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, conduit }:
     mkDerivation {
       pname = "ndjson-conduit";
       version = "0.1.0.2";
       sha256 = "12aa0f01b8c186f038e0d2617f744491fd0464def34fef4bebd06bc5d8b2bd3b";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring conduit
       ];
       homepage = "https://github.com/srijs/haskell-ndjson-conduit";
       description = "Conduit-based parsing and serialization for newline delimited JSON";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ndjson-conduit" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, conduit }:
     mkDerivation {
       pname = "ndjson-conduit";
       version = "0.1.0.3";
       sha256 = "a4f9e574af6d565ea9edc313c78ea9ee95c957d2abe61f4a0991a49231e9b592";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring conduit
       ];
       homepage = "https://github.com/srijs/haskell-ndjson-conduit";
       description = "Conduit-based parsing and serialization for newline delimited JSON";
       license = stdenv.lib.licenses.mit;
     }) {};

  "neat" = callPackage
    ({ mkDerivation, base, filepath, parsec }:
     mkDerivation {
       pname = "neat";
       version = "0.1.0";
       sha256 = "539add46d102a12c153fb4366bfa79e8e67fb94839d5fa532bed4f472d650552";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base filepath parsec ];
       executableHaskellDepends = [ base filepath parsec ];
       homepage = "https://github.com/ajg/neat";
       description = "A Fast Retargetable Template Engine";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "neat-interpolation_0_2_2" = callPackage
    ({ mkDerivation, base, base-prelude, HTF, parsec, template-haskell
     }:
     mkDerivation {
       pname = "neat-interpolation";
       version = "0.2.2";
       sha256 = "0c082aa3ccae379496836a34730e294d1888635f6528fba1e3d1cd78df185b42";
       libraryHaskellDepends = [
         base base-prelude parsec template-haskell
       ];
       testHaskellDepends = [ base-prelude HTF ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/neat-interpolation";
       description = "A quasiquoter for neat and simple multiline text interpolation";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "neat-interpolation_0_2_2_1" = callPackage
    ({ mkDerivation, base, base-prelude, HTF, parsec, template-haskell
     }:
     mkDerivation {
       pname = "neat-interpolation";
       version = "0.2.2.1";
       sha256 = "de357ec4b78f68c5797d84e8bb01a35aff53e8c0d10d5d1ebbe5185d0483b303";
       libraryHaskellDepends = [
         base base-prelude parsec template-haskell
       ];
       testHaskellDepends = [ base-prelude HTF ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/neat-interpolation";
       description = "A quasiquoter for neat and simple multiline text interpolation";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "neat-interpolation_0_2_3" = callPackage
    ({ mkDerivation, base, base-prelude, HTF, parsec, template-haskell
     }:
     mkDerivation {
       pname = "neat-interpolation";
       version = "0.2.3";
       sha256 = "a60966321467bf8065796f37774756f94a89c443ee59fac4fbeac964d4a1c20b";
       libraryHaskellDepends = [
         base base-prelude parsec template-haskell
       ];
       testHaskellDepends = [ base-prelude HTF ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/neat-interpolation";
       description = "A quasiquoter for neat and simple multiline text interpolation";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "neat-interpolation_0_3" = callPackage
    ({ mkDerivation, base, base-prelude, HTF, parsec, template-haskell
     , text
     }:
     mkDerivation {
       pname = "neat-interpolation";
       version = "0.3";
       sha256 = "fd8b935d2e674456a6db7af90974cb5d2381709bca20051c2da024888b80fd25";
       libraryHaskellDepends = [
         base base-prelude parsec template-haskell text
       ];
       testHaskellDepends = [ base-prelude HTF ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/neat-interpolation";
       description = "A quasiquoter for neat and simple multiline text interpolation";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "neat-interpolation_0_3_1" = callPackage
    ({ mkDerivation, base, base-prelude, HTF, parsec, template-haskell
     , text
     }:
     mkDerivation {
       pname = "neat-interpolation";
       version = "0.3.1";
       sha256 = "dd5ac81fb44ab9dff1ae1e0a1a67bc59358e4ad1a6fdf17529b1c7d3582a221f";
       libraryHaskellDepends = [
         base base-prelude parsec template-haskell text
       ];
       testHaskellDepends = [ base-prelude HTF ];
       homepage = "https://github.com/nikita-volkov/neat-interpolation";
       description = "A quasiquoter for neat and simple multiline text interpolation";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "neat-interpolation" = callPackage
    ({ mkDerivation, base, base-prelude, HTF, parsec, template-haskell
     , text
     }:
     mkDerivation {
       pname = "neat-interpolation";
       version = "0.3.1.1";
       sha256 = "051a3ee1f9389e2ff1d05dc8f78fc3aae0e50be90ddee1868561ecac095469c9";
       libraryHaskellDepends = [
         base base-prelude parsec template-haskell text
       ];
       testHaskellDepends = [ base-prelude HTF ];
       homepage = "https://github.com/nikita-volkov/neat-interpolation";
       description = "A quasiquoter for neat and simple multiline text interpolation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "needle" = callPackage
    ({ mkDerivation, base, containers, haskell-src-meta, mtl, parsec
     , parsec-extra, template-haskell, text, vector
     }:
     mkDerivation {
       pname = "needle";
       version = "0.1.0.1";
       sha256 = "e2f9f39947d5ed9eeced7bb3069f4d14859856c97f9d2d4168abed7a94acf0dc";
       libraryHaskellDepends = [
         base containers haskell-src-meta mtl parsec parsec-extra
         template-haskell text vector
       ];
       jailbreak = true;
       homepage = "http://scrambledeggsontoast.github.io/2014/09/28/needle-announce/";
       description = "ASCII-fied arrow notation";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "neet" = callPackage
    ({ mkDerivation, base, cereal, containers, graphviz, MonadRandom
     , multimap, parallel, random, transformers
     }:
     mkDerivation {
       pname = "neet";
       version = "0.4.0.1";
       sha256 = "f27956192a15ec9dc4d869c980562ced7abe3b4fda584b9ed89ac9036684cf9c";
       libraryHaskellDepends = [
         base cereal containers graphviz MonadRandom multimap parallel
         random transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/raymoo/NEET";
       description = "A NEAT library for Haskell";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "nehe-tuts" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, directory, GLFW-b
     , GLURaw, OpenGLRaw, random
     }:
     mkDerivation {
       pname = "nehe-tuts";
       version = "0.2.4";
       sha256 = "208bca9c3d65c2ad99438da6548abfcadd5824d987ec8ea9109490f910a2f403";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring cereal directory GLFW-b GLURaw OpenGLRaw
         random
       ];
       description = "Port of the NeHe OpenGL tutorials to Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "neil" = callPackage
    ({ mkDerivation, base, cmdargs, containers, directory, extra
     , filepath, GoogleChart, json, old-time, process, time
     }:
     mkDerivation {
       pname = "neil";
       version = "0.10";
       sha256 = "7bf2215903836e058bdbbc0c884e773f081c03f79cfa99964e620969e03a139f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs containers directory extra filepath GoogleChart json
         old-time process time
       ];
       homepage = "http://community.haskell.org/~ndm/";
       description = "General tools for Neil";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "neither" = callPackage
    ({ mkDerivation, base, failure, transformers }:
     mkDerivation {
       pname = "neither";
       version = "0.3.1.1";
       sha256 = "ce07d3be22d9dc157d78b3455dd70df42995552f5d1d2ca5cbf786e5014154a4";
       libraryHaskellDepends = [ base failure transformers ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/neither";
       description = "Provide versions of Either with good monad and applicative instances. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nemesis" = callPackage
    ({ mkDerivation, air, air-th, base, containers, directory, dlist
     , Glob, mtl, process, time
     }:
     mkDerivation {
       pname = "nemesis";
       version = "2015.5.4";
       sha256 = "511a5e927c340f5d5d2e351e1921271421410b27e6be707b4e8ea18092e82e91";
       libraryHaskellDepends = [
         air air-th base containers directory dlist Glob mtl process time
       ];
       homepage = "http://github.com/nfjinjing/nemesis";
       description = "a task management tool for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nemesis-titan" = callPackage
    ({ mkDerivation, air, air-th, base, bytestring, directory, filepath
     , hspec, HStringTemplate, nemesis, random, uuid
     }:
     mkDerivation {
       pname = "nemesis-titan";
       version = "2014.5.19";
       sha256 = "ad76a2da37da0b483dcb8205c71ed95ffdb24f5321fccedd2c2e53513e3775a0";
       libraryHaskellDepends = [
         air air-th base bytestring directory filepath hspec HStringTemplate
         nemesis random uuid
       ];
       homepage = "http://github.com/nfjinjing/nemesis-titan";
       description = "A collection of Nemesis tasks to bootstrap a Haskell project with a focus on continuous integration";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nerf" = callPackage
    ({ mkDerivation, base, binary, bytestring, cmdargs, containers
     , crf-chain1, data-named, dawg, directory, filepath, IntervalMap
     , monad-ox, mtl, network, polimorf, polysoup, sgd, tagsoup
     , temporary, text, text-binary, tokenize, vector
     }:
     mkDerivation {
       pname = "nerf";
       version = "0.5.3";
       sha256 = "5311500253965eb5163a1505b9bb2882299f76f354b4b66425e8982ce69333a3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring cmdargs containers crf-chain1 data-named
         dawg IntervalMap monad-ox mtl network polimorf polysoup sgd tagsoup
         text text-binary tokenize vector
       ];
       executableHaskellDepends = [ directory filepath temporary ];
       jailbreak = true;
       homepage = "https://github.com/kawu/nerf";
       description = "Nerf, the named entity recognition tool based on linear-chain CRFs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nero" = callPackage
    ({ mkDerivation, base, bifunctors, bytestring, containers, doctest
     , Glob, lens, tasty, tasty-hunit, text
     }:
     mkDerivation {
       pname = "nero";
       version = "0.3.1";
       sha256 = "a0349a6ae3650a53b5b49127da4101447e9d75274a1c7b2fec21c1d81b9eb1da";
       libraryHaskellDepends = [
         base bifunctors bytestring containers lens text
       ];
       testHaskellDepends = [
         base bytestring doctest Glob lens tasty tasty-hunit text
       ];
       homepage = "https://github.com/plutonbrb/nero";
       description = "Lens-based HTTP toolkit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nero-wai" = callPackage
    ({ mkDerivation, base, bytestring, http-types, lens, nero, text
     , wai, wai-extra
     }:
     mkDerivation {
       pname = "nero-wai";
       version = "0.3";
       sha256 = "5ca1f5a3fd0d91c3ae6ea98b23a94de40bea8f9754e63c038ed8d150b4e2e2cb";
       libraryHaskellDepends = [
         base bytestring http-types lens nero text wai wai-extra
       ];
       homepage = "https://github.com/plutonbrb/nero-wai";
       description = "WAI adapter for Nero server applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nero-warp" = callPackage
    ({ mkDerivation, base, nero, nero-wai, warp }:
     mkDerivation {
       pname = "nero-warp";
       version = "0.3";
       sha256 = "1a9094c0c274f987cb9db1d4206e9f8e1df4415c0e80b58a23279f9e3404b9b5";
       libraryHaskellDepends = [ base nero nero-wai warp ];
       homepage = "https://github.com/plutonbrb/nero-warp";
       description = "Run Nero server applications with Warp";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nested-routes" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, composition-extra
     , errors, exceptions, hashable, hspec, hspec-wai, http-types, mtl
     , poly-arity, pred-trie, regex-compat, semigroups, text
     , transformers, tries, unordered-containers
     , wai-middleware-content-type, wai-middleware-verbs
     , wai-transformers, warp
     }:
     mkDerivation {
       pname = "nested-routes";
       version = "7.0.0";
       sha256 = "eac01cd730d3cbcafab4a0ac2b6b8c3ca8cdcd31f996379092f2f60bc31c21a2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring composition-extra errors exceptions
         hashable mtl poly-arity pred-trie regex-compat semigroups text
         transformers tries unordered-containers wai-middleware-content-type
         wai-middleware-verbs wai-transformers
       ];
       executableHaskellDepends = [
         attoparsec base bytestring composition-extra errors exceptions
         hashable http-types mtl poly-arity pred-trie regex-compat
         semigroups text transformers tries unordered-containers
         wai-middleware-content-type wai-middleware-verbs wai-transformers
         warp
       ];
       testHaskellDepends = [
         attoparsec base bytestring composition-extra errors exceptions
         hashable hspec hspec-wai http-types mtl poly-arity pred-trie
         regex-compat semigroups text transformers tries
         unordered-containers wai-middleware-content-type
         wai-middleware-verbs wai-transformers
       ];
       description = "Declarative, compositional Wai responses";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nested-sets" = callPackage
    ({ mkDerivation, base, containers, hspec }:
     mkDerivation {
       pname = "nested-sets";
       version = "0.0.1.1";
       sha256 = "915cd4c664ec8d5d1575f2a7963ae529bd0667c8d1bbd3f715d0a76ea8be7728";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [ base containers hspec ];
       description = "Nested set model implementation";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "nestedmap" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, containers
     , data-ordlist, hspec, QuickCheck
     }:
     mkDerivation {
       pname = "nestedmap";
       version = "0.1.0.3";
       sha256 = "542ab8bfb173b79e7d409311cf8bab5a0c9fee16e6c318cfea25fb8f75493ac2";
       libraryHaskellDepends = [ base base-unicode-symbols containers ];
       testHaskellDepends = [
         base base-unicode-symbols containers data-ordlist hspec QuickCheck
       ];
       jailbreak = true;
       description = "A library for nested maps";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "net-concurrent" = callPackage
    ({ mkDerivation, base, bytestring, containers, ghc-binary, hslogger
     , monad-loops, network
     }:
     mkDerivation {
       pname = "net-concurrent";
       version = "0.1.0";
       sha256 = "0624d4108f27c055b306788a252e8342b64d37f84c763f8407013e6cd1f0252b";
       libraryHaskellDepends = [
         base bytestring containers ghc-binary hslogger monad-loops network
       ];
       jailbreak = true;
       homepage = "http://phaul.hobby-site.org/node/4123";
       description = "Concurrent over the network execution library";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {ghc-binary = null;};

  "netclock" = callPackage
    ({ mkDerivation, base, bytestring, hosc, network }:
     mkDerivation {
       pname = "netclock";
       version = "0.6";
       sha256 = "e82677679268f2140d9c81e8a2e4adca4db85992265b28e8d72b6de83ef3536f";
       libraryHaskellDepends = [ base bytestring hosc network ];
       homepage = "http://netclock.slab.org/";
       description = "Netclock protocol";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "netcore" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, bimap, binary, binary-strict
     , bytestring, containers, fgl, HList, hslogger, HUnit, mtl
     , multiset, network, parsec, process, QuickCheck, random, syb
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , test-framework-th
     }:
     mkDerivation {
       pname = "netcore";
       version = "1.0.0";
       sha256 = "45a5c0da1906e49eb94af8a76228e9d6172de698d828f9aead957fbd5d85382e";
       libraryHaskellDepends = [
         ansi-wl-pprint base bimap binary binary-strict bytestring
         containers fgl HList hslogger mtl multiset network parsec process
         random syb
       ];
       testHaskellDepends = [
         ansi-wl-pprint base bimap binary binary-strict bytestring
         containers fgl HList hslogger HUnit mtl multiset network parsec
         process QuickCheck random syb test-framework test-framework-hunit
         test-framework-quickcheck2 test-framework-th
       ];
       jailbreak = true;
       homepage = "http://frenetic-lang.org";
       description = "The NetCore compiler and runtime system for OpenFlow networks";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "netlines" = callPackage
    ({ mkDerivation, base, bytestring, contstuff, enumerator, HTF
     , random, text, time
     }:
     mkDerivation {
       pname = "netlines";
       version = "1.0.0";
       sha256 = "f2c97065cc4d843ec5c28db464e67be176e0048d1ab4d8d0a70940981351cc00";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring contstuff enumerator text time
       ];
       executableHaskellDepends = [ base HTF random ];
       description = "Enumerator tools for text-based network protocols";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "netlink" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, cereal, containers
     , monad-loops, unix
     }:
     mkDerivation {
       pname = "netlink";
       version = "0.1";
       sha256 = "9653369535aac39f759d20ab34e49397b6d9d218e3a108de437394596bf75170";
       revision = "1";
       editedCabalFile = "a95c52a24e2db0fb3670350b3205c62d9e30bd8a596c34885cb65a3b73452294";
       libraryHaskellDepends = [
         base bytestring cereal containers monad-loops unix
       ];
       libraryToolDepends = [ c2hs ];
       jailbreak = true;
       homepage = "http://netlink-hs.googlecode.com/";
       description = "Netlink communication for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "netlist" = callPackage
    ({ mkDerivation, base, binary, containers, syb }:
     mkDerivation {
       pname = "netlist";
       version = "0.3.1";
       sha256 = "c7d4ee1f6f3d8a09daea45d72ee16aac784ac02719afeffa936a5cf0eee36e38";
       libraryHaskellDepends = [ base binary containers syb ];
       description = "Netlist AST";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "netlist-to-vhdl" = callPackage
    ({ mkDerivation, base, netlist, pretty }:
     mkDerivation {
       pname = "netlist-to-vhdl";
       version = "0.3.2";
       sha256 = "c128e165707a35b046057a64d3a939b9c07b99761cdaccdd94581809e39cf780";
       libraryHaskellDepends = [ base netlist pretty ];
       description = "Convert a Netlist AST to VHDL";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "netpbm" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-binary, base, bytestring
     , hspec, HUnit, storable-record, unordered-containers, vector
     , vector-th-unbox
     }:
     mkDerivation {
       pname = "netpbm";
       version = "1.0.1";
       sha256 = "cc8d790d0255b2554c62c5df3185c7ff9c6fccc2c55630efcc54c7fa4e3df209";
       libraryHaskellDepends = [
         attoparsec attoparsec-binary base bytestring storable-record
         unordered-containers vector vector-th-unbox
       ];
       testHaskellDepends = [ base bytestring hspec HUnit vector ];
       homepage = "https://github.com/nh2/haskell-netpbm";
       description = "Loading PBM, PGM, PPM image files";
       license = stdenv.lib.licenses.mit;
     }) {};

  "netrc" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, parsec, tasty
     , tasty-golden, tasty-quickcheck
     }:
     mkDerivation {
       pname = "netrc";
       version = "0.2.0.0";
       sha256 = "9a5e07efa44f4b715b110aa4f9687e2b75458fb7537a2f4f1a3582c9e2e82a86";
       revision = "1";
       editedCabalFile = "55e4e8785866fa2145f9b4de21522d4092a7c486845062915704b2917b8c4fbd";
       libraryHaskellDepends = [ base bytestring deepseq parsec ];
       testHaskellDepends = [
         base bytestring tasty tasty-golden tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "https://github.com/hvr/netrc";
       description = "Parser for .netrc files";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "netspec" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, mtl, network
     , template-haskell, text, transformers
     }:
     mkDerivation {
       pname = "netspec";
       version = "0.2.0.0";
       sha256 = "5831b4dca07bb02736b5e3a5d91969bb6aea87868f236550551f64e36e51ac62";
       libraryHaskellDepends = [
         aeson base binary bytestring mtl network template-haskell text
         transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/DanBurton/netspec";
       description = "Simplify static Networking tasks";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "netstring-enumerator" = callPackage
    ({ mkDerivation, base, bytestring, enumerator, transformers }:
     mkDerivation {
       pname = "netstring-enumerator";
       version = "0.1.1";
       sha256 = "75c232b70e53430128efcfb5d4401ef4c803bd8964f1912299201e5050432fd8";
       libraryHaskellDepends = [
         base bytestring enumerator transformers
       ];
       jailbreak = true;
       homepage = "https://john-millikin.com/software/netstring-enumerator/";
       description = "Enumerator-based netstring parsing";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "nettle_0_1_0" = callPackage
    ({ mkDerivation, array, base, byteable, bytestring
     , crypto-cipher-tests, crypto-cipher-types, HUnit, nettle
     , QuickCheck, securemem, tagged, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "nettle";
       version = "0.1.0";
       sha256 = "5ab189ab230b567f6dd2ac1474b4de03c80a2aa7d5f0ead3d056b4a4143549d7";
       libraryHaskellDepends = [
         base byteable bytestring crypto-cipher-types securemem tagged
       ];
       libraryPkgconfigDepends = [ nettle ];
       testHaskellDepends = [
         array base bytestring crypto-cipher-tests crypto-cipher-types HUnit
         QuickCheck tagged test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/stbuehler/haskell-nettle";
       description = "safe nettle binding";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) nettle;};

  "nettle_0_1_1" = callPackage
    ({ mkDerivation, array, base, byteable, bytestring
     , crypto-cipher-tests, crypto-cipher-types, HUnit, nettle
     , QuickCheck, securemem, tagged, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "nettle";
       version = "0.1.1";
       sha256 = "d94f69735738fcc6a4c3450e7aa39807514e431a2da4ddd9cc6905a2670925d1";
       libraryHaskellDepends = [
         base byteable bytestring crypto-cipher-types securemem tagged
       ];
       libraryPkgconfigDepends = [ nettle ];
       testHaskellDepends = [
         array base bytestring crypto-cipher-tests crypto-cipher-types HUnit
         QuickCheck tagged test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "https://github.com/stbuehler/haskell-nettle";
       description = "safe nettle binding";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) nettle;};

  "nettle" = callPackage
    ({ mkDerivation, array, base, byteable, bytestring
     , crypto-cipher-tests, crypto-cipher-types, HUnit, nettle
     , QuickCheck, securemem, tagged, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "nettle";
       version = "0.2.0";
       sha256 = "220184713b802c53ee26783b891a3bbee6c6b2571f798bd6def2496a504e9bde";
       libraryHaskellDepends = [
         base byteable bytestring crypto-cipher-types securemem tagged
       ];
       libraryPkgconfigDepends = [ nettle ];
       testHaskellDepends = [
         array base bytestring crypto-cipher-tests crypto-cipher-types HUnit
         QuickCheck tagged test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "https://github.com/stbuehler/haskell-nettle";
       description = "safe nettle binding";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) nettle;};

  "nettle-frp" = callPackage
    ({ mkDerivation, base, bimap, binary, bytestring, containers, mtl
     , nettle-openflow, network, network-data, random, time
     }:
     mkDerivation {
       pname = "nettle-frp";
       version = "0.1.1";
       sha256 = "9951b429dba5ace3a12d2a99d9893dbc0307ad5a322099437f2145b6874a6b4a";
       libraryHaskellDepends = [
         base bimap binary bytestring containers mtl nettle-openflow network
         network-data random time
       ];
       jailbreak = true;
       description = "FRP for controlling networks of OpenFlow switches";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nettle-netkit" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, mtl
     , nettle-openflow, unix
     }:
     mkDerivation {
       pname = "nettle-netkit";
       version = "0.2.0";
       sha256 = "977a661005238467bbaca27114ecfa4c0e2bfc46f43b4bf0df2b3b5c5b255194";
       libraryHaskellDepends = [
         base containers directory filepath mtl nettle-openflow unix
       ];
       description = "DSL for describing OpenFlow networks, and a compiler generating NetKit labs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nettle-openflow" = callPackage
    ({ mkDerivation, array, base, bimap, binary, binary-strict
     , bytestring, containers, HList, mtl, network, parsec, syb
     }:
     mkDerivation {
       pname = "nettle-openflow";
       version = "0.2.0";
       sha256 = "f3b562757db4db5386a7ddc28cfa480e473f513cbeb75667ddd168f4f56d89c9";
       libraryHaskellDepends = [
         array base bimap binary binary-strict bytestring containers HList
         mtl network parsec syb
       ];
       description = "OpenFlow protocol messages, binary formats, and servers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "netwire" = callPackage
    ({ mkDerivation, base, containers, deepseq, parallel, profunctors
     , random, semigroups, time, transformers
     }:
     mkDerivation {
       pname = "netwire";
       version = "5.0.1";
       sha256 = "199dd2bb49fdf31ed125e4063ba3545a0d73eff36c3ed38014df30965524f4c7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers deepseq parallel profunctors random semigroups time
         transformers
       ];
       executableHaskellDepends = [ base containers ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/ertes/netwire";
       description = "Functional reactive programming library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "netwire-input" = callPackage
    ({ mkDerivation, base, netwire }:
     mkDerivation {
       pname = "netwire-input";
       version = "0.0.4";
       sha256 = "06821950dd44925e208f740d747675ab42a51f0cf1b7eb0b5ed10566df670db8";
       libraryHaskellDepends = [ base netwire ];
       homepage = "https://www.github.com/Mokosha/netwire-input";
       description = "Input handling abstractions for netwire";
       license = stdenv.lib.licenses.mit;
     }) {};

  "netwire-input-glfw" = callPackage
    ({ mkDerivation, base, containers, GLFW-b, mtl, netwire-input, stm
     }:
     mkDerivation {
       pname = "netwire-input-glfw";
       version = "0.0.4";
       sha256 = "8fb6ba62fe7b122d204ff8af390de98a1631af370b231d4a4e5e57b0166a7298";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers GLFW-b mtl netwire-input stm
       ];
       homepage = "https://www.github.com/Mokosha/netwire-input-glfw";
       description = "GLFW instance of netwire-input";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "network_2_5_0_0" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, parsec, test-framework
     , test-framework-hunit, test-framework-quickcheck2, unix
     }:
     mkDerivation {
       pname = "network";
       version = "2.5.0.0";
       sha256 = "b2166f54af2aed140fbd2c1d7915f8e11eef37b9e33c2cd71618bfe87e7320f5";
       libraryHaskellDepends = [ base bytestring parsec unix ];
       testHaskellDepends = [
         base bytestring HUnit test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/haskell/network";
       description = "Low-level networking interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network_2_6_0_2" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, test-framework
     , test-framework-hunit, unix
     }:
     mkDerivation {
       pname = "network";
       version = "2.6.0.2";
       sha256 = "846d4099c4b1b3d05bec32c52cbef57313d513696a3e7a19a146bd5295d26789";
       libraryHaskellDepends = [ base bytestring unix ];
       testHaskellDepends = [
         base bytestring HUnit test-framework test-framework-hunit
       ];
       doCheck = false;
       homepage = "https://github.com/haskell/network";
       description = "Low-level networking interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network_2_6_1_0" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, test-framework
     , test-framework-hunit, unix
     }:
     mkDerivation {
       pname = "network";
       version = "2.6.1.0";
       sha256 = "b249c30da5826c1711f66bbfbeed61373e42228597ae92312aa2ca9ff72ca85b";
       libraryHaskellDepends = [ base bytestring unix ];
       testHaskellDepends = [
         base bytestring HUnit test-framework test-framework-hunit
       ];
       doCheck = false;
       homepage = "https://github.com/haskell/network";
       description = "Low-level networking interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network_2_6_2_0" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, test-framework
     , test-framework-hunit, unix
     }:
     mkDerivation {
       pname = "network";
       version = "2.6.2.0";
       sha256 = "c50eb0bfa05fb5ca1dd49a40b31dde15b17d7c71d3dbf39d387a1b7629fdf36b";
       libraryHaskellDepends = [ base bytestring unix ];
       testHaskellDepends = [
         base bytestring HUnit test-framework test-framework-hunit
       ];
       doCheck = false;
       homepage = "https://github.com/haskell/network";
       description = "Low-level networking interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, test-framework
     , test-framework-hunit, unix
     }:
     mkDerivation {
       pname = "network";
       version = "2.6.2.1";
       sha256 = "a3fda15c9bbe2c7274d97f40398c6cf8d1d3a9fe896fbf6531e1bfc849bb1bfa";
       libraryHaskellDepends = [ base bytestring unix ];
       testHaskellDepends = [
         base bytestring HUnit test-framework test-framework-hunit
       ];
       doCheck = false;
       homepage = "https://github.com/haskell/network";
       description = "Low-level networking interface";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-address" = callPackage
    ({ mkDerivation, base, Cabal, criterion, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "network-address";
       version = "0.2.0";
       sha256 = "614517e9712b1320ca86a1e77535e6cfb426850ca3e62e49f0eb776543e8e65f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base Cabal ];
       executableHaskellDepends = [ base Cabal criterion ];
       testHaskellDepends = [
         base Cabal QuickCheck test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/sebnow/haskell-network-address";
       description = "IP data structures and textual representation";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-anonymous-i2p" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, exceptions, hspec
     , hspec-attoparsec, hspec-expectations, mtl, network
     , network-attoparsec, network-simple, text, transformers, uuid
     }:
     mkDerivation {
       pname = "network-anonymous-i2p";
       version = "0.10.0";
       sha256 = "cff5796c36c1ebbb969e5433538eb3f3979acef9825a7bfb683ed002023fff2c";
       libraryHaskellDepends = [
         attoparsec base bytestring exceptions mtl network
         network-attoparsec network-simple text transformers uuid
       ];
       testHaskellDepends = [
         attoparsec base bytestring exceptions hspec hspec-attoparsec
         hspec-expectations mtl network network-simple transformers uuid
       ];
       doCheck = false;
       homepage = "http://github.com/solatis/haskell-network-anonymous-i2p";
       description = "Haskell API for I2P anonymous networking";
       license = stdenv.lib.licenses.mit;
     }) {};

  "network-anonymous-tor_0_9_2" = callPackage
    ({ mkDerivation, attoparsec, base, base32string, bytestring
     , exceptions, hexstring, hspec, hspec-attoparsec
     , hspec-expectations, network, network-attoparsec, network-simple
     , socks, splice, text, transformers
     }:
     mkDerivation {
       pname = "network-anonymous-tor";
       version = "0.9.2";
       sha256 = "3c4ca645220011bc78ce49edd620e666c0132dd47b5ea47245f25b7e2d5a5aff";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base base32string bytestring exceptions hexstring
         network network-attoparsec network-simple socks text transformers
       ];
       executableHaskellDepends = [
         base exceptions network network-simple splice
       ];
       testHaskellDepends = [
         attoparsec base base32string bytestring exceptions hspec
         hspec-attoparsec hspec-expectations network network-simple socks
         text transformers
       ];
       homepage = "http://www.leonmergen.com/opensource.html";
       description = "Haskell API for Tor anonymous networking";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-anonymous-tor" = callPackage
    ({ mkDerivation, attoparsec, base, base32string, bytestring
     , exceptions, hexstring, hspec, hspec-attoparsec
     , hspec-expectations, network, network-attoparsec, network-simple
     , socks, splice, text, transformers
     }:
     mkDerivation {
       pname = "network-anonymous-tor";
       version = "0.11.0";
       sha256 = "41aee5b34aaaec6fa47a56cca61fafec22097bda25d13d5baef6b7924e127549";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base base32string bytestring exceptions hexstring
         network network-attoparsec network-simple socks text transformers
       ];
       executableHaskellDepends = [
         base exceptions network network-simple splice
       ];
       testHaskellDepends = [
         attoparsec base base32string bytestring exceptions hspec
         hspec-attoparsec hspec-expectations network network-simple socks
         text transformers
       ];
       homepage = "http://www.leonmergen.com/opensource.html";
       description = "Haskell API for Tor anonymous networking";
       license = stdenv.lib.licenses.mit;
     }) {};

  "network-api-support" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , case-insensitive, http-client, http-client-tls, http-types, text
     , time, tls
     }:
     mkDerivation {
       pname = "network-api-support";
       version = "0.2.1";
       sha256 = "829e03488cf95f57d00cdd37078487e3c857861bcf79e0eb3dcbcda55b4d1a68";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring case-insensitive http-client
         http-client-tls http-types text time tls
       ];
       jailbreak = true;
       homepage = "https://github.com/markhibberd/network-api-support";
       description = "Toolkit for building http client libraries over Network.Http.Conduit";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-attoparsec" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, enclosed-exceptions
     , exceptions, hspec, lifted-base, monad-control, mtl, network
     , network-simple, transformers
     }:
     mkDerivation {
       pname = "network-attoparsec";
       version = "0.12.2";
       sha256 = "9790a9bad286ab1474dadbece3e4b2e1dd068d4ede3847cb73bcd66386bf08f0";
       libraryHaskellDepends = [
         attoparsec base bytestring enclosed-exceptions exceptions
         lifted-base monad-control mtl network transformers
       ];
       testHaskellDepends = [
         attoparsec base bytestring exceptions hspec mtl network
         network-simple transformers
       ];
       homepage = "http://github.com/solatis/haskell-network-attoparsec";
       description = "Utility functions for running a parser against a socket";
       license = stdenv.lib.licenses.mit;
     }) {};

  "network-bitcoin" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, cookie, HTTP
     , http-client, http-types, network, QuickCheck, text, time
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "network-bitcoin";
       version = "1.8.1";
       sha256 = "30256fd9e3ff52bef53e5851f1726f7cb601615bc073d0b7bf9b48222027803f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring cookie HTTP http-client http-types
         network text time unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson attoparsec base bytestring cookie HTTP http-client http-types
         network QuickCheck text time unordered-containers vector
       ];
       jailbreak = true;
       homepage = "http://github.com/mndrix/network-bitcoin";
       description = "An interface to bitcoind";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-builder" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cabal-test-bin, hspec
     , hspec-server, optparse-applicative, process, shelly, text, yaml
     }:
     mkDerivation {
       pname = "network-builder";
       version = "0.1.0";
       sha256 = "dcb3a677e5ad80aa58b9bc2de4164cd328fab5a5ab12cf52452500f4291b4a39";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ aeson base bytestring shelly text yaml ];
       executableHaskellDepends = [
         aeson base bytestring optparse-applicative shelly text yaml
       ];
       testHaskellDepends = [
         base cabal-test-bin hspec hspec-server process
       ];
       description = "Linux NetworkNameSpace Builder";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-bytestring" = callPackage
    ({ mkDerivation, base, bytestring, network, unix }:
     mkDerivation {
       pname = "network-bytestring";
       version = "0.1.3.4";
       sha256 = "263d405345b7cd0ef03a1629eb0f14ae6e3831f42d6daf813e4a639b6405a1a6";
       libraryHaskellDepends = [ base bytestring network unix ];
       jailbreak = true;
       homepage = "http://github.com/tibbe/network-bytestring";
       description = "Fast, memory-efficient, low-level networking";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-carbon_1_0_5" = callPackage
    ({ mkDerivation, base, bytestring, network, text, time, vector }:
     mkDerivation {
       pname = "network-carbon";
       version = "1.0.5";
       sha256 = "9126abf5a1328a677deec15e2ba895ff5cb50111f326ed478aaf1552d07f634d";
       libraryHaskellDepends = [
         base bytestring network text time vector
       ];
       homepage = "http://github.com/ocharles/network-carbon";
       description = "A Haskell implementation of the Carbon protocol (part of the Graphite monitoring tools)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-carbon" = callPackage
    ({ mkDerivation, base, bytestring, network, text, time, vector }:
     mkDerivation {
       pname = "network-carbon";
       version = "1.0.6";
       sha256 = "28e0a72d86be8a21637a62a83273311aab446b1d6e4a13f2638101aa6cd19ef6";
       libraryHaskellDepends = [
         base bytestring network text time vector
       ];
       homepage = "http://github.com/ocharles/network-carbon";
       description = "A Haskell implementation of the Carbon protocol (part of the Graphite monitoring tools)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-conduit" = callPackage
    ({ mkDerivation, base, conduit }:
     mkDerivation {
       pname = "network-conduit";
       version = "1.1.0";
       sha256 = "57a43448e6b508a7b65b133fdc1a6630e2e47b2dd8c7c05eb5ee939711ed5519";
       libraryHaskellDepends = [ base conduit ];
       doHaddock = false;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Stream socket data using conduits. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-conduit-tls_1_1_0_2" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , connection, cprng-aes, data-default, HUnit, monad-control, mtl
     , network, streaming-commons, system-fileio, system-filepath, tls
     , transformers
     }:
     mkDerivation {
       pname = "network-conduit-tls";
       version = "1.1.0.2";
       sha256 = "5da97f40a8398423a663f000a9a3d340f35261e1a98147aacfe03aedc613fbc9";
       revision = "1";
       editedCabalFile = "0e9403511841615990eacb97af80d3b7b4565b23fe1beccc774fc63a71b1ae99";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra connection cprng-aes
         data-default monad-control network streaming-commons system-fileio
         system-filepath tls transformers
       ];
       testHaskellDepends = [
         base bytestring conduit conduit-extra connection HUnit mtl
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/conduit";
       description = "Create TLS-aware network code with conduits";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-conduit-tls_1_1_1" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , connection, cprng-aes, data-default, HUnit, monad-control, mtl
     , network, streaming-commons, system-fileio, system-filepath, tls
     , transformers
     }:
     mkDerivation {
       pname = "network-conduit-tls";
       version = "1.1.1";
       sha256 = "37c876d0b955081e4a377ca7aa618ad1f49fa2b1c7aac07980c3726b26390073";
       revision = "1";
       editedCabalFile = "8eef5122840a7735925aff551d6dcf95110759c9a38bc6d402732df72dfc4883";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra connection cprng-aes
         data-default monad-control network streaming-commons system-fileio
         system-filepath tls transformers
       ];
       testHaskellDepends = [
         base bytestring conduit conduit-extra connection HUnit mtl
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/conduit";
       description = "Create TLS-aware network code with conduits";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-conduit-tls_1_1_1_1" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , connection, cprng-aes, data-default, HUnit, monad-control, mtl
     , network, streaming-commons, system-fileio, system-filepath, tls
     , transformers
     }:
     mkDerivation {
       pname = "network-conduit-tls";
       version = "1.1.1.1";
       sha256 = "0bbf8f62fb29a7b7c90ce8af00dd64de2d668ee78f5315e816211f6a641b9da1";
       revision = "1";
       editedCabalFile = "cda1e05e1b0bdb5d32e5819b8ee9f5fde23b0cf6acf656fdac4e1573fcc7ccd6";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra connection cprng-aes
         data-default monad-control network streaming-commons system-fileio
         system-filepath tls transformers
       ];
       testHaskellDepends = [
         base bytestring conduit conduit-extra connection HUnit mtl
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/conduit";
       description = "Create TLS-aware network code with conduits";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-conduit-tls_1_1_2" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , connection, cprng-aes, data-default, HUnit, monad-control, mtl
     , network, streaming-commons, system-fileio, system-filepath, tls
     , transformers
     }:
     mkDerivation {
       pname = "network-conduit-tls";
       version = "1.1.2";
       sha256 = "da4136d81cb52ea21f33915d72af90fb6365b653e9c1c07eebe61836d5c66c78";
       revision = "1";
       editedCabalFile = "64c4c5e41d646aa3ea46b8e95f967afbf58913cb75119879f93190c557862b85";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra connection cprng-aes
         data-default monad-control network streaming-commons system-fileio
         system-filepath tls transformers
       ];
       testHaskellDepends = [
         base bytestring conduit conduit-extra connection HUnit mtl
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/conduit";
       description = "Create TLS-aware network code with conduits";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-conduit-tls" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , connection, cprng-aes, data-default, HUnit, monad-control, mtl
     , network, streaming-commons, tls, transformers
     }:
     mkDerivation {
       pname = "network-conduit-tls";
       version = "1.2.0.1";
       sha256 = "0088bbb5253f1d940c05e649bee397574b9bbc4f16cd6984c15693f3f431a29d";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra connection cprng-aes
         data-default monad-control network streaming-commons tls
         transformers
       ];
       testHaskellDepends = [
         base bytestring conduit conduit-extra connection HUnit mtl
       ];
       homepage = "https://github.com/snoyberg/conduit";
       description = "Create TLS-aware network code with conduits";
       license = stdenv.lib.licenses.mit;
     }) {};

  "network-connection" = callPackage
    ({ mkDerivation, base, bytestring, containers, network
     , network-bytestring, stm
     }:
     mkDerivation {
       pname = "network-connection";
       version = "0.1.1";
       sha256 = "01837867fbff278e735f605aed68eb6aeffd8674ad5981a3b6f3d5be0be66d6c";
       libraryHaskellDepends = [
         base bytestring containers network network-bytestring stm
       ];
       homepage = "http://darcs.imperialviolet.org/network-connection";
       description = "A wrapper around a generic stream-like connection";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-data" = callPackage
    ({ mkDerivation, base, bytestring, cereal, pretty }:
     mkDerivation {
       pname = "network-data";
       version = "0.5.3";
       sha256 = "ffeb6030a4a0c4d0f2c296133b2f72c67bc550c1de8a1781a429a19c3fbd7c7d";
       libraryHaskellDepends = [ base bytestring cereal pretty ];
       description = "Library for network data structures and their serialization";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-dbus" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, mtl, network
     , parsec, unix, utf8-string
     }:
     mkDerivation {
       pname = "network-dbus";
       version = "0.0";
       sha256 = "891323d175bd6fcacc7a941445ceab45ee3b0770961c0f1274151efbdc039008";
       libraryHaskellDepends = [
         base binary bytestring containers mtl network parsec unix
         utf8-string
       ];
       jailbreak = true;
       description = "D-Bus";
       license = "unknown";
     }) {};

  "network-dns" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, containers
     , data-textual, hashable, network-ip, parsers, tagged, text-latin1
     , text-printer
     }:
     mkDerivation {
       pname = "network-dns";
       version = "1.0.0.1";
       sha256 = "c87e0518318aebf91441f8ccd110493801f844556d7cab0affcdc4655f78e13d";
       libraryHaskellDepends = [
         base binary bytestring cereal containers data-textual hashable
         network-ip parsers tagged text-latin1 text-printer
       ];
       homepage = "https://github.com/mvv/network-dns";
       description = "Domain Name System data structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-enumerator" = callPackage
    ({ mkDerivation, base, bytestring, enumerator, network
     , transformers
     }:
     mkDerivation {
       pname = "network-enumerator";
       version = "0.1.5";
       sha256 = "736beeeaf446c2263266b5ed192346ff2cfdd3a3b87839d59869a801787b1c86";
       libraryHaskellDepends = [
         base bytestring enumerator network transformers
       ];
       homepage = "https://john-millikin.com/software/network-enumerator/";
       description = "Enumerators for network sockets";
       license = stdenv.lib.licenses.mit;
     }) {};

  "network-fancy" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "network-fancy";
       version = "0.2.3";
       sha256 = "c5c5818797db9fcacc1a68e47233f64f590a7ec3add7a0e1e078e4b8305f90ac";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://github.com/taruti/network-fancy";
       description = "Networking support with a cleaner API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "network-house" = callPackage
    ({ mkDerivation, array, base, containers, mtl }:
     mkDerivation {
       pname = "network-house";
       version = "0.1.0.2";
       sha256 = "071fbc22fc516175e78235d9e29ccefd8eec7c3caa2e6de74dddf62cdbffab43";
       libraryHaskellDepends = [ array base containers mtl ];
       homepage = "https://github.com/nh2/network-house";
       description = "data and parsers for Ethernet, TCP, UDP, IPv4, IPv6, ICMP, DHCP, TFTP";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "network-info_0_2_0_5" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "network-info";
       version = "0.2.0.5";
       sha256 = "8ee37b7e3219d18395a3c9020a9be8cfa7c5390f2c4b0e54b5feea35e5b4fd3d";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/jystic/network-info";
       description = "Access the local computer's basic network configuration";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-info_0_2_0_6" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "network-info";
       version = "0.2.0.6";
       sha256 = "47bd1764a66779d75b8abb341db0488f485111ae5a73c06ddc9c84343813b1fa";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/jystic/network-info";
       description = "Access the local computer's basic network configuration";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-info_0_2_0_7" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "network-info";
       version = "0.2.0.7";
       sha256 = "ef36e2c3d60d120c91d07dfe1081c87b73d0917cee858fba42598f284301405d";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/jystic/network-info";
       description = "Access the local computer's basic network configuration";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-info" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "network-info";
       version = "0.2.0.8";
       sha256 = "ecdff121f3e154c480f363bc8660959a051790bfae5b5fe573810873cedbcd76";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/jystic/network-info";
       description = "Access the local computer's basic network configuration";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-interfacerequest" = callPackage
    ({ mkDerivation, base, bytestring, ioctl, network }:
     mkDerivation {
       pname = "network-interfacerequest";
       version = "0.0.1";
       sha256 = "cc9409a117f8e72d4dac16495610b79469078f00524e22eb795d25ced6ca4561";
       libraryHaskellDepends = [ base bytestring ioctl network ];
       jailbreak = true;
       description = "Haskell bindings for the ifreq structure";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "network-ip" = callPackage
    ({ mkDerivation, base, binary, cereal, data-default-class
     , data-dword, data-endian, data-textual, hashable, parsers, tasty
     , tasty-quickcheck, text-printer, type-hint
     }:
     mkDerivation {
       pname = "network-ip";
       version = "0.2.1.1";
       sha256 = "3e8294bc1ecb2a4cbe78de237f6adf60332303a6f693091bd5b9a511ef016c29";
       libraryHaskellDepends = [
         base binary cereal data-default-class data-dword data-endian
         data-textual hashable parsers text-printer type-hint
       ];
       testHaskellDepends = [
         base data-dword data-textual parsers tasty tasty-quickcheck
         text-printer
       ];
       homepage = "https://github.com/mvv/network-ip";
       description = "Internet Protocol data structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-metrics" = callPackage
    ({ mkDerivation, base, binary, bytestring, data-default, network
     , random, time
     }:
     mkDerivation {
       pname = "network-metrics";
       version = "0.4";
       sha256 = "8c20831696fb7b89963a991dac5bfdb630aef723d51dc6fb15a4b64b90937937";
       libraryHaskellDepends = [
         base binary bytestring data-default network random time
       ];
       homepage = "http://github.com/brendanhay/network-metrics";
       description = "Send metrics to Ganglia, Graphite, and statsd";
       license = "unknown";
     }) {};

  "network-minihttp" = callPackage
    ({ mkDerivation, base, binary, binary-strict, bytestring
     , containers, filepath, HsOpenSSL, mtl, network, network-bytestring
     , network-connection, network-dns, old-locale, stm, tagsoup, time
     , unix
     }:
     mkDerivation {
       pname = "network-minihttp";
       version = "0.2";
       sha256 = "c505645aba2043f2efb51f34d61f3e73648cb70269c051156a4f75b0f4749280";
       libraryHaskellDepends = [
         base binary binary-strict bytestring containers filepath HsOpenSSL
         mtl network network-bytestring network-connection network-dns
         old-locale stm tagsoup time unix
       ];
       homepage = "http://darcs.imperialviolet.org/network-minihttp";
       description = "A ByteString based library for writing HTTP(S) servers and clients";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-msg" = callPackage
    ({ mkDerivation, base, binary, bytestring, network, unix }:
     mkDerivation {
       pname = "network-msg";
       version = "0.7";
       sha256 = "dc11cb84d44b805bf004d4fcd2e687f5d1858de3b33cf3f60960977dbf50ba9b";
       libraryHaskellDepends = [ base binary bytestring network unix ];
       description = "Recvmsg and sendmsg bindings";
       license = "unknown";
     }) {};

  "network-multicast_0_0_11" = callPackage
    ({ mkDerivation, base, network }:
     mkDerivation {
       pname = "network-multicast";
       version = "0.0.11";
       sha256 = "65842175e53bb72164b7b1a448a3cc4bdf42df8d64089853ea54ccccd266fa39";
       libraryHaskellDepends = [ base network ];
       description = "Simple multicast library";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-multicast" = callPackage
    ({ mkDerivation, base, network }:
     mkDerivation {
       pname = "network-multicast";
       version = "0.1.0";
       sha256 = "18c2db0f8db5b9f4d3b65dbaa19ed77f4ebcf9c97e2d85657b6777f2b0e47a8a";
       libraryHaskellDepends = [ base network ];
       description = "Simple multicast library";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "network-netpacket" = callPackage
    ({ mkDerivation, base, bytestring, foreign-storable-asymmetric
     , ioctl, network, network-interfacerequest
     }:
     mkDerivation {
       pname = "network-netpacket";
       version = "0.0.1";
       sha256 = "a6f46a9bebbcd45283c7e34a569ac376c189f598ed1342473544d2533c5e038b";
       libraryHaskellDepends = [
         base bytestring foreign-storable-asymmetric ioctl network
         network-interfacerequest
       ];
       jailbreak = true;
       description = "Haskell bindings for low-level packet sockets (AF_PACKET)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "network-pgi" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , bytestring, enumerator, tnet
     }:
     mkDerivation {
       pname = "network-pgi";
       version = "0.0.1";
       sha256 = "dc0b3bc2c96de0706802a1a86c1714973fb426e817e4cb56142c521bf0981968";
       libraryHaskellDepends = [
         attoparsec attoparsec-enumerator base bytestring enumerator tnet
       ];
       description = "Library for writing PGI applications";
       license = "unknown";
     }) {};

  "network-protocol-xmpp" = callPackage
    ({ mkDerivation, base, bytestring, gnuidn, gnutls, gsasl
     , libxml-sax, monads-tf, network, text, transformers, xml-types
     }:
     mkDerivation {
       pname = "network-protocol-xmpp";
       version = "0.4.8";
       sha256 = "ea7729e00452da11ed489a71f482e0aa082b0fb872eedca2e3722a05fd421e1e";
       libraryHaskellDepends = [
         base bytestring gnuidn gnutls gsasl libxml-sax monads-tf network
         text transformers xml-types
       ];
       homepage = "https://john-millikin.com/software/haskell-xmpp/";
       description = "Client library for the XMPP protocol";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "network-rpca" = callPackage
    ({ mkDerivation, array, base, binary, binary-strict, bytestring
     , codec-libevent, containers, control-timeout, network
     , network-bytestring, stm
     }:
     mkDerivation {
       pname = "network-rpca";
       version = "0.0.1";
       sha256 = "39b6ad26c57ae28fd2824e0de1365c9c6f85b6acaf6aabae313d0b5080251eb6";
       libraryHaskellDepends = [
         array base binary binary-strict bytestring codec-libevent
         containers control-timeout network network-bytestring stm
       ];
       description = "A cross-platform RPC library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-server" = callPackage
    ({ mkDerivation, base, network, unix }:
     mkDerivation {
       pname = "network-server";
       version = "0.2.0";
       sha256 = "b39b550ef66e0df0270d4df863980869ce06c9ba28a94d1acbe39575007f3246";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base network unix ];
       executableHaskellDepends = [ base network unix ];
       description = "A light abstraction over sockets & co. for servers";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-service" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, network
     , network-simple
     }:
     mkDerivation {
       pname = "network-service";
       version = "0.1.0.0";
       sha256 = "e41ea01bb2705fde2a862f487ee5e90deeb74ec2ec9282adcc48ba2322b840cb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring bytestring network
       ];
       executableHaskellDepends = [
         base base64-bytestring bytestring network network-simple
       ];
       jailbreak = true;
       homepage = "https://github.com/angerman/network-service";
       description = "Provide a service at the data type level";
       license = stdenv.lib.licenses.mit;
     }) {};

  "network-simple_0_4_0_2" = callPackage
    ({ mkDerivation, base, bytestring, exceptions, network
     , transformers
     }:
     mkDerivation {
       pname = "network-simple";
       version = "0.4.0.2";
       sha256 = "0e1ade155970eafdd449bc3abebc72837b79344b9ca3af6f3e25cca3432d254c";
       libraryHaskellDepends = [
         base bytestring exceptions network transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/k0001/network-simple";
       description = "Simple network sockets usage patterns";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-simple_0_4_0_3" = callPackage
    ({ mkDerivation, base, bytestring, exceptions, network
     , transformers
     }:
     mkDerivation {
       pname = "network-simple";
       version = "0.4.0.3";
       sha256 = "05c5a011e18d2e8e8969b34b9cbc50543e967fc8cfe646c4f028f403763a7a59";
       libraryHaskellDepends = [
         base bytestring exceptions network transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/k0001/network-simple";
       description = "Simple network sockets usage patterns";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-simple" = callPackage
    ({ mkDerivation, base, bytestring, exceptions, network
     , transformers
     }:
     mkDerivation {
       pname = "network-simple";
       version = "0.4.0.4";
       sha256 = "50fd2ea6796222c4e05f471cfe530b98889abadd5934e05400f5449644574361";
       libraryHaskellDepends = [
         base bytestring exceptions network transformers
       ];
       homepage = "https://github.com/k0001/network-simple";
       description = "Simple network sockets usage patterns";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-simple-sockaddr" = callPackage
    ({ mkDerivation, base, bytestring, directory, exceptions, network
     , transformers
     }:
     mkDerivation {
       pname = "network-simple-sockaddr";
       version = "0.2";
       sha256 = "5d948ab7bd7a8c04dd3a508f1f3052fd8e6a849d80872c6d12efaefd6f93f230";
       libraryHaskellDepends = [
         base bytestring directory exceptions network transformers
       ];
       homepage = "https://github.com/jdnavarro/network-simple-sockaddr";
       description = "network-simple for resolved addresses";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-simple-tls" = callPackage
    ({ mkDerivation, base, bytestring, certificate, cprng-aes
     , exceptions, network, network-simple, tls, tls-extra, transformers
     }:
     mkDerivation {
       pname = "network-simple-tls";
       version = "0.2.1";
       sha256 = "1330d833ac5e39358da28d27c77af3cacdc967cb34e3a5a78b7d9d32f4ea7741";
       libraryHaskellDepends = [
         base bytestring certificate cprng-aes exceptions network
         network-simple tls tls-extra transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/k0001/network-simple-tls";
       description = "Simple interface to TLS secured network sockets";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-socket-options" = callPackage
    ({ mkDerivation, base, network }:
     mkDerivation {
       pname = "network-socket-options";
       version = "0.2.0.1";
       sha256 = "7998c5f7e75baae47eb0159d4d681fa7fce89452d89ff5921068ebcfad100e03";
       libraryHaskellDepends = [ base network ];
       homepage = "https://github.com/joeyadams/haskell-network-socket-options";
       description = "Type-safe, portable alternative to getSocketOption/setSocketOption";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-stream" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, enumerator
     , network, stm, text, transformers
     }:
     mkDerivation {
       pname = "network-stream";
       version = "0.1.0";
       sha256 = "c116a6d964b092c98d4b9b0a348d06db52587b5f529b8d713c66cdec5115ecf8";
       libraryHaskellDepends = [
         base binary bytestring cereal enumerator network stm text
         transformers
       ];
       jailbreak = true;
       description = "ByteString and Text streams for networking";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "network-topic-models" = callPackage
    ({ mkDerivation, base, bayes-stack, bimap, bytestring, cereal
     , containers, deepseq, directory, filepath, logfloat, mwc-random
     , optparse-applicative, random-fu, statistics, stm, text
     , transformers, vector
     }:
     mkDerivation {
       pname = "network-topic-models";
       version = "0.2.0.1";
       sha256 = "4b0c9cb611c8686cf4f78ff46d2063a814c735da5737b167eff94785804bb5d0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bayes-stack bimap bytestring cereal containers deepseq
         directory filepath logfloat mwc-random optparse-applicative
         random-fu statistics stm text transformers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/bgamari/bayes-stack";
       description = "A few network topic model implementations for bayes-stack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-transport_0_4_1_0" = callPackage
    ({ mkDerivation, base, binary, bytestring, hashable, transformers
     }:
     mkDerivation {
       pname = "network-transport";
       version = "0.4.1.0";
       sha256 = "23b1c02ec54e79fc9cb95119af99594d0b0163ec7d691e6238d5aefc6c3ac876";
       libraryHaskellDepends = [
         base binary bytestring hashable transformers
       ];
       homepage = "http://haskell-distributed.github.com";
       description = "Network abstraction layer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-transport_0_4_2_0" = callPackage
    ({ mkDerivation, base, binary, bytestring, deepseq, hashable
     , transformers
     }:
     mkDerivation {
       pname = "network-transport";
       version = "0.4.2.0";
       sha256 = "0ec70dc6bf406aefe02db29ad542556605d3c13237da9a4f1063d4ac59f13c2b";
       libraryHaskellDepends = [
         base binary bytestring deepseq hashable transformers
       ];
       homepage = "http://haskell-distributed.github.com";
       description = "Network abstraction layer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-transport" = callPackage
    ({ mkDerivation, base, binary, bytestring, deepseq, hashable
     , transformers
     }:
     mkDerivation {
       pname = "network-transport";
       version = "0.4.3.1";
       sha256 = "77fd80f672d6cabed4b60cc728f89543500080203cd91b76e07f814baabbd836";
       libraryHaskellDepends = [
         base binary bytestring deepseq hashable transformers
       ];
       homepage = "http://haskell-distributed.github.com";
       description = "Network abstraction layer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-transport-amqp" = callPackage
    ({ mkDerivation, amqp, async, base, bytestring, cereal, containers
     , exceptions, lens-family, lens-family-th, network-transport
     , network-transport-tests, stm, stm-chans, string-conv, tasty
     , tasty-hunit, text, uuid
     }:
     mkDerivation {
       pname = "network-transport-amqp";
       version = "0.1.0.0";
       sha256 = "b861dc085fc19a8b35a9cd64df844fcc9a9d3f8c97ff6d891f8254f40aedc584";
       revision = "2";
       editedCabalFile = "724410b5035d55d170110908838d023a675306faf5fc056ed2a8d68beeb112d4";
       libraryHaskellDepends = [
         amqp async base bytestring cereal containers exceptions lens-family
         lens-family-th network-transport stm stm-chans string-conv text
         uuid
       ];
       testHaskellDepends = [
         amqp base network-transport network-transport-tests tasty
         tasty-hunit
       ];
       jailbreak = true;
       description = "AMQP-based transport layer for distributed-process (aka Cloud Haskell)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-transport-composed" = callPackage
    ({ mkDerivation, base, bytestring, network-transport }:
     mkDerivation {
       pname = "network-transport-composed";
       version = "0.2.0.1";
       sha256 = "965f9e2ce1c2ea8e97b80caa8a226ec4a5ea745a0ca4fd640e72d7d37d41724f";
       revision = "1";
       editedCabalFile = "fc0de146faca57d38e8dc93909679b7aa154bdf8e4e216346353ccd0234f96bb";
       libraryHaskellDepends = [ base bytestring network-transport ];
       homepage = "http://haskell-distributed.github.com";
       description = "Compose network transports";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-transport-inmemory" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-accessor
     , network-transport, network-transport-tests, stm
     }:
     mkDerivation {
       pname = "network-transport-inmemory";
       version = "0.5.1";
       sha256 = "e34ae4169e91739851b31eda9750d3df711389279961290fd006a79b51a70bdd";
       libraryHaskellDepends = [
         base bytestring containers data-accessor network-transport stm
       ];
       testHaskellDepends = [
         base network-transport network-transport-tests
       ];
       homepage = "http://haskell-distributed.github.com";
       description = "In-memory instantiation of Network.Transport";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-transport-tcp_0_4_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-accessor
     , network, network-transport, network-transport-tests
     }:
     mkDerivation {
       pname = "network-transport-tcp";
       version = "0.4.1";
       sha256 = "4e79416665730213a04b8479a08ce88b1c0d19b864b91df5b0b8edec8503d285";
       libraryHaskellDepends = [
         base bytestring containers data-accessor network network-transport
       ];
       testHaskellDepends = [
         base network network-transport network-transport-tests
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://haskell-distributed.github.com";
       description = "TCP instantiation of Network.Transport";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-transport-tcp" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-accessor
     , network, network-transport, network-transport-tests
     }:
     mkDerivation {
       pname = "network-transport-tcp";
       version = "0.4.2";
       sha256 = "9a2664d9765498021db23997ddc1bb35d51367aca6b0d481ea0b57c7ce680372";
       libraryHaskellDepends = [
         base bytestring containers data-accessor network network-transport
       ];
       testHaskellDepends = [
         base network network-transport network-transport-tests
       ];
       doCheck = false;
       homepage = "http://haskell-distributed.github.com";
       description = "TCP instantiation of Network.Transport";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-transport-tcp_0_5_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-accessor
     , network, network-transport, network-transport-tests
     }:
     mkDerivation {
       pname = "network-transport-tcp";
       version = "0.5.1";
       sha256 = "c4c3d67d08f8213ebc99d369cfeb8813f9dd03def464d6097bed533bfbec7beb";
       libraryHaskellDepends = [
         base bytestring containers data-accessor network network-transport
       ];
       testHaskellDepends = [
         base network network-transport network-transport-tests
       ];
       homepage = "http://haskell-distributed.github.com";
       description = "TCP instantiation of Network.Transport";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-transport-tests_0_2_1_0" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, containers, mtl
     , network-transport, random
     }:
     mkDerivation {
       pname = "network-transport-tests";
       version = "0.2.1.0";
       sha256 = "c4d41bf1ac45ebb090f658d5e6c11d732729d2a7aaa005ed8bc92a7394280e9f";
       libraryHaskellDepends = [
         ansi-terminal base bytestring containers mtl network-transport
         random
       ];
       jailbreak = true;
       homepage = "http://haskell-distributed.github.com";
       description = "Unit tests for Network.Transport implementations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-transport-tests_0_2_2_0" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, containers, mtl
     , network-transport, random
     }:
     mkDerivation {
       pname = "network-transport-tests";
       version = "0.2.2.0";
       sha256 = "06040d36e952aac4e0d4f3cab091bd11d09d5de9c090baba2e57138486d42424";
       libraryHaskellDepends = [
         ansi-terminal base bytestring containers mtl network-transport
         random
       ];
       homepage = "http://haskell-distributed.github.com";
       description = "Unit tests for Network.Transport implementations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-transport-tests" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, containers, mtl
     , network-transport, random
     }:
     mkDerivation {
       pname = "network-transport-tests";
       version = "0.2.3.0";
       sha256 = "8277bd97eb7d719891aa6494673506d0d3c7e135c4098f49e17f06b281f53b6c";
       libraryHaskellDepends = [
         ansi-terminal base bytestring containers mtl network-transport
         random
       ];
       homepage = "http://haskell-distributed.github.com";
       description = "Unit tests for Network.Transport implementations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-transport-zeromq" = callPackage
    ({ mkDerivation, async, base, binary, bytestring, containers
     , criterion, data-accessor, distributed-process
     , distributed-process-tests, exceptions, network, network-transport
     , network-transport-tests, random, semigroups, stm, stm-chans
     , tasty, tasty-hunit, test-framework, transformers, zeromq4-haskell
     }:
     mkDerivation {
       pname = "network-transport-zeromq";
       version = "0.2.1.1";
       sha256 = "93b56e1a2b337c24cc899874d23eed335ff640c5c1e143b69584c4d71f0cca35";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base binary bytestring containers data-accessor exceptions
         network-transport random semigroups stm stm-chans transformers
         zeromq4-haskell
       ];
       executableHaskellDepends = [
         base binary bytestring criterion distributed-process
       ];
       testHaskellDepends = [
         base bytestring containers distributed-process-tests network
         network-transport network-transport-tests stm stm-chans tasty
         tasty-hunit test-framework zeromq4-haskell
       ];
       doCheck = false;
       homepage = "https://github.com/tweag/network-transport-zeromq";
       description = "ZeroMQ backend for network-transport";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-uri_2_5_0_0" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "network-uri";
       version = "2.5.0.0";
       sha256 = "c3ecc5d07943d8130be850a12db130b62b800cf938aef105918df3fdb68f224e";
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/haskell/network-uri";
       description = "URI manipulation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-uri_2_6_0_1" = callPackage
    ({ mkDerivation, base, HUnit, network, parsec, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "network-uri";
       version = "2.6.0.1";
       sha256 = "67dc2394a92c66654e1a051b8611a56a9ccc6c8f96a876e1c34f22115655d527";
       libraryHaskellDepends = [ base parsec ];
       testHaskellDepends = [
         base HUnit network test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "https://github.com/haskell/network-uri";
       description = "URI manipulation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-uri_2_6_0_2" = callPackage
    ({ mkDerivation, base, deepseq, HUnit, parsec, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "network-uri";
       version = "2.6.0.2";
       sha256 = "55d2bf8f99054c1678f558be4d3e410cdc75d97a1e19d07034490320909a5057";
       libraryHaskellDepends = [ base deepseq parsec ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "https://github.com/haskell/network-uri";
       description = "URI manipulation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "network-uri" = callPackage
    ({ mkDerivation, base, deepseq, HUnit, parsec, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "network-uri";
       version = "2.6.0.3";
       sha256 = "0fc2cdff47ca77d826ebeb5cabe6ddac2333ca1504b2b629dd369399c5c28bdf";
       libraryHaskellDepends = [ base deepseq parsec ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "https://github.com/haskell/network-uri";
       description = "URI manipulation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "network-uri-static" = callPackage
    ({ mkDerivation, base, doctest, network-uri, template-haskell }:
     mkDerivation {
       pname = "network-uri-static";
       version = "0.1.0.0";
       sha256 = "c93ac20fb39a326ddbef5a18e4c1205e107a8eb4b6c6df9f68df9c278e956899";
       libraryHaskellDepends = [ base network-uri template-haskell ];
       testHaskellDepends = [ base doctest ];
       homepage = "http://github.com/snakamura/network-uri-static";
       description = "A small utility to declare type-safe static URIs";
       license = stdenv.lib.licenses.mit;
     }) {};

  "network-wai-router" = callPackage
    ({ mkDerivation, base, wai }:
     mkDerivation {
       pname = "network-wai-router";
       version = "0.3.0.1";
       sha256 = "299e21e75cfe2c3c7914d05b5fe142209cbd50553369318cffc643b57660d8ba";
       libraryHaskellDepends = [ base wai ];
       jailbreak = true;
       description = "A routing library for wai";
       license = stdenv.lib.licenses.mit;
     }) {};

  "network-websocket" = callPackage
    ({ mkDerivation, base, haskell98, network, webserver }:
     mkDerivation {
       pname = "network-websocket";
       version = "0.3";
       sha256 = "75cd59bd534b39db084c73843c6d29c33e8d3557c440ba19ad24b4252acd7814";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base haskell98 network webserver ];
       jailbreak = true;
       homepage = "http://github.com/michaelmelanson/network-websocket";
       description = "WebSocket library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "networked-game" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, network
     , time, transformers
     }:
     mkDerivation {
       pname = "networked-game";
       version = "0.1.0.1";
       sha256 = "dfaa45c867596131bcd454390a95171f71bd38baf63300b9c75567fcd8495e8b";
       revision = "1";
       editedCabalFile = "01590db1085c70805c76e7f752dfa741336d1647cb6c7cee46f361c83c67a99d";
       libraryHaskellDepends = [
         base binary bytestring containers network time transformers
       ];
       description = "Networked-game support library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "newports" = callPackage
    ({ mkDerivation, base, directory, old-time }:
     mkDerivation {
       pname = "newports";
       version = "1.1";
       sha256 = "8c4b0eb1bf382fae7f63f75967e6846a0266ce3e4d639310b88ba29a51c65ddd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory old-time ];
       homepage = "http://www.b7j0c.org/content/haskell-newports.html";
       description = "List ports newer than N days on a FreeBSD system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "newsynth" = callPackage
    ({ mkDerivation, base, containers, fixedprec, random, superdoc
     , time
     }:
     mkDerivation {
       pname = "newsynth";
       version = "0.3.0.2";
       sha256 = "68d4cb379fc339baeeaf4a6cdc5dc1adec63fadecf9b587043b9e041d11bf172";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers fixedprec random superdoc
       ];
       executableHaskellDepends = [ base random superdoc time ];
       homepage = "http://www.mathstat.dal.ca/~selinger/newsynth/";
       description = "Exact and approximate synthesis of quantum circuits";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "newt" = callPackage
    ({ mkDerivation, array, base, bytestring, cmdargs, containers
     , directory, filemanip, filepath, HUnit, mtl, process, QuickCheck
     , safe, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, Unixutils, uuid
     }:
     mkDerivation {
       pname = "newt";
       version = "0.0.3.1";
       sha256 = "f2eed533acc85bbc590994f0adbc26757c59449b774b18f7b0ea228ff1beb02a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cmdargs containers directory filemanip
         filepath mtl process safe text Unixutils
       ];
       executableHaskellDepends = [
         base cmdargs containers directory filepath HUnit mtl process
         QuickCheck safe test-framework test-framework-hunit
         test-framework-quickcheck2 Unixutils uuid
       ];
       jailbreak = true;
       description = "A trivially simple app to create things from simple templates";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "newtype" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "newtype";
       version = "0.2";
       sha256 = "b714033abd9a8b0903bcef0d36d0913de2a5003c852f43f97fa688717289e459";
       libraryHaskellDepends = [ base ];
       description = "A typeclass and set of functions for working with newtypes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "newtype-deriving" = callPackage
    ({ mkDerivation, base, base-prelude, monad-control
     , template-haskell, transformers, transformers-base
     }:
     mkDerivation {
       pname = "newtype-deriving";
       version = "0.1.3";
       sha256 = "15090bbb5327da577b9f06d8d703c9762aabf7446cf930096b9c1273d28f83ba";
       libraryHaskellDepends = [
         base base-prelude monad-control template-haskell transformers
         transformers-base
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/newtype-deriving";
       description = "Instance derivers for newtype wrappers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "newtype-generics" = callPackage
    ({ mkDerivation, base, hspec, HUnit }:
     mkDerivation {
       pname = "newtype-generics";
       version = "0.4.1";
       sha256 = "a5ed63130601fa2f97b105adeced7e691ee7924bcfd3f7da6605495f7a655fe2";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec HUnit ];
       jailbreak = true;
       doCheck = false;
       description = "A typeclass and set of functions for working with newtypes, with generics support";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "newtype-th" = callPackage
    ({ mkDerivation, base, haskell-src-meta, newtype, syb
     , template-haskell
     }:
     mkDerivation {
       pname = "newtype-th";
       version = "0.3.3";
       sha256 = "13a10334d90704897b137e4d389ff0ee2a1ee194d1d1a85fefeb77593dbc8fea";
       libraryHaskellDepends = [
         base haskell-src-meta newtype syb template-haskell
       ];
       jailbreak = true;
       homepage = "http://github.com/mgsloan/newtype-th";
       description = "A template haskell deriver to create Control.Newtype instances.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "newtyper" = callPackage
    ({ mkDerivation, base, Kleislify, newtype }:
     mkDerivation {
       pname = "newtyper";
       version = "0.1";
       sha256 = "da91972558dde25762cf253617282865171004a0ada0c8c2e6eaf25183ff35e8";
       libraryHaskellDepends = [ base Kleislify newtype ];
       homepage = "https://github.com/techtangents/Newtyper";
       description = "Extra functions for the Control.Newtype typeclass";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nextstep-plist" = callPackage
    ({ mkDerivation, base, parsec, pretty, QuickCheck }:
     mkDerivation {
       pname = "nextstep-plist";
       version = "0.0.1";
       sha256 = "dc6b46a81a478dea50c53515bc95bb963b4d99977b0353a72066336898258d72";
       libraryHaskellDepends = [ base parsec pretty QuickCheck ];
       description = "NextStep style plist parser and printer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nf" = callPackage
    ({ mkDerivation, base, deepseq }:
     mkDerivation {
       pname = "nf";
       version = "1.0.1.0";
       sha256 = "aa8c542f3703d486a46eef3538157d8ca248a9722b20420e6a0e5971a7363cfb";
       libraryHaskellDepends = [ base deepseq ];
       homepage = "https://github.com/ezyang/nf";
       description = "NF data type to statically enforce normal form";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ngrams-loader" = callPackage
    ({ mkDerivation, attoparsec, base, machines, mtl, parseargs
     , resourcet, sqlite-simple, text
     }:
     mkDerivation {
       pname = "ngrams-loader";
       version = "0.1.0.1";
       sha256 = "edd65db08b02a354e61e9f80dabc39d59ebaaef1dc793637e9161e1ce6ad467c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base machines mtl resourcet sqlite-simple text
       ];
       executableHaskellDepends = [ base parseargs ];
       jailbreak = true;
       homepage = "http://github.com/YoEight/ngrams-loader";
       description = "Ngrams loader based on http://www.ngrams.info format";
       license = stdenv.lib.licenses.mit;
     }) {};

  "niagra" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, mtl, text
     , transformers
     }:
     mkDerivation {
       pname = "niagra";
       version = "0.2.1";
       sha256 = "5b6cb93d70015fc48a200f4937470b73c1e1fd152ce6dd2a4413e3b547d6ee00";
       libraryHaskellDepends = [
         base containers ghc-prim mtl text transformers
       ];
       homepage = "https://github.com/fhsjaagshs/niagra";
       description = "CSS EDSL for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nibblestring" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, base16-bytestring
     , bytestring, containers, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "nibblestring";
       version = "0.0.3";
       sha256 = "39af3eb5507fd51167cc024f7c580195181cf98b4f26e029a5b52600efd94c46";
       libraryHaskellDepends = [
         ansi-wl-pprint base base16-bytestring bytestring
       ];
       testHaskellDepends = [
         base base16-bytestring bytestring containers HUnit test-framework
         test-framework-hunit
       ];
       description = "Packed, strict nibble arrays with a list interface (ByteString for nibbles)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nicify" = callPackage
    ({ mkDerivation, base, nicify-lib }:
     mkDerivation {
       pname = "nicify";
       version = "1.2.1";
       sha256 = "933b3f01f066310e43d0e79075968af5654c3756292edc9dfdae4ad22a0af562";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base nicify-lib ];
       description = "Pretty print the standard output of default `Show` instances";
       license = stdenv.lib.licenses.mit;
     }) {};

  "nicify-lib" = callPackage
    ({ mkDerivation, base, parsec, transformers }:
     mkDerivation {
       pname = "nicify-lib";
       version = "1.0.1";
       sha256 = "7d26f86d792dda166805e9dda17cfbc7a2101f3654fe798f4231385d8136e732";
       libraryHaskellDepends = [ base parsec transformers ];
       description = "Pretty print the standard output of default `Show` instances";
       license = stdenv.lib.licenses.mit;
     }) {};

  "nicovideo-translator" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, cmdargs
     , containers, dns, http-client, http-types, iso639, lens
     , naver-translate, setlocale, text, text-format, wai, warp, wreq
     , xml-conduit
     }:
     mkDerivation {
       pname = "nicovideo-translator";
       version = "0.1.0.1";
       sha256 = "d2a7963385d06c67dad7d3aadd215c7d243e1e189b9fc3358bceb36a5c65f68a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring case-insensitive cmdargs containers dns http-client
         http-types iso639 lens naver-translate setlocale text text-format
         wai warp wreq xml-conduit
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/dahlia/nicovideo-translator";
       description = "Nico Nico Douga (ニコニコ動画) Comment Translator";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "nikepub" = callPackage
    ({ mkDerivation, base, containers, filepath, GoogleChart, haskell98
     , haxr, hs-twitter, HStringTemplate, HTTP, hxt, json, network
     , old-locale, old-time, regex-compat, regex-posix, syb, time
     }:
     mkDerivation {
       pname = "nikepub";
       version = "1.1.2";
       sha256 = "60971359f504b1b52f0d7939037483267c94a935d0ed2c8c4df15c33e0dcecf0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers filepath GoogleChart haskell98 haxr hs-twitter
         HStringTemplate HTTP hxt json network old-locale old-time
         regex-compat regex-posix syb time
       ];
       homepage = "http://www.codemanic.com/uwe";
       description = "Command line utility publishes Nike+ runs on blogs and Twitter";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nimber" = callPackage
    ({ mkDerivation, arithmoi, base }:
     mkDerivation {
       pname = "nimber";
       version = "0.1.3";
       sha256 = "1cc126f4135d6bc900a0c094d299191ef7bc62a12ea1180a48e03adb5a75a00c";
       libraryHaskellDepends = [ arithmoi base ];
       homepage = "http://andersk.mit.edu/haskell/nimber/";
       description = "Finite nimber arithmetic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "nitro" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "nitro";
       version = "0.2.2.5";
       sha256 = "ab97b3fca710114f3a928803f811042b348a5a9518a8c81577e0183cc3fc589d";
       libraryHaskellDepends = [ base bytestring ];
       jailbreak = true;
       homepage = "http://haskell.gonitro.io";
       description = "Haskell bindings for Nitro";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nix-eval" = callPackage
    ({ mkDerivation, base, process, QuickCheck, tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "nix-eval";
       version = "0.1.0.2";
       sha256 = "f603ce62cd8abaab8cf09c8cf3f8b17332b0490658310eadea5242826b2ef419";
       libraryHaskellDepends = [ base process ];
       testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
       homepage = "http://chriswarbo.net/git/nix-eval";
       description = "Evaluate Haskell expressions using Nix to get packages";
       license = "GPL";
     }) {};

  "nix-paths" = callPackage
    ({ mkDerivation, base, nix, process }:
     mkDerivation {
       pname = "nix-paths";
       version = "1";
       sha256 = "6b06ec3f14102653711ba9434b91235db7d60ff1c0f339d1e7834eba33144959";
       revision = "1";
       editedCabalFile = "f8cff48213a8b9c1fe0aabbc7a607da4f1253d6ddbaa6d83791cccde7c44ad18";
       libraryHaskellDepends = [ base process ];
       libraryToolDepends = [ nix ];
       homepage = "https://github.com/peti/nix-paths";
       description = "Knowledge of Nix's installation directories";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) nix;};

  "nixfromnpm" = callPackage
    ({ mkDerivation, aeson, base, bytestring, classy-prelude
     , containers, data-default, directory, error-list, filepath, github
     , hnix, hspec, hspec-expectations, http-client-streams, io-streams
     , MissingH, mtl, network-uri, optparse-applicative, parsec, shelly
     , system-filepath, text, text-render, unordered-containers
     }:
     mkDerivation {
       pname = "nixfromnpm";
       version = "0.2.1";
       sha256 = "c623621b04e5d924e7d2565c3ce618c6604a25b2755fa4e273b8fad8f62c2db8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring classy-prelude containers data-default
         directory error-list filepath hnix MissingH mtl network-uri
         optparse-applicative parsec shelly system-filepath text text-render
         unordered-containers
       ];
       executableHaskellDepends = [
         aeson base bytestring classy-prelude containers data-default
         directory error-list filepath hnix MissingH mtl network-uri
         optparse-applicative parsec shelly system-filepath text text-render
         unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring classy-prelude containers data-default
         directory error-list filepath github hnix hspec hspec-expectations
         http-client-streams io-streams MissingH mtl network-uri
         optparse-applicative parsec shelly system-filepath text text-render
         unordered-containers
       ];
       description = "Generate nix expressions from npm packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nixos-types" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "nixos-types";
       version = "1.5";
       sha256 = "cc0c894bd1560e533636bccc5a9d674dd7efc9389895e14972de1d72806668e0";
       doHaddock = false;
       homepage = "http://hackage.haskell.org/package/cabal2nix";
       description = "this package is obsolete; see cabal2nix instead";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nkjp" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-named, filepath
     , polysoup, tar, text, zlib
     }:
     mkDerivation {
       pname = "nkjp";
       version = "0.4.0";
       sha256 = "d480e874f55702f1e40f193721bdeb743d48c6cbd4793493d86c44ec7c0738c5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers data-named filepath polysoup tar text
         zlib
       ];
       jailbreak = true;
       homepage = "https://github.com/kawu/nkjp";
       description = "Manipulating the National Corpus of Polish (NKJP)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nlp-scores" = callPackage
    ({ mkDerivation, base, containers, strict }:
     mkDerivation {
       pname = "nlp-scores";
       version = "0.7.0";
       sha256 = "3535b055ef6d0a3db8b2f95a547a925f207c3170d8724215852690e18933aa33";
       libraryHaskellDepends = [ base containers strict ];
       homepage = "https://bitbucket.org/gchrupala/lingo";
       description = "Scoring functions commonly used for evaluation in NLP and IR";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nlp-scores-scripts" = callPackage
    ({ mkDerivation, base, containers, nlp-scores, split, text }:
     mkDerivation {
       pname = "nlp-scores-scripts";
       version = "0.2.0.0";
       sha256 = "4cb4570e4c788477864a9e962795890677984c5861a476ce96f47faa51d7510a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers nlp-scores split text
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/gchrupala/lingo";
       description = "NLP scoring command-line programs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nm" = callPackage
    ({ mkDerivation, base, g, glib, libnm-glib, nm-glib, vector }:
     mkDerivation {
       pname = "nm";
       version = "1.0.1";
       sha256 = "c1713c63efbbab3f662a0d5e4b015ed76f1bb311fe20df7cde1433b16e111709";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base vector ];
       librarySystemDepends = [ g nm-glib ];
       libraryPkgconfigDepends = [ glib libnm-glib ];
       executableHaskellDepends = [ base ];
       description = "Network Manager, binding to libnm-glib";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {g = null; inherit (pkgs) glib; libnm-glib = null; 
         nm-glib = null;};

  "nme" = callPackage
    ({ mkDerivation, base, bytestring, utf8-string }:
     mkDerivation {
       pname = "nme";
       version = "0.2";
       sha256 = "952327e5fe121a50efc38932c2d27f40f62ec322ff68d7a4afa1dee014611f93";
       libraryHaskellDepends = [ base bytestring utf8-string ];
       homepage = "https://github.com/singpolyma/NME-Haskell";
       description = "Bindings to the Nyctergatis Markup Engine";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nntp" = callPackage
    ({ mkDerivation, base, bytestring, monad-loops, mtl, network
     , old-locale, parsec, time
     }:
     mkDerivation {
       pname = "nntp";
       version = "0.0.4";
       sha256 = "653c14333da036cdef6eede32dd8b6043e2953d07aea8ffde93d4f12d50fe9f9";
       libraryHaskellDepends = [
         base bytestring monad-loops mtl network old-locale parsec time
       ];
       description = "Library to connect to an NNTP Server";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "no-buffering-workaround" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "no-buffering-workaround";
       version = "0.1.0.0";
       sha256 = "8dfa0c40633c7cb59a44a6498652b81d7ef6de1661b61cc7b0e73aceede2daa7";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/arotenberg/no-buffering-workaround#readme";
       description = "Workaround for GHC bug #2189";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "no-role-annots" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "no-role-annots";
       version = "1.1";
       sha256 = "47176ab485236f4b92950452a0d855e837bee7267f7d4cbf1ab101c24b8c69ce";
       libraryHaskellDepends = [ base template-haskell ];
       testHaskellDepends = [ base template-haskell ];
       homepage = "https://github.com/goldfirere/no-role-annots";
       description = "Role annotations without -XRoleAnnotations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nofib-analyse" = callPackage
    ({ mkDerivation, array, base, containers, regex-compat }:
     mkDerivation {
       pname = "nofib-analyse";
       version = "7.12.0.20151208";
       sha256 = "d0ba0f82bbd0d1324e6331d75f43a0b5c1c207a3ad7df16668b730bb336725ad";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base containers regex-compat ];
       homepage = "https://ghc.haskell.org/trac/ghc/wiki/Building/RunningNoFib";
       description = "Parse and compare nofib runs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nofib-analyze" = callPackage
    ({ mkDerivation, array, base, containers, regex-compat }:
     mkDerivation {
       pname = "nofib-analyze";
       version = "7.10.1";
       sha256 = "d4412e1e564ff638c0cf4b5bf7e75e4585af579f58fbb6db8bc1ecae9f29c012";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base containers regex-compat ];
       homepage = "https://ghc.haskell.org/trac/ghc/wiki/Building/RunningNoFib";
       description = "Parse and compare nofib runs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "noise" = callPackage
    ({ mkDerivation, base, blaze-markup, blaze-svg, bytestring
     , containers, cryptohash, HTF, HUnit, network, parsec, QuickCheck
     , string-qq
     }:
     mkDerivation {
       pname = "noise";
       version = "0.0.1";
       sha256 = "1828a9abe89326e7f5dbdfe8bad571ac0cda14f00505dce0af4c058b1cc12a41";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-markup blaze-svg bytestring containers cryptohash
         network parsec
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base HTF HUnit parsec QuickCheck string-qq
       ];
       jailbreak = true;
       homepage = "http://github.com/brow/noise";
       description = "A friendly language for graphic design";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "non-empty" = callPackage
    ({ mkDerivation, base, containers, QuickCheck, utility-ht }:
     mkDerivation {
       pname = "non-empty";
       version = "0.2.1";
       sha256 = "e3956b73026647bab019b52b50c94f196df7f64607bbf28a6ae730da09b912dc";
       libraryHaskellDepends = [ base containers QuickCheck utility-ht ];
       homepage = "http://code.haskell.org/~thielema/non-empty/";
       description = "List-like structures with static restrictions on the number of elements";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "non-negative" = callPackage
    ({ mkDerivation, base, QuickCheck, utility-ht }:
     mkDerivation {
       pname = "non-negative";
       version = "0.1.1";
       sha256 = "e7060fe3a02b0f2fd0bbab2e358fade1f9eefd50d072f1569e32f4dc871c6f98";
       libraryHaskellDepends = [ base QuickCheck utility-ht ];
       testHaskellDepends = [ base QuickCheck utility-ht ];
       homepage = "http://code.haskell.org/~thielema/non-negative/";
       description = "Non-negative numbers";
       license = "GPL";
     }) {};

  "nonce" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, cprng-aes
     , crypto-random, text, transformers
     }:
     mkDerivation {
       pname = "nonce";
       version = "1.0.2";
       sha256 = "1004184996ea797b43189a0e73eab0b939f129cafc776341ca82289edb329cd0";
       libraryHaskellDepends = [
         base base64-bytestring bytestring cprng-aes crypto-random text
         transformers
       ];
       homepage = "https://github.com/prowdsponsor/nonce";
       description = "Generate cryptographic nonces";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nondeterminism" = callPackage
    ({ mkDerivation, base, containers, mtl, tasty, tasty-hunit }:
     mkDerivation {
       pname = "nondeterminism";
       version = "1.4";
       sha256 = "3037c93b0277037ab51ad8640f72a7975dcf48ba81570640be12d390d7b47dc5";
       libraryHaskellDepends = [ base containers mtl ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       description = "A monad and monad transformer for nondeterministic computations";
       license = "LGPL";
     }) {};

  "nonfree" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "nonfree";
       version = "0.1.0.1";
       sha256 = "11d7f5d66a6ec832cb2c15b5f33b6b2fbc3cdf8c49da3a5a8f9ca252531c4e16";
       libraryHaskellDepends = [ base ];
       description = "Free structures sans laws";
       license = stdenv.lib.licenses.mit;
     }) {};

  "nonlinear-optimization" = callPackage
    ({ mkDerivation, base, primitive, vector }:
     mkDerivation {
       pname = "nonlinear-optimization";
       version = "0.3.10";
       sha256 = "ee5cdb0c1a833ab3f9d96e26e97052dabc2d7ae5c2a1f2e6d76035edb73bb885";
       libraryHaskellDepends = [ base primitive vector ];
       description = "Various iterative algorithms for optimization of nonlinear functions";
       license = "GPL";
     }) {};

  "nonlinear-optimization-ad" = callPackage
    ({ mkDerivation, ad, base, csv, nonlinear-optimization, primitive
     , reflection, vector
     }:
     mkDerivation {
       pname = "nonlinear-optimization-ad";
       version = "0.2.1";
       sha256 = "4da26e17e8b8f877d1c6cfb2da008153d7372cbaadf1e0b54ab5ee76aff5714c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ad base nonlinear-optimization primitive reflection vector
       ];
       executableHaskellDepends = [ base csv ];
       jailbreak = true;
       homepage = "https://github.com/msakai/nonlinear-optimization-ad";
       description = "Wrapper of nonlinear-optimization package for using with AD package";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "noodle" = callPackage
    ({ mkDerivation, base, directory, filepath }:
     mkDerivation {
       pname = "noodle";
       version = "0.0.19";
       sha256 = "a0dbcf7f20b0324140c3cdbdabf67016d28abb9ce6d08224ee58d5a9cbcf6523";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory filepath ];
       executableHaskellDepends = [ base directory filepath ];
       homepage = "https://github.com/jessopher/noodle";
       description = "the noodle programming language";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "normaldistribution" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "normaldistribution";
       version = "1.1.0.3";
       sha256 = "6d7ba381946f76f3bd848c90e5bcc6f6ae5c418f7ae294cfc2559541fa02f7e0";
       libraryHaskellDepends = [ base random ];
       homepage = "https://github.com/bjornbm/normaldistribution";
       description = "Minimum fuss normally distributed random values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "not-gloss" = callPackage
    ({ mkDerivation, base, binary, bmp, bytestring, cereal, GLUT
     , OpenGL, OpenGLRaw, spatial-math, time, vector
     , vector-binary-instances
     }:
     mkDerivation {
       pname = "not-gloss";
       version = "0.7.6.4";
       sha256 = "a43d0b18834237da91b9ffb44ce23a6fe764b962ed0b3bca56ea01903603534e";
       libraryHaskellDepends = [
         base binary bmp bytestring cereal GLUT OpenGL OpenGLRaw
         spatial-math time vector vector-binary-instances
       ];
       description = "Painless 3D graphics, no affiliation with gloss";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "not-gloss-examples" = callPackage
    ({ mkDerivation, base, containers, GLUT, linear, not-gloss
     , spatial-math, X11
     }:
     mkDerivation {
       pname = "not-gloss-examples";
       version = "0.5.1.1";
       sha256 = "596165d84f1f5d28f6a4710c424e7c76a20e5151bb5a880fb415fa59f083fd21";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers GLUT linear not-gloss spatial-math X11
       ];
       description = "examples for not-gloss";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "not-in-base" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "not-in-base";
       version = "0.1.1";
       sha256 = "452accdd5ed99901b26fb47c81673e8094fb8d0b8fe8b8c0bc1d23382890a1d6";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/finnsson/not-in-base";
       description = "Useful utility functions that only depend on base";
       license = "unknown";
     }) {};

  "notcpp" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "notcpp";
       version = "0.2.0.3";
       sha256 = "8a2542bed0dedf3bdcf47af754dfca452fc2262e4da199184f1d98dfbe494a95";
       libraryHaskellDepends = [ base template-haskell ];
       testHaskellDepends = [ base template-haskell ];
       description = "Avoiding the C preprocessor via cunning use of Template Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "notmuch-haskell" = callPackage
    ({ mkDerivation, base, containers, filepath, notmuch, old-locale
     , parseargs, time
     }:
     mkDerivation {
       pname = "notmuch-haskell";
       version = "1.0.0.3";
       sha256 = "f273feba545d96197e9d92433e25a7178384c17e5d7d026c2d290d29d7d6cb7e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers filepath time ];
       librarySystemDepends = [ notmuch ];
       executableHaskellDepends = [ base old-locale parseargs ];
       executableSystemDepends = [ notmuch ];
       description = "Binding for notmuch MUA library";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) notmuch;};

  "notmuch-web" = callPackage
    ({ mkDerivation, aeson, attoparsec, attoparsec-conduit, base
     , blaze-builder, blaze-html, blaze-markup, bytestring
     , case-insensitive, conduit, containers, data-default, directory
     , email-validate, filepath, hamlet, hashable, hjsmin, hspec
     , http-conduit, http-types, HUnit, lifted-base, markdown, mime-mail
     , network, old-locale, process, process-conduit, pwstore-fast
     , random, tagsoup, template-haskell, text, text-icu, time
     , transformers, unordered-containers, vector, wai, wai-extra, warp
     , xss-sanitize, yaml, yesod, yesod-auth, yesod-core, yesod-static
     , yesod-test
     }:
     mkDerivation {
       pname = "notmuch-web";
       version = "0.2.0";
       sha256 = "1a668866b0bb8fff3889be03dabefc25ca59ca7d19a0345fe6c95df8a11b53ca";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec attoparsec-conduit base blaze-builder blaze-html
         blaze-markup bytestring case-insensitive conduit containers
         data-default directory email-validate filepath hamlet hashable
         hjsmin http-conduit http-types lifted-base markdown mime-mail
         network old-locale process process-conduit pwstore-fast random
         tagsoup template-haskell text text-icu time transformers
         unordered-containers vector wai wai-extra warp xss-sanitize yaml
         yesod yesod-auth yesod-static
       ];
       executableHaskellDepends = [ base pwstore-fast text yesod ];
       testHaskellDepends = [
         base hspec HUnit mime-mail text yesod yesod-core yesod-test
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/wuzzeb/notmuch-web";
       description = "A web interface to the notmuch email indexer";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "notzero" = callPackage
    ({ mkDerivation, base, bifunctors, directory, doctest, filepath
     , lens, mtl, QuickCheck, semigroupoids, semigroups
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "notzero";
       version = "0.0.10";
       sha256 = "17fdfc0152869243d6523f003316427be9c8e64fc4a6294e506d54e3ca22943c";
       libraryHaskellDepends = [
         base bifunctors lens mtl semigroupoids semigroups transformers
       ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck template-haskell
       ];
       homepage = "https://github.com/NICTA/notzero";
       description = "A data type for representing numeric values, except zero";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "np-extras" = callPackage
    ({ mkDerivation, base, containers, numeric-prelude, primes }:
     mkDerivation {
       pname = "np-extras";
       version = "0.3.0.1";
       sha256 = "15ac78e4ba39331eee1b4db52dd822e2adabb3770c0e24d1ae58ed8b9141b2a6";
       libraryHaskellDepends = [ base containers numeric-prelude primes ];
       description = "NumericPrelude extras";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "np-linear" = callPackage
    ({ mkDerivation, base, binary, containers, numeric-prelude
     , reflection, tagged
     }:
     mkDerivation {
       pname = "np-linear";
       version = "0.3.0.2";
       sha256 = "e17fe739b8709f79a2b2e552ab1c294cab04763031fb0e549826221dcda83503";
       libraryHaskellDepends = [
         base binary containers numeric-prelude reflection tagged
       ];
       jailbreak = true;
       description = "Linear algebra for the numeric-prelude framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nptools" = callPackage
    ({ mkDerivation, ansi-terminal, array, base, bytestring, colour
     , containers, HSH, old-locale, process, split, time, unix
     }:
     mkDerivation {
       pname = "nptools";
       version = "0.6.0";
       sha256 = "6dc0537284ea57c187fed48e56c2f9a19b04efd971fb10bf5e2851341d5737fe";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal array base bytestring colour containers HSH
         old-locale process split time unix
       ];
       description = "A collection of random tools";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nsis_0_2_4" = callPackage
    ({ mkDerivation, base, process, transformers, uniplate }:
     mkDerivation {
       pname = "nsis";
       version = "0.2.4";
       sha256 = "a3d9e33ca04df71b033cbfbaec07ad7f9a5da56674d3b4726146e98a882e549e";
       libraryHaskellDepends = [ base transformers uniplate ];
       testHaskellDepends = [ base process transformers uniplate ];
       homepage = "https://github.com/ndmitchell/nsis#readme";
       description = "DSL for producing Windows Installer using NSIS";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nsis_0_2_5" = callPackage
    ({ mkDerivation, base, directory, process, transformers, uniplate
     }:
     mkDerivation {
       pname = "nsis";
       version = "0.2.5";
       sha256 = "c15cc5cbe76673a824f9c2c4fd26b689eddb2f4e6d4c89caae26652fba0f6dd1";
       libraryHaskellDepends = [ base transformers uniplate ];
       testHaskellDepends = [
         base directory process transformers uniplate
       ];
       doCheck = false;
       homepage = "https://github.com/ndmitchell/nsis#readme";
       description = "DSL for producing Windows Installer using NSIS";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nsis" = callPackage
    ({ mkDerivation, base, directory, process, transformers, uniplate
     }:
     mkDerivation {
       pname = "nsis";
       version = "0.3";
       sha256 = "03af564c2edb8f0e0d291403d3b452c496ef3e2ab33d247b73eddfdec08df570";
       libraryHaskellDepends = [ base transformers uniplate ];
       testHaskellDepends = [
         base directory process transformers uniplate
       ];
       doCheck = false;
       homepage = "https://github.com/ndmitchell/nsis#readme";
       description = "DSL for producing Windows Installer using NSIS";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nth-prime" = callPackage
    ({ mkDerivation, base, opentheory-prime, opentheory-primitive }:
     mkDerivation {
       pname = "nth-prime";
       version = "1.2";
       sha256 = "30c7bbd741db2bd43a767821241243574abb480b4a8d09bd88967b2751310147";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base opentheory-prime opentheory-primitive
       ];
       testHaskellDepends = [
         base opentheory-prime opentheory-primitive
       ];
       description = "Computing the nth prime";
       license = stdenv.lib.licenses.mit;
     }) {};

  "nthable" = callPackage
    ({ mkDerivation, base, type-level }:
     mkDerivation {
       pname = "nthable";
       version = "0.1";
       sha256 = "9e6a4e4cf0116a8aab09185bcdb62106206c6b41816cc1c6d6e3dac50fe621e2";
       libraryHaskellDepends = [ base type-level ];
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ntp-control" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-lexing, cereal
     , network, old-locale, time
     }:
     mkDerivation {
       pname = "ntp-control";
       version = "0.1";
       sha256 = "9e308bc1ec004e4aea7f1799db4c73dda5d02259395de96af6c0b6b5172dda92";
       libraryHaskellDepends = [
         base bytestring bytestring-lexing cereal network old-locale time
       ];
       testHaskellDepends = [
         base bytestring bytestring-lexing cereal network old-locale time
       ];
       description = "Client library for NTP control messaging";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "null-canvas" = callPackage
    ({ mkDerivation, aeson, base, containers, filepath, scotty, split
     , stm, text, transformers, wai-extra, warp
     }:
     mkDerivation {
       pname = "null-canvas";
       version = "0.2.7";
       sha256 = "9436573bb39d3ed4ed8ffe78337571444c3d38abc58e1b5a2dbbb645fbcbd3c4";
       libraryHaskellDepends = [
         aeson base containers filepath scotty split stm text transformers
         wai-extra warp
       ];
       jailbreak = true;
       homepage = "https://github.com/Tener/null-canvas";
       description = "HTML5 Canvas Graphics Library - forked Blank Canvas";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nullary" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "nullary";
       version = "0.1.0.0";
       sha256 = "0cd4f880627ea551167c981feff890c656f560d515296addab99d0c8b47f7ca7";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/derekelkins/nullary";
       description = "A package for working with nullary type classes";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "number" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "number";
       version = "0.1.1.0";
       sha256 = "72157b8ca57272b8881510b9d2051044d543151ee322ecb27cc08903446f4951";
       libraryHaskellDepends = [ base ];
       description = "A library for real numbers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "number-length" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "number-length";
       version = "0.1.0.1";
       sha256 = "6c024aad9a8a751a621b0804b58ea2dd3e67703db1b75c71776996f67268e9c5";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       homepage = "https://github.com/trskop/number-length";
       description = "Number of digits in a number in decimal and hexadecimal representation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "numbering" = callPackage
    ({ mkDerivation, base, containers, vector }:
     mkDerivation {
       pname = "numbering";
       version = "0.2.1";
       sha256 = "9b667acb6c8838effd167ebefc0094eaf38d5dccc1091296ce47eff5459d0442";
       libraryHaskellDepends = [ base containers vector ];
       homepage = "https://github.com/DanielSchuessler/numbering";
       description = "Combinators for creating bijections from some type to the natural numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "numbers" = callPackage
    ({ mkDerivation, base, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "numbers";
       version = "3000.2.0.1";
       sha256 = "736d0551e4a13510dfe43a777a220bd4b17a19a73e6cd17bf901b1854b5ce183";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       homepage = "https://github.com/jwiegley/numbers#readme";
       description = "Various number types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "numerals" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, containers
     , containers-unicode-symbols, fingertree, HUnit, integer-gmp
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "numerals";
       version = "0.4";
       sha256 = "15139b63ec44ce2c308176c96184b3b2d94537f64298a1e128c32e641ca77dba";
       libraryHaskellDepends = [
         base base-unicode-symbols containers containers-unicode-symbols
         fingertree integer-gmp text
       ];
       testHaskellDepends = [
         base base-unicode-symbols HUnit integer-gmp QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "https://github.com/roelvandijk/numerals";
       description = "Convert numbers to number words";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "numerals-base" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, containers
     , containers-unicode-symbols, fingertree, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "numerals-base";
       version = "0.3";
       sha256 = "e85d7830e56c55d69c5c77e8d99755faae191876ee4bee7cd442e88d35ece962";
       libraryHaskellDepends = [
         base base-unicode-symbols containers containers-unicode-symbols
         fingertree
       ];
       testHaskellDepends = [
         base base-unicode-symbols containers containers-unicode-symbols
         fingertree HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "https://github.com/roelvandijk/numerals-base";
       description = "Convert numbers to number words";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "numeric-extras_0_0_3" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "numeric-extras";
       version = "0.0.3";
       sha256 = "efdb608471e7938554e447bfb98c09ae7de37a0e703d3e9f1effc76866965ea2";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/ekmett/numeric-extras";
       description = "Useful tools from the C standard library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "numeric-extras" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "numeric-extras";
       version = "0.1";
       sha256 = "c700711021d96334be43a21fbd80a5f7146fdd6706ef8656f1d287ff000b61d6";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/ekmett/numeric-extras";
       description = "Useful tools from the C standard library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "numeric-limits" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "numeric-limits";
       version = "0.1.0.0";
       sha256 = "8b956ce9ecf6465e19068885b77da623a3af23fcabf1253718edd2427c055153";
       libraryHaskellDepends = [ base ];
       description = "Various floating point limit related constants";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "numeric-prelude" = callPackage
    ({ mkDerivation, array, base, containers, deepseq, non-negative
     , parsec, QuickCheck, random, storable-record, utility-ht
     }:
     mkDerivation {
       pname = "numeric-prelude";
       version = "0.4.2";
       sha256 = "5327a9ffcc5997a062d2a9ea405130741114a0c6fe440a8e5b6d6c35fe56d8c4";
       revision = "1";
       editedCabalFile = "acbf128b14ff1177ed767ec9ebb89b1c3c0e998d5d031fdd0e4bc64ebc6bffe2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers deepseq non-negative parsec QuickCheck random
         storable-record utility-ht
       ];
       homepage = "http://www.haskell.org/haskellwiki/Numeric_Prelude";
       description = "An experimental alternative hierarchy of numeric type classes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "numeric-qq" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, loch-th
     , placeholders, template-haskell
     }:
     mkDerivation {
       pname = "numeric-qq";
       version = "0.1.3";
       sha256 = "beaf86d233adad0d6dcf23769e4e0f3f43a1b551f19fb772fbcfedd885f19b85";
       libraryHaskellDepends = [
         base loch-th placeholders template-haskell
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "https://github.com/nikita-volkov/numeric-qq";
       description = "Quasi-quoters for numbers of different bases";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "numeric-quest" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "numeric-quest";
       version = "0.2.0.1";
       sha256 = "ea9d279f35a1a7a2c4545cf42460698d6d921fe6880efae57bb72060b3131b84";
       revision = "1";
       editedCabalFile = "aae9d00f380bf447af5575311f566cd6960aafb7eec8c30abbab09a2fcff092e";
       libraryHaskellDepends = [ array base ];
       homepage = "http://www.haskell.org/haskellwiki/Numeric_Quest";
       description = "Math and quantum mechanics";
       license = "GPL";
     }) {};

  "numeric-ranges" = callPackage
    ({ mkDerivation, base, hspec, HUnit, QuickCheck }:
     mkDerivation {
       pname = "numeric-ranges";
       version = "0.1.0.0";
       sha256 = "0085294502dc6673fc6ca5525fa014f56f73b2bfa92d841b9d61a8c119b53982";
       revision = "1";
       editedCabalFile = "68b2a84c67b84bfe3cc3e7f4f2b0fafcd8e0741d4a3c57359f4437bb8824ea07";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec HUnit QuickCheck ];
       jailbreak = true;
       homepage = "http://github.com/nicodelpiano/numeric-ranges";
       description = "A framework for numeric ranges";
       license = stdenv.lib.licenses.mit;
     }) {};

  "numeric-tools" = callPackage
    ({ mkDerivation, base, HUnit, ieee754, primitive, vector }:
     mkDerivation {
       pname = "numeric-tools";
       version = "0.2.0.1";
       sha256 = "a3418fad0ed8cf32b8a1466cd1f0e46b0da21a737f3ab97c29eae20792d42d3b";
       libraryHaskellDepends = [ base ieee754 primitive vector ];
       testHaskellDepends = [ base HUnit ];
       homepage = "https://bitbucket.org/Shimuuar/numeric-tools";
       description = "Collection of numerical tools for integration, differentiation etc";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "numericpeano" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "numericpeano";
       version = "0.2.0.0";
       sha256 = "3b0576c3dee798440dd878390027b2c3864d80c0b99ef5b3ea287ede26ca2ab9";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/ombocomp/numericpeano/";
       description = "Peano numbers with attendant bells and whistles";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "nums" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "nums";
       version = "1.2.0";
       sha256 = "689b965e2cb0bd5ce066308559b0cbbd7319f288168f334552da8886873b742d";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "numtype" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "numtype";
       version = "1.1";
       sha256 = "a720f3cef646e5f8029d0806f6bbb43d8fd271140f418b93f7171bea5807e1ab";
       libraryHaskellDepends = [ base ];
       homepage = "http://dimensional.googlecode.com/";
       description = "Type-level (low cardinality) integers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "numtype-dk" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "numtype-dk";
       version = "0.5";
       sha256 = "adafa783b499dffe02265bfb7b126b53ea3548f0c706670adb842fe06051a13d";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/bjornbm/numtype-dk";
       description = "Type-level integers, using TypeNats, Data Kinds, and Closed Type Families";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "numtype-tf" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "numtype-tf";
       version = "0.1.2";
       sha256 = "ddcbfcd3e83979c44364914a30a1a65b0a95cd96f88cae36f941604b66fa7601";
       libraryHaskellDepends = [ base ];
       homepage = "http://dimensional.googlecode.com/";
       description = "Type-level (low cardinality) integers, implemented using type families";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nurbs" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, hspec, lens, linear
     , mtl
     }:
     mkDerivation {
       pname = "nurbs";
       version = "0.1.1.0";
       sha256 = "42459775e2b1c419343402da693465f3db61c5ab6e5666f44d810b568cf33054";
       revision = "1";
       editedCabalFile = "17ee68339f33b5fa8ccc3ddf788ee5cb3ab3f40170b93175925a1b97534afdbc";
       libraryHaskellDepends = [
         base base-unicode-symbols lens linear mtl
       ];
       testHaskellDepends = [
         base base-unicode-symbols hspec lens linear
       ];
       homepage = "https://github.com/mvoidex/nurbs";
       description = "NURBS";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nvim-hs" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, bytestring, cereal
     , cereal-conduit, conduit, conduit-extra, containers, data-default
     , directory, dyre, exceptions, filepath, foreign-store, hslogger
     , hspec, hspec-discover, HUnit, lifted-base, messagepack
     , monad-control, mtl, network, optparse-applicative, parsec
     , process, QuickCheck, resourcet, setenv, stm, streaming-commons
     , template-haskell, text, time, time-locale-compat, transformers
     , transformers-base, utf8-string
     }:
     mkDerivation {
       pname = "nvim-hs";
       version = "0.0.6";
       sha256 = "744b7b949bc0499f481d289e489a220d4b618d0bab2f308e8cefb5afc70aba38";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-wl-pprint base bytestring cereal cereal-conduit conduit
         conduit-extra containers data-default directory dyre exceptions
         filepath foreign-store hslogger lifted-base messagepack
         monad-control mtl network optparse-applicative parsec process
         resourcet setenv stm streaming-commons template-haskell text time
         time-locale-compat transformers transformers-base utf8-string
       ];
       executableHaskellDepends = [ base data-default ];
       testHaskellDepends = [
         ansi-wl-pprint base bytestring cereal cereal-conduit conduit
         conduit-extra containers data-default directory dyre exceptions
         filepath foreign-store hslogger hspec hspec-discover HUnit
         lifted-base messagepack mtl network optparse-applicative parsec
         process QuickCheck resourcet setenv stm streaming-commons
         template-haskell text time time-locale-compat transformers
         transformers-base utf8-string
       ];
       homepage = "https://github.com/neovimhaskell/nvim-hs";
       description = "Haskell plugin backend for neovim";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nvim-hs-contrib" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, bytestring, data-default
     , directory, exceptions, hspec, hspec-discover, messagepack, mtl
     , nvim-hs, parsec, process, QuickCheck, resourcet, setenv, stm
     , text, time, transformers, transformers-base, utf8-string
     }:
     mkDerivation {
       pname = "nvim-hs-contrib";
       version = "0.0.6";
       sha256 = "0825e32af7a9ee26a1f3d8104b2864208ac8142ce10c3f79516897cb5d12682d";
       libraryHaskellDepends = [
         ansi-wl-pprint base bytestring data-default directory exceptions
         messagepack mtl nvim-hs parsec process resourcet setenv stm text
         time transformers transformers-base utf8-string
       ];
       testHaskellDepends = [
         ansi-wl-pprint base bytestring data-default exceptions hspec
         hspec-discover messagepack mtl nvim-hs parsec process QuickCheck
         resourcet setenv stm text time transformers transformers-base
         utf8-string
       ];
       homepage = "https://github.com/neovimhaskell/nvim-hs";
       description = "Haskell plugin backend for neovim";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "nyan" = callPackage
    ({ mkDerivation, base, bytestring, mtl, ncurses, text }:
     mkDerivation {
       pname = "nyan";
       version = "0.2";
       sha256 = "89184df9cb730b5b51b0655c1a76025ba6bd7601f79a2c1a41d5ac15cdf26c09";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bytestring mtl ncurses text ];
       description = "Bored? Nyan cat!";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nylas" = callPackage
    ({ mkDerivation, aeson, base, bytestring, lens, lens-aeson, pipes
     , pipes-aeson, pipes-bytestring, pipes-http, pipes-parse, text
     , time, wreq
     }:
     mkDerivation {
       pname = "nylas";
       version = "0.1.1";
       sha256 = "a78d4e6d4841049f447b110df0ad22a0af764d845a19791b54a8f5d29e29d6b0";
       libraryHaskellDepends = [
         aeson base bytestring lens lens-aeson pipes pipes-aeson
         pipes-bytestring pipes-http pipes-parse text time wreq
       ];
       homepage = "https://github.com/bts/nylas-hs";
       description = "Client for the Nylas API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "nymphaea" = callPackage
    ({ mkDerivation, base, cairo, containers, glade, glib, gtk, mtl
     , parsec, random
     }:
     mkDerivation {
       pname = "nymphaea";
       version = "0.3";
       sha256 = "23b0eb1b54e661dd08ba18b70662bf1d856db259cebbb0c9c50cceb6ebf996da";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cairo containers glade glib gtk mtl parsec random
       ];
       jailbreak = true;
       description = "An interactive GUI for manipulating L-systems";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "oanda-rest-api" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, Decimal
     , hlint, hspec, HUnit, lens, old-locale, scientific, text, time
     , vector, wreq
     }:
     mkDerivation {
       pname = "oanda-rest-api";
       version = "0.1.0.0";
       sha256 = "7a22fbe550d0bd7d80d9a07e4e563557ff81f294eef423026542bc2bd8a18b0f";
       libraryHaskellDepends = [
         aeson base bytestring containers Decimal lens old-locale scientific
         text time vector wreq
       ];
       testHaskellDepends = [
         aeson base bytestring containers Decimal hlint hspec HUnit lens
         old-locale scientific text time vector wreq
       ];
       homepage = "http://github.com/jdreaver/oanda-rest-api";
       description = "Client to the OANDA REST API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "oauthenticated" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, blaze-builder
     , bytestring, case-insensitive, crypto-random, cryptohash, either
     , exceptions, http-client, http-types, mtl, network, network-uri
     , text, time, transformers
     }:
     mkDerivation {
       pname = "oauthenticated";
       version = "0.1.3.4";
       sha256 = "75ad10cec68d0a9c0fd536fd2d71ce42730aab315452569240f8468b4d8ed8d0";
       libraryHaskellDepends = [
         aeson base base64-bytestring blaze-builder bytestring
         case-insensitive crypto-random cryptohash either exceptions
         http-client http-types mtl network network-uri text time
         transformers
       ];
       jailbreak = true;
       description = "Simple OAuth for http-client";
       license = stdenv.lib.licenses.mit;
     }) {};

  "obdd" = callPackage
    ({ mkDerivation, array, base, containers, mtl, random }:
     mkDerivation {
       pname = "obdd";
       version = "0.3.2";
       sha256 = "1c862c5d1e9431f04ba5a8789420095ceaae2193bdcac602b3bb6ac1950c9335";
       libraryHaskellDepends = [ array base containers mtl random ];
       homepage = "https://github.com/jwaldmann/haskell-obdd";
       description = "Ordered Reduced Binary Decision Diagrams";
       license = "GPL";
     }) {};

  "oberon0" = callPackage
    ({ mkDerivation, array, AspectAG, base, containers, ghc-prim, HList
     , language-c, mtl, murder, template-haskell, transformers
     , uu-parsinglib, uulib
     }:
     mkDerivation {
       pname = "oberon0";
       version = "0.0.2";
       sha256 = "1b96e40cacb6a00856d55d7059fbefe5aa018a15bf9002189db2868cef7d1e71";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array AspectAG base containers ghc-prim HList mtl murder
         template-haskell transformers uu-parsinglib uulib
       ];
       executableHaskellDepends = [
         AspectAG base containers HList language-c murder uu-parsinglib
         uulib
       ];
       doHaddock = false;
       homepage = "http://www.cs.uu.nl/wiki/Center/CoCoCo";
       description = "Oberon0 Compiler";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "obj" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, checkers
     , Codec-Image-DevIL, containers, directory, filepath
     , graphicsFormats, haskell98, InfixApplicative, OpenGL, OpenGLCheck
     , QuickCheck
     }:
     mkDerivation {
       pname = "obj";
       version = "0.1.2";
       sha256 = "9f34957f6927cb20933ca6f38d78a158839ee73fcec247319c14a1289af73e71";
       libraryHaskellDepends = [
         array base binary bytestring checkers Codec-Image-DevIL containers
         directory filepath graphicsFormats haskell98 InfixApplicative
         OpenGL OpenGLCheck QuickCheck
       ];
       description = "Reads and writes obj models";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "objectid" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring
     , bytestring-arbitrary, cereal, cryptohash, QuickCheck, tasty
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "objectid";
       version = "0.1.0.2";
       sha256 = "fa6dd38c2e6f814095c3b2f18efa482ce69a81f7cf3454fd7b462139f38729b3";
       libraryHaskellDepends = [
         base blaze-builder bytestring cereal cryptohash
       ];
       testHaskellDepends = [
         base bytestring bytestring-arbitrary cereal QuickCheck tasty
         tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "https://github.com/tsuraan/objectid";
       description = "Rather unique identifier for things that need to be stored";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "objective" = callPackage
    ({ mkDerivation, base, containers, either, exceptions, free
     , hashable, monad-skeleton, monad-stm, mtl, profunctors, stm
     , template-haskell, transformers, transformers-compat
     , unordered-containers, void, witherable
     }:
     mkDerivation {
       pname = "objective";
       version = "1.0.5";
       sha256 = "d0c38a442d8adef6f489dc404e30878664e6e53038cb10b9e35d8bf657d6611f";
       libraryHaskellDepends = [
         base containers either exceptions free hashable monad-skeleton
         monad-stm mtl profunctors stm template-haskell transformers
         transformers-compat unordered-containers void witherable
       ];
       homepage = "https://github.com/fumieval/objective";
       description = "Composable objects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "observable-sharing" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "observable-sharing";
       version = "0.2.4";
       sha256 = "400efecddcfdd992717caccc3a7b00590e7635bf92305d7d93f81d47327811d3";
       libraryHaskellDepends = [ base containers ];
       homepage = "https://github.com/atzeus/observable-sharing";
       description = "Simple observable sharing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "octane" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers
     , data-binary-ieee754, deepseq, tasty, tasty-hspec, text
     }:
     mkDerivation {
       pname = "octane";
       version = "0.4.0";
       sha256 = "577f5a867e6ae3eabf00a77661bba48f5386908734728fc91e24d01e9fdd83d0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers data-binary-ieee754 deepseq text
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base binary bytestring containers tasty tasty-hspec
       ];
       homepage = "https://github.com/tfausak/octane";
       description = "A Rocket League replay parser";
       license = stdenv.lib.licenses.mit;
     }) {};

  "octohat" = callPackage
    ({ mkDerivation, aeson, base, base-compat, base16-bytestring
     , base64-bytestring, bytestring, containers, cryptohash, dotenv
     , either, errors, ghc-prim, hspec, hspec-expectations, http-client
     , http-types, lens, mtl, optparse-applicative, text, time
     , transformers, unordered-containers, utf8-string, wreq-sb, xmlhtml
     , yaml
     }:
     mkDerivation {
       pname = "octohat";
       version = "0.1.5.0";
       sha256 = "a064f32fdf4272e6b653ccc1bc13036c77b1bb902f1d9f6482ea76a02674639d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base-compat base16-bytestring base64-bytestring
         bytestring containers cryptohash dotenv either errors ghc-prim
         http-client http-types lens mtl text time transformers
         unordered-containers wreq-sb xmlhtml
       ];
       executableHaskellDepends = [
         aeson base optparse-applicative text utf8-string yaml
       ];
       testHaskellDepends = [
         base base-compat dotenv hspec hspec-expectations text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/stackbuilders/octohat";
       description = "A tested, minimal wrapper around GitHub's API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "octopus" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, hexpr, mtl
     , parsec, symbol, text
     }:
     mkDerivation {
       pname = "octopus";
       version = "0.0.2.1";
       sha256 = "8a9de2db20925fc6895823970d22bea4f8e54e7b1e8d28d6f6f9174592713adc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers hexpr mtl parsec symbol text
       ];
       executableHaskellDepends = [
         array base bytestring containers hexpr mtl parsec symbol text
       ];
       jailbreak = true;
       homepage = "https://github.com/Zankoku-Okuno/octopus/";
       description = "Lisp with more dynamism, more power, more simplicity";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "oculus" = callPackage
    ({ mkDerivation, base, either, libX11, libXinerama, mesa, monads-tf
     , ovr, systemd, transformers, vect-floating
     }:
     mkDerivation {
       pname = "oculus";
       version = "0.1.0.2";
       sha256 = "44d778d6f0285ff01d52b125061a32988a44ad08d69d694c7b66c802172f0110";
       libraryHaskellDepends = [
         base either monads-tf transformers vect-floating
       ];
       librarySystemDepends = [ libX11 libXinerama mesa ovr systemd ];
       jailbreak = true;
       homepage = "http://github.com/cpdurham/oculus";
       description = "Oculus Rift ffi providing head tracking data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.xorg) libX11; inherit (pkgs.xorg) libXinerama; 
         inherit (pkgs) mesa; ovr = null; inherit (pkgs) systemd;};

  "oeis" = callPackage
    ({ mkDerivation, base, HTTP, HUnit, network, network-uri
     , test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "oeis";
       version = "0.3.6";
       sha256 = "4039b69a7aa0412eb4a37f36be7bf442ea32dd4672fc8765b6b134513fe3fee0";
       libraryHaskellDepends = [ base HTTP network network-uri ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       description = "Interface to the Online Encyclopedia of Integer Sequences (OEIS)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "off-simple" = callPackage
    ({ mkDerivation, base, parsec3, vector }:
     mkDerivation {
       pname = "off-simple";
       version = "0.1";
       sha256 = "7247e8b9c2c81e159754665b06c52c1e572d2de2f5cf8f400a60232eeb124b0f";
       libraryHaskellDepends = [ base parsec3 vector ];
       jailbreak = true;
       homepage = "https://github.com/acfoltzer/off-simple";
       description = "A parser for simplified-syntax OFF files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ofx" = callPackage
    ({ mkDerivation, base, parsec, pretty, time }:
     mkDerivation {
       pname = "ofx";
       version = "0.4.0.4";
       sha256 = "c953333a0b8b85d57534823a57d219d245b7cb682d493c0afc38c4652b9e05fd";
       libraryHaskellDepends = [ base parsec pretty time ];
       homepage = "http://www.github.com/massysett/ofx";
       description = "Parser for OFX data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ohloh-hs" = callPackage
    ({ mkDerivation, base, cmdargs, data-lens, hxt, hxt-curl
     , pretty-show, QuickCheck, test-framework
     , test-framework-quickcheck2, text-format-simple
     }:
     mkDerivation {
       pname = "ohloh-hs";
       version = "0.0.2";
       sha256 = "d24339be4df9ac8dd7945a26d6fa1af19f1ae8871f0fa4fa5559ce593d117359";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base data-lens hxt text-format-simple ];
       executableHaskellDepends = [
         base cmdargs data-lens hxt hxt-curl pretty-show text-format-simple
       ];
       testHaskellDepends = [
         base data-lens hxt QuickCheck test-framework
         test-framework-quickcheck2 text-format-simple
       ];
       homepage = "https://github.com/fthomas/ohloh-hs";
       description = "Interface to the Ohloh API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "oi" = callPackage
    ({ mkDerivation, base, comonad, directory, filepath, parallel }:
     mkDerivation {
       pname = "oi";
       version = "0.4.0";
       sha256 = "2757014767b21d1938d8acaa4742514457482aa52c47b5fea4ba9e72ea810e32";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base comonad directory filepath parallel
       ];
       executableHaskellDepends = [ base directory filepath parallel ];
       description = "Library for purely functional lazy interactions with the outer world";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "oidc-client" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, exceptions
     , hspec, http-client, http-client-tls, http-types, jose-jwt
     , network, network-uri, text, time, tls
     }:
     mkDerivation {
       pname = "oidc-client";
       version = "0.2.0.0";
       sha256 = "b2d7daa84844d0cc1057bbaffc836bb52ff2992b98a17b4b285778bacdefc03c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring exceptions http-client
         http-client-tls jose-jwt network network-uri text time tls
       ];
       testHaskellDepends = [
         base bytestring hspec http-client http-client-tls http-types text
       ];
       homepage = "https://github.com/krdlab/haskell-oidc-client";
       description = "OpenID Connect 1.0 library for RP";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ois-input-manager" = callPackage
    ({ mkDerivation, base, hogre, OIS }:
     mkDerivation {
       pname = "ois-input-manager";
       version = "0.1.0.1";
       sha256 = "384e36f04810ca71a298e0e1a18d33a04f6dbe6a344e58f04d07143797ef64dc";
       libraryHaskellDepends = [ base hogre ];
       librarySystemDepends = [ OIS ];
       jailbreak = true;
       description = "wrapper for OIS input manager for use with hogre";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {OIS = null;};

  "old-locale" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "old-locale";
       version = "1.0.0.7";
       sha256 = "dbaf8bf6b888fb98845705079296a23c3f40ee2f449df7312f7f7f1de18d7b50";
       revision = "1";
       editedCabalFile = "f87c7c0495bf863c82ca051e68b10b3133a286aed11f0291253385a5856a6ceb";
       libraryHaskellDepends = [ base ];
       description = "locale library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "old-time" = callPackage
    ({ mkDerivation, base, old-locale }:
     mkDerivation {
       pname = "old-time";
       version = "1.1.0.3";
       sha256 = "1ccb158b0f7851715d36b757c523b026ca1541e2030d02239802ba39b4112bc1";
       revision = "1";
       editedCabalFile = "c1a016dd23d38e879b7972ce95f22b1498d39fc62a7b755ff5f344bfeeaf796e";
       libraryHaskellDepends = [ base old-locale ];
       description = "Time library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "old-version" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "old-version";
       version = "1.4.2";
       sha256 = "63e1741635b38b100c954133923c46de83c7c5e053ecfcc414e0b05c9d500feb";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Basic versioning library";
       license = "unknown";
     }) {};

  "olwrapper" = callPackage
    ({ mkDerivation, base, bytestring, fay, fay-jquery, fay-text, lens
     , mtl, snap, snap-core, snap-loader-dynamic, snap-loader-static
     , snap-server, snaplet-fay, text
     }:
     mkDerivation {
       pname = "olwrapper";
       version = "0.4.1";
       sha256 = "51d1ef071ca8fcace46060fd5372301310f6bddf4b9fe1c5845a67dd9555d332";
       revision = "2";
       editedCabalFile = "1166385cf5605d7d543f591234ac81feb1a307dee476c962d8603baebd66ba44";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring fay fay-jquery fay-text lens mtl snap snap-core
         snap-loader-dynamic snap-loader-static snap-server snaplet-fay text
       ];
       executableHaskellDepends = [
         base bytestring fay fay-jquery fay-text lens mtl snap snap-core
         snap-loader-static snap-server snaplet-fay text
       ];
       jailbreak = true;
       description = "An OpenLayers JavaScript Wrapper and Webframework with snaplet-fay";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "omaketex" = callPackage
    ({ mkDerivation, base, optparse-applicative, shakespeare-text
     , shelly, text
     }:
     mkDerivation {
       pname = "omaketex";
       version = "0.1.1.0";
       sha256 = "c96ee573ab8f5c72a2c092f4974444a42af4d816027a3a9b74c3fe662f92024f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base optparse-applicative shakespeare-text shelly text
       ];
       jailbreak = true;
       homepage = "https://github.com/pcapriotti/omaketex";
       description = "A simple tool to generate OMakefile for latex files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "omega" = callPackage
    ({ mkDerivation, array, base, containers, directory, filepath
     , pretty, time
     }:
     mkDerivation {
       pname = "omega";
       version = "1.5.2";
       sha256 = "9e822da1175d8fd214c221e2a070171c76a1c63c7939ddd2b3e5a1f49f90216c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory filepath pretty time
       ];
       homepage = "http://code.google.com/p/omega/";
       description = "A purely functional programming language and a proof system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "omnicodec" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, conduit, sandi
     , transformers
     }:
     mkDerivation {
       pname = "omnicodec";
       version = "0.7";
       sha256 = "a746a4f83528d09ce7360abb68ce91a144bd31f8a3ae4404106d4b67a3e6b3a3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs conduit sandi transformers
       ];
       jailbreak = true;
       description = "data encoding and decoding command line utilities";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "omnifmt" = callPackage
    ({ mkDerivation, aeson, base, exceptions, extra, fast-logger
     , filepath, monad-logger, monad-parallel, mtl, optparse-applicative
     , pipes, pipes-concurrency, temporary, text, time
     , unordered-containers, yaml
     }:
     mkDerivation {
       pname = "omnifmt";
       version = "0.2.1.1";
       sha256 = "1964789180234ea2ae72fa397beab99985392dac86f527ec7866463288341731";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base exceptions extra filepath monad-logger mtl pipes text
         unordered-containers yaml
       ];
       executableHaskellDepends = [
         base exceptions extra fast-logger filepath monad-logger
         monad-parallel mtl optparse-applicative pipes pipes-concurrency
         temporary text time
       ];
       homepage = "https://github.com/hjwylde/omnifmt";
       description = "A pretty-printer wrapper to faciliate ease of formatting during development";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "on-a-horse" = callPackage
    ({ mkDerivation, arrows, base, bytestring, case-insensitive
     , containers, cookie, http-types, mtl, random, safe, split, text
     , time, transformers, utf8-string, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "on-a-horse";
       version = "0.3";
       sha256 = "6f5f635345ac2b528d31b4a9f640a3cae46da37911eebdaaafae80d756dbcba2";
       libraryHaskellDepends = [
         arrows base bytestring case-insensitive containers cookie
         http-types mtl random safe split text time transformers utf8-string
         wai wai-extra warp
       ];
       homepage = "http://haskell.on-a-horse.org";
       description = "\"Haskell on a Horse\" - A combinatorial web framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "on-demand-ssh-tunnel" = callPackage
    ({ mkDerivation, base, bytestring, GenericPretty, network, process
     , random
     }:
     mkDerivation {
       pname = "on-demand-ssh-tunnel";
       version = "0.1.0.6";
       sha256 = "7f3e0e003466bf95154f8497eec916f10b0af0f17518f19148ce26c30757b35e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring GenericPretty network process random
       ];
       executableHaskellDepends = [
         base bytestring GenericPretty network process random
       ];
       homepage = "https://github.com/crackleware/on-demand-ssh-tunnel";
       description = "Program that sends traffic through SSH tunnels on-demand";
       license = stdenv.lib.licenses.mit;
     }) {};

  "once" = callPackage
    ({ mkDerivation, base, containers, hashable, template-haskell
     , unordered-containers
     }:
     mkDerivation {
       pname = "once";
       version = "0.1.0.0";
       sha256 = "9a59a79946079ea2d00469f9c4a6a319ad96425f38f4b90093789109c268a7ab";
       libraryHaskellDepends = [
         base containers hashable template-haskell unordered-containers
       ];
       homepage = "https://anonscm.debian.org/cgit/users/kaction-guest/haskell-once.git";
       description = "memoization for IO actions and functions";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "one-liner" = callPackage
    ({ mkDerivation, base, contravariant, ghc-prim, transformers }:
     mkDerivation {
       pname = "one-liner";
       version = "0.5.2";
       sha256 = "9b2332118fd4e8ce127b11989b73af2a9812c98bbf1e2dfa762c718561b6df79";
       libraryHaskellDepends = [
         base contravariant ghc-prim transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/sjoerdvisscher/one-liner";
       description = "Constraint-based generics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "one-time-password" = callPackage
    ({ mkDerivation, base, byteable, bytestring, cereal, cryptohash
     , tasty, tasty-hunit, time
     }:
     mkDerivation {
       pname = "one-time-password";
       version = "1.0.0.1";
       sha256 = "40e1c392c846dfa9b08696f38e6426c9cba9fbe9699b51d4c6c49c7929eafcce";
       libraryHaskellDepends = [
         base byteable bytestring cereal cryptohash time
       ];
       testHaskellDepends = [
         base bytestring cryptohash tasty tasty-hunit time
       ];
       homepage = "https://github.com/s9gf4ult/one-time-password";
       description = "HMAC-Based and Time-Based One-Time Passwords";
       license = stdenv.lib.licenses.mit;
     }) {};

  "oneOfN" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "oneOfN";
       version = "0.1.0.1";
       sha256 = "938651b2b834074f0655047336262851842cd9a834f496a85c08e0fdc565fe15";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/mokus0/oneOfN";
       description = "Anonymous coproduct type";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "oneormore" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "oneormore";
       version = "0.1.0.3";
       sha256 = "7798aed4847e21ba9c840fb05ad9538d7acf6ea941f1a1bce3189fb95412e4d3";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/thinkpad20/oneormore";
       description = "A never-empty list type";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "only" = callPackage
    ({ mkDerivation, base, parsec, regex-compat }:
     mkDerivation {
       pname = "only";
       version = "0.0.6.0";
       sha256 = "410b03ed4f8f91feae734d645a1b9b6c6fbbe710119a855dbbb043ed80f7899d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base parsec regex-compat ];
       description = "A grep-like tool for filtering on words or lines";
       license = "GPL";
     }) {};

  "onu-course" = callPackage
    ({ mkDerivation, base, smallcheck }:
     mkDerivation {
       pname = "onu-course";
       version = "1";
       sha256 = "609ad30d28bbda02a6c7334982abd69f14dd26403d8b10576739122057b11eb4";
       libraryHaskellDepends = [ base smallcheck ];
       description = "Code for the Haskell course taught at the Odessa National University in 2012";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "oo-prototypes" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "oo-prototypes";
       version = "0.1.0.0";
       sha256 = "9eaee40e3221f817b957e472917977bdb06ac0e163a0c6ef87941de29a12f576";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/yi-editor/oo-prototypes";
       description = "Support for OO-like prototypes";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "opaleye_0_3" = callPackage
    ({ mkDerivation, base, contravariant, old-locale, postgresql-simple
     , pretty, product-profunctors, profunctors, semigroups, text, time
     , transformers, uuid
     }:
     mkDerivation {
       pname = "opaleye";
       version = "0.3";
       sha256 = "3d7b2f5a262f95f7ca409b1dc72b76363463bc15b697d6f494453eae1bc002cb";
       revision = "1";
       editedCabalFile = "fba09de3e538f5f3271e5b736a08541a8738fc291ab0d1a7dc537fb30dd60a85";
       libraryHaskellDepends = [
         base contravariant old-locale postgresql-simple pretty
         product-profunctors profunctors semigroups text time transformers
         uuid
       ];
       testHaskellDepends = [
         base postgresql-simple product-profunctors profunctors time
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/tomjaguarpaw/haskell-opaleye";
       description = "An SQL-generating DSL targeting PostgreSQL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "opaleye_0_3_1" = callPackage
    ({ mkDerivation, attoparsec, base, case-insensitive, contravariant
     , old-locale, postgresql-simple, pretty, product-profunctors
     , profunctors, semigroups, text, time, transformers, uuid
     }:
     mkDerivation {
       pname = "opaleye";
       version = "0.3.1";
       sha256 = "0524c4b4c57a91ea569bcdd10acee922e928d01d91afa509d46e57ee812d0ca1";
       revision = "2";
       editedCabalFile = "a82fed5cc74432826c4a4704c424938d1d2653bafbda0124c9a0e628f78401cd";
       libraryHaskellDepends = [
         attoparsec base case-insensitive contravariant old-locale
         postgresql-simple pretty product-profunctors profunctors semigroups
         text time transformers uuid
       ];
       testHaskellDepends = [
         base postgresql-simple product-profunctors profunctors time
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/tomjaguarpaw/haskell-opaleye";
       description = "An SQL-generating DSL targeting PostgreSQL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "opaleye_0_3_1_2" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, bytestring
     , case-insensitive, contravariant, postgresql-simple, pretty
     , product-profunctors, profunctors, semigroups, text, time
     , time-locale-compat, transformers, uuid
     }:
     mkDerivation {
       pname = "opaleye";
       version = "0.3.1.2";
       sha256 = "69ab0386a210e8c593f27693da007709bc83a7930a5ebd2f7b38d0a23e7c8d06";
       revision = "3";
       editedCabalFile = "9ee83219b8bc26fe01cca7484513bc3373d2868855ba8757fd210482f0605852";
       libraryHaskellDepends = [
         attoparsec base base16-bytestring bytestring case-insensitive
         contravariant postgresql-simple pretty product-profunctors
         profunctors semigroups text time time-locale-compat transformers
         uuid
       ];
       testHaskellDepends = [
         base postgresql-simple product-profunctors profunctors time
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/tomjaguarpaw/haskell-opaleye";
       description = "An SQL-generating DSL targeting PostgreSQL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "opaleye_0_4_0_0" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, bytestring
     , case-insensitive, containers, contravariant, postgresql-simple
     , pretty, product-profunctors, profunctors, QuickCheck, semigroups
     , text, time, time-locale-compat, transformers, uuid, void
     }:
     mkDerivation {
       pname = "opaleye";
       version = "0.4.0.0";
       sha256 = "3387a369f811a73d5a2be9b57827ade2a6275b56e4e02da365185e918befeeb7";
       libraryHaskellDepends = [
         attoparsec base base16-bytestring bytestring case-insensitive
         contravariant postgresql-simple pretty product-profunctors
         profunctors semigroups text time time-locale-compat transformers
         uuid void
       ];
       testHaskellDepends = [
         base containers contravariant postgresql-simple product-profunctors
         profunctors QuickCheck semigroups time
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/tomjaguarpaw/haskell-opaleye";
       description = "An SQL-generating DSL targeting PostgreSQL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "opaleye_0_4_1_0" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, bytestring
     , case-insensitive, containers, contravariant, multiset
     , postgresql-simple, pretty, product-profunctors, profunctors
     , QuickCheck, semigroups, text, time, time-locale-compat
     , transformers, uuid, void
     }:
     mkDerivation {
       pname = "opaleye";
       version = "0.4.1.0";
       sha256 = "eca2210c89f76ddcc01c927d317fe58b212a446bffd3d61264a52056edcb91eb";
       revision = "1";
       editedCabalFile = "8d7f434cceda05cb188865f4a2dbca5f7de41fe1ec51f6bceae208d50d2a61a3";
       libraryHaskellDepends = [
         attoparsec base base16-bytestring bytestring case-insensitive
         contravariant postgresql-simple pretty product-profunctors
         profunctors semigroups text time time-locale-compat transformers
         uuid void
       ];
       testHaskellDepends = [
         base containers contravariant multiset postgresql-simple
         product-profunctors profunctors QuickCheck semigroups time
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/tomjaguarpaw/haskell-opaleye";
       description = "An SQL-generating DSL targeting PostgreSQL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "opaleye" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , bytestring, case-insensitive, containers, contravariant, multiset
     , postgresql-simple, pretty, product-profunctors, profunctors
     , QuickCheck, semigroups, text, time, time-locale-compat
     , transformers, uuid, void
     }:
     mkDerivation {
       pname = "opaleye";
       version = "0.4.2.0";
       sha256 = "b924c4d0fa7151c0dbaee5ddcd89adfa569614204a805392625752ea6dc13c20";
       revision = "2";
       editedCabalFile = "bf554e82c1ac3c72f9df13494052197f0e8f131d0f44487073443a180c51395a";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring bytestring case-insensitive
         contravariant postgresql-simple pretty product-profunctors
         profunctors semigroups text time time-locale-compat transformers
         uuid void
       ];
       testHaskellDepends = [
         base containers contravariant multiset postgresql-simple
         product-profunctors profunctors QuickCheck semigroups time
       ];
       doCheck = false;
       homepage = "https://github.com/tomjaguarpaw/haskell-opaleye";
       description = "An SQL-generating DSL targeting PostgreSQL";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "opaleye-classy" = callPackage
    ({ mkDerivation, base, bytestring, lens, mtl, opaleye
     , postgresql-simple, product-profunctors, transformers
     }:
     mkDerivation {
       pname = "opaleye-classy";
       version = "0.3.1.1";
       sha256 = "2c3e216384bdb5e9e9eb84e67dd86b4daaf31568ccb5714b8aa84e2d3550ca9b";
       revision = "1";
       editedCabalFile = "79b08c58924ba2f19fa919f97895adb4dbb6b8e0b1644c91aaf5307e414fbc27";
       libraryHaskellDepends = [
         base bytestring lens mtl opaleye postgresql-simple
         product-profunctors transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/benkolera/opaleye-classy/tree/master";
       description = "Opaleye wrapped up in classy MTL attire";
       license = stdenv.lib.licenses.mit;
     }) {};

  "opaleye-sqlite" = callPackage
    ({ mkDerivation, base, base16-bytestring, bytestring
     , case-insensitive, containers, contravariant, direct-sqlite
     , pretty, product-profunctors, profunctors, QuickCheck, semigroups
     , sqlite-simple, text, time, time-locale-compat, transformers, uuid
     , void
     }:
     mkDerivation {
       pname = "opaleye-sqlite";
       version = "0.0.1.0";
       sha256 = "b8afd6df526f94bad4067e74f25e7c25e2909b1bc57270280405f7c905907164";
       libraryHaskellDepends = [
         base base16-bytestring bytestring case-insensitive contravariant
         direct-sqlite pretty product-profunctors profunctors semigroups
         sqlite-simple text time time-locale-compat transformers uuid void
       ];
       testHaskellDepends = [
         base containers contravariant product-profunctors profunctors
         QuickCheck semigroups sqlite-simple time
       ];
       jailbreak = true;
       homepage = "https://github.com/tomjaguarpaw/haskell-opaleye";
       description = "An SQL-generating DSL targeting SQLite";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "opaleye-trans" = callPackage
    ({ mkDerivation, base, mtl, opaleye, postgresql-simple
     , product-profunctors, transformers, transformers-base
     }:
     mkDerivation {
       pname = "opaleye-trans";
       version = "0.3.1";
       sha256 = "61c5c21c4bbb9bcc3111ed3310fe454c3cd9e612c2c79cc34f5bbbbae28024f7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base mtl opaleye postgresql-simple product-profunctors transformers
         transformers-base
       ];
       executableHaskellDepends = [
         base opaleye postgresql-simple product-profunctors
       ];
       homepage = "https://github.com/tomjaguarpaw/haskell-opaleye";
       description = "A monad transformer for Opaleye";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "open-browser" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "open-browser";
       version = "0.2.1.0";
       sha256 = "0bed2e63800f738e78a4803ed22902accb50ac02068b96c17ce83a267244ca66";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base process ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/rightfold/open-browser";
       description = "Open a web browser from Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "open-haddock" = callPackage
    ({ mkDerivation, base, basic-prelude, text, turtle }:
     mkDerivation {
       pname = "open-haddock";
       version = "0.1.0.0";
       sha256 = "310b4b7dfeef8a4b07e77c9f5b646fe292bd49ef343ddbff7e8ddd02281fefdc";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base basic-prelude text turtle ];
       description = "Open haddock HTML documentation";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "open-pandoc" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory
     , extensible-exceptions, filepath, HTTP, mtl, network, old-time
     , parsec, pretty, process, syb, texmath, utf8-string, xhtml, xml
     , zip-archive
     }:
     mkDerivation {
       pname = "open-pandoc";
       version = "1.5.1.1";
       sha256 = "f6339da2a922cebc39de5289dd52b69c5787c5cb6018051daad4e0f3430e2dcd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers directory extensible-exceptions filepath
         HTTP mtl network old-time parsec pretty process syb texmath
         utf8-string xhtml xml zip-archive
       ];
       homepage = "http://johnmacfarlane.net/pandoc";
       description = "Conversion between markup formats";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "open-symbology" = callPackage
    ({ mkDerivation, attoparsec, base, conduit, mtl, text }:
     mkDerivation {
       pname = "open-symbology";
       version = "0.1";
       sha256 = "d5bfa2190950c71e1b21ba755d440da10c2cfe0d0103b2c185af0e124564e637";
       libraryHaskellDepends = [ attoparsec base conduit mtl text ];
       homepage = "https://github.com/alphaHeavy/open-symbology";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "open-typerep" = callPackage
    ({ mkDerivation, base, constraints, mtl, syntactic, tagged
     , template-haskell
     }:
     mkDerivation {
       pname = "open-typerep";
       version = "0.5";
       sha256 = "8060a300cc6a3f72a0b3aba74574399c112362f74bbc69498203e82dd0986d22";
       libraryHaskellDepends = [
         base constraints mtl syntactic tagged template-haskell
       ];
       testHaskellDepends = [ base syntactic ];
       homepage = "https://github.com/emilaxelsson/open-typerep";
       description = "Open type representations and dynamic types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "open-union" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "open-union";
       version = "0.1.0.1";
       sha256 = "1ceb46a9eeb6114a5eb8eeb3805a9d4f218c88cd2f24e42c25271b348b3a7fb6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/RobotGymnast/open-union";
       description = "Extensible, type-safe unions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "open-witness" = callPackage
    ({ mkDerivation, base, mtl, witness }:
     mkDerivation {
       pname = "open-witness";
       version = "0.1.1";
       sha256 = "74dc0d586b21116cc47ba8614e52301a869c4e30c0f9c51eee40511e3ca468c4";
       libraryHaskellDepends = [ base mtl witness ];
       jailbreak = true;
       description = "open witnesses";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "opencog-atomspace" = callPackage
    ({ mkDerivation, atomspace-cwrapper, base, transformers }:
     mkDerivation {
       pname = "opencog-atomspace";
       version = "0.1.0.3";
       sha256 = "c4848b27f3c2d6f7e2fc22d338a9bc1547c5282d970c0d7d4d83672a948e4dd0";
       libraryHaskellDepends = [ base transformers ];
       librarySystemDepends = [ atomspace-cwrapper ];
       homepage = "github.com/opencog/atomspace/tree/master/opencog/haskell";
       description = "Haskell Bindings for the AtomSpace";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {atomspace-cwrapper = null;};

  "opencv-raw" = callPackage
    ({ mkDerivation, base, bindings-DSL, Cabal, opencv, vector }:
     mkDerivation {
       pname = "opencv-raw";
       version = "0.1.0.0";
       sha256 = "96df8e0d3bd7df173a8d3e4b4b769cecb9f97de5683bbb3e6a137fd1f0941010";
       libraryHaskellDepends = [ base bindings-DSL Cabal vector ];
       libraryPkgconfigDepends = [ opencv ];
       jailbreak = true;
       homepage = "www.github.com/arjuncomar/opencv-raw.git";
       description = "Raw Haskell bindings to OpenCV >= 2.0";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) opencv;};

  "opendatatable" = callPackage
    ({ mkDerivation, base, hxt, template-haskell, th-lift }:
     mkDerivation {
       pname = "opendatatable";
       version = "0.0.0";
       sha256 = "6194b08a0236a6fcc767e300dde4ec93dfe98cc416bcefd2cfea002e691267af";
       libraryHaskellDepends = [ base hxt template-haskell th-lift ];
       jailbreak = true;
       homepage = "https://github.com/fabianbergmark/OpenDataTable";
       description = "A library for working with Open Data Tables";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "openexchangerates" = callPackage
    ({ mkDerivation, aeson, base, containers, currency, errors, HTTP
     , network, text
     }:
     mkDerivation {
       pname = "openexchangerates";
       version = "0.1.0.0";
       sha256 = "14c9a1dd65790b6ab3c6d42aa2403e87eb64ed255f105ae4b0ba02c79a832132";
       libraryHaskellDepends = [
         aeson base containers currency errors HTTP network text
       ];
       homepage = "https://github.com/singpolyma/openexchangerates-haskell";
       description = "Fetch exchange rates from OpenExchangeRates.org";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "openflow" = callPackage
    ({ mkDerivation, aeson, base, bimap, binary, bytestring, containers
     , deepseq-generics, hashable, network
     }:
     mkDerivation {
       pname = "openflow";
       version = "0.3.0";
       sha256 = "6269b0b64008600c53ed70c9e3ab408a2791cac3c71446b9d921d74834190f36";
       libraryHaskellDepends = [
         aeson base bimap binary bytestring containers deepseq-generics
         hashable network
       ];
       jailbreak = true;
       homepage = "https://github.com/AndreasVoellmy/openflow";
       description = "OpenFlow";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "opengl-dlp-stereo" = callPackage
    ({ mkDerivation, base, data-default, GLUT, OpenGL, vector }:
     mkDerivation {
       pname = "opengl-dlp-stereo";
       version = "0.1.5.2";
       sha256 = "ae6c39a874af2fe12fd5af0dfc312ed9c2156a9240243c8ff81aa66970b0cad1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base data-default GLUT OpenGL vector ];
       executableHaskellDepends = [
         base data-default GLUT OpenGL vector
       ];
       homepage = "https://bitbucket.org/bwbush/opengl-dlp-stereo";
       description = "Library and example for using DLP stereo in OpenGL";
       license = stdenv.lib.licenses.mit;
     }) {};

  "opengl-spacenavigator" = callPackage
    ({ mkDerivation, base, binary, data-default, GLUT, OpenGL }:
     mkDerivation {
       pname = "opengl-spacenavigator";
       version = "0.1.5.4";
       sha256 = "a6b1d313e0dce09ad4134b69df197acec6cc75ff5f3c2db9ca18cf384db64a54";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base binary data-default GLUT OpenGL ];
       executableHaskellDepends = [
         base binary data-default GLUT OpenGL
       ];
       homepage = "https://bitbucket.org/bwbush/opengl-spacenavigator";
       description = "Library and example for using a SpaceNavigator-compatible 3-D mouse with OpenGL";
       license = stdenv.lib.licenses.mit;
     }) {};

  "opengles" = callPackage
    ({ mkDerivation, base, bytestring, distributive, EGL
     , future-resource, ghc-prim, GLESv2, lens, linear, packer, vector
     }:
     mkDerivation {
       pname = "opengles";
       version = "0.7.0";
       sha256 = "b2956a7ebfa7d57d40b9c01a84c398ddb537b576c15b4ee021499cf35c0bed6f";
       libraryHaskellDepends = [
         base bytestring distributive future-resource ghc-prim lens linear
         packer vector
       ];
       librarySystemDepends = [ EGL GLESv2 ];
       jailbreak = true;
       description = "OpenGL ES 2.0 and 3.0 with EGL 1.4";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {EGL = null; GLESv2 = null;};

  "openid" = callPackage
    ({ mkDerivation, base, bytestring, containers, HsOpenSSL, HTTP
     , monadLib, network, time, xml
     }:
     mkDerivation {
       pname = "openid";
       version = "0.2.0.2";
       sha256 = "5a33c21ca3e2b652bcea93bd32a96dbeabd336260d7617337331693a3e140d66";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers HsOpenSSL HTTP monadLib network time xml
       ];
       homepage = "http://github.com/elliottt/hsopenid";
       description = "An implementation of the OpenID-2.0 spec.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "openpgp" = callPackage
    ({ mkDerivation, base, binary, bytestring, bzlib, HUnit, QuickCheck
     , quickcheck-instances, test-framework, test-framework-hunit
     , test-framework-quickcheck2, utf8-string, zlib
     }:
     mkDerivation {
       pname = "openpgp";
       version = "0.6.1";
       sha256 = "3a1915d308bf69819a6db23d6cec29bac05efe9a9dbe69197a0bdbfe2da04d0f";
       libraryHaskellDepends = [
         base binary bytestring bzlib utf8-string zlib
       ];
       testHaskellDepends = [
         base binary bytestring bzlib HUnit QuickCheck quickcheck-instances
         test-framework test-framework-hunit test-framework-quickcheck2
         utf8-string zlib
       ];
       homepage = "http://github.com/singpolyma/OpenPGP-Haskell";
       description = "Implementation of the OpenPGP message format";
       license = "unknown";
     }) {};

  "openpgp-Crypto" = callPackage
    ({ mkDerivation, base, binary, bytestring, Crypto, HUnit, openpgp
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, utf8-string
     }:
     mkDerivation {
       pname = "openpgp-Crypto";
       version = "0.5";
       sha256 = "f980dff35b9adaed3022d883f975d16836d6a51ae4f97ca7d047a2339efb4d3f";
       libraryHaskellDepends = [
         base binary bytestring Crypto openpgp utf8-string
       ];
       testHaskellDepends = [
         base binary bytestring Crypto HUnit openpgp QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
         utf8-string
       ];
       jailbreak = true;
       homepage = "http://github.com/singpolyma/OpenPGP-Crypto";
       description = "Implementation of cryptography for use with OpenPGP using the Crypto library";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "openpgp-asciiarmor" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, bytestring
     , cereal, HUnit, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "openpgp-asciiarmor";
       version = "0.1";
       sha256 = "5cd45aad8fb9e0d07ed27da1801937b4d8598dac1c55bcfbfe11d9608f053bf7";
       libraryHaskellDepends = [
         attoparsec base base64-bytestring bytestring cereal
       ];
       testHaskellDepends = [
         attoparsec base base64-bytestring bytestring cereal HUnit
         test-framework test-framework-hunit
       ];
       homepage = "http://floss.scru.org/openpgp-asciiarmor";
       description = "OpenPGP (RFC4880) ASCII Armor codec";
       license = "unknown";
     }) {};

  "openpgp-crypto-api" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, crypto-api
     , cryptocipher, cryptohash, HUnit, openpgp, QuickCheck
     , quickcheck-instances, tagged, test-framework
     , test-framework-hunit, test-framework-quickcheck2, transformers
     , utf8-string
     }:
     mkDerivation {
       pname = "openpgp-crypto-api";
       version = "0.6.3";
       sha256 = "554694dd432a4a57fc29d47a5d85a463b202a8506c70dec131c41ef76559f9a1";
       libraryHaskellDepends = [
         base binary bytestring cereal crypto-api cryptocipher cryptohash
         openpgp tagged transformers
       ];
       testHaskellDepends = [
         base binary bytestring cereal crypto-api cryptocipher cryptohash
         HUnit openpgp QuickCheck quickcheck-instances tagged test-framework
         test-framework-hunit test-framework-quickcheck2 transformers
         utf8-string
       ];
       jailbreak = true;
       homepage = "http://github.com/singpolyma/OpenPGP-CryptoAPI";
       description = "Implement cryptography for OpenPGP using crypto-api compatible libraries";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "opensoundcontrol-ht" = callPackage
    ({ mkDerivation, base, binary, bytestring, hosc, process, random
     , transformers, utility-ht
     }:
     mkDerivation {
       pname = "opensoundcontrol-ht";
       version = "0.3";
       sha256 = "ea4fef00ad8762f438d0441148c102fe71624e28433813a9002ac18955dc8b94";
       libraryHaskellDepends = [
         base binary bytestring hosc process random transformers utility-ht
       ];
       homepage = "http://www.haskell.org/haskellwiki/SuperCollider";
       description = "Haskell OpenSoundControl utilities";
       license = "GPL";
     }) {};

  "openssh-github-keys" = callPackage
    ({ mkDerivation, base, directory, dotenv, filepath, hspec
     , keyword-args, octohat, optparse-applicative, parsec, text, unix
     }:
     mkDerivation {
       pname = "openssh-github-keys";
       version = "0.1.1.0";
       sha256 = "ca8cdaa6c8379e4840087b60d599676156cd9ae0d08b84dff3715c82f872fb28";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base octohat text ];
       executableHaskellDepends = [
         base directory dotenv filepath keyword-args octohat
         optparse-applicative parsec text unix
       ];
       testHaskellDepends = [
         base hspec keyword-args octohat optparse-applicative parsec text
       ];
       homepage = "https://github.com/stackbuilders/openssh-github-keys";
       description = "Fetch OpenSSH keys from a GitHub team";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "openssl-createkey" = callPackage
    ({ mkDerivation, base, directory, HsOpenSSL, time, unix }:
     mkDerivation {
       pname = "openssl-createkey";
       version = "0.1";
       sha256 = "e5c5d0ef9aee675b75eebaf8f985fdd17126fc5eff7faba1e78dfc1c27e5a9dc";
       libraryHaskellDepends = [ base directory HsOpenSSL time unix ];
       description = "Create OpenSSL keypairs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "openssl-streams" = callPackage
    ({ mkDerivation, base, bytestring, HsOpenSSL, HUnit, io-streams
     , network, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "openssl-streams";
       version = "1.2.1.0";
       sha256 = "a9965909dc67261f9328ac4bb364181a37ba53fceac2c5de3629f0dd796219cb";
       libraryHaskellDepends = [
         base bytestring HsOpenSSL io-streams network
       ];
       testHaskellDepends = [
         base bytestring HsOpenSSL HUnit io-streams network test-framework
         test-framework-hunit
       ];
       description = "OpenSSL network support for io-streams";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "opentheory" = callPackage
    ({ mkDerivation, base, opentheory-primitive, QuickCheck }:
     mkDerivation {
       pname = "opentheory";
       version = "1.200";
       sha256 = "d0c50336be6c16fcb9ef8f7adad26572c25f28034bb90e900f97b0c1f5cdbd39";
       libraryHaskellDepends = [ base opentheory-primitive QuickCheck ];
       testHaskellDepends = [ base opentheory-primitive QuickCheck ];
       homepage = "http://opentheory.gilith.com/?pkg=base";
       description = "The standard theory library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "opentheory-bits" = callPackage
    ({ mkDerivation, base, opentheory, opentheory-primitive
     , opentheory-probability, QuickCheck
     }:
     mkDerivation {
       pname = "opentheory-bits";
       version = "1.69";
       sha256 = "c9ab3cbbd5b63db86c28d70ca1e61c4cef7af77a0032d5ebc694dbb6e71b897a";
       libraryHaskellDepends = [
         base opentheory opentheory-primitive opentheory-probability
         QuickCheck
       ];
       homepage = "http://opentheory.gilith.com/?pkg=natural-bits";
       description = "Natural number to bit-list conversions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "opentheory-byte" = callPackage
    ({ mkDerivation, base, opentheory, opentheory-bits
     , opentheory-primitive, opentheory-probability, QuickCheck
     }:
     mkDerivation {
       pname = "opentheory-byte";
       version = "1.128";
       sha256 = "0c0c0df4532acbb335bf211b439327a119eeaa93130836e92ea11c07add3e376";
       libraryHaskellDepends = [
         base opentheory opentheory-bits opentheory-primitive
         opentheory-probability QuickCheck
       ];
       homepage = "http://opentheory.gilith.com/?pkg=byte";
       description = "Bytes";
       license = stdenv.lib.licenses.mit;
     }) {};

  "opentheory-char" = callPackage
    ({ mkDerivation, base, opentheory, opentheory-parser
     , opentheory-primitive, QuickCheck, random
     }:
     mkDerivation {
       pname = "opentheory-char";
       version = "1.41";
       sha256 = "31c9a4667bd0dcf358b0e0d5a9532d31d5277af5251e5588951e4df6d6780d7c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base opentheory opentheory-parser opentheory-primitive QuickCheck
         random
       ];
       executableHaskellDepends = [
         base opentheory opentheory-parser opentheory-primitive QuickCheck
         random
       ];
       jailbreak = true;
       description = "Unicode characters";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "opentheory-divides" = callPackage
    ({ mkDerivation, base, opentheory, opentheory-primitive, QuickCheck
     }:
     mkDerivation {
       pname = "opentheory-divides";
       version = "1.66";
       sha256 = "dcbeeeb31870d5860eeb604b18cf616930566718459b9b707d7faa6a4c192e9b";
       libraryHaskellDepends = [
         base opentheory opentheory-primitive QuickCheck
       ];
       testHaskellDepends = [
         base opentheory opentheory-primitive QuickCheck
       ];
       homepage = "http://opentheory.gilith.com/?pkg=natural-divides";
       description = "The divides relation on natural numbers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "opentheory-fibonacci" = callPackage
    ({ mkDerivation, base, opentheory, opentheory-primitive
     , opentheory-stream, QuickCheck
     }:
     mkDerivation {
       pname = "opentheory-fibonacci";
       version = "1.72";
       sha256 = "8af8af9bb12af856142f89839dcb45d9be705f38b80bdaaa5fdb8c252fcb82bb";
       libraryHaskellDepends = [
         base opentheory opentheory-primitive opentheory-stream QuickCheck
       ];
       testHaskellDepends = [
         base opentheory opentheory-primitive opentheory-stream QuickCheck
       ];
       description = "Fibonacci numbers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "opentheory-parser" = callPackage
    ({ mkDerivation, base, opentheory, opentheory-primitive, QuickCheck
     }:
     mkDerivation {
       pname = "opentheory-parser";
       version = "1.160";
       sha256 = "3215209e7f01b7b548e46546591e51b84ff39c333ed45dc552623db2d933d3a3";
       libraryHaskellDepends = [
         base opentheory opentheory-primitive QuickCheck
       ];
       testHaskellDepends = [
         base opentheory opentheory-primitive QuickCheck
       ];
       homepage = "http://opentheory.gilith.com/?pkg=parser";
       description = "Stream parsers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "opentheory-prime" = callPackage
    ({ mkDerivation, base, opentheory, opentheory-divides
     , opentheory-primitive, opentheory-stream, QuickCheck
     }:
     mkDerivation {
       pname = "opentheory-prime";
       version = "1.85";
       sha256 = "77721fc4cf5791bacb59c576e8a1525c2e1767d350cd95b39cd77f353968e54c";
       libraryHaskellDepends = [
         base opentheory opentheory-divides opentheory-primitive
         opentheory-stream QuickCheck
       ];
       testHaskellDepends = [
         base opentheory opentheory-divides opentheory-primitive
         opentheory-stream QuickCheck
       ];
       homepage = "http://opentheory.gilith.com/?pkg=natural-prime";
       description = "Prime natural numbers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "opentheory-primitive" = callPackage
    ({ mkDerivation, base, QuickCheck, random }:
     mkDerivation {
       pname = "opentheory-primitive";
       version = "1.8";
       sha256 = "e8924d11e642820fc4ffbf0cc0a72577b0a5719845bd30ec522ff8d87c78ee8a";
       libraryHaskellDepends = [ base QuickCheck random ];
       testHaskellDepends = [ base QuickCheck random ];
       homepage = "http://www.gilith.com/research/opentheory/";
       description = "Haskell primitives used by OpenTheory packages";
       license = stdenv.lib.licenses.mit;
     }) {};

  "opentheory-probability" = callPackage
    ({ mkDerivation, base, opentheory, opentheory-primitive, QuickCheck
     }:
     mkDerivation {
       pname = "opentheory-probability";
       version = "1.52";
       sha256 = "c23cf05b961bda0c50ebb4ea82e90172fbbe5f6c1528ef1ef858a690e419bd2e";
       libraryHaskellDepends = [
         base opentheory opentheory-primitive QuickCheck
       ];
       homepage = "http://opentheory.gilith.com/?pkg=probability";
       description = "Probability";
       license = stdenv.lib.licenses.mit;
     }) {};

  "opentheory-stream" = callPackage
    ({ mkDerivation, base, opentheory, opentheory-primitive, QuickCheck
     }:
     mkDerivation {
       pname = "opentheory-stream";
       version = "1.49";
       sha256 = "fb77d60d61bba1fd868a284a2bf5e5eff4b69b2ec48cbb9a76046e0f20627483";
       libraryHaskellDepends = [
         base opentheory opentheory-primitive QuickCheck
       ];
       homepage = "http://opentheory.gilith.com/?pkg=stream";
       description = "Infinite stream types";
       license = stdenv.lib.licenses.mit;
     }) {};

  "opentheory-unicode" = callPackage
    ({ mkDerivation, base, opentheory, opentheory-bits, opentheory-byte
     , opentheory-parser, opentheory-primitive, opentheory-probability
     , QuickCheck
     }:
     mkDerivation {
       pname = "opentheory-unicode";
       version = "1.142";
       sha256 = "fad5850a6a853de5b686101f374f297d6a00089fc7d051154a2da3091a5f5451";
       libraryHaskellDepends = [
         base opentheory opentheory-bits opentheory-byte opentheory-parser
         opentheory-primitive opentheory-probability QuickCheck
       ];
       testHaskellDepends = [
         base opentheory opentheory-bits opentheory-byte opentheory-parser
         opentheory-primitive opentheory-probability QuickCheck
       ];
       homepage = "http://opentheory.gilith.com/?pkg=char";
       description = "Unicode characters";
       license = stdenv.lib.licenses.mit;
     }) {};

  "operational" = callPackage
    ({ mkDerivation, base, mtl, random }:
     mkDerivation {
       pname = "operational";
       version = "0.2.3.2";
       sha256 = "ed02d521b86b6791104a489b6225baf92f8a1641e6fa8ac1022990ef239443aa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl ];
       executableHaskellDepends = [ random ];
       homepage = "http://haskell.org/haskellwiki/Operational";
       description = "Implementation of difficult monads made easy with operational semantics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "operational-alacarte" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "operational-alacarte";
       version = "0.1.1";
       sha256 = "123eca69007a2be60987e323facbaa8639b34073507584b753665619012e24ef";
       libraryHaskellDepends = [ base mtl ];
       testHaskellDepends = [ base ];
       homepage = "https://github.com/emilaxelsson/operational-alacarte";
       description = "A version of Operational suitable for extensible EDSLs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "operational-class" = callPackage
    ({ mkDerivation, base, operational, transformers }:
     mkDerivation {
       pname = "operational-class";
       version = "0.3.0.0";
       sha256 = "8b28b9cb86a2dd520196f6a563538dc2c9e8730f0a0f5e5f3bca19559631e70b";
       libraryHaskellDepends = [ base operational transformers ];
       homepage = "https://github.com/srijs/haskell-operational-class";
       description = "MonadProgram typeclass for the operational package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "operational-extra" = callPackage
    ({ mkDerivation, base, operational, time }:
     mkDerivation {
       pname = "operational-extra";
       version = "0.1.0.0";
       sha256 = "d0ab3fa58e55ff94f2e12d563410dfcc11c6ce6c1ab863602afd6b5522549c9b";
       libraryHaskellDepends = [ base operational time ];
       homepage = "http://github.com/andrewthad/vinyl-operational#readme";
       description = "Initial project template from stack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "opml" = callPackage
    ({ mkDerivation, base, directory, xml }:
     mkDerivation {
       pname = "opml";
       version = "0.4";
       sha256 = "3d091a71f0b86f47d987e69c450c3de6313a6b2f0ab59af73d1a0bc72635d9ae";
       libraryHaskellDepends = [ base directory xml ];
       description = "Representing and handling OPML subscription information";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "opml-conduit_0_4_0_0" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, conduit
     , conduit-combinators, conduit-parse, containers, data-default
     , exceptions, foldl, hlint, lens-simple, mono-traversable
     , monoid-subclasses, mtl, parsers, QuickCheck, quickcheck-instances
     , resourcet, semigroups, tasty, tasty-hunit, tasty-quickcheck, text
     , time, timerep, uri-bytestring, xml-conduit, xml-conduit-parse
     , xml-types
     }:
     mkDerivation {
       pname = "opml-conduit";
       version = "0.4.0.0";
       sha256 = "7a684983ad76067cce5d6b9358cfb581a2222a6495928eca9d61aa04bd0e9e1d";
       libraryHaskellDepends = [
         base case-insensitive conduit conduit-parse containers exceptions
         foldl lens-simple mono-traversable monoid-subclasses parsers
         semigroups text time timerep uri-bytestring xml-conduit
         xml-conduit-parse xml-types
       ];
       testHaskellDepends = [
         base bytestring conduit conduit-combinators conduit-parse
         containers data-default exceptions hlint lens-simple
         mono-traversable mtl parsers QuickCheck quickcheck-instances
         resourcet semigroups tasty tasty-hunit tasty-quickcheck text time
         uri-bytestring xml-conduit-parse
       ];
       homepage = "https://github.com/k0ral/opml-conduit";
       description = "Streaming parser/renderer for the OPML 2.0 format.";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "opml-conduit" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, conduit
     , conduit-combinators, conduit-parse, containers, data-default
     , exceptions, foldl, hlint, lens-simple, mono-traversable
     , monoid-subclasses, mtl, parsers, QuickCheck, quickcheck-instances
     , resourcet, semigroups, tasty, tasty-hunit, tasty-quickcheck, text
     , time, timerep, uri-bytestring, xml-conduit, xml-conduit-parse
     , xml-types
     }:
     mkDerivation {
       pname = "opml-conduit";
       version = "0.4.0.1";
       sha256 = "6b1ed378cdf1d8b6cc1aeb8038eac5ed770e572946bf8ff98b474fc315d2a93c";
       libraryHaskellDepends = [
         base case-insensitive conduit conduit-parse containers exceptions
         foldl lens-simple mono-traversable monoid-subclasses parsers
         semigroups text time timerep uri-bytestring xml-conduit
         xml-conduit-parse xml-types
       ];
       testHaskellDepends = [
         base bytestring conduit conduit-combinators conduit-parse
         containers data-default exceptions hlint lens-simple
         mono-traversable mtl parsers QuickCheck quickcheck-instances
         resourcet semigroups tasty tasty-hunit tasty-quickcheck text time
         uri-bytestring xml-conduit-parse
       ];
       homepage = "https://github.com/k0ral/opml-conduit";
       description = "Streaming parser/renderer for the OPML 2.0 format.";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "opn" = callPackage
    ({ mkDerivation, base, directory, filepath, ini, network-uri
     , optparse-applicative, process, text, unordered-containers
     }:
     mkDerivation {
       pname = "opn";
       version = "0.1.2";
       sha256 = "90913a9e9721b613221b883eac57701051ddc79a8d23fd01802eb575d99ea374";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath ini network-uri optparse-applicative
         process text unordered-containers
       ];
       homepage = "http://github.com/akc/opn";
       description = "Open files or URLs using associated programs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "optimal-blocks" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-arbitrary, cryptohash
     , deepseq, hex, QuickCheck, vector
     }:
     mkDerivation {
       pname = "optimal-blocks";
       version = "0.1.0";
       sha256 = "2b59a43b888c653c44c9430a0ff93e4d76b5fe1a574bbc6289c73b2f04d4c3a0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring deepseq vector ];
       executableHaskellDepends = [
         base bytestring cryptohash deepseq hex vector
       ];
       testHaskellDepends = [
         base bytestring bytestring-arbitrary deepseq QuickCheck vector
       ];
       jailbreak = true;
       homepage = "https://github.com/tsuraan/optimal-blocks";
       description = "Optimal Block boundary determination for rsync-like behaviours";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "optimization" = callPackage
    ({ mkDerivation, ad, base, distributive, linear, semigroupoids
     , vector
     }:
     mkDerivation {
       pname = "optimization";
       version = "0.1.7";
       sha256 = "166af247883dab29171440bb97e3fd836fb66a5f4d0133fee0c96e6c120489f8";
       libraryHaskellDepends = [
         ad base distributive linear semigroupoids vector
       ];
       jailbreak = true;
       homepage = "http://github.com/bgamari/optimization";
       description = "Numerical optimization";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "optimusprime" = callPackage
    ({ mkDerivation, base, cmdargs, containers, fgl, flite, graphviz
     , haskell98, mtl, parsec, uniplate, wl-pprint
     }:
     mkDerivation {
       pname = "optimusprime";
       version = "0.0.1.20091117";
       sha256 = "aeaebbf0f3162ac3bb6039c10415744e6ca7c52c363e79c7c41e23b077728218";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs containers fgl flite graphviz haskell98 mtl parsec
         uniplate wl-pprint
       ];
       jailbreak = true;
       homepage = "http://optimusprime.posterous.com/";
       description = "A supercompiler for f-lite";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "option" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "option";
       version = "0.1.0.1";
       sha256 = "52cddd415c4baeb2148fadcbca5cfd9105762df58e5b5660a5cd55cd385802d4";
       libraryHaskellDepends = [ base ];
       description = "A strict version of Maybe";
       license = stdenv.lib.licenses.mit;
     }) {};

  "optional" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, QuickCheck }:
     mkDerivation {
       pname = "optional";
       version = "0.0.1";
       sha256 = "0f498781f6ff1e899c333a8674fcedc4ce4867bd393ab5876bd695f702a236c4";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck
       ];
       homepage = "https://github.com/tonymorris/optional";
       description = "Using type-classes for optional function arguments";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "optional-args" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "optional-args";
       version = "1.0.0";
       sha256 = "1f94a16920e5250b7cbf1b24aeb82b23bf2a12a6250c0e3753e9bee3cb658948";
       libraryHaskellDepends = [ base ];
       description = "Optional function arguments";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "options_1_2" = callPackage
    ({ mkDerivation, base, chell, chell-quickcheck, containers
     , monads-tf, transformers
     }:
     mkDerivation {
       pname = "options";
       version = "1.2";
       sha256 = "7d9353b93ff22a9a20c088a6895d08b02266e1a61e5c7192711c14881a9f1993";
       revision = "1";
       editedCabalFile = "30e97d6dc89626a56478926fc41b7e4f8b7908c721255e8cc331d22ecaadbf3b";
       libraryHaskellDepends = [ base containers monads-tf transformers ];
       testHaskellDepends = [
         base chell chell-quickcheck containers monads-tf transformers
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://john-millikin.com/software/haskell-options/";
       description = "A powerful and easy-to-use command-line option parser";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "options_1_2_1" = callPackage
    ({ mkDerivation, base, chell, chell-quickcheck, containers
     , monads-tf, transformers
     }:
     mkDerivation {
       pname = "options";
       version = "1.2.1";
       sha256 = "75f84bc3d369f534daef5b9f7db9f581f38974d7ae7bd389b754d30f59bc32f9";
       revision = "1";
       editedCabalFile = "e3a956d7492d4c4c114e63d69c10641f68190041cee3301fffacf422d35ca495";
       libraryHaskellDepends = [ base containers monads-tf transformers ];
       testHaskellDepends = [
         base chell chell-quickcheck containers monads-tf transformers
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://john-millikin.com/software/haskell-options/";
       description = "A powerful and easy-to-use command-line option parser";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "options" = callPackage
    ({ mkDerivation, base, chell, chell-quickcheck, containers
     , monads-tf, transformers
     }:
     mkDerivation {
       pname = "options";
       version = "1.2.1.1";
       sha256 = "283eea9ae2c539830c6c65f5c03fb00626cfd1274da0526c285c146fc3065a62";
       libraryHaskellDepends = [ base containers monads-tf transformers ];
       testHaskellDepends = [
         base chell chell-quickcheck containers monads-tf transformers
       ];
       doCheck = false;
       homepage = "https://john-millikin.com/software/haskell-options/";
       description = "A powerful and easy-to-use command-line option parser";
       license = stdenv.lib.licenses.mit;
     }) {};

  "options-time" = callPackage
    ({ mkDerivation, base, chell, options, time }:
     mkDerivation {
       pname = "options-time";
       version = "1.0.1";
       sha256 = "15aec00c77000d8cf1174127198e16ebf50386024f9b39040fc7675ba9e25567";
       libraryHaskellDepends = [ base options time ];
       testHaskellDepends = [ base chell options time ];
       homepage = "https://john-millikin.com/software/haskell-options/";
       description = "Command-line option types for dates and times";
       license = stdenv.lib.licenses.mit;
     }) {};

  "optparse-applicative_0_11_0_1" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, process, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "optparse-applicative";
       version = "0.11.0.1";
       sha256 = "c919c7cc44dd325b49026661963a4d5dd45fe3a0a9d450ce86af019ea454bf49";
       libraryHaskellDepends = [
         ansi-wl-pprint base process transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "https://github.com/pcapriotti/optparse-applicative";
       description = "Utilities and combinators for parsing command line options";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "optparse-applicative_0_11_0_2" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, process, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "optparse-applicative";
       version = "0.11.0.2";
       sha256 = "31c6923c01cfd6dce0cf83f3430c17d164169f0db6ff2de9b3b294926214255a";
       libraryHaskellDepends = [
         ansi-wl-pprint base process transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "https://github.com/pcapriotti/optparse-applicative";
       description = "Utilities and combinators for parsing command line options";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "optparse-applicative_0_12_0_0" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, process, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "optparse-applicative";
       version = "0.12.0.0";
       sha256 = "49d5bf745a10f30cc469b95e1cf1c935df3a70203f7c61718f9398c6fdba2123";
       libraryHaskellDepends = [
         ansi-wl-pprint base process transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "https://github.com/pcapriotti/optparse-applicative";
       description = "Utilities and combinators for parsing command line options";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "optparse-applicative" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, process, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "optparse-applicative";
       version = "0.12.1.0";
       sha256 = "18b46d6d2c17e941bb02f84e980390f056795dce73ece946d71d3d4d002313d5";
       libraryHaskellDepends = [
         ansi-wl-pprint base process transformers transformers-compat
       ];
       homepage = "https://github.com/pcapriotti/optparse-applicative";
       description = "Utilities and combinators for parsing command line options";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "optparse-declarative" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "optparse-declarative";
       version = "0.3.0";
       sha256 = "48ae1a50b2d6b8b208d5fa86fe97b673144916f40cff1eae5b928c29cd037eab";
       libraryHaskellDepends = [ base mtl ];
       homepage = "https://github.com/tanakh/optparse-declarative";
       description = "Declarative command line option parser";
       license = stdenv.lib.licenses.mit;
     }) {};

  "optparse-simple_0_0_2" = callPackage
    ({ mkDerivation, base, either, gitrev, optparse-applicative
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "optparse-simple";
       version = "0.0.2";
       sha256 = "27a618c4fe53e30a8a74554559dd28be6cb69f53dd5a4e7045a0ba095742f81f";
       libraryHaskellDepends = [
         base either gitrev optparse-applicative template-haskell
         transformers
       ];
       description = "Simple interface to optparse-applicative";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "optparse-simple" = callPackage
    ({ mkDerivation, base, either, gitrev, optparse-applicative
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "optparse-simple";
       version = "0.0.3";
       sha256 = "4547f0a6c1bd959b1d9c3c2a5fabee39ac9a19dffabbb2d75461a2d461df8c7e";
       libraryHaskellDepends = [
         base either gitrev optparse-applicative template-haskell
         transformers
       ];
       description = "Simple interface to optparse-applicative";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "orc" = callPackage
    ({ mkDerivation, base, deepseq, monadIO, mtl, process, random, stm
     }:
     mkDerivation {
       pname = "orc";
       version = "1.2.1.4";
       sha256 = "1d64fbd34d73865a8baa08232c635e3be56e741bdd1d4cc54446f12ab629847e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base deepseq monadIO mtl process stm ];
       executableHaskellDepends = [
         base deepseq monadIO mtl process random stm
       ];
       description = "Orchestration-style co-ordination EDSL";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "orchestrate" = callPackage
    ({ mkDerivation, aeson, base, bytestring, case-insensitive
     , data-default, either, errors, hspec, http-client, http-types
     , lens, mtl, QuickCheck, smallcheck, text, transformers
     , unordered-containers, wreq
     }:
     mkDerivation {
       pname = "orchestrate";
       version = "0.2.0.3";
       sha256 = "ccc60ad893d0590a92495a3982a0a753cd2628dca9307ffe2e5077a4740eb0d7";
       libraryHaskellDepends = [
         aeson base bytestring case-insensitive data-default either errors
         http-client http-types lens mtl text transformers
         unordered-containers wreq
       ];
       testHaskellDepends = [
         aeson base bytestring errors hspec lens QuickCheck smallcheck text
         wreq
       ];
       jailbreak = true;
       description = "An API client for http://orchestrate.io/.";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "orchid" = callPackage
    ({ mkDerivation, base, bytestring, containers, encoding
     , extensible-exceptions, fclabels, filestore, hscolour, mtl
     , nano-md5, parsec, process, QuickCheck, salvia, salvia-extras, stm
     , time, unix, xml
     }:
     mkDerivation {
       pname = "orchid";
       version = "0.0.8";
       sha256 = "7536f260eefee340cf37e4341581647c1b257ae7493362638c1787ad21746cb4";
       libraryHaskellDepends = [
         base bytestring containers encoding extensible-exceptions fclabels
         filestore hscolour mtl nano-md5 parsec process QuickCheck salvia
         salvia-extras stm time unix xml
       ];
       jailbreak = true;
       description = "Haskell Wiki Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "orchid-demo" = callPackage
    ({ mkDerivation, base, extensible-exceptions, mtl, network, orchid
     , Pipe, salvia, salvia-extras, stm
     }:
     mkDerivation {
       pname = "orchid-demo";
       version = "0.0.6";
       sha256 = "3f09f88e04c3d760526babef1e11a585c095a214f72dec032644a0eea6aad2bd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base extensible-exceptions mtl network orchid Pipe salvia
         salvia-extras stm
       ];
       jailbreak = true;
       description = "Haskell Wiki Demo";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ord-adhoc" = callPackage
    ({ mkDerivation, base, void }:
     mkDerivation {
       pname = "ord-adhoc";
       version = "0.0.0.1";
       sha256 = "c3889d5962b31c1e602f95177ba9e4657e95cc10621ae1631f2c06ceaf9b5c18";
       libraryHaskellDepends = [ base void ];
       homepage = "https://github.com/fumieval/ord-adhoc/";
       description = "Creating Ord instances instantly";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "order-maintenance" = callPackage
    ({ mkDerivation, base, Cabal, cabal-test-quickcheck, containers
     , QuickCheck, transformers
     }:
     mkDerivation {
       pname = "order-maintenance";
       version = "0.1.1.0";
       sha256 = "6dd7f457978619dbc4d5fd919a61e1108f56af4aa2e9b08032a338724e60c234";
       libraryHaskellDepends = [ base containers transformers ];
       testHaskellDepends = [
         base Cabal cabal-test-quickcheck containers QuickCheck transformers
       ];
       homepage = "http://darcs.wolfgang.jeltsch.info/haskell/order-maintenance";
       description = "Algorithms for the order maintenance problem with a safe interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "order-statistics" = callPackage
    ({ mkDerivation, base, containers, math-functions, statistics
     , vector, vector-space
     }:
     mkDerivation {
       pname = "order-statistics";
       version = "0.1.1";
       sha256 = "ea78e694a3bd5eb1f8946aa7e18c5afff9e8ef6593dd83c969f6d54c3058c9b5";
       libraryHaskellDepends = [
         base containers math-functions statistics vector vector-space
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/order-statistics/";
       description = "L-Estimators for robust statistics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ordered" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ordered";
       version = "0.1";
       sha256 = "c9e07a14324f32cb01847cde6406882bf5aa28935fb7c69a96f8f0f6df2c0f68";
       libraryHaskellDepends = [ base ];
       description = "A definition of Posets";
       license = "unknown";
     }) {};

  "orders" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "orders";
       version = "0.1.0.0";
       sha256 = "f9d34b503516bf1bb0119ff12be4e81d78d2bc3a66e2797ba070405d1e75c6e7";
       libraryHaskellDepends = [ base containers ];
       jailbreak = true;
       description = "basic orders";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ordrea" = callPackage
    ({ mkDerivation, base, containers, directory, process, split
     , transformers, vector
     }:
     mkDerivation {
       pname = "ordrea";
       version = "0.3.0.0";
       sha256 = "2120282fa0967af9ade101de8a392b3be95b0acdaa9fc6f50620e2d89271f618";
       libraryHaskellDepends = [ base containers transformers vector ];
       testHaskellDepends = [ base directory process split ];
       description = "Push-pull implementation of discrete-time FRP";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "organize-imports" = callPackage
    ({ mkDerivation, attoparsec, base, text }:
     mkDerivation {
       pname = "organize-imports";
       version = "0.3.0.0";
       sha256 = "5d15e24ffba4e607c453f261c28d619e283707e36ab546d1b45e5fd3cd34a511";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ attoparsec base text ];
       jailbreak = true;
       description = "Organize scala imports";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "orgmode" = callPackage
    ({ mkDerivation, base, containers, hspec, HStringTemplate, network
     , network-uri, parsec, QuickCheck, random, regex-posix, syb, text
     }:
     mkDerivation {
       pname = "orgmode";
       version = "0.1.0.1";
       sha256 = "06826255c8d7de812ccca4a6bfd612786c5566780d6e5a50cd058f69a5bfeafe";
       libraryHaskellDepends = [
         base containers HStringTemplate parsec regex-posix syb text
       ];
       testHaskellDepends = [
         base containers hspec HStringTemplate network network-uri parsec
         QuickCheck random regex-posix syb text
       ];
       description = "Org Mode library for haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "orgmode-parse" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , free, hashable, HUnit, old-locale, tasty, tasty-hunit, text
     , thyme, unordered-containers
     }:
     mkDerivation {
       pname = "orgmode-parse";
       version = "0.1.1.2";
       sha256 = "b10f3d1db39338cd763f2df71db969288898c1f9b5d9a356b15dded83c7b49fb";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers free hashable
         old-locale text thyme unordered-containers
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring containers hashable HUnit
         old-locale tasty tasty-hunit text thyme unordered-containers
       ];
       description = "A collection of Attoparsec combinators for parsing org-mode flavored documents";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "origami" = callPackage
    ({ mkDerivation, base, bifunctors, containers, HUnit, lens, mtl
     , pretty, template-haskell, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "origami";
       version = "0.0.6";
       sha256 = "34586cfdcc5a93283b79363aa1c6dac0bd775cd64095645cf5c8d2c711e50d0e";
       libraryHaskellDepends = [
         base bifunctors containers lens mtl pretty template-haskell
       ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       homepage = "http://github.com/nedervold/origami";
       description = "An un-SYB framework for transforming heterogenous data through folds";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "os-release" = callPackage
    ({ mkDerivation, base, containers, hlint, hspec, parsec, process
     , regex-compat, temporary, transformers
     }:
     mkDerivation {
       pname = "os-release";
       version = "0.2.2";
       sha256 = "a91357fec161695ca6868d27c150f2de05666a6a7708114b3e06ff100f4d2ca7";
       libraryHaskellDepends = [ base containers parsec transformers ];
       testHaskellDepends = [
         base containers hlint hspec parsec process regex-compat temporary
         transformers
       ];
       homepage = "https://github.com/yaccz/os-release";
       description = "/etc/os-release helpers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "osc" = callPackage
    ({ mkDerivation, attoparsec, base, binary, bytestring
     , data-binary-ieee754, network
     }:
     mkDerivation {
       pname = "osc";
       version = "1.0.0.2";
       sha256 = "0307fd84cf38dacb32baadc47b4bcef682216c9a7218ab73c1f5286b0d8fed38";
       libraryHaskellDepends = [
         attoparsec base binary bytestring data-binary-ieee754 network
       ];
       jailbreak = true;
       homepage = "https://github.com/peacememories/haskell-osc";
       description = "A library to handle messages in the OSC protocol";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "osdkeys" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , containers, libnotify, process, resourcet, time, transformers
     }:
     mkDerivation {
       pname = "osdkeys";
       version = "0.0";
       sha256 = "dec832706085c29e571c92fee286378a8a8eac232b467b72336b2ca64a16eca2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra containers libnotify
         resourcet time transformers
       ];
       executableHaskellDepends = [ base process ];
       description = "Show keys pressed with an on-screen display (Linux only)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "osm-download" = callPackage
    ({ mkDerivation, base, bytestring, conduit, containers
     , data-default, directory, gps, http-conduit, http-types
     , monad-control, monadIO, mtl, persistent, persistent-sqlite
     , persistent-template, pool-conduit, stm, stm-chans, text, time
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "osm-download";
       version = "0.4";
       sha256 = "63e995150da721181b5c96f255169da897097afd2bd6f952f98f791bc67ecf14";
       libraryHaskellDepends = [
         base bytestring conduit containers data-default directory gps
         http-conduit http-types monad-control monadIO mtl persistent
         persistent-sqlite persistent-template pool-conduit stm stm-chans
         text time transformers transformers-base
       ];
       jailbreak = true;
       description = "Download Open Street Map tiles";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "oso2pdf" = callPackage
    ({ mkDerivation, base, directory, filepath, lens, mtl
     , optparse-applicative, pandoc-types, process, temporary
     }:
     mkDerivation {
       pname = "oso2pdf";
       version = "0.1.0";
       sha256 = "40e80c3360b33241219494ea3d948fac3d07265a4f98541df64bef6e3e977dee";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath lens mtl optparse-applicative pandoc-types
         process temporary
       ];
       homepage = "https://github.com/spwhitton/oso2pdf";
       description = "Better conversion of Oxford Scholarship Online material to PDF";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "osx-ar" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers }:
     mkDerivation {
       pname = "osx-ar";
       version = "0.11";
       sha256 = "b6f5818893a629018a4f44350af2dc63738182ffc18b2b0cc0f1f9fd8eb254b4";
       libraryHaskellDepends = [ base binary bytestring containers ];
       description = "Parser for OS X static archive format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ot" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, binary, either, ghc
     , HUnit, mtl, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "ot";
       version = "0.2.1.0";
       sha256 = "56f1c888103c699b1025c1f23a7e3423a5b7cf93041af24d8fbd1eb9f08caa04";
       libraryHaskellDepends = [
         aeson attoparsec base binary either ghc mtl QuickCheck text
       ];
       testHaskellDepends = [
         aeson base binary HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 text
       ];
       homepage = "https://github.com/operational-transformation/ot.hs";
       description = "Real-time collaborative editing with Operational Transformation";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ottparse-pretty" = callPackage
    ({ mkDerivation, base, containers, parsec, split, uniplate }:
     mkDerivation {
       pname = "ottparse-pretty";
       version = "0.1.2.5";
       sha256 = "a4aeef67d3f01694114c9e28869f01df8c2931b2d3d21ac53fab7098974c94b7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers parsec split uniplate
       ];
       description = "Pretty-printer for Ott parse trees";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "overture" = callPackage
    ({ mkDerivation, base, doctest }:
     mkDerivation {
       pname = "overture";
       version = "0.0.5";
       sha256 = "fcdbff55a72636cfb27694ea6731cd6233fa57af937de08ee34afa80a78a6957";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base doctest ];
       jailbreak = true;
       description = "An alternative to some of the Prelude";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pack" = callPackage
    ({ mkDerivation, array, base, bytestring, lens, transformers
     , vector
     }:
     mkDerivation {
       pname = "pack";
       version = "0.4.0";
       sha256 = "497e70f72ff7ca62622d8e8185eb23d076d4a536c289d3132c799582660bfaa6";
       libraryHaskellDepends = [
         array base bytestring lens transformers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/capsjac/pack";
       description = "Bidirectional fast ByteString packer/unpacker";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "package-description-remote" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, lens, lens-aeson, wreq }:
     mkDerivation {
       pname = "package-description-remote";
       version = "0.2.0.0";
       sha256 = "4a936d2346265d4d960875b12272e9f15aedf6aa6aa5f177f7ce30c7e4f68744";
       libraryHaskellDepends = [
         base bytestring Cabal lens lens-aeson wreq
       ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/yamadapc/stack-run-auto/package-description-remote";
       description = "Fetches a 'GenericPackageDescription' from Hackage";
       license = stdenv.lib.licenses.mit;
     }) {};

  "package-o-tron" = callPackage
    ({ mkDerivation, base, Cabal, filemanip, filepath, groom, packdeps
     , process
     }:
     mkDerivation {
       pname = "package-o-tron";
       version = "0.1.0.0";
       sha256 = "c8b521e87ce4056e538eb8274f2ea89625d39065414bafbce71eaeafbd9e9f64";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base filemanip filepath groom process ];
       executableHaskellDepends = [
         base Cabal filemanip filepath groom packdeps process
       ];
       description = "Utilities for working with cabal packages and your package database";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "package-vt" = callPackage
    ({ mkDerivation, base, Cabal, Diff, filepath, haskell-src-exts }:
     mkDerivation {
       pname = "package-vt";
       version = "0.1.3.3";
       sha256 = "1552443b4e3e742ebc481c10d396691ec9de143cf1cb06a39c3335672c305b67";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal Diff filepath haskell-src-exts
       ];
       jailbreak = true;
       description = "Haskell Package Versioning Tool";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "packdeps" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, directory
     , filepath, split, tar, text, time
     }:
     mkDerivation {
       pname = "packdeps";
       version = "0.4.2.1";
       sha256 = "468fd8d83023865bb240c5b8fd5615501ffb2dcced9eaa2f15d22502d208c85c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring Cabal containers directory filepath split tar text
         time
       ];
       executableHaskellDepends = [ base Cabal ];
       homepage = "http://packdeps.haskellers.com/";
       description = "Check your cabal packages for lagging dependencies";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "packed-dawg" = callPackage
    ({ mkDerivation, base, binary, deepseq, HUnit, mtl, QuickCheck
     , tasty, tasty-hunit, tasty-quickcheck, unordered-containers
     , vector, vector-binary-instances
     }:
     mkDerivation {
       pname = "packed-dawg";
       version = "0.2.0.8";
       sha256 = "79046d9fac55aecfa2e181ed4ce00d8667e639bee9e3a821d2eca80a6239cafc";
       libraryHaskellDepends = [
         base binary deepseq mtl unordered-containers vector
         vector-binary-instances
       ];
       testHaskellDepends = [
         base binary deepseq HUnit mtl QuickCheck tasty tasty-hunit
         tasty-quickcheck unordered-containers vector
         vector-binary-instances
       ];
       description = "Generation and traversal of highly compressed directed acyclic word graphs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "packedstring" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "packedstring";
       version = "0.1.0.1";
       sha256 = "4862908be029df4f28e4c351252af6c375562a72349f7113acec5adafebfe8f4";
       revision = "1";
       editedCabalFile = "cbc334ff8e721fb18b6799b28dc3e77addc7234aa553725b0af68375f75e0bcf";
       libraryHaskellDepends = [ array base ];
       jailbreak = true;
       description = "(Deprecated) Packed Strings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "packer" = callPackage
    ({ mkDerivation, base, bytestring, ghc-prim, tasty, tasty-hunit
     , tasty-quickcheck, transformers
     }:
     mkDerivation {
       pname = "packer";
       version = "0.1.9";
       sha256 = "d2926f876da4ef8e4590bbc501caf83b0703018971ad5413e9d6647667d681e4";
       libraryHaskellDepends = [ base bytestring ghc-prim transformers ];
       testHaskellDepends = [
         base bytestring tasty tasty-hunit tasty-quickcheck
       ];
       homepage = "http://github.com/vincenthz/hs-packer";
       description = "Fast byte serializer and unserializer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "packman" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, Cabal, directory
     , ghc-prim, primitive, QuickCheck
     }:
     mkDerivation {
       pname = "packman";
       version = "0.3.0";
       sha256 = "98110c7c428f898f2f309202097c6ce00cf497701f6b6507abe2efe430562a1f";
       libraryHaskellDepends = [
         array base binary bytestring ghc-prim primitive
       ];
       testHaskellDepends = [
         array base binary bytestring Cabal directory ghc-prim primitive
         QuickCheck
       ];
       description = "Serialization library for GHC";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "packunused" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, haskell-src-exts
     , optparse-applicative, split
     }:
     mkDerivation {
       pname = "packunused";
       version = "0.1.1.4";
       sha256 = "c86ff007f3f1504c20f0fc86c8d277a1e424a16768debb19ffce767f30470baa";
       revision = "1";
       editedCabalFile = "5ddb122ff2a1ac4e79226f31b4d8f7dab67bb5501d0e715d84dbfe36c845b772";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal directory filepath haskell-src-exts optparse-applicative
         split
       ];
       jailbreak = true;
       homepage = "https://github.com/hvr/packunused";
       description = "Tool for detecting redundant Cabal package dependencies";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pacman-memcache" = callPackage
    ({ mkDerivation, base, deepseq, directory-tree }:
     mkDerivation {
       pname = "pacman-memcache";
       version = "0.1.0.3";
       sha256 = "db71983fe985b8483fad9c8135799bf5f432e35100cc8c8197130ddd6c745412";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base deepseq directory-tree ];
       jailbreak = true;
       homepage = "https://github.com/Tener/archlinux-utils";
       description = "Read whole Pacman database which pushes it into the memory cache";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "padKONTROL" = callPackage
    ({ mkDerivation, base, containers, hmidi, minioperational
     , transformers
     }:
     mkDerivation {
       pname = "padKONTROL";
       version = "0.1";
       sha256 = "cdb5f9ef3a18793495f40a1714496608d6e9a1eec18cc5c5c2ba0a5d890867eb";
       libraryHaskellDepends = [
         base containers hmidi minioperational transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/fumieval/padKONTROL";
       description = "Controlling padKONTROL native mode";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pagarme" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, lens, text
     , wreq
     }:
     mkDerivation {
       pname = "pagarme";
       version = "0.1.0.0";
       sha256 = "40daa3218986b66706070973a660f0c5bcc958fb7fa67e54f6fab5453a4370fe";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers lens text wreq
       ];
       executableHaskellDepends = [ base text wreq ];
       jailbreak = true;
       homepage = "https://github.com/diogob/pagarme_haskell";
       description = "Pagarme API wrapper";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pager" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , directory, process, resourcet, safe, terminfo, text, transformers
     , unix
     }:
     mkDerivation {
       pname = "pager";
       version = "0.1.1.0";
       sha256 = "3e1e4f2ca17be6dd68d2d480f29e7a770c0f7ca3109aa1980da677d96cd4eef3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra directory process resourcet
         safe terminfo text transformers unix
       ];
       executableHaskellDepends = [ base bytestring conduit-extra text ];
       homepage = "https://github.com/pharpend/pager";
       description = "Open up a pager, like 'less' or 'more'";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "pagerduty_0_0_3" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, bytestring
     , bytestring-conversion, conduit, data-default-class, exceptions
     , generics-sop, http-client, http-types, lens, lens-aeson, mmorph
     , monad-control, mtl, template-haskell, text, time
     , time-locale-compat, transformers, transformers-base
     , transformers-compat, unordered-containers
     }:
     mkDerivation {
       pname = "pagerduty";
       version = "0.0.3";
       sha256 = "415ec6653ecb10c85b2fcc166af6e6a4c972d126c766b059d90e9dbcc13c0fcb";
       revision = "2";
       editedCabalFile = "ac488ece984ce9ec3b817abe513b2f02ed2fcd1e3c06151578c7230173b52a3f";
       libraryHaskellDepends = [
         aeson base bifunctors bytestring bytestring-conversion conduit
         data-default-class exceptions generics-sop http-client http-types
         lens lens-aeson mmorph monad-control mtl template-haskell text time
         time-locale-compat transformers transformers-base
         transformers-compat unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/brendanhay/pagerduty";
       description = "Client library for PagerDuty Integration and REST APIs";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pagerduty_0_0_3_1" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, bytestring
     , bytestring-conversion, conduit, data-default-class, exceptions
     , generics-sop, http-client, http-types, lens, lens-aeson, mmorph
     , monad-control, mtl, template-haskell, text, time
     , time-locale-compat, transformers, transformers-base
     , transformers-compat, unordered-containers
     }:
     mkDerivation {
       pname = "pagerduty";
       version = "0.0.3.1";
       sha256 = "59d868670bba6b8bb08e2fade0b0df3717910e364fb48a71b0a20f4e7451c8d0";
       revision = "3";
       editedCabalFile = "af187adbe270ca0153f073116fa7f4214d473358585d6903fb0a4cefcef7c172";
       libraryHaskellDepends = [
         aeson base bifunctors bytestring bytestring-conversion conduit
         data-default-class exceptions generics-sop http-client http-types
         lens lens-aeson mmorph monad-control mtl template-haskell text time
         time-locale-compat transformers transformers-base
         transformers-compat unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/brendanhay/pagerduty";
       description = "Client library for PagerDuty Integration and REST APIs";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pagerduty_0_0_3_2" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, bytestring
     , bytestring-conversion, conduit, data-default-class, exceptions
     , generics-sop, http-client, http-types, lens, lens-aeson, mmorph
     , monad-control, mtl, template-haskell, text, time
     , time-locale-compat, transformers, transformers-base
     , transformers-compat, unordered-containers
     }:
     mkDerivation {
       pname = "pagerduty";
       version = "0.0.3.2";
       sha256 = "9aafe3a9b528623598a540cfaba2f38f8364761bda8a1c952d88ba8b6b2fb631";
       revision = "4";
       editedCabalFile = "0a211f47b152a8c848cdcfb29f5d90c8bbf2fe2cfe28b0dc65d53717552bba45";
       libraryHaskellDepends = [
         aeson base bifunctors bytestring bytestring-conversion conduit
         data-default-class exceptions generics-sop http-client http-types
         lens lens-aeson mmorph monad-control mtl template-haskell text time
         time-locale-compat transformers transformers-base
         transformers-compat unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/brendanhay/pagerduty";
       description = "Client library for PagerDuty Integration and REST APIs";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pagerduty_0_0_3_3" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, bytestring
     , bytestring-conversion, conduit, data-default-class, exceptions
     , generics-sop, http-client, http-types, lens, lens-aeson, mmorph
     , monad-control, mtl, template-haskell, text, time
     , time-locale-compat, transformers, transformers-base
     , transformers-compat, unordered-containers
     }:
     mkDerivation {
       pname = "pagerduty";
       version = "0.0.3.3";
       sha256 = "f55d80029003f6748dd00e3dc6b3b38dc99c3d9d4c62f617e3ee93cd25113477";
       revision = "1";
       editedCabalFile = "a73a38fe2e6123a228be6e506783a057ef6a734efe7676184b22becd2d5da938";
       libraryHaskellDepends = [
         aeson base bifunctors bytestring bytestring-conversion conduit
         data-default-class exceptions generics-sop http-client http-types
         lens lens-aeson mmorph monad-control mtl template-haskell text time
         time-locale-compat transformers transformers-base
         transformers-compat unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/brendanhay/pagerduty";
       description = "Client library for PagerDuty Integration and REST APIs";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pagerduty_0_0_4" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, bytestring
     , bytestring-conversion, conduit, data-default-class, exceptions
     , generics-sop, http-client, http-types, lens, lens-aeson, mmorph
     , monad-control, mtl, template-haskell, text, time
     , time-locale-compat, transformers, transformers-base
     , transformers-compat, unordered-containers
     }:
     mkDerivation {
       pname = "pagerduty";
       version = "0.0.4";
       sha256 = "41549771fe6689ffb97806e615e86a3c7384177cbcc1c77873167a3e9d05be9c";
       libraryHaskellDepends = [
         aeson base bifunctors bytestring bytestring-conversion conduit
         data-default-class exceptions generics-sop http-client http-types
         lens lens-aeson mmorph monad-control mtl template-haskell text time
         time-locale-compat transformers transformers-base
         transformers-compat unordered-containers
       ];
       homepage = "http://github.com/brendanhay/pagerduty";
       description = "Client library for PagerDuty Integration and REST APIs";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pagerduty" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, bytestring
     , bytestring-conversion, conduit, data-default-class, exceptions
     , generics-sop, http-client, http-types, lens, lens-aeson, mmorph
     , monad-control, mtl, template-haskell, text, time
     , time-locale-compat, transformers, transformers-base
     , transformers-compat, unordered-containers
     }:
     mkDerivation {
       pname = "pagerduty";
       version = "0.0.6";
       sha256 = "4e00ab7235af51640a1599e523fe388b98d9dffa04130d7d6f7fedfe05d342ef";
       libraryHaskellDepends = [
         aeson base bifunctors bytestring bytestring-conversion conduit
         data-default-class exceptions generics-sop http-client http-types
         lens lens-aeson mmorph monad-control mtl template-haskell text time
         time-locale-compat transformers transformers-base
         transformers-compat unordered-containers
       ];
       homepage = "http://github.com/brendanhay/pagerduty";
       description = "Client library for PagerDuty Integration and REST APIs";
       license = "unknown";
     }) {};

  "pagure-hook-receiver" = callPackage
    ({ mkDerivation, base, containers, scotty, shelly, text
     , transformers, unix
     }:
     mkDerivation {
       pname = "pagure-hook-receiver";
       version = "0.1.0.0";
       sha256 = "944d3a664f57700dc82ef64ee60a16683373639c18bbc0cc1e0491a6589fd662";
       libraryHaskellDepends = [
         base containers scotty shelly text transformers unix
       ];
       homepage = "https://pagure.io/pagure-hook-receiver";
       description = "Receive hooks from pagure and do things with them";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "palette_0_1_0_1" = callPackage
    ({ mkDerivation, array, base, colour, containers }:
     mkDerivation {
       pname = "palette";
       version = "0.1.0.1";
       sha256 = "0aaaf83069f19d2a27b79843aefaaefa9686311c37a56152cd98d68c075ac500";
       libraryHaskellDepends = [ array base colour containers ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/diagrams";
       description = "Utilities for choosing and creating color schemes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "palette_0_1_0_2" = callPackage
    ({ mkDerivation, array, base, colour, containers }:
     mkDerivation {
       pname = "palette";
       version = "0.1.0.2";
       sha256 = "3967a3e7de6aaef26716c1c8845ca6b5711625a901ce739a2e5da1f22bb1d0ea";
       libraryHaskellDepends = [ array base colour containers ];
       homepage = "http://projects.haskell.org/diagrams";
       description = "Utilities for choosing and creating color schemes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "palette" = callPackage
    ({ mkDerivation, array, base, colour, containers }:
     mkDerivation {
       pname = "palette";
       version = "0.1.0.3";
       sha256 = "f75a713245af54d86cd34ce79f2b6d2d8c35aa7d56c28c07e33465227cdedea1";
       libraryHaskellDepends = [ array base colour containers ];
       homepage = "http://projects.haskell.org/diagrams";
       description = "Utilities for choosing and creating color schemes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "palindromes" = callPackage
    ({ mkDerivation, array, base, bytestring, containers }:
     mkDerivation {
       pname = "palindromes";
       version = "0.4";
       sha256 = "7692ce59705026ff0141c5767262031f4dbfc9aa1c4ee4eaad7cc77051db13cc";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [ array base bytestring containers ];
       homepage = "http://www.jeuring.net/homepage/palindromes/index.html";
       description = "Finding palindromes in strings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pam" = callPackage
    ({ mkDerivation, base, c2hs, pam }:
     mkDerivation {
       pname = "pam";
       version = "0.1";
       sha256 = "d29607fc47cb11aa301b94c41c8403fe04608a8236f7c344df0aa37045c0b3d2";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ pam ];
       libraryToolDepends = [ c2hs ];
       description = "Haskell binding for C PAM API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) pam;};

  "panda" = callPackage
    ({ mkDerivation, base, cgi, containers, data-default, directory
     , filepath, gravatar, haskell98, hcheat, kibro, MissingH, mps
     , network, old-locale, old-time, pandoc, parsec, parsedate, process
     , rss, utf8-string, xhtml
     }:
     mkDerivation {
       pname = "panda";
       version = "2009.4.1";
       sha256 = "67c3938d9b34714aaf7ab2a5172c024d174b4ef5a728828edcae507c838ac67a";
       libraryHaskellDepends = [
         base cgi containers data-default directory filepath gravatar
         haskell98 hcheat kibro MissingH mps network old-locale old-time
         pandoc parsec parsedate process rss utf8-string xhtml
       ];
       homepage = "http://www.haskell.org/haskellwiki/Panda";
       description = "A simple static blog engine";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc_1_13_1" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, array, base
     , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
     , containers, data-default, deepseq-generics, Diff, directory
     , executable-path, extensible-exceptions, filepath, haddock-library
     , highlighting-kate, hslua, HTTP, http-client, http-client-tls
     , http-types, HUnit, JuicyPixels, mtl, network, network-uri
     , old-locale, old-time, pandoc-types, parsec, process, QuickCheck
     , random, scientific, SHA, syb, tagsoup, temporary, test-framework
     , test-framework-hunit, test-framework-quickcheck2, texmath, text
     , time, unordered-containers, vector, xml, yaml, zip-archive, zlib
     }:
     mkDerivation {
       pname = "pandoc";
       version = "1.13.1";
       sha256 = "7b1bb9b7d66edfbac33796a3f5d3218c2add786b95ea9dfbd497dc0e8ed27e6f";
       revision = "1";
       editedCabalFile = "2f73e20910c6a01f53c3f24f1e348bccf209059ace20cd4eda8f507cc3f4a7c4";
       configureFlags = [ "-fhttps" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array base base64-bytestring binary blaze-html blaze-markup
         bytestring containers data-default deepseq-generics directory
         extensible-exceptions filepath haddock-library highlighting-kate
         hslua HTTP http-client http-client-tls http-types JuicyPixels mtl
         network network-uri old-locale old-time pandoc-types parsec process
         random scientific SHA syb tagsoup temporary texmath text time
         unordered-containers vector xml yaml zip-archive zlib
       ];
       executableHaskellDepends = [
         aeson base bytestring containers directory extensible-exceptions
         filepath highlighting-kate HTTP network-uri old-time pandoc-types
         text time yaml
       ];
       testHaskellDepends = [
         ansi-terminal base bytestring containers Diff directory
         executable-path filepath highlighting-kate HUnit pandoc-types
         process QuickCheck syb test-framework test-framework-hunit
         test-framework-quickcheck2 text zip-archive
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://johnmacfarlane.net/pandoc";
       description = "Conversion between markup formats";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc_1_13_2" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, array, base
     , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
     , containers, data-default, deepseq-generics, Diff, directory
     , executable-path, extensible-exceptions, filepath, haddock-library
     , highlighting-kate, hslua, HTTP, http-client, http-client-tls
     , http-types, HUnit, JuicyPixels, mtl, network, network-uri
     , old-locale, old-time, pandoc-types, parsec, process, QuickCheck
     , random, scientific, SHA, syb, tagsoup, temporary, test-framework
     , test-framework-hunit, test-framework-quickcheck2, texmath, text
     , time, unordered-containers, vector, xml, yaml, zip-archive, zlib
     }:
     mkDerivation {
       pname = "pandoc";
       version = "1.13.2";
       sha256 = "e65c445f4454e9efcf1bc8c28754260d7108803bd8979bc2ff3c34705e386d8a";
       revision = "3";
       editedCabalFile = "23325052ac34c80bbb51c2f5b73ae474d684d2be3fdea83db875a105f2ffbf87";
       configureFlags = [ "-fhttps" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array base base64-bytestring binary blaze-html blaze-markup
         bytestring containers data-default deepseq-generics directory
         extensible-exceptions filepath haddock-library highlighting-kate
         hslua HTTP http-client http-client-tls http-types JuicyPixels mtl
         network network-uri old-locale old-time pandoc-types parsec process
         random scientific SHA syb tagsoup temporary texmath text time
         unordered-containers vector xml yaml zip-archive zlib
       ];
       executableHaskellDepends = [
         aeson base bytestring containers directory extensible-exceptions
         filepath highlighting-kate HTTP network network-uri old-time
         pandoc-types text time yaml
       ];
       testHaskellDepends = [
         ansi-terminal base bytestring containers Diff directory
         executable-path filepath highlighting-kate HUnit pandoc-types
         process QuickCheck syb test-framework test-framework-hunit
         test-framework-quickcheck2 text zip-archive
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://johnmacfarlane.net/pandoc";
       description = "Conversion between markup formats";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc_1_13_2_1" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, array, base
     , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
     , containers, data-default, deepseq-generics, Diff, directory
     , executable-path, extensible-exceptions, filepath, haddock-library
     , highlighting-kate, hslua, HTTP, http-client, http-client-tls
     , http-types, HUnit, JuicyPixels, mtl, network, network-uri
     , old-locale, old-time, pandoc-types, parsec, process, QuickCheck
     , random, scientific, SHA, syb, tagsoup, temporary, test-framework
     , test-framework-hunit, test-framework-quickcheck2, texmath, text
     , time, unordered-containers, vector, xml, yaml, zip-archive, zlib
     }:
     mkDerivation {
       pname = "pandoc";
       version = "1.13.2.1";
       sha256 = "66da6eb690b8de41eccf05620e165630854d74c08cf69dbfb68d0ea84589785f";
       configureFlags = [ "-fhttps" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array base base64-bytestring binary blaze-html blaze-markup
         bytestring containers data-default deepseq-generics directory
         extensible-exceptions filepath haddock-library highlighting-kate
         hslua HTTP http-client http-client-tls http-types JuicyPixels mtl
         network network-uri old-locale old-time pandoc-types parsec process
         random scientific SHA syb tagsoup temporary texmath text time
         unordered-containers vector xml yaml zip-archive zlib
       ];
       executableHaskellDepends = [
         aeson base bytestring containers directory extensible-exceptions
         filepath highlighting-kate HTTP network network-uri old-time
         pandoc-types text time yaml
       ];
       testHaskellDepends = [
         ansi-terminal base bytestring containers Diff directory
         executable-path filepath highlighting-kate HUnit pandoc-types
         process QuickCheck syb test-framework test-framework-hunit
         test-framework-quickcheck2 text zip-archive
       ];
       jailbreak = true;
       homepage = "http://johnmacfarlane.net/pandoc";
       description = "Conversion between markup formats";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc_1_15_0_6" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, array, base
     , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
     , cmark, containers, data-default, deepseq-generics, Diff
     , directory, executable-path, extensible-exceptions, filemanip
     , filepath, haddock-library, highlighting-kate, hslua, HTTP
     , http-client, http-client-tls, http-types, HUnit, JuicyPixels, mtl
     , network, network-uri, old-locale, old-time, pandoc-types, parsec
     , process, QuickCheck, random, scientific, SHA, syb, tagsoup
     , temporary, test-framework, test-framework-hunit
     , test-framework-quickcheck2, texmath, text, time
     , unordered-containers, vector, xml, yaml, zip-archive, zlib
     }:
     mkDerivation {
       pname = "pandoc";
       version = "1.15.0.6";
       sha256 = "d950968142526d5a765af7dfb26b47c3f60d4f883aa9d9eab668614179f1ed46";
       configureFlags = [ "-fhttps" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array base base64-bytestring binary blaze-html blaze-markup
         bytestring cmark containers data-default deepseq-generics directory
         extensible-exceptions filemanip filepath haddock-library
         highlighting-kate hslua HTTP http-client http-client-tls http-types
         JuicyPixels mtl network network-uri old-locale old-time
         pandoc-types parsec process random scientific SHA syb tagsoup
         temporary texmath text time unordered-containers vector xml yaml
         zip-archive zlib
       ];
       executableHaskellDepends = [
         aeson base bytestring containers directory extensible-exceptions
         filepath highlighting-kate HTTP network network-uri pandoc-types
         text yaml
       ];
       testHaskellDepends = [
         ansi-terminal base bytestring containers Diff directory
         executable-path filepath highlighting-kate HUnit pandoc-types
         process QuickCheck syb test-framework test-framework-hunit
         test-framework-quickcheck2 text zip-archive
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://pandoc.org";
       description = "Conversion between markup formats";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc_1_15_1" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, array, base
     , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
     , cmark, containers, data-default, deepseq-generics, Diff
     , directory, executable-path, extensible-exceptions, filemanip
     , filepath, ghc-prim, haddock-library, highlighting-kate, hslua
     , HTTP, http-client, http-client-tls, http-types, HUnit
     , JuicyPixels, mtl, network, network-uri, old-locale, old-time
     , pandoc-types, parsec, process, QuickCheck, random, scientific
     , SHA, syb, tagsoup, temporary, test-framework
     , test-framework-hunit, test-framework-quickcheck2, texmath, text
     , time, unordered-containers, vector, xml, yaml, zip-archive, zlib
     }:
     mkDerivation {
       pname = "pandoc";
       version = "1.15.1";
       sha256 = "77503f8981cfcbe7df841ed1c71de9164d0eaf17b8b9c51e6d966e4fd333b733";
       configureFlags = [ "-fhttps" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array base base64-bytestring binary blaze-html blaze-markup
         bytestring cmark containers data-default deepseq-generics directory
         extensible-exceptions filemanip filepath ghc-prim haddock-library
         highlighting-kate hslua HTTP http-client http-client-tls http-types
         JuicyPixels mtl network network-uri old-locale old-time
         pandoc-types parsec process random scientific SHA syb tagsoup
         temporary texmath text time unordered-containers vector xml yaml
         zip-archive zlib
       ];
       executableHaskellDepends = [
         aeson base bytestring containers directory extensible-exceptions
         filepath highlighting-kate HTTP network network-uri pandoc-types
         text yaml
       ];
       testHaskellDepends = [
         ansi-terminal base bytestring containers Diff directory
         executable-path filepath highlighting-kate HUnit pandoc-types
         process QuickCheck syb test-framework test-framework-hunit
         test-framework-quickcheck2 text zip-archive
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://pandoc.org";
       description = "Conversion between markup formats";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc_1_15_1_1" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, array, base
     , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
     , cmark, containers, data-default, deepseq-generics, Diff
     , directory, executable-path, extensible-exceptions, filemanip
     , filepath, ghc-prim, haddock-library, highlighting-kate, hslua
     , HTTP, http-client, http-client-tls, http-types, HUnit
     , JuicyPixels, mtl, network, network-uri, old-locale, old-time
     , pandoc-types, parsec, process, QuickCheck, random, scientific
     , SHA, syb, tagsoup, temporary, test-framework
     , test-framework-hunit, test-framework-quickcheck2, texmath, text
     , time, unordered-containers, vector, xml, yaml, zip-archive, zlib
     }:
     mkDerivation {
       pname = "pandoc";
       version = "1.15.1.1";
       sha256 = "a70e0af56c294dbb1ba646df24f90b81542d060ec7167f70ff2b873ed7ed6d5e";
       configureFlags = [ "-fhttps" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array base base64-bytestring binary blaze-html blaze-markup
         bytestring cmark containers data-default deepseq-generics directory
         extensible-exceptions filemanip filepath ghc-prim haddock-library
         highlighting-kate hslua HTTP http-client http-client-tls http-types
         JuicyPixels mtl network network-uri old-locale old-time
         pandoc-types parsec process random scientific SHA syb tagsoup
         temporary texmath text time unordered-containers vector xml yaml
         zip-archive zlib
       ];
       executableHaskellDepends = [
         aeson base bytestring containers directory extensible-exceptions
         filepath highlighting-kate HTTP network network-uri pandoc-types
         text yaml
       ];
       testHaskellDepends = [
         ansi-terminal base bytestring containers Diff directory
         executable-path filepath highlighting-kate HUnit pandoc-types
         process QuickCheck syb test-framework test-framework-hunit
         test-framework-quickcheck2 text zip-archive
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://pandoc.org";
       description = "Conversion between markup formats";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc_1_15_2" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, array, base
     , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
     , cmark, containers, data-default, deepseq-generics, Diff
     , directory, executable-path, extensible-exceptions, filemanip
     , filepath, ghc-prim, haddock-library, highlighting-kate, hslua
     , HTTP, http-client, http-client-tls, http-types, HUnit
     , JuicyPixels, mtl, network, network-uri, old-time, pandoc-types
     , parsec, process, QuickCheck, random, scientific, SHA, syb
     , tagsoup, temporary, test-framework, test-framework-hunit
     , test-framework-quickcheck2, texmath, text, time
     , unordered-containers, vector, xml, yaml, zip-archive, zlib
     }:
     mkDerivation {
       pname = "pandoc";
       version = "1.15.2";
       sha256 = "9c6ffe77006513306b35daa7256c1625c6eaf2e16a8de8fe5248f20015c3d335";
       configureFlags = [ "-fhttps" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array base base64-bytestring binary blaze-html blaze-markup
         bytestring cmark containers data-default deepseq-generics directory
         extensible-exceptions filemanip filepath ghc-prim haddock-library
         highlighting-kate hslua HTTP http-client http-client-tls http-types
         JuicyPixels mtl network network-uri old-time pandoc-types parsec
         process random scientific SHA syb tagsoup temporary texmath text
         time unordered-containers vector xml yaml zip-archive zlib
       ];
       executableHaskellDepends = [
         aeson base bytestring containers directory extensible-exceptions
         filepath highlighting-kate HTTP network network-uri pandoc-types
         text yaml
       ];
       testHaskellDepends = [
         ansi-terminal base bytestring containers Diff directory
         executable-path filepath highlighting-kate HUnit pandoc-types
         process QuickCheck syb test-framework test-framework-hunit
         test-framework-quickcheck2 text zip-archive
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://pandoc.org";
       description = "Conversion between markup formats";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc_1_15_2_1" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, array, base
     , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
     , cmark, containers, data-default, deepseq-generics, Diff
     , directory, executable-path, extensible-exceptions, filemanip
     , filepath, ghc-prim, haddock-library, highlighting-kate, hslua
     , HTTP, http-client, http-client-tls, http-types, HUnit
     , JuicyPixels, mtl, network, network-uri, old-time, pandoc-types
     , parsec, process, QuickCheck, random, scientific, SHA, syb
     , tagsoup, temporary, test-framework, test-framework-hunit
     , test-framework-quickcheck2, texmath, text, time
     , unordered-containers, vector, xml, yaml, zip-archive, zlib
     }:
     mkDerivation {
       pname = "pandoc";
       version = "1.15.2.1";
       sha256 = "60bcb0e65ecb63953dd26d5aacf1a5df83700d116062ffaeffe9edbc9be6df59";
       configureFlags = [ "-fhttps" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array base base64-bytestring binary blaze-html blaze-markup
         bytestring cmark containers data-default deepseq-generics directory
         extensible-exceptions filemanip filepath ghc-prim haddock-library
         highlighting-kate hslua HTTP http-client http-client-tls http-types
         JuicyPixels mtl network network-uri old-time pandoc-types parsec
         process random scientific SHA syb tagsoup temporary texmath text
         time unordered-containers vector xml yaml zip-archive zlib
       ];
       executableHaskellDepends = [
         aeson base bytestring containers directory extensible-exceptions
         filepath highlighting-kate HTTP network network-uri pandoc-types
         text yaml
       ];
       testHaskellDepends = [
         ansi-terminal base bytestring containers Diff directory
         executable-path filepath highlighting-kate HUnit pandoc-types
         process QuickCheck syb test-framework test-framework-hunit
         test-framework-quickcheck2 text zip-archive
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://pandoc.org";
       description = "Conversion between markup formats";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, array, base
     , base64-bytestring, binary, blaze-html, blaze-markup, bytestring
     , cmark, containers, data-default, deepseq, Diff, directory
     , executable-path, extensible-exceptions, filemanip, filepath
     , ghc-prim, haddock-library, highlighting-kate, hslua, HTTP
     , http-client, http-client-tls, http-types, HUnit, JuicyPixels, mtl
     , network, network-uri, old-time, pandoc-types, parsec, process
     , QuickCheck, random, scientific, SHA, syb, tagsoup, temporary
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , texmath, text, time, unordered-containers, vector, xml, yaml
     , zip-archive, zlib
     }:
     mkDerivation {
       pname = "pandoc";
       version = "1.16.0.2";
       sha256 = "f5f3262ef4574a111936fea0118557c523a8b0eaa7fea84b64b377b20a80f348";
       configureFlags = [ "-fhttps" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array base base64-bytestring binary blaze-html blaze-markup
         bytestring cmark containers data-default deepseq directory
         extensible-exceptions filemanip filepath ghc-prim haddock-library
         highlighting-kate hslua HTTP http-client http-client-tls http-types
         JuicyPixels mtl network network-uri old-time pandoc-types parsec
         process random scientific SHA syb tagsoup temporary texmath text
         time unordered-containers vector xml yaml zip-archive zlib
       ];
       executableHaskellDepends = [
         aeson base bytestring containers directory extensible-exceptions
         filepath highlighting-kate HTTP network network-uri pandoc-types
         text yaml
       ];
       testHaskellDepends = [
         ansi-terminal base bytestring containers Diff directory
         executable-path filepath highlighting-kate HUnit pandoc-types
         process QuickCheck syb test-framework test-framework-hunit
         test-framework-quickcheck2 text zip-archive
       ];
       homepage = "http://pandoc.org";
       description = "Conversion between markup formats";
       license = "GPL";
     }) {};

  "pandoc-citeproc_0_6" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
     , containers, data-default, directory, filepath, hs-bibutils, mtl
     , old-locale, pandoc, pandoc-types, parsec, process, rfc5051, split
     , syb, tagsoup, temporary, text, time, vector, xml-conduit, yaml
     }:
     mkDerivation {
       pname = "pandoc-citeproc";
       version = "0.6";
       sha256 = "ab60459ead81420d1320314b194a40f6d91bd89b34c88547e6283ab8724511f2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers data-default directory filepath
         hs-bibutils mtl old-locale pandoc pandoc-types parsec rfc5051 split
         syb tagsoup text time vector xml-conduit yaml
       ];
       executableHaskellDepends = [
         aeson aeson-pretty attoparsec base bytestring containers directory
         filepath pandoc pandoc-types process syb temporary text vector yaml
       ];
       testHaskellDepends = [
         aeson base bytestring directory filepath pandoc pandoc-types
         process temporary text yaml
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       description = "Supports using pandoc with citeproc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc-citeproc_0_6_0_1" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
     , containers, data-default, directory, filepath, hs-bibutils, mtl
     , old-locale, pandoc, pandoc-types, parsec, process, rfc5051, split
     , syb, tagsoup, temporary, text, time, vector, xml-conduit, yaml
     }:
     mkDerivation {
       pname = "pandoc-citeproc";
       version = "0.6.0.1";
       sha256 = "af696d7ffb83b6545263c0e69c2cda516e0ae81364c705a146c6bdfbb26c8617";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers data-default directory filepath
         hs-bibutils mtl old-locale pandoc pandoc-types parsec rfc5051 split
         syb tagsoup text time vector xml-conduit yaml
       ];
       executableHaskellDepends = [
         aeson aeson-pretty attoparsec base bytestring containers directory
         filepath pandoc pandoc-types process syb temporary text vector yaml
       ];
       testHaskellDepends = [
         aeson base bytestring directory filepath pandoc pandoc-types
         process temporary text yaml
       ];
       jailbreak = true;
       doCheck = false;
       description = "Supports using pandoc with citeproc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc-citeproc_0_7_3" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
     , containers, data-default, directory, filepath, hs-bibutils, mtl
     , old-locale, pandoc, pandoc-types, parsec, process, rfc5051
     , setenv, split, syb, tagsoup, temporary, text, time, vector
     , xml-conduit, yaml
     }:
     mkDerivation {
       pname = "pandoc-citeproc";
       version = "0.7.3";
       sha256 = "72fc81d962812d037bb78c6d38d602ca2c6895f0436c8be94cb71600ed288e68";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers data-default directory filepath
         hs-bibutils mtl old-locale pandoc pandoc-types parsec rfc5051
         setenv split syb tagsoup text time vector xml-conduit yaml
       ];
       executableHaskellDepends = [
         aeson aeson-pretty attoparsec base bytestring containers directory
         filepath pandoc pandoc-types process syb temporary text vector yaml
       ];
       testHaskellDepends = [
         aeson base bytestring directory filepath pandoc pandoc-types
         process temporary text yaml
       ];
       doCheck = false;
       description = "Supports using pandoc with citeproc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc-citeproc_0_7_3_1" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
     , containers, data-default, directory, filepath, hs-bibutils, mtl
     , old-locale, pandoc, pandoc-types, parsec, process, rfc5051
     , setenv, split, syb, tagsoup, temporary, text, time, vector
     , xml-conduit, yaml
     }:
     mkDerivation {
       pname = "pandoc-citeproc";
       version = "0.7.3.1";
       sha256 = "b2e9b814603dbb60b845fa14d767a154e43a2115a9a81b218a173e9bc1a319f5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers data-default directory filepath
         hs-bibutils mtl old-locale pandoc pandoc-types parsec rfc5051
         setenv split syb tagsoup text time vector xml-conduit yaml
       ];
       executableHaskellDepends = [
         aeson aeson-pretty attoparsec base bytestring containers directory
         filepath pandoc pandoc-types process syb temporary text vector yaml
       ];
       testHaskellDepends = [
         aeson base bytestring directory filepath pandoc pandoc-types
         process temporary text yaml
       ];
       doCheck = false;
       description = "Supports using pandoc with citeproc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc-citeproc_0_7_4" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
     , containers, data-default, directory, filepath, hs-bibutils, mtl
     , old-locale, pandoc, pandoc-types, parsec, process, rfc5051
     , setenv, split, syb, tagsoup, temporary, text, time, vector
     , xml-conduit, yaml
     }:
     mkDerivation {
       pname = "pandoc-citeproc";
       version = "0.7.4";
       sha256 = "905112d8995fb6de5ee4c4bfd62cc89baa3bf1598f258aaba1704f85cf739fd2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers data-default directory filepath
         hs-bibutils mtl old-locale pandoc pandoc-types parsec rfc5051
         setenv split syb tagsoup text time vector xml-conduit yaml
       ];
       executableHaskellDepends = [
         aeson aeson-pretty attoparsec base bytestring containers directory
         filepath pandoc pandoc-types process syb temporary text vector yaml
       ];
       testHaskellDepends = [
         aeson base bytestring directory filepath pandoc pandoc-types
         process temporary text yaml
       ];
       doCheck = false;
       description = "Supports using pandoc with citeproc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc-citeproc_0_8_1_3" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
     , containers, data-default, directory, filepath, hs-bibutils, mtl
     , old-locale, pandoc, pandoc-types, parsec, process, rfc5051
     , setenv, split, syb, tagsoup, temporary, text, time
     , unordered-containers, vector, xml-conduit, yaml
     }:
     mkDerivation {
       pname = "pandoc-citeproc";
       version = "0.8.1.3";
       sha256 = "aa15ff9cbb9c1cca504943c94cd891e23944cb0106172886821cb048a9726c7d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers data-default directory filepath
         hs-bibutils mtl old-locale pandoc pandoc-types parsec rfc5051
         setenv split syb tagsoup text time unordered-containers vector
         xml-conduit yaml
       ];
       executableHaskellDepends = [
         aeson aeson-pretty attoparsec base bytestring containers directory
         filepath pandoc pandoc-types process syb temporary text vector yaml
       ];
       testHaskellDepends = [
         aeson base bytestring directory filepath pandoc pandoc-types
         process temporary text yaml
       ];
       doCheck = false;
       description = "Supports using pandoc with citeproc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc-citeproc" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
     , containers, data-default, directory, filepath, hs-bibutils, mtl
     , old-locale, pandoc, pandoc-types, parsec, process, rfc5051
     , setenv, split, syb, tagsoup, temporary, text, time
     , unordered-containers, vector, xml-conduit, yaml
     }:
     mkDerivation {
       pname = "pandoc-citeproc";
       version = "0.9";
       sha256 = "ae880aa27b5fcaf93886844bd9473c764329dc96211482bf014f350335887fbd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers data-default directory filepath
         hs-bibutils mtl old-locale pandoc pandoc-types parsec rfc5051
         setenv split syb tagsoup text time unordered-containers vector
         xml-conduit yaml
       ];
       executableHaskellDepends = [
         aeson aeson-pretty attoparsec base bytestring containers directory
         filepath pandoc pandoc-types process syb temporary text vector yaml
       ];
       testHaskellDepends = [
         aeson base bytestring directory filepath pandoc pandoc-types
         process temporary text yaml
       ];
       doCheck = false;
       homepage = "https://github.com/jgm/pandoc-citeproc";
       description = "Supports using pandoc with citeproc";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pandoc-citeproc-preamble" = callPackage
    ({ mkDerivation, base, directory, filepath, pandoc-types, process
     }:
     mkDerivation {
       pname = "pandoc-citeproc-preamble";
       version = "1.0.0";
       sha256 = "1afb34f7aa93a22ab389ae934259a4bcc408708ee74676001eb6c89d5eef7be9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath pandoc-types process
       ];
       homepage = "https://github.com/spwhitton/pandoc-citeproc-preamble";
       description = "Insert a preamble before pandoc-citeproc's bibliography";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "pandoc-crossref" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-accessor
     , data-accessor-transformers, data-default, hspec, mtl, pandoc
     , pandoc-types, process, yaml
     }:
     mkDerivation {
       pname = "pandoc-crossref";
       version = "0.1.6.5";
       sha256 = "6b92a2730ed28c0242b81e47c0e21902321f98eb2b580d2114d906ca89a451e2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers data-accessor data-accessor-transformers
         data-default mtl pandoc pandoc-types yaml
       ];
       executableHaskellDepends = [
         base bytestring containers data-default mtl pandoc pandoc-types
         yaml
       ];
       testHaskellDepends = [
         base bytestring containers data-accessor data-accessor-transformers
         data-default hspec mtl pandoc pandoc-types process yaml
       ];
       description = "Pandoc filter for cross-references";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "pandoc-csv2table" = callPackage
    ({ mkDerivation, base, csv, pandoc, pandoc-types, text }:
     mkDerivation {
       pname = "pandoc-csv2table";
       version = "1.0.4";
       sha256 = "c1f14975239d5b26faba78f3db6c84573d4db99ab021560c184755259ca61b82";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base csv pandoc pandoc-types text ];
       executableHaskellDepends = [ base csv pandoc pandoc-types ];
       homepage = "https://github.com/baig/pandoc-csv2table-filter";
       description = "Convert CSV to Pandoc Table Markdown";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pandoc-include" = callPackage
    ({ mkDerivation, base, directory, pandoc, pandoc-types, text }:
     mkDerivation {
       pname = "pandoc-include";
       version = "0.0.1";
       sha256 = "cdb6516356fbbd4b9ff619da0ec8f0216e01356309f75037349d56af0c9768c3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory pandoc pandoc-types text
       ];
       executableHaskellDepends = [
         base directory pandoc pandoc-types text
       ];
       doHaddock = false;
       homepage = "https://github.com/steindani/pandoc-include";
       description = "Include other Markdown files";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pandoc-japanese-filters" = callPackage
    ({ mkDerivation, base, containers, data-default, effin, HaTeX
     , HaTeX-qq, hxt, pandoc, pandoc-types, shelly, system-fileio
     , system-filepath, text
     }:
     mkDerivation {
       pname = "pandoc-japanese-filters";
       version = "0.1.0.1";
       sha256 = "dc97d57265b7b5f5a40fcdf3ec422e03cd04fd7c4dc5a71045642dfde0d41301";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers data-default effin HaTeX HaTeX-qq hxt pandoc
         pandoc-types shelly system-fileio system-filepath text
       ];
       description = "Japanese-specific markup filters for pandoc";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "pandoc-lens" = callPackage
    ({ mkDerivation, base, containers, lens, pandoc-types }:
     mkDerivation {
       pname = "pandoc-lens";
       version = "0.4.1";
       sha256 = "bd319f64abf3ebaac915e20135aadb06ab1f77ab562f7bac87580ceda37fc12d";
       libraryHaskellDepends = [ base containers lens pandoc-types ];
       jailbreak = true;
       homepage = "http://github.com/bgamari/pandoc-lens";
       description = "Lenses for Pandoc documents";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pandoc-placetable" = callPackage
    ({ mkDerivation, base, explicit-exception, http-conduit
     , pandoc-types, spreadsheet, utf8-string
     }:
     mkDerivation {
       pname = "pandoc-placetable";
       version = "0.3";
       sha256 = "81ed103e20c68a7a0dd29653fee6044f63792144f3f317f87409c779c3088e18";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base explicit-exception http-conduit pandoc-types spreadsheet
         utf8-string
       ];
       homepage = "https://github.com/mb21/pandoc-placetable";
       description = "Pandoc filter to include CSV files";
       license = "GPL";
     }) {};

  "pandoc-plantuml-diagrams" = callPackage
    ({ mkDerivation, base, bytestring, directory, hspec, hspec-discover
     , mtl, pandoc-types, process, SHA, utf8-string
     }:
     mkDerivation {
       pname = "pandoc-plantuml-diagrams";
       version = "0.1.0.3";
       sha256 = "08ebe0e341283f0aaca31ba19358838bac0c9eb11048b6346d44a0b312b879d0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring directory pandoc-types process SHA utf8-string
       ];
       executableHaskellDepends = [ base pandoc-types ];
       testHaskellDepends = [
         base hspec hspec-discover mtl pandoc-types SHA utf8-string
       ];
       description = "Render and insert PlantUML diagrams with Pandoc";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pandoc-types_1_12_4_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , deepseq-generics, ghc-prim, syb
     }:
     mkDerivation {
       pname = "pandoc-types";
       version = "1.12.4.1";
       sha256 = "187bda4b12746b9cc460ae98b39d0964adace2bcca2fd0e343b1ea4234a86ff1";
       libraryHaskellDepends = [
         aeson base bytestring containers deepseq-generics ghc-prim syb
       ];
       jailbreak = true;
       homepage = "http://johnmacfarlane.net/pandoc";
       description = "Types for representing a structured document";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc-types_1_12_4_2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , deepseq-generics, ghc-prim, syb
     }:
     mkDerivation {
       pname = "pandoc-types";
       version = "1.12.4.2";
       sha256 = "c90ac284da3185f9fbb489427826cf9cfa038aff56bb903276c87bc92ffd3f49";
       libraryHaskellDepends = [
         aeson base bytestring containers deepseq-generics ghc-prim syb
       ];
       jailbreak = true;
       homepage = "http://johnmacfarlane.net/pandoc";
       description = "Types for representing a structured document";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc-types_1_12_4_3" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , deepseq-generics, ghc-prim, syb
     }:
     mkDerivation {
       pname = "pandoc-types";
       version = "1.12.4.3";
       sha256 = "65f9e6cc6f0208d2a18a5486c03290d9edb10f9326c8e45f1a2032247c2047aa";
       libraryHaskellDepends = [
         aeson base bytestring containers deepseq-generics ghc-prim syb
       ];
       jailbreak = true;
       homepage = "http://johnmacfarlane.net/pandoc";
       description = "Types for representing a structured document";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc-types_1_12_4_4" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , deepseq-generics, ghc-prim, syb
     }:
     mkDerivation {
       pname = "pandoc-types";
       version = "1.12.4.4";
       sha256 = "aff8953bee52f9ddd296c59a641dc5cf2c712fe06e46119803b40e892c136662";
       libraryHaskellDepends = [
         aeson base bytestring containers deepseq-generics ghc-prim syb
       ];
       jailbreak = true;
       homepage = "http://johnmacfarlane.net/pandoc";
       description = "Types for representing a structured document";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc-types_1_12_4_5" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , deepseq-generics, ghc-prim, syb
     }:
     mkDerivation {
       pname = "pandoc-types";
       version = "1.12.4.5";
       sha256 = "87a1db206be3eccd2e66518363340e90e7592d8e82e2a5f006620cd3e1ac877b";
       libraryHaskellDepends = [
         aeson base bytestring containers deepseq-generics ghc-prim syb
       ];
       jailbreak = true;
       homepage = "http://johnmacfarlane.net/pandoc";
       description = "Types for representing a structured document";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc-types_1_12_4_7" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , deepseq-generics, ghc-prim, syb
     }:
     mkDerivation {
       pname = "pandoc-types";
       version = "1.12.4.7";
       sha256 = "560ca3291b5558cf810b17f3bee40b17a4aee1671d38cf468c42aab666081681";
       libraryHaskellDepends = [
         aeson base bytestring containers deepseq-generics ghc-prim syb
       ];
       homepage = "http://johnmacfarlane.net/pandoc";
       description = "Types for representing a structured document";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc-types_1_16_0_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, deepseq
     , ghc-prim, syb
     }:
     mkDerivation {
       pname = "pandoc-types";
       version = "1.16.0.1";
       sha256 = "3e61dff33d104ffdac9920bf7bf9c28f566cb3da237715ad05bd40b4d4e8beb6";
       libraryHaskellDepends = [
         aeson base bytestring containers deepseq ghc-prim syb
       ];
       homepage = "http://johnmacfarlane.net/pandoc";
       description = "Types for representing a structured document";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pandoc-types" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, deepseq
     , ghc-prim, syb
     }:
     mkDerivation {
       pname = "pandoc-types";
       version = "1.16.1";
       sha256 = "846054157d7072ca3f7260b988a6752536b42bbd32c051400e55f46229b8179e";
       libraryHaskellDepends = [
         aeson base bytestring containers deepseq ghc-prim syb
       ];
       homepage = "http://johnmacfarlane.net/pandoc";
       description = "Types for representing a structured document";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pandoc-unlit" = callPackage
    ({ mkDerivation, base, pandoc }:
     mkDerivation {
       pname = "pandoc-unlit";
       version = "0.1.0";
       sha256 = "891e3bcda3d19c85afb4b9b45a590ad524ed50b5cd0a8cd3d5d2c0732176b449";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base pandoc ];
       description = "Literate Haskell support for GitHub's Markdown flavor";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pango_0_13_0_4" = callPackage
    ({ mkDerivation, array, base, cairo, containers, directory, glib
     , gtk2hs-buildtools, mtl, pango, pretty, process, text
     }:
     mkDerivation {
       pname = "pango";
       version = "0.13.0.4";
       sha256 = "5887aa3b3c4c79a0acaa2e09674b7ecd6ae28499babd2be55dca0ca6b8e7f4b9";
       libraryHaskellDepends = [
         array base cairo containers directory glib mtl pretty process text
       ];
       libraryPkgconfigDepends = [ pango ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Pango text rendering engine";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.gnome) pango;};

  "pango_0_13_0_5" = callPackage
    ({ mkDerivation, array, base, cairo, containers, directory, glib
     , gtk2hs-buildtools, mtl, pango, pretty, process, text
     }:
     mkDerivation {
       pname = "pango";
       version = "0.13.0.5";
       sha256 = "7db411d5d021f6bcf17942b338078ce831f2611d59852cae444c9368becb3e0c";
       libraryHaskellDepends = [
         array base cairo containers directory glib mtl pretty process text
       ];
       libraryPkgconfigDepends = [ pango ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Pango text rendering engine";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.gnome) pango;};

  "pango_0_13_1_0" = callPackage
    ({ mkDerivation, array, base, cairo, containers, directory, glib
     , gtk2hs-buildtools, mtl, pango, pretty, process, text
     }:
     mkDerivation {
       pname = "pango";
       version = "0.13.1.0";
       sha256 = "1612dbe198f8bbbb394bf043eb06c554d5e1c0dc76cdee186ef925fb8a7ac968";
       libraryHaskellDepends = [
         array base cairo containers directory glib mtl pretty process text
       ];
       libraryPkgconfigDepends = [ pango ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Pango text rendering engine";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.gnome) pango;};

  "pango" = callPackage
    ({ mkDerivation, array, base, cairo, containers, directory, glib
     , gtk2hs-buildtools, mtl, pango, pretty, process, text
     }:
     mkDerivation {
       pname = "pango";
       version = "0.13.1.1";
       sha256 = "3c22f339fe2e30cb6d6cbc5906e1064c5fdabfbc56d2a2c015ac70b4aa5165ad";
       libraryHaskellDepends = [
         array base cairo containers directory glib mtl pretty process text
       ];
       libraryPkgconfigDepends = [ pango ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Pango text rendering engine";
       license = stdenv.lib.licenses.lgpl21;
     }) {inherit (pkgs.gnome) pango;};

  "papillon" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, monads-tf
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "papillon";
       version = "0.1.0.2";
       sha256 = "2a7a6d5b08e6be261dca18cc80a4040a1215a5a8e66953a1e766845455ba4861";
       revision = "1";
       editedCabalFile = "5c1af18fd9437293a3fd51ebfe1386e82e4ec7727be4a0703c5f198138ffb8cd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring monads-tf template-haskell transformers
       ];
       executableHaskellDepends = [
         base directory filepath monads-tf template-haskell transformers
       ];
       jailbreak = true;
       homepage = "https://skami.iocikun.jp/computer/haskell/packages/papillon";
       description = "packrat parser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pappy" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "pappy";
       version = "0.1.0.2";
       sha256 = "ad536b3821ff826cc82713f708875e469d581b8e353c37bcaf95e3d7d3aec491";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       homepage = "http://pdos.csail.mit.edu/~baford/packrat/thesis/";
       description = "Packrat parsing; linear-time parsers for grammars in TDPL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "para" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "para";
       version = "1.1";
       sha256 = "7049ac1b81ca8da008605ed2af0385f042481a2522d4831c081a9112715daa50";
       libraryHaskellDepends = [ base ];
       description = "Text paragraph formatting";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "paragon" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers, cpphs
     , directory, filepath, haskell-src-meta, parsec, pretty, syb
     , template-haskell, th-lift, uniplate
     }:
     mkDerivation {
       pname = "paragon";
       version = "0.1.28";
       sha256 = "2cb18348079e05de1c012fced276edc4e65042151f30c503766ee0f8cf73e7c7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers cpphs directory filepath
         haskell-src-meta parsec pretty syb template-haskell th-lift
         uniplate
       ];
       libraryToolDepends = [ alex ];
       executableHaskellDepends = [
         array base bytestring containers cpphs directory filepath
         haskell-src-meta parsec pretty syb template-haskell th-lift
         uniplate
       ];
       executableToolDepends = [ alex ];
       jailbreak = true;
       description = "Paragon";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parallel_3_2_0_3" = callPackage
    ({ mkDerivation, array, base, containers, deepseq }:
     mkDerivation {
       pname = "parallel";
       version = "3.2.0.3";
       sha256 = "163a40ef3c6258c623abe690a9837c9de2bf7fe87d3fac7d0758229d7efb6dcd";
       libraryHaskellDepends = [ array base containers deepseq ];
       jailbreak = true;
       description = "Parallel programming library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parallel_3_2_0_5" = callPackage
    ({ mkDerivation, array, base, containers, deepseq }:
     mkDerivation {
       pname = "parallel";
       version = "3.2.0.5";
       sha256 = "b5a241bfbf43be0d18d0864c1cbcbfdbd60d64f2404fadd3c338897c51d4109a";
       libraryHaskellDepends = [ array base containers deepseq ];
       description = "Parallel programming library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parallel_3_2_0_6" = callPackage
    ({ mkDerivation, array, base, containers, deepseq }:
     mkDerivation {
       pname = "parallel";
       version = "3.2.0.6";
       sha256 = "b928d3fbd0b7b247bfb7072796c6950f3a5b61ec051449cddf86ebfe89dbe642";
       libraryHaskellDepends = [ array base containers deepseq ];
       description = "Parallel programming library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parallel" = callPackage
    ({ mkDerivation, array, base, containers, deepseq }:
     mkDerivation {
       pname = "parallel";
       version = "3.2.1.0";
       sha256 = "4de3cdbb71dfd13cbb70a1dc1d1d5cf34fbe9828e05eb02b3dc658fdc2148526";
       libraryHaskellDepends = [ array base containers deepseq ];
       description = "Parallel programming library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parallel-io" = callPackage
    ({ mkDerivation, base, containers, extensible-exceptions, random }:
     mkDerivation {
       pname = "parallel-io";
       version = "0.3.3";
       sha256 = "3a14c02b9b8b7c72577eb90a8dd72de75d99192def87d7aa79545ee4d6e80645";
       revision = "1";
       editedCabalFile = "75eeeb51593fa2771c8dbc965ca09d830d62e08135870188a10446f842178bee";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers extensible-exceptions random
       ];
       homepage = "http://batterseapower.github.com/parallel-io";
       description = "Combinators for executing IO actions in parallel on a thread pool";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parallel-tasks" = callPackage
    ({ mkDerivation, base, bytestring, cereal, deepseq, here
     , old-locale, stm, time, transformers, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "parallel-tasks";
       version = "4.0.1.0";
       sha256 = "7d547dfd92ee1a17d9589a79094f9deb6ea05391e483aefae00ccc1d2f09cf32";
       libraryHaskellDepends = [
         base bytestring cereal deepseq here old-locale stm time
         transformers vector vector-algorithms
       ];
       jailbreak = true;
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parallel-tree-search" = callPackage
    ({ mkDerivation, base, parallel, tree-monad }:
     mkDerivation {
       pname = "parallel-tree-search";
       version = "0.4.1";
       sha256 = "99d91a7926dfa580d02b66714753b95c38a95291e1f16dc24f1f3f83133153f4";
       libraryHaskellDepends = [ base parallel tree-monad ];
       homepage = "http://github.com/sebfisch/parallel-tree-search";
       description = "Parallel Tree Search";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "parameterized-data" = callPackage
    ({ mkDerivation, base, template-haskell, type-level }:
     mkDerivation {
       pname = "parameterized-data";
       version = "0.1.5";
       sha256 = "013322381cff9c560857fd9812ae282ba1c57412082f6479ceeed7b7aeba8efd";
       libraryHaskellDepends = [ base template-haskell type-level ];
       homepage = "http://code.haskell.org/parameterized-data";
       description = "Parameterized data library implementing lightweight dependent types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parco" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "parco";
       version = "0.1";
       sha256 = "045362f7cdd5ee72cd4c0267046dbf551128c92725efe10ba4c432fccd872815";
       libraryHaskellDepends = [ base mtl ];
       description = "Generalised parser combinators";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parco-attoparsec" = callPackage
    ({ mkDerivation, attoparsec, base, mtl, parco }:
     mkDerivation {
       pname = "parco-attoparsec";
       version = "0.1";
       sha256 = "500eaadf7f21a9e17fab04ce12e961d59da5a683467f01ce1d74c4c0b67f822d";
       libraryHaskellDepends = [ attoparsec base mtl parco ];
       description = "Generalised parser combinators - Attoparsec interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parco-parsec" = callPackage
    ({ mkDerivation, base, mtl, parco, parsec }:
     mkDerivation {
       pname = "parco-parsec";
       version = "0.1";
       sha256 = "c3f5471769e384ec340f3c208c6193b3925997efdc1c4936f064abe195d46d54";
       libraryHaskellDepends = [ base mtl parco parsec ];
       description = "Generalised parser combinators - Parsec interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parcom-lib" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, text
     , transformers, utf8-string, word8
     }:
     mkDerivation {
       pname = "parcom-lib";
       version = "0.8.0.3";
       sha256 = "4b252259a97ef22d2882d11b9181f8e8f5390b415b9477594f19cfcb359e7d76";
       libraryHaskellDepends = [
         base bytestring containers mtl text transformers utf8-string word8
       ];
       homepage = "https://bitbucket.org/tdammers/parcom-lib";
       description = "A simple parser-combinator library, a bit like Parsec but without the frills";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parconc-examples" = callPackage
    ({ mkDerivation, abstract-par, accelerate, accelerate-io, array
     , async, base, binary, bytestring, containers, deepseq, directory
     , distributed-process, distributed-process-simplelocalnet
     , distributed-static, fclabels, filepath, HTTP, monad-par, network
     , normaldistribution, parallel, random, repa, stm, template-haskell
     , time, transformers, utf8-string, vector, xml
     }:
     mkDerivation {
       pname = "parconc-examples";
       version = "0.3.5";
       sha256 = "57dde98fbad6f2c0136c301a3d503795affdfa03fbfde364d0bf31b172322d16";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         abstract-par accelerate accelerate-io array async base binary
         bytestring containers deepseq directory distributed-process
         distributed-process-simplelocalnet distributed-static fclabels
         filepath HTTP monad-par network normaldistribution parallel random
         repa stm template-haskell time transformers utf8-string vector xml
       ];
       jailbreak = true;
       description = "Examples to accompany the book \"Parallel and Concurrent Programming in Haskell\"";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parport" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "parport";
       version = "0.0.0";
       sha256 = "dd961b363ed5ce5de6ec456a42f6b9a65bcb02198052122b75c6a6138ec18eb4";
       libraryHaskellDepends = [ array base ];
       description = "Simply interfacing the parallel port on linux";
       license = "GPL";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "parse-dimacs" = callPackage
    ({ mkDerivation, array, base, bytestring, parsec }:
     mkDerivation {
       pname = "parse-dimacs";
       version = "1.3";
       sha256 = "f202179d3a4eb2e1ce48e4761c686ac085a8a62c9e9141519fc5c49e081cb02a";
       libraryHaskellDepends = [ array base bytestring parsec ];
       description = "DIMACS CNF parser library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parse-help" = callPackage
    ({ mkDerivation, attoparsec, base, cmdargs, containers
     , data-default, file-location, template-haskell, text, th-lift
     }:
     mkDerivation {
       pname = "parse-help";
       version = "0.0";
       sha256 = "ce9f4fea07bf416b3b685b4aa17b0ab6b310363ce845bdcf9a0f186813d9c7ef";
       libraryHaskellDepends = [
         attoparsec base containers data-default file-location
         template-haskell text th-lift
       ];
       testHaskellDepends = [ cmdargs ];
       jailbreak = true;
       homepage = "http://github.com/gregwebs/cmdargs-help";
       description = "generate command line arguments from a --help output";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parseargs_0_1_5_2" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "parseargs";
       version = "0.1.5.2";
       sha256 = "5595532abd4a515344f1e306304b169e9f61afcf23d9879d333b8b3c033ffc5f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [ base ];
       homepage = "http://github.com/BartMassey/parseargs";
       description = "Command-line argument parsing library for Haskell programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parseargs" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "parseargs";
       version = "0.2.0.4";
       sha256 = "79241584c88dbde0abd5dd32a079b9baaad4a87b136a19e78492141ace1aa090";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [ base ];
       homepage = "http://github.com/BartMassey/parseargs";
       description = "Full-featured command-line argument parsing library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parsec_3_1_7" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, mtl, test-framework
     , test-framework-hunit, text
     }:
     mkDerivation {
       pname = "parsec";
       version = "3.1.7";
       sha256 = "8aa31e78a7dc017d23a04cf99c8f836f1a49e2bda3f9149a8b89ab77ccb0078a";
       libraryHaskellDepends = [ base bytestring mtl text ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://www.cs.uu.nl/~daan/parsec.html";
       description = "Monadic parser combinators";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parsec_3_1_8" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, mtl, test-framework
     , test-framework-hunit, text
     }:
     mkDerivation {
       pname = "parsec";
       version = "3.1.8";
       sha256 = "98e6655432cae06fe38794b7c15693d697fed7964d360f865bc6c395e7997807";
       libraryHaskellDepends = [ base bytestring mtl text ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://www.cs.uu.nl/~daan/parsec.html";
       description = "Monadic parser combinators";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parsec" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, mtl, test-framework
     , test-framework-hunit, text
     }:
     mkDerivation {
       pname = "parsec";
       version = "3.1.9";
       sha256 = "71f711d24c89581a43b8bc2d3ed56a1a802bbf1cd0b083bc34636c232b0342c9";
       libraryHaskellDepends = [ base bytestring mtl text ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/aslatter/parsec";
       description = "Monadic parser combinators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parsec-extra" = callPackage
    ({ mkDerivation, base, monads-tf, parsec, transformers }:
     mkDerivation {
       pname = "parsec-extra";
       version = "0.1.0.5";
       sha256 = "c463e37a18a5f661a51e5b1b67b7b025bafa969fada109eef3467ce4e9bcb474";
       libraryHaskellDepends = [ base monads-tf parsec transformers ];
       description = "Some miscellaneous basic string parsers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parsec-numbers" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "parsec-numbers";
       version = "0.1.0";
       sha256 = "77019a4817712f6bfc61c9d148b680579955eb40d286f7766f7b0a90c726febf";
       libraryHaskellDepends = [ base parsec ];
       description = "Utilities for parsing numbers from strings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parsec-parsers" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, parsec
     , parsers
     }:
     mkDerivation {
       pname = "parsec-parsers";
       version = "0.2";
       sha256 = "72e841d83ea5f21a6e8309b661d009c092623e8704f6a10db8fb00ec2363d5ce";
       libraryHaskellDepends = [ base parsec parsers ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/parsec-parsers/";
       description = "Parsing instances for Parsec";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parsec-permutation" = callPackage
    ({ mkDerivation, base, parsec, QuickCheck }:
     mkDerivation {
       pname = "parsec-permutation";
       version = "0.1.2.0";
       sha256 = "b187eebf9d24bf66a2d5dbf66cf83442eb68bf316519985a2c738e04f87ecd79";
       libraryHaskellDepends = [ base parsec ];
       testHaskellDepends = [ base parsec QuickCheck ];
       description = "Applicative permutation parser for Parsec intended as a replacement for Text.Parsec.Perm.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parsec-tagsoup" = callPackage
    ({ mkDerivation, base, parsec, tagsoup }:
     mkDerivation {
       pname = "parsec-tagsoup";
       version = "0.1";
       sha256 = "c196a02bb9ce47f511703a7dc4b97037b5db66f89d0eeb4a9c54d6e88abbfadf";
       libraryHaskellDepends = [ base parsec tagsoup ];
       description = "Parsec parsers for Tagsoup tag streams";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "parsec-trace" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec }:
     mkDerivation {
       pname = "parsec-trace";
       version = "0.0.0.2";
       sha256 = "fc55e1feb6ec0247c52c4bdc533924688c4d5dbd29bf5f5a714e9fec6f4aa820";
       libraryHaskellDepends = [ base containers mtl parsec ];
       homepage = "http://github.com/sleepomeno/parsec-trace#readme";
       description = "Add a hierarchical trace to Parsec parsers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "parsec-utils" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "parsec-utils";
       version = "0.1.0.0";
       sha256 = "714723263ab6c35216b0d1bad13f864d9bb7986c648833a05cacffa67fa2cd5d";
       libraryHaskellDepends = [ base parsec ];
       description = "Utility functions and combinators for Text.Parsec";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parsec1" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "parsec1";
       version = "1.0.0.6";
       sha256 = "6698a7c36a8a4c145c1f1cb4c01e4bd7a69606ac8cf3d4f9ad1533a4287c9573";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.cs.uu.nl/~daan/parsec.html";
       description = "Portable monadic parser combinators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parsec2" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "parsec2";
       version = "1.0.1";
       sha256 = "9e0834db335562955515970bcc65938700d1cc0ab1159396d75a80b8ae29be1c";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/aslatter/parsec2";
       description = "Monadic parser combinators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parsec3" = callPackage
    ({ mkDerivation, base, bytestring, mtl, text }:
     mkDerivation {
       pname = "parsec3";
       version = "1.0.1.8";
       sha256 = "0e37050f755034f125a8e85eadbbdda93e3a28b6c0a8bbfaa626ea8a9d9be302";
       libraryHaskellDepends = [ base bytestring mtl text ];
       homepage = "http://www.cs.uu.nl/~daan/parsec.html";
       description = "Monadic parser combinators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parsec3-numbers" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "parsec3-numbers";
       version = "0.1.0";
       sha256 = "a532a1e77f43f10f283d94f51dafa54d907537d869cf501ab5c5d5bde1daee44";
       libraryHaskellDepends = [ base parsec ];
       description = "Utilities for parsing numbers from Char sequences";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parsedate" = callPackage
    ({ mkDerivation, base, old-locale, old-time, parsec }:
     mkDerivation {
       pname = "parsedate";
       version = "3000.0.0";
       sha256 = "37c6a51cd63b5bb34bf85ac476cd6b0ddc57317e52fbf106acad658deaa65e3f";
       libraryHaskellDepends = [ base old-locale old-time parsec ];
       homepage = "http://www.cs.chalmers.se/~bringert/darcs/parsedate/doc/";
       description = "Data and time parsing for CalendarTime";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parseerror-eq" = callPackage
    ({ mkDerivation, base, hspec, parsec }:
     mkDerivation {
       pname = "parseerror-eq";
       version = "0.1.0.1";
       sha256 = "035000bf10b842dabc917132e05dd797b20c2bbd3619d415c3027bfe40b1b0f0";
       libraryHaskellDepends = [ base parsec ];
       testHaskellDepends = [ base hspec parsec ];
       homepage = "https://github.com/stackbuilders/parseerror-eq";
       description = "Adds and Eq instance for Parsec's ParseError if needed";
       license = stdenv.lib.licenses.mit;
     }) {};

  "parsek" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "parsek";
       version = "1.0.1.3";
       sha256 = "e7768c89be8ac97ddf35a7a1d6bd92e0f822f6f3f3739197147b8fff125f8ca0";
       libraryHaskellDepends = [ base ];
       description = "Parallel Parsing Processes";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "parsely" = callPackage
    ({ mkDerivation, base, mtl, parsec }:
     mkDerivation {
       pname = "parsely";
       version = "0.1";
       sha256 = "cb7bf9cfc03e2aac44e358fb2a678039bab480f8033533394101cfa0b1184f9b";
       libraryHaskellDepends = [ base mtl parsec ];
       homepage = "http://naesten.dyndns.org:8080/repos/parsely";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parser-helper" = callPackage
    ({ mkDerivation, aeson, base, bytestring, haskell-src-exts, text }:
     mkDerivation {
       pname = "parser-helper";
       version = "0.1.0.0";
       sha256 = "ebde93c3f9cfb983c6bca8e37a4556f0a5b2265984f982132ddb2fdae1dd6d33";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring haskell-src-exts text
       ];
       jailbreak = true;
       description = "Prints Haskell parse trees in JSON";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parser241" = callPackage
    ({ mkDerivation, base, containers, hspec, mtl }:
     mkDerivation {
       pname = "parser241";
       version = "0.1.0.2";
       sha256 = "701863271570594b6ebadbcea7222ef7a6fd284119ba009bd38a33179f6d2280";
       revision = "1";
       editedCabalFile = "530e10fa50239e46be70ff47ab2e78214527ea5f76dc4de31c7e894ed13c7120";
       libraryHaskellDepends = [ base containers mtl ];
       testHaskellDepends = [ base containers hspec mtl ];
       homepage = "https://github.com/YLiLarry/parser241";
       description = "An interface to create production rules using augmented grammars";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parsergen" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, HUnit
     , parsec, QuickCheck, template-haskell, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "parsergen";
       version = "0.2.0.7";
       sha256 = "d1d5b408ddecc622671f850163e6a3723a6fd7c932a534d1c7f6a05ed425dd07";
       libraryHaskellDepends = [
         base bytestring directory filepath parsec template-haskell
       ];
       testHaskellDepends = [
         base bytestring directory filepath HUnit parsec QuickCheck
         template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       jailbreak = true;
       description = "TH parser generator for splitting bytestring into fixed-width fields";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parsers_0_12_1_1" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, charset, containers
     , directory, doctest, filepath, parsec, QuickCheck
     , quickcheck-instances, text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "parsers";
       version = "0.12.1.1";
       sha256 = "dcfd2a225dd6cad4a08c541054f562e505445de225a72321d0958e57572fa7fb";
       libraryHaskellDepends = [
         attoparsec base charset containers parsec text transformers
         unordered-containers
       ];
       testHaskellDepends = [
         attoparsec base bytestring containers directory doctest filepath
         parsec QuickCheck quickcheck-instances
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/parsers/";
       description = "Parsing combinators";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parsers_0_12_2_1" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, charset, containers
     , directory, doctest, filepath, parsec, QuickCheck
     , quickcheck-instances, scientific, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "parsers";
       version = "0.12.2.1";
       sha256 = "c7cae580925dded426c4a434a4f9a4a4db07f5fcc2395b401dec798144c73f73";
       libraryHaskellDepends = [
         attoparsec base charset containers parsec scientific text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         attoparsec base bytestring containers directory doctest filepath
         parsec QuickCheck quickcheck-instances
       ];
       doCheck = false;
       homepage = "http://github.com/ekmett/parsers/";
       description = "Parsing combinators";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parsers" = callPackage
    ({ mkDerivation, attoparsec, base, base-orphans, bytestring
     , charset, containers, directory, doctest, filepath, parsec
     , QuickCheck, quickcheck-instances, scientific, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "parsers";
       version = "0.12.3";
       sha256 = "c29058e385d6235d3222aa1fde08399ed7ef24a8b8eb0691c2c4dfe1d1ad9fa3";
       revision = "1";
       editedCabalFile = "a3ba295c6c3541e45a98f0b7f1d4ccc811817d77e09b50fbdad4a98a5c74405f";
       libraryHaskellDepends = [
         attoparsec base base-orphans charset containers parsec scientific
         text transformers unordered-containers
       ];
       testHaskellDepends = [
         attoparsec base bytestring containers directory doctest filepath
         parsec QuickCheck quickcheck-instances
       ];
       doCheck = false;
       homepage = "http://github.com/ekmett/parsers/";
       description = "Parsing combinators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "parsestar" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, bytestring-mmap
     , bytestring-nums, bytestring-show, containers, deepseq, derive
     , happy, mtl, zlib
     }:
     mkDerivation {
       pname = "parsestar";
       version = "1.5";
       sha256 = "5811e779d4495dfe89701588c6ee0c8d6c9c3e459515ed4837e62e11f7b12b5f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring bytestring-mmap bytestring-nums
         bytestring-show containers deepseq derive mtl zlib
       ];
       libraryToolDepends = [ happy ];
       executableHaskellDepends = [
         array base binary bytestring containers deepseq mtl
       ];
       jailbreak = true;
       description = "NMR-STAR file format parser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "parsimony" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "parsimony";
       version = "1.3";
       sha256 = "8f229049dccb73c13518977b7a6859d4a30d6c2647d3de1d2ea82694e6f66a6d";
       libraryHaskellDepends = [ base bytestring text ];
       description = "Monadic parser combinators derived from Parsec";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "partial" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "partial";
       version = "0.1.0.0";
       sha256 = "286fb90d8f2516ae553eda63b40cc7e707a6154a4487c9b55b5c3d64be077079";
       revision = "1";
       editedCabalFile = "f49cbb0cfb2f101a006bb54ada3982ae85b6413d019fd92927ce259b3666e172";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/paf31/partial";
       description = "A nullary type class for partial functions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "partial-handler_0_1_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "partial-handler";
       version = "0.1.0";
       sha256 = "ba919e32b21d1d3fe934b102fedd6b8060a601ef3ce580c88f3b269445d5b01d";
       revision = "1";
       editedCabalFile = "30dcb7f4190d779bcc35e9bfa48bb3620b8c48fbfa8627ab8a9a4633409e3288";
       libraryHaskellDepends = [ base ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/partial-handler";
       description = "A composable exception handler";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "partial-handler_0_1_1" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "partial-handler";
       version = "0.1.1";
       sha256 = "f57e914df9076135d3ea35a1bb884744ea2d1c56d45cbb5f444ba84a210b2195";
       revision = "1";
       editedCabalFile = "03c0fa67de9ab603f10ff005654e2648a824e65e90713edb36e74b99a35c4135";
       libraryHaskellDepends = [ base ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/partial-handler";
       description = "A composable exception handler";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "partial-handler" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "partial-handler";
       version = "1.0.0.0";
       sha256 = "f4676b5f9347309d807d4a571dbdf79935513bfebfc00e04b4ea9c8d068faeba";
       revision = "1";
       editedCabalFile = "2e1042c8b036ba686e544bfdd1302fd9f66f377010fa05739e7fc000d97fa597";
       libraryHaskellDepends = [ base ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/partial-handler";
       description = "A composable exception handler";
       license = stdenv.lib.licenses.mit;
     }) {};

  "partial-isomorphisms" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "partial-isomorphisms";
       version = "0.2";
       sha256 = "fd92b4a0e8346802e02423344fff6ce1817f14de0f0950f4b839c5735be8b472";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://www.informatik.uni-marburg.de/~rendel/unparse";
       description = "Partial isomorphisms";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "partial-lens" = callPackage
    ({ mkDerivation, base, comonad-transformers, data-lens
     , transformers
     }:
     mkDerivation {
       pname = "partial-lens";
       version = "0.0.1";
       sha256 = "48c96300942d503ea8b2c2d949a4965d76d60029c4c164452778a8405d32f768";
       libraryHaskellDepends = [
         base comonad-transformers data-lens transformers
       ];
       jailbreak = true;
       description = "Haskell 98 Partial Lenses";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "partial-uri" = callPackage
    ({ mkDerivation, base, network-uri }:
     mkDerivation {
       pname = "partial-uri";
       version = "0.2";
       sha256 = "630c946085926027b917a9b4d5660bb7a86cd440d68c29cdc4cddbbaa4aa7958";
       libraryHaskellDepends = [ base network-uri ];
       homepage = "https://github.com/singpolyma/partial-uri";
       description = "Datatype for passing around unresolved URIs";
       license = "unknown";
     }) {};

  "partly" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, base64-bytestring
     , binary, bytestring, optparse-applicative, QuickCheck, vector
     }:
     mkDerivation {
       pname = "partly";
       version = "1.0.0.2";
       sha256 = "fb9d644b442b07171edad28af5f08c9473c593504f381f3f6de4ecae3dc8ac68";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base binary bytestring ];
       executableHaskellDepends = [
         aeson aeson-pretty base base64-bytestring binary bytestring
         optparse-applicative vector
       ];
       testHaskellDepends = [
         aeson base base64-bytestring binary bytestring QuickCheck vector
       ];
       homepage = "https://github.com/startling/partly";
       description = "Inspect, create, and alter MBRs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "passage" = callPackage
    ({ mkDerivation, array, base, containers, directory, filepath
     , GraphSCC, monadLib, mwc-random, pretty, primitive, process
     , random
     }:
     mkDerivation {
       pname = "passage";
       version = "0.1";
       sha256 = "2f227b21ae53a6e735f9f61bcb2eaa7469309a0580040c3ebac8baa08ea81987";
       libraryHaskellDepends = [
         array base containers directory filepath GraphSCC monadLib
         mwc-random pretty primitive process random
       ];
       description = "Parallel code generation for hierarchical Bayesian modeling";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "passwords" = callPackage
    ({ mkDerivation, base, containers, MonadRandom, random }:
     mkDerivation {
       pname = "passwords";
       version = "0.1.0.6";
       sha256 = "919a4961db3daf7426532608202fcac4a9acac5321cf294a904b21a1dc2d6474";
       libraryHaskellDepends = [ base containers MonadRandom random ];
       description = "Password generation/validation library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pastis" = callPackage
    ({ mkDerivation, base, HTTP, network }:
     mkDerivation {
       pname = "pastis";
       version = "0.1.2";
       sha256 = "54f658e6309dfa8953612074e9f878fcaa4981e17aef0c6ffe58d5a2f57f4590";
       libraryHaskellDepends = [ base HTTP network ];
       description = "Interface to the past.is URL shortening service";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pasty" = callPackage
    ({ mkDerivation, base, bytestring, mtl }:
     mkDerivation {
       pname = "pasty";
       version = "0.1";
       sha256 = "5f083c5babf398673b97260fa75e4c282d24e328ea110e08bcf219852fc3f58a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bytestring mtl ];
       homepage = "http://github.com/markusle/pasty/tree/master";
       description = "A simple command line pasting utility";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "patch-combinators" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "patch-combinators";
       version = "0.2.2";
       sha256 = "267a992811a978e898df1d33b45112365779381e76ccb4485f5562d74deeeb00";
       libraryHaskellDepends = [ base ];
       description = "A library for patching functions and data structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "patch-image" = callPackage
    ({ mkDerivation, accelerate, accelerate-arithmetic, accelerate-cuda
     , accelerate-fft, accelerate-io, accelerate-utility, base, Cabal
     , filepath, gnuplot, hmatrix, JuicyPixels, utility-ht, vector
     }:
     mkDerivation {
       pname = "patch-image";
       version = "0.1.0.1";
       sha256 = "82cadcdd7aee8793777de191c2f0fe7702bf0e110b2b95031d88c4f9386d4353";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         accelerate accelerate-arithmetic accelerate-cuda accelerate-fft
         accelerate-io accelerate-utility base Cabal filepath gnuplot
         hmatrix JuicyPixels utility-ht vector
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/patch-image/";
       description = "Compose a big image from overlapping parts";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "patches-vector_0_1_5_0" = callPackage
    ({ mkDerivation, base, criterion, doctest, edit-distance-vector
     , microlens, QuickCheck, vector
     }:
     mkDerivation {
       pname = "patches-vector";
       version = "0.1.5.0";
       sha256 = "c220b914475430e7cae141e8d574c10b08c78d82977df40e6cf6e7cbe74ad113";
       libraryHaskellDepends = [
         base edit-distance-vector microlens vector
       ];
       testHaskellDepends = [ base criterion doctest QuickCheck vector ];
       jailbreak = true;
       homepage = "https://github.com/liamoc/patches-vector";
       description = "Patches (diffs) on vectors: composable, mergeable, and invertible";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "patches-vector" = callPackage
    ({ mkDerivation, base, criterion, doctest, edit-distance-vector
     , hspec, microlens, QuickCheck, vector
     }:
     mkDerivation {
       pname = "patches-vector";
       version = "0.1.5.1";
       sha256 = "9de35bf7cb4d5a4d10ad44a43a67a6310b4c5543248f43984fc4ee6689ca0db1";
       libraryHaskellDepends = [
         base edit-distance-vector microlens vector
       ];
       testHaskellDepends = [
         base criterion doctest hspec QuickCheck vector
       ];
       homepage = "https://github.com/liamoc/patches-vector";
       description = "Patches (diffs) on vectors: composable, mergeable, and invertible";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "path_0_5_2" = callPackage
    ({ mkDerivation, base, exceptions, filepath, hspec, HUnit, mtl
     , template-haskell
     }:
     mkDerivation {
       pname = "path";
       version = "0.5.2";
       sha256 = "64502de46ac2507bec7c571e95f38768bfabc08636086162bbf106aa9e075181";
       libraryHaskellDepends = [
         base exceptions filepath template-haskell
       ];
       testHaskellDepends = [ base hspec HUnit mtl ];
       description = "Path";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "path" = callPackage
    ({ mkDerivation, base, exceptions, filepath, hspec, HUnit, mtl
     , template-haskell
     }:
     mkDerivation {
       pname = "path";
       version = "0.5.3";
       sha256 = "6501bec6cf4a63520ad993bac5d7a0a71d4d0cb3c2155755a5faba93b82703c4";
       libraryHaskellDepends = [
         base exceptions filepath template-haskell
       ];
       testHaskellDepends = [ base hspec HUnit mtl ];
       description = "Path";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "path-extra" = callPackage
    ({ mkDerivation, base, exceptions, path }:
     mkDerivation {
       pname = "path-extra";
       version = "0.0.3";
       sha256 = "55043bb37a3aaecd162d336c19483b3fb36397fa6cd48a182caf876502638b59";
       libraryHaskellDepends = [ base exceptions path ];
       description = "Chris Done's path library, enriched with URL-related goodies";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "path-io_0_2_0" = callPackage
    ({ mkDerivation, base, directory, exceptions, filepath, path
     , temporary, time, transformers
     }:
     mkDerivation {
       pname = "path-io";
       version = "0.2.0";
       sha256 = "bb72cdbefe7083f2ad9e7eada730e6297bff9941989c0652f698342c4359e735";
       libraryHaskellDepends = [
         base directory exceptions filepath path temporary time transformers
       ];
       homepage = "https://github.com/mrkkrp/path-io";
       description = "Interface to ‘directory’ package for users of ‘path’";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "path-io" = callPackage
    ({ mkDerivation, base, directory, exceptions, filepath, path
     , temporary, time, transformers
     }:
     mkDerivation {
       pname = "path-io";
       version = "0.3.1";
       sha256 = "b96763bd3a123a50341e003b2176a2fc72e93f8c9e717279cffe56fd824f693f";
       libraryHaskellDepends = [
         base directory exceptions filepath path temporary time transformers
       ];
       homepage = "https://github.com/mrkkrp/path-io";
       description = "Interface to ‘directory’ package for users of ‘path’";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "path-pieces_0_1_4" = callPackage
    ({ mkDerivation, base, hspec, HUnit, QuickCheck, text, time }:
     mkDerivation {
       pname = "path-pieces";
       version = "0.1.4";
       sha256 = "5b78f3375dcbac842b7b7bf08e8398255234e8f12ede96c33f75223417b9b0bb";
       libraryHaskellDepends = [ base text time ];
       testHaskellDepends = [ base hspec HUnit QuickCheck text ];
       description = "Components of paths";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "path-pieces_0_1_5" = callPackage
    ({ mkDerivation, base, hspec, HUnit, QuickCheck, text, time }:
     mkDerivation {
       pname = "path-pieces";
       version = "0.1.5";
       sha256 = "bca399f1545423a940672106139fce1a8b5208dc9b998b89baa3d6bb1f513e17";
       libraryHaskellDepends = [ base text time ];
       testHaskellDepends = [ base hspec HUnit QuickCheck text ];
       description = "Components of paths";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "path-pieces_0_2_0" = callPackage
    ({ mkDerivation, base, hspec, HUnit, QuickCheck, text, time }:
     mkDerivation {
       pname = "path-pieces";
       version = "0.2.0";
       sha256 = "c097672ab0dd1835b8cadbbd9db412893f02e02eca044c5a1690fbefb3e8df84";
       libraryHaskellDepends = [ base text time ];
       testHaskellDepends = [ base hspec HUnit QuickCheck text ];
       description = "Components of paths";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "path-pieces" = callPackage
    ({ mkDerivation, base, hspec, HUnit, QuickCheck, text, time }:
     mkDerivation {
       pname = "path-pieces";
       version = "0.2.1";
       sha256 = "080bd49f53e20597ca3e5962e0c279a3422345f5b088840a30a751cd76d4a36f";
       revision = "1";
       editedCabalFile = "c713a8d04b3e6b89f1116c1d5fe434305031e17a9f0ad30a457a8402e1d5fc5c";
       libraryHaskellDepends = [ base text time ];
       testHaskellDepends = [ base hspec HUnit QuickCheck text ];
       description = "Components of paths";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "pathfinding" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "pathfinding";
       version = "0.1.0.0";
       sha256 = "007971e690fdcee9844c576028fe291f666f880528da1ace4283d047fabc3bb4";
       libraryHaskellDepends = [ base containers ];
       homepage = "https://github.com/rvion/pathfinding";
       description = "pathfinding in grid and graphs";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pathfindingcore" = callPackage
    ({ mkDerivation, array, base, HUnit, split, tasty, tasty-hunit }:
     mkDerivation {
       pname = "pathfindingcore";
       version = "1.2";
       sha256 = "88990d5daa4beff64a134e11bfbeb81b4f67367ea0345c3c6c3697ead3e14b74";
       libraryHaskellDepends = [ array base split ];
       testHaskellDepends = [ array base HUnit tasty tasty-hunit ];
       homepage = "http://github.com/TheBizzle";
       description = "A toy pathfinding library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pathtype" = callPackage
    ({ mkDerivation, base, deepseq, directory, QuickCheck, random
     , tagged, time, transformers, utility-ht
     }:
     mkDerivation {
       pname = "pathtype";
       version = "0.7.0.1";
       sha256 = "f63692c829eed50588feb68a4ba1a711354f680553c9788c9c4795f821ff47b4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base deepseq directory QuickCheck tagged time transformers
         utility-ht
       ];
       testHaskellDepends = [ base random ];
       homepage = "http://hub.darcs.net/thielema/pathtype/";
       description = "Type-safe replacement for System.FilePath etc";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pathwalk" = callPackage
    ({ mkDerivation, base, directory, filepath, transformers }:
     mkDerivation {
       pname = "pathwalk";
       version = "0.3.1.2";
       sha256 = "76e0d0646a3133a062dbae4e9d37d59e71d6328706bb178552a93800e4550e91";
       libraryHaskellDepends = [ base directory filepath transformers ];
       testHaskellDepends = [ base ];
       homepage = "https://github.com/Xe/pathwalk";
       description = "Path walking utilities for Haskell programs";
       license = stdenv.lib.licenses.mit;
     }) {};

  "patience" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "patience";
       version = "0.1.1";
       sha256 = "35c7c334d344b3cbdc61cc88c559bedb300ace860a80e3990aeb268f1f10db63";
       libraryHaskellDepends = [ base containers ];
       description = "Patience diff and longest increasing subsequence";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "patronscraper" = callPackage
    ({ mkDerivation, base, HandsomeSoup, hxt }:
     mkDerivation {
       pname = "patronscraper";
       version = "0.0.0.1";
       sha256 = "71437a5231b53d4751c305d6da7908a3793319dcde799c9903e1b48dc77df529";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base HandsomeSoup hxt ];
       jailbreak = true;
       description = "A webpage scraper for Patreon which dumps a list of patrons to a text file";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pattern-arrows" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "pattern-arrows";
       version = "0.0.2";
       sha256 = "6fc2d972e72785d727d2b68e1f82ef94a2c93cedbc00e6a4cdc03498825c078f";
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://blog.functorial.com/posts/2013-10-27-Pretty-Printing-Arrows.html";
       description = "Arrows for Pretty Printing";
       license = stdenv.lib.licenses.mit;
     }) {};

  "patterns" = callPackage
    ({ mkDerivation, base, bytestring, conduit, containers, mtl, time
     , utf8-string, zeromq-haskell
     }:
     mkDerivation {
       pname = "patterns";
       version = "0.1.1";
       sha256 = "fba27077c859449c3af545cc441f80aaa0c675c3e05dadf97174e6f5c588da9c";
       libraryHaskellDepends = [
         base bytestring conduit containers mtl time utf8-string
         zeromq-haskell
       ];
       homepage = "http://github.com/toschoo/mom";
       description = "Common patterns in message-oriented applications";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "paymill" = callPackage
    ({ mkDerivation, base, hspec }:
     mkDerivation {
       pname = "paymill";
       version = "0.0.0";
       sha256 = "40edc09ae13eac3457294fb21543fbce246b91639820ebad2a8e1b7360af83bf";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec ];
       description = "This is an unofficial client for the Paymill API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "paypal-adaptive-hoops" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, errors
     , filepath, http-client, HUnit, lens, lens-aeson, test-framework
     , test-framework-hunit, text, time, transformers, vector, wreq
     }:
     mkDerivation {
       pname = "paypal-adaptive-hoops";
       version = "0.13.1.0";
       sha256 = "09997162d0533ec80a0cda3bcb84f48a59acdac367a61703fb32c98594d5965f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring errors http-client lens lens-aeson text time
         transformers vector wreq
       ];
       executableHaskellDepends = [ base text ];
       testHaskellDepends = [
         aeson base bytestring directory filepath HUnit test-framework
         test-framework-hunit text
       ];
       jailbreak = true;
       homepage = "https://github.com/fanjam/paypal-adaptive-hoops";
       description = "Client for a limited part of PayPal's Adaptive Payments API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "paypal-api" = callPackage
    ({ mkDerivation, base, bytestring, conduit, containers, failure
     , http-conduit, http-types, mtl, old-locale, text, time, wai
     }:
     mkDerivation {
       pname = "paypal-api";
       version = "0.2";
       sha256 = "304d94bd70eb5ddb7289d3ad2e97b4ef08a539bbde0fb4c0d2e8acb5bb37a946";
       libraryHaskellDepends = [
         base bytestring conduit containers failure http-conduit http-types
         mtl old-locale text time wai
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/paypal-api/";
       description = "PayPal API, currently supporting \"ButtonManager\"";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pb" = callPackage
    ({ mkDerivation, base, containers, HTTP, network, process }:
     mkDerivation {
       pname = "pb";
       version = "0.1.0";
       sha256 = "aefd84fffef08e89b21086f90ecb26164c56c5092427501f686cf3e3632b8b0d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers HTTP network process
       ];
       description = "pastebin command line application";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pbc4hs" = callPackage
    ({ mkDerivation, base, hslua, string-qq }:
     mkDerivation {
       pname = "pbc4hs";
       version = "0.1.1.5";
       sha256 = "e98b3d9e9c0361eb43f1f7dfcdc2d85d72eb51572081aed6bcd9f4d4048ab399";
       libraryHaskellDepends = [ base hslua string-qq ];
       jailbreak = true;
       homepage = "https://github.com/DavidFeng/pbc4hs";
       description = "pbc for HsLua";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pbkdf" = callPackage
    ({ mkDerivation, base, binary, byteable, bytedump, bytestring
     , cryptohash, utf8-string
     }:
     mkDerivation {
       pname = "pbkdf";
       version = "1.1.1.1";
       sha256 = "ddc5755cc895b00af47cadf70f71c0a97675659754a137c403200e62d54476d9";
       libraryHaskellDepends = [
         base binary byteable bytedump bytestring cryptohash utf8-string
       ];
       testHaskellDepends = [
         base binary byteable bytedump bytestring cryptohash utf8-string
       ];
       homepage = "https://github.com/cdornan/pbkdf";
       description = "Haskell implementation of the PBKDF functions from RFC-2898";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pcap" = callPackage
    ({ mkDerivation, base, bytestring, network, time }:
     mkDerivation {
       pname = "pcap";
       version = "0.4.5.2";
       sha256 = "e7e92e6ff4bffa22102335a38dabb97fd0771fdf3b75d45cd7c1708c85e1cd5f";
       libraryHaskellDepends = [ base bytestring network time ];
       homepage = "https://github.com/bos/pcap";
       description = "A system-independent interface for user-level packet capture";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pcap-conduit" = callPackage
    ({ mkDerivation, base, bytestring, conduit, pcap, transformers }:
     mkDerivation {
       pname = "pcap-conduit";
       version = "0.1";
       sha256 = "7f1a026da82f3d29c89a92e78ed08795eb455992cb4b6911490a19831567461d";
       libraryHaskellDepends = [
         base bytestring conduit pcap transformers
       ];
       homepage = "http://github.com/thoughtpolice/pcap-conduit";
       description = "Conduit <-> libpcap";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pcap-enumerator" = callPackage
    ({ mkDerivation, base, bytestring, enumerator, pcap, transformers
     }:
     mkDerivation {
       pname = "pcap-enumerator";
       version = "0.5";
       sha256 = "ab614d7037df2fbd093f277353764310b17b9854bbfeb5325c9114bde4c8ea6c";
       libraryHaskellDepends = [
         base bytestring enumerator pcap transformers
       ];
       homepage = "http://github.com/cutsea110/pcap-enumerator";
       description = "Convert a pcap into an enumerator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pcd-loader" = callPackage
    ({ mkDerivation, attoparsec, base, binary, bytestring, deepseq
     , directory, HUnit, lens, linear, mtl, string-qq, test-framework
     , test-framework-hunit, text, vector
     }:
     mkDerivation {
       pname = "pcd-loader";
       version = "0.3.0.1";
       sha256 = "a72226ce1394d7badacf16a9c5809f072c05bb5dc094712459c2880e58d99edb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base binary bytestring deepseq lens linear mtl text
         vector
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base directory HUnit lens string-qq test-framework
         test-framework-hunit text vector
       ];
       description = "PCD file loader";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pcf" = callPackage
    ({ mkDerivation, base, bound, c-dsl, containers, monad-gen, mtl
     , prelude-extras, transformers, void
     }:
     mkDerivation {
       pname = "pcf";
       version = "0.1.0.1";
       sha256 = "a5b0d367e72b43fdce2baa53093da60941c48bb07c08d5dfb1c469ea9d4ab7b6";
       libraryHaskellDepends = [
         base bound c-dsl containers monad-gen mtl prelude-extras
         transformers void
       ];
       description = "A one file compiler for PCF";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pcg-random" = callPackage
    ({ mkDerivation, base, bytestring, doctest, entropy, primitive
     , random, time
     }:
     mkDerivation {
       pname = "pcg-random";
       version = "0.1.3.2";
       sha256 = "288db42bb77ffef6e57007b893b41df5a3ac8f252d5a519306448cb5802ebe71";
       libraryHaskellDepends = [
         base bytestring entropy primitive random time
       ];
       testHaskellDepends = [ base doctest ];
       homepage = "http://github.com/cchalmers/pcg-random";
       description = "Haskell bindings to the PCG random number generator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pcre-heavy_0_2_2" = callPackage
    ({ mkDerivation, base, bytestring, doctest, Glob, pcre-light
     , stringable, template-haskell
     }:
     mkDerivation {
       pname = "pcre-heavy";
       version = "0.2.2";
       sha256 = "834ba945e545983a96d7aa960b86cbbbd8cf5861e367f7919ff2e2e2ea369b21";
       libraryHaskellDepends = [
         base bytestring pcre-light stringable template-haskell
       ];
       testHaskellDepends = [ base doctest Glob ];
       homepage = "https://github.com/myfreeweb/pcre-heavy";
       description = "A regexp library on top of pcre-light you can actually use";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pcre-heavy_0_2_3" = callPackage
    ({ mkDerivation, base, bytestring, doctest, Glob, pcre-light
     , stringable, template-haskell
     }:
     mkDerivation {
       pname = "pcre-heavy";
       version = "0.2.3";
       sha256 = "d516a6d589fc44906650e8adc044860d30efb9427f5d8ac4da6c0a1ab3123759";
       libraryHaskellDepends = [
         base bytestring pcre-light stringable template-haskell
       ];
       testHaskellDepends = [ base doctest Glob ];
       homepage = "https://github.com/myfreeweb/pcre-heavy";
       description = "A regexp library on top of pcre-light you can actually use";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pcre-heavy_0_2_5" = callPackage
    ({ mkDerivation, base, bytestring, doctest, Glob, pcre-light
     , stringable, template-haskell
     }:
     mkDerivation {
       pname = "pcre-heavy";
       version = "0.2.5";
       sha256 = "01b599e8a3629795b4afb2bbb9e65bb114ddbccd867ca8806d75aa56e3bacde7";
       libraryHaskellDepends = [
         base bytestring pcre-light stringable template-haskell
       ];
       testHaskellDepends = [ base doctest Glob ];
       homepage = "https://github.com/myfreeweb/pcre-heavy";
       description = "A regexp library on top of pcre-light you can actually use";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pcre-heavy" = callPackage
    ({ mkDerivation, base, base-compat, bytestring, doctest, Glob
     , pcre-light, semigroups, string-conversions, template-haskell
     }:
     mkDerivation {
       pname = "pcre-heavy";
       version = "1.0.0.1";
       sha256 = "a83e86a72c2bd8073dc71fc115c3b432c00c6294918250bed87f34a8c31ab0ec";
       libraryHaskellDepends = [
         base base-compat bytestring pcre-light semigroups
         string-conversions template-haskell
       ];
       testHaskellDepends = [ base doctest Glob ];
       homepage = "https://github.com/myfreeweb/pcre-heavy";
       description = "A regexp library on top of pcre-light you can actually use";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "pcre-less" = callPackage
    ({ mkDerivation, array, base, regex-pcre }:
     mkDerivation {
       pname = "pcre-less";
       version = "0.2.1";
       sha256 = "c9617e9bd07dc01885c5d320abc93a32c920ea0e02e7cea9495f894cfeb52df2";
       libraryHaskellDepends = [ array base regex-pcre ];
       description = "Nicer interface to regex-pcre";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pcre-light_0_4_0_3" = callPackage
    ({ mkDerivation, base, bytestring, pcre }:
     mkDerivation {
       pname = "pcre-light";
       version = "0.4.0.3";
       sha256 = "6e6309fe0f759fe685c8c58a14dd204f7691675b15adbd88208ee332b5702d50";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ pcre ];
       homepage = "https://github.com/Daniel-Diaz/pcre-light";
       description = "A small, efficient and portable regex library for Perl 5 compatible regular expressions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) pcre;};

  "pcre-light" = callPackage
    ({ mkDerivation, base, bytestring, pcre }:
     mkDerivation {
       pname = "pcre-light";
       version = "0.4.0.4";
       sha256 = "02c97e39263d18fd26aa63d52c88c4bfbb5c3f66ab40564552e7f11d5d889e75";
       libraryHaskellDepends = [ base bytestring ];
       libraryPkgconfigDepends = [ pcre ];
       homepage = "https://github.com/Daniel-Diaz/pcre-light";
       description = "Portable regex library for Perl 5 compatible regular expressions";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) pcre;};

  "pcre-light-extra" = callPackage
    ({ mkDerivation, base, bytestring, pcre-light }:
     mkDerivation {
       pname = "pcre-light-extra";
       version = "0.0.0";
       sha256 = "7daf891775c00f9105051c9246ff8d8ecaee0a163503a8b309ed6bfa9e1950ce";
       libraryHaskellDepends = [ base bytestring pcre-light ];
       jailbreak = true;
       homepage = "http://github.com/urso/pcre-light-extra";
       description = "pcre-light extra functionality";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pcre-utils" = callPackage
    ({ mkDerivation, array, attoparsec, base, bytestring, HUnit, mtl
     , regex-pcre-builtin, vector
     }:
     mkDerivation {
       pname = "pcre-utils";
       version = "0.1.7";
       sha256 = "27eb5861a85399fb4d3fe1e95898a95fd4d9b4f68fdab4ef38c38a1b260e2ed6";
       libraryHaskellDepends = [
         array attoparsec base bytestring mtl regex-pcre-builtin vector
       ];
       testHaskellDepends = [ base bytestring HUnit regex-pcre-builtin ];
       homepage = "https://github.com/bartavelle/pcre-utils";
       description = "Perl-like substitute and split for PCRE regexps";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pdf-toolbox-content_0_0_5_0" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, bytestring
     , containers, io-streams, pdf-toolbox-core, text
     }:
     mkDerivation {
       pname = "pdf-toolbox-content";
       version = "0.0.5.0";
       sha256 = "586fcc00bc9f1f71c7d19612133cd10bbad215013abe8c6b5019f05645b678fc";
       libraryHaskellDepends = [
         attoparsec base base16-bytestring bytestring containers io-streams
         pdf-toolbox-core text
       ];
       homepage = "https://github.com/Yuras/pdf-toolbox";
       description = "A collection of tools for processing PDF files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pdf-toolbox-content" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, bytestring
     , containers, io-streams, pdf-toolbox-core, text
     }:
     mkDerivation {
       pname = "pdf-toolbox-content";
       version = "0.0.5.1";
       sha256 = "1c104e232e178603ff9dd8c6eaaf0ccbda918c70b40ed63f08fa1922a3c88488";
       libraryHaskellDepends = [
         attoparsec base base16-bytestring bytestring containers io-streams
         pdf-toolbox-core text
       ];
       homepage = "https://github.com/Yuras/pdf-toolbox";
       description = "A collection of tools for processing PDF files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pdf-toolbox-core_0_0_4_0" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, errors
     , io-streams, scientific, transformers, zlib-bindings
     }:
     mkDerivation {
       pname = "pdf-toolbox-core";
       version = "0.0.4.0";
       sha256 = "72760da19e24bea4f2bee3114ce702437d413c531347c8fd544fcae717c83e95";
       libraryHaskellDepends = [
         attoparsec base bytestring containers errors io-streams scientific
         transformers zlib-bindings
       ];
       homepage = "https://github.com/Yuras/pdf-toolbox";
       description = "A collection of tools for processing PDF files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pdf-toolbox-core" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, errors
     , io-streams, scientific, transformers, zlib-bindings
     }:
     mkDerivation {
       pname = "pdf-toolbox-core";
       version = "0.0.4.1";
       sha256 = "cce3949ef5596b5d61032ce1547160dc5f52e3d5c556dcdb9aabf1582173a981";
       libraryHaskellDepends = [
         attoparsec base bytestring containers errors io-streams scientific
         transformers zlib-bindings
       ];
       homepage = "https://github.com/Yuras/pdf-toolbox";
       description = "A collection of tools for processing PDF files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pdf-toolbox-document_0_0_7_0" = callPackage
    ({ mkDerivation, base, bytestring, cipher-aes, cipher-rc4
     , containers, crypto-api, cryptohash, io-streams
     , pdf-toolbox-content, pdf-toolbox-core, text, transformers
     }:
     mkDerivation {
       pname = "pdf-toolbox-document";
       version = "0.0.7.0";
       sha256 = "35df65f736f7ab5ea27214d8680b6eb7098a5a0d2d477709702d5c8a2880cd2d";
       libraryHaskellDepends = [
         base bytestring cipher-aes cipher-rc4 containers crypto-api
         cryptohash io-streams pdf-toolbox-content pdf-toolbox-core text
         transformers
       ];
       homepage = "https://github.com/Yuras/pdf-toolbox";
       description = "A collection of tools for processing PDF files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pdf-toolbox-document" = callPackage
    ({ mkDerivation, base, bytestring, cipher-aes, cipher-rc4
     , containers, crypto-api, cryptohash, io-streams
     , pdf-toolbox-content, pdf-toolbox-core, text, transformers
     }:
     mkDerivation {
       pname = "pdf-toolbox-document";
       version = "0.0.7.1";
       sha256 = "3f7d379baa85c1cf9998e3f84177ad24b5cc8632fb211af7a09603e59596f0e1";
       libraryHaskellDepends = [
         base bytestring cipher-aes cipher-rc4 containers crypto-api
         cryptohash io-streams pdf-toolbox-content pdf-toolbox-core text
         transformers
       ];
       homepage = "https://github.com/Yuras/pdf-toolbox";
       description = "A collection of tools for processing PDF files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pdf-toolbox-viewer" = callPackage
    ({ mkDerivation, base, bytestring, cairo, containers, directory
     , filepath, gtk, io-streams, pdf-toolbox-content
     , pdf-toolbox-document, process, random, text, transformers
     }:
     mkDerivation {
       pname = "pdf-toolbox-viewer";
       version = "0.0.5.0";
       sha256 = "b8e595dae83fb2b8e47e0fd18a5dda508f85c2352beed3c507e3fe6fad0669ef";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cairo containers directory filepath gtk io-streams
         pdf-toolbox-content pdf-toolbox-document process random text
         transformers
       ];
       homepage = "https://github.com/Yuras/pdf-toolbox";
       description = "Simple pdf viewer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pdf2line" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, filepath
     , FindBin, process
     }:
     mkDerivation {
       pname = "pdf2line";
       version = "0.0.1";
       sha256 = "45ddbc65221843e866947c014ed32d1df23a1a7062b41a36dcc41549726b491d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring containers filepath FindBin process
       ];
       description = "Simple command-line utility to convert PDF into text";
       license = "GPL";
     }) {};

  "pdfinfo_1_5_1" = callPackage
    ({ mkDerivation, base, mtl, old-locale, process-extras, text, time
     }:
     mkDerivation {
       pname = "pdfinfo";
       version = "1.5.1";
       sha256 = "bd64327ff0c047e303083d66bb1349e197adf3ab535e6fdddf9e747c13b41ff6";
       libraryHaskellDepends = [
         base mtl old-locale process-extras text time
       ];
       jailbreak = true;
       homepage = "https://github.com/chrisdone/pdfinfo";
       description = "Wrapper around the pdfinfo command";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pdfinfo_1_5_2" = callPackage
    ({ mkDerivation, base, mtl, old-locale, process-extras, text, time
     }:
     mkDerivation {
       pname = "pdfinfo";
       version = "1.5.2";
       sha256 = "58c20aac5312d8e7cea06e4bede9ba36e8baceb9336f89ef75a73c8d598550e8";
       libraryHaskellDepends = [
         base mtl old-locale process-extras text time
       ];
       jailbreak = true;
       homepage = "https://github.com/chrisdone/pdfinfo";
       description = "Wrapper around the pdfinfo command";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pdfinfo" = callPackage
    ({ mkDerivation, base, mtl, old-locale, process-extras, text, time
     , time-locale-compat
     }:
     mkDerivation {
       pname = "pdfinfo";
       version = "1.5.4";
       sha256 = "9a6a1f7d8ab0a5e8f7f8276da070ccddec140d6b2549b084042159b639230911";
       libraryHaskellDepends = [
         base mtl old-locale process-extras text time time-locale-compat
       ];
       homepage = "https://github.com/chrisdone/pdfinfo";
       description = "Wrapper around the pdfinfo command";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pdfsplit" = callPackage
    ({ mkDerivation, base, directory, pdfinfo, process, temporary }:
     mkDerivation {
       pname = "pdfsplit";
       version = "0.0.1";
       sha256 = "aa5f6fffa6e82c848e59a6aa9047160835611df506d6bd53db897235bc5b7601";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory pdfinfo process temporary
       ];
       jailbreak = true;
       homepage = "http://dmwit.com/pdfsplit";
       description = "split two-column PDFs, so there is one column per page";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pdynload" = callPackage
    ({ mkDerivation, base, directory, filepath, ghc, ghc-paths
     , old-time, process
     }:
     mkDerivation {
       pname = "pdynload";
       version = "0.0.3";
       sha256 = "23f10b8bb9ef6213c8d950b92abe625794f7fa348d81b48ddee9ba82e6b78924";
       libraryHaskellDepends = [
         base directory filepath ghc ghc-paths old-time process
       ];
       description = "pdynload is polymorphic dynamic linking library";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "peakachu" = callPackage
    ({ mkDerivation, base, derive, GLUT, List, template-haskell, time
     , TypeCompose
     }:
     mkDerivation {
       pname = "peakachu";
       version = "0.3.1";
       sha256 = "b7d768596049ba0caaea35bc7e0c8399119d463d1c629275e6f7e7656d54b4f2";
       libraryHaskellDepends = [
         base derive GLUT List template-haskell time TypeCompose
       ];
       description = "Experiemental library for composable interactive programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "peano" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "peano";
       version = "0.1.0.1";
       sha256 = "31fdd23993a76155738224a7b230a1a6fcfde091b2fbc945df4cb54068eeec7b";
       libraryHaskellDepends = [ base ];
       description = "Peano numbers";
       license = "unknown";
     }) {};

  "peano-inf" = callPackage
    ({ mkDerivation, base, containers, lazysmallcheck }:
     mkDerivation {
       pname = "peano-inf";
       version = "0.6.5";
       sha256 = "6b8cb7a289c57d1f3aa834e7bdb94d26d1819c154b3381230bc4333c19dd19f1";
       libraryHaskellDepends = [ base containers lazysmallcheck ];
       description = "Lazy Peano numbers including observable infinity value";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pec" = callPackage
    ({ mkDerivation, array, base, Cabal, cmdargs, containers, deepseq
     , derive, directory, filepath, grm, mtl, old-time, process, shake
     , syb, uniplate, wl-pprint
     }:
     mkDerivation {
       pname = "pec";
       version = "0.2.3";
       sha256 = "609aa09bd87ab0f8da5df7ed06c46f02976c91ca5b84669539cbd43792271184";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base Cabal cmdargs containers deepseq derive grm mtl shake
         syb uniplate wl-pprint
       ];
       executableHaskellDepends = [
         base Cabal cmdargs deepseq derive directory filepath grm mtl
         old-time process shake syb uniplate wl-pprint
       ];
       description = "pec embedded compiler";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pecoff" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers }:
     mkDerivation {
       pname = "pecoff";
       version = "0.11";
       sha256 = "38fc0de406f1d44ccf570e39bf8fa69d159d3d2b0100b48c223381419d14626d";
       libraryHaskellDepends = [ base binary bytestring containers ];
       description = "Parser for PE/COFF format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "peg" = callPackage
    ({ mkDerivation, base, containers, filepath, haskeline, logict, mtl
     , parsec
     }:
     mkDerivation {
       pname = "peg";
       version = "0.2";
       sha256 = "8d7d6b939df8ee34cc343e2d90fcb9c373e79f010b0d41b3bfbc8561a7350556";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers filepath haskeline logict mtl parsec
       ];
       homepage = "http://github.com/HackerFoo/peg";
       description = "a lazy non-deterministic concatenative programming language";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "peggy" = callPackage
    ({ mkDerivation, base, hashtables, haskell-src-meta, ListLike
     , monad-control, mtl, template-haskell
     }:
     mkDerivation {
       pname = "peggy";
       version = "0.3.2";
       sha256 = "de689373195748a273ba224adf5eae6dd91ffeee68e4c60ce6230596d521a8ce";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base hashtables haskell-src-meta ListLike monad-control mtl
         template-haskell
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://tanakh.github.com/Peggy";
       description = "The Parser Generator for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pell" = callPackage
    ({ mkDerivation, arithmoi, base, Cabal, cabal-test-quickcheck
     , containers, primes, QuickCheck
     }:
     mkDerivation {
       pname = "pell";
       version = "0.1.0.0";
       sha256 = "addb0a4330e748f2d7fe4305acf7af5344f437208a90d6c7a637820679a4af6b";
       libraryHaskellDepends = [ arithmoi base containers ];
       testHaskellDepends = [
         arithmoi base Cabal cabal-test-quickcheck containers primes
         QuickCheck
       ];
       jailbreak = true;
       homepage = "https://github.com/brunjlar/pell";
       description = "Package to solve the Generalized Pell Equation";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pem" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, HUnit, mtl
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "pem";
       version = "0.2.2";
       sha256 = "372808c76c6d860aedb4e30171cb4ee9f6154d9f68e3f2310f820bf174995a98";
       libraryHaskellDepends = [ base base64-bytestring bytestring mtl ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "http://github.com/vincenthz/hs-pem";
       description = "Privacy Enhanced Mail (PEM) format reader and writer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "penn-treebank" = callPackage
    ({ mkDerivation, base, containers, parsec }:
     mkDerivation {
       pname = "penn-treebank";
       version = "0.1.0.1";
       sha256 = "1e831f8f1be59fface2ef986eabc223306855a3ed6146fe940073135ec5f8589";
       libraryHaskellDepends = [ base containers parsec ];
       description = "Tools for manipulating the Penn TreeBank";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "penny" = callPackage
    ({ mkDerivation, action-permutations, anonymous-sums, base
     , bytestring, cereal, containers, contravariant, either, matchers
     , multiarg, ofx, old-locale, parsec, prednote, QuickCheck, rainbow
     , rainbox, random-shuffle, semigroups, split, tasty
     , tasty-quickcheck, text, time, transformers
     }:
     mkDerivation {
       pname = "penny";
       version = "0.32.0.10";
       sha256 = "110bc1e475cebf0b02605a15238e11d93711a436ae9e6f176648b313218cfd2f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         action-permutations anonymous-sums base bytestring cereal
         containers contravariant either matchers multiarg ofx old-locale
         parsec prednote rainbow rainbox semigroups split text time
         transformers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         anonymous-sums base parsec QuickCheck random-shuffle semigroups
         tasty tasty-quickcheck text time transformers
       ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/penny";
       description = "Extensible double-entry accounting system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "penny-bin" = callPackage
    ({ mkDerivation, base, containers, explicit-exception, multiarg
     , parsec, penny-lib, pretty-show, semigroups, text, transformers
     }:
     mkDerivation {
       pname = "penny-bin";
       version = "0.22.0.0";
       sha256 = "34e5ac3bdcb51548fc69dd072d41ecc5f3f8e02e7b1bce2fd3df0bcf2e47b455";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers explicit-exception multiarg parsec penny-lib
         pretty-show semigroups text transformers
       ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/penny";
       description = "Deprecated - use penny package instead";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "penny-lib" = callPackage
    ({ mkDerivation, action-permutations, base, binary, bytestring
     , cereal, containers, explicit-exception, matchers, multiarg, ofx
     , old-locale, parsec, prednote, pretty-show, rainbow, semigroups
     , split, text, time, transformers
     }:
     mkDerivation {
       pname = "penny-lib";
       version = "0.22.0.0";
       sha256 = "272c53dc6cecc0353d4a6a53a9d8e6e57babdf485b5f9e1995f3a8b87b38c63b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         action-permutations base binary bytestring cereal containers
         explicit-exception matchers multiarg ofx old-locale parsec prednote
         pretty-show rainbow semigroups split text time transformers
       ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/penny";
       description = "Deprecated - use penny package instead";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "peparser" = callPackage
    ({ mkDerivation, base, binary, bytestring, haskell98 }:
     mkDerivation {
       pname = "peparser";
       version = "0.21";
       sha256 = "a4f8b002ed40c29a9fc3dbc97af410e8f4db822dc5ea49706c31dd7de183c8e3";
       libraryHaskellDepends = [ base binary bytestring haskell98 ];
       homepage = "https://github.com/igraves/peparser-haskell";
       description = "A parser for PE object files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "perceptron" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "perceptron";
       version = "0.1.0.3";
       sha256 = "e854329cfb148c22c4117914f877cf70622aafd0dfa6adb7f122fd41b6ce3b70";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "The perceptron learning algorithm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "perdure" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, cognimeta-utils
     , collections-api, comonad-transformers, containers, cryptohash
     , data-binary-ieee754, data-lens, data-lens-fd, data-lens-template
     , filepath, ghc-prim, MonadRandom, mtl, primitive, QuickCheck, stm
     , strict, tagged, template-haskell, time, transformers, unix
     }:
     mkDerivation {
       pname = "perdure";
       version = "0.2.1";
       sha256 = "7f625e300da2edd6844e81b51b8890c4748b3806cef7913272b9e2a2f6447213";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring cognimeta-utils collections-api
         comonad-transformers containers cryptohash data-binary-ieee754
         data-lens data-lens-fd data-lens-template filepath ghc-prim
         MonadRandom mtl primitive QuickCheck stm strict tagged
         template-haskell time transformers unix
       ];
       executableHaskellDepends = [
         base bytestring cognimeta-utils containers MonadRandom mtl
         QuickCheck template-haskell transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/Cognimeta/perdure";
       description = "Robust persistence for acyclic immutable data";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "period" = callPackage
    ({ mkDerivation, base, hspec, HUnit, old-locale
     , optparse-applicative, parsec, text, text-show, time
     }:
     mkDerivation {
       pname = "period";
       version = "0.1.0.3";
       sha256 = "d5f9c9e798341990e186f98330244f22a875e87a600098666f81438b69f15ab3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base old-locale parsec text text-show time
       ];
       executableHaskellDepends = [ base optparse-applicative text ];
       testHaskellDepends = [ base hspec HUnit text time ];
       homepage = "https://github.com/w3rs/period";
       description = "Parse and format date periods, collapse and expand their text representations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "perm" = callPackage
    ({ mkDerivation, base, catch-fd, HUnit, mtl, test-framework
     , test-framework-hunit, transformers
     }:
     mkDerivation {
       pname = "perm";
       version = "0.4.0.0";
       sha256 = "3d9719cb8f33cc1cb5756c183b2ebc1bf052c60fc7f8a25ee65b8c3a78d5c651";
       libraryHaskellDepends = [ base catch-fd mtl transformers ];
       testHaskellDepends = [
         base HUnit mtl test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "https://github.com/sonyandy/perm";
       description = "permutation Applicative and Monad with many mtl instances";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "permutation" = callPackage
    ({ mkDerivation, base, ghc-prim, QuickCheck }:
     mkDerivation {
       pname = "permutation";
       version = "0.5.0.5";
       sha256 = "51b5caa115625e6b9a3b2f2240f1142c0cc6c31c351027abbcaea569f419a700";
       libraryHaskellDepends = [ base ghc-prim QuickCheck ];
       homepage = "https://github.com/spacekitteh/permutation";
       description = "A library for permutations and combinations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "permute" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "permute";
       version = "1.0";
       sha256 = "90253f58a9cbda5e8efd8f67c9f0dfb76c167c4ffe45652f68313823606ae10d";
       libraryHaskellDepends = [ base mtl ];
       description = "Generalised permutation parser combinator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "persist2er" = callPackage
    ({ mkDerivation, base, optparse-applicative, persistent, text }:
     mkDerivation {
       pname = "persist2er";
       version = "0.1.0.1";
       sha256 = "579c3575300064bad50b90b7635247b7f643c831d937cf39f79919c0eb94cf24";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base optparse-applicative persistent text
       ];
       jailbreak = true;
       description = "Transforms persist's quasi-quoted syntax into ER format";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "persistable-record" = callPackage
    ({ mkDerivation, array, base, containers, dlist, names-th
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "persistable-record";
       version = "0.4.0.0";
       sha256 = "b0227677da0c54514e8f98adef99ee5f2fdad5c6d251c5cfb36357e68abaeaa5";
       libraryHaskellDepends = [
         array base containers dlist names-th template-haskell transformers
       ];
       homepage = "http://khibino.github.io/haskell-relational-record/";
       description = "Binding between SQL database values and haskell records";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "persistable-types-HDBC-pg" = callPackage
    ({ mkDerivation, base, bytestring, convertible, HDBC
     , persistable-record, relational-query-HDBC, text-postgresql
     }:
     mkDerivation {
       pname = "persistable-types-HDBC-pg";
       version = "0.0.1.3";
       sha256 = "586cbb0b471c957c0e3979a019ef7e5bfdf4db50092a196cac72aa4f8b82cca0";
       libraryHaskellDepends = [
         base bytestring convertible HDBC persistable-record
         relational-query-HDBC text-postgresql
       ];
       homepage = "http://khibino.github.io/haskell-relational-record/";
       description = "HDBC and Relational-Record instances of PostgreSQL extended types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "persistent_2_1_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, blaze-markup, bytestring, conduit, containers
     , exceptions, fast-logger, hspec, lifted-base, monad-control
     , monad-logger, mtl, path-pieces, resource-pool, resourcet
     , scientific, silently, tagged, template-haskell, text, time
     , transformers, transformers-base, unordered-containers, vector
     }:
     mkDerivation {
       pname = "persistent";
       version = "2.1.1";
       sha256 = "a1b52bd19203f09adc30d336a0898b0693a0a7de10415d708aa57ff07f94bb72";
       revision = "1";
       editedCabalFile = "4c05891a2e797fc51edca2593f28a7eba2604f1eda8ef568cae9ed19c0bbf3d4";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html blaze-markup
         bytestring conduit containers exceptions fast-logger lifted-base
         monad-control monad-logger mtl path-pieces resource-pool resourcet
         scientific silently tagged template-haskell text time transformers
         transformers-base unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         conduit containers hspec monad-control monad-logger path-pieces
         resourcet scientific text time transformers unordered-containers
         vector
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, multi-backend data serialization";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent_2_1_1_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, blaze-markup, bytestring, conduit, containers
     , exceptions, fast-logger, hspec, lifted-base, monad-control
     , monad-logger, mtl, path-pieces, resource-pool, resourcet
     , scientific, silently, tagged, template-haskell, text, time
     , transformers, transformers-base, unordered-containers, vector
     }:
     mkDerivation {
       pname = "persistent";
       version = "2.1.1.2";
       sha256 = "1cf1e83747f4a0393749f2bd4b580e68cbd99e90bfcdd11066648b6c48730571";
       revision = "1";
       editedCabalFile = "83baf1255aa9090e93de7ba83da87e4f3f331ffcc8809f2b17739f0ea4d99733";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html blaze-markup
         bytestring conduit containers exceptions fast-logger lifted-base
         monad-control monad-logger mtl path-pieces resource-pool resourcet
         scientific silently tagged template-haskell text time transformers
         transformers-base unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         conduit containers hspec monad-control monad-logger path-pieces
         resourcet scientific text time transformers unordered-containers
         vector
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, multi-backend data serialization";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent_2_1_1_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, blaze-markup, bytestring, conduit, containers
     , exceptions, fast-logger, hspec, lifted-base, monad-control
     , monad-logger, mtl, old-locale, path-pieces, resource-pool
     , resourcet, scientific, silently, tagged, template-haskell, text
     , time, transformers, transformers-base, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "persistent";
       version = "2.1.1.3";
       sha256 = "afbe0d26267dece6433bfa2ac6179c322b8b72c13eb4bb2c2964688ea74af79e";
       revision = "1";
       editedCabalFile = "39c01ba21f43050cedcdaef6c96867d4f07e532e6b8b6386b42c4d0e4cc51d1d";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html blaze-markup
         bytestring conduit containers exceptions fast-logger lifted-base
         monad-control monad-logger mtl old-locale path-pieces resource-pool
         resourcet scientific silently tagged template-haskell text time
         transformers transformers-base unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         conduit containers hspec monad-control monad-logger old-locale
         path-pieces resourcet scientific text time transformers
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, multi-backend data serialization";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent_2_1_1_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, blaze-markup, bytestring, conduit, containers
     , exceptions, fast-logger, hspec, lifted-base, monad-control
     , monad-logger, mtl, old-locale, path-pieces, resource-pool
     , resourcet, scientific, silently, tagged, template-haskell, text
     , time, transformers, transformers-base, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "persistent";
       version = "2.1.1.4";
       sha256 = "a22573fdb21abd2a91fc2bf0e097c6d962d21e65d548078a632422017bf6765a";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html blaze-markup
         bytestring conduit containers exceptions fast-logger lifted-base
         monad-control monad-logger mtl old-locale path-pieces resource-pool
         resourcet scientific silently tagged template-haskell text time
         transformers transformers-base unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         conduit containers hspec monad-control monad-logger old-locale
         path-pieces resourcet scientific text time transformers
         unordered-containers vector
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, multi-backend data serialization";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent_2_1_1_7" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, blaze-markup, bytestring, conduit, containers
     , exceptions, fast-logger, hspec, lifted-base, monad-control
     , monad-logger, mtl, old-locale, path-pieces, resource-pool
     , resourcet, scientific, silently, tagged, template-haskell, text
     , time, transformers, transformers-base, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "persistent";
       version = "2.1.1.7";
       sha256 = "4e0ceff25435f410534920232725249c3ae07dbd358c097d0fb3a4f725b742da";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html blaze-markup
         bytestring conduit containers exceptions fast-logger lifted-base
         monad-control monad-logger mtl old-locale path-pieces resource-pool
         resourcet scientific silently tagged template-haskell text time
         transformers transformers-base unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         conduit containers hspec monad-control monad-logger old-locale
         path-pieces resourcet scientific text time transformers
         unordered-containers vector
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, multi-backend data serialization";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent_2_1_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, blaze-markup, bytestring, conduit, containers
     , exceptions, fast-logger, hspec, lifted-base, monad-control
     , monad-logger, mtl, old-locale, path-pieces, resource-pool
     , resourcet, scientific, silently, tagged, template-haskell, text
     , time, transformers, transformers-base, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "persistent";
       version = "2.1.2";
       sha256 = "a98c152836ee729e36ae4741fa497d08a0d6e26696b35f2a141af3c3830ee89e";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html blaze-markup
         bytestring conduit containers exceptions fast-logger lifted-base
         monad-control monad-logger mtl old-locale path-pieces resource-pool
         resourcet scientific silently tagged template-haskell text time
         transformers transformers-base unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         conduit containers hspec monad-control monad-logger old-locale
         path-pieces resourcet scientific text time transformers
         unordered-containers vector
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, multi-backend data serialization";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent_2_1_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, blaze-markup, bytestring, conduit, containers
     , exceptions, fast-logger, hspec, lifted-base, monad-control
     , monad-logger, mtl, old-locale, path-pieces, resource-pool
     , resourcet, scientific, silently, tagged, template-haskell, text
     , time, transformers, transformers-base, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "persistent";
       version = "2.1.3";
       sha256 = "beaf3690ad656b84e59cdf5c9f880b42b101d51393adea5796c4dbc6223081e7";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html blaze-markup
         bytestring conduit containers exceptions fast-logger lifted-base
         monad-control monad-logger mtl old-locale path-pieces resource-pool
         resourcet scientific silently tagged template-haskell text time
         transformers transformers-base unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         conduit containers hspec monad-control monad-logger old-locale
         path-pieces resourcet scientific text time transformers
         unordered-containers vector
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, multi-backend data serialization";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent_2_1_5" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, blaze-markup, bytestring, conduit, containers
     , exceptions, fast-logger, hspec, lifted-base, monad-control
     , monad-logger, mtl, old-locale, path-pieces, resource-pool
     , resourcet, scientific, silently, tagged, template-haskell, text
     , time, transformers, transformers-base, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "persistent";
       version = "2.1.5";
       sha256 = "7fda67eff91fcc078bf089e425ef1fb18342574e88107962af439910473f9682";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html blaze-markup
         bytestring conduit containers exceptions fast-logger lifted-base
         monad-control monad-logger mtl old-locale path-pieces resource-pool
         resourcet scientific silently tagged template-haskell text time
         transformers transformers-base unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         conduit containers hspec monad-control monad-logger old-locale
         path-pieces resourcet scientific text time transformers
         unordered-containers vector
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, multi-backend data serialization";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent_2_1_6" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, blaze-markup, bytestring, conduit, containers
     , exceptions, fast-logger, hspec, lifted-base, monad-control
     , monad-logger, mtl, old-locale, path-pieces, resource-pool
     , resourcet, scientific, silently, tagged, template-haskell, text
     , time, transformers, transformers-base, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "persistent";
       version = "2.1.6";
       sha256 = "d4d74384c6f4017215fea11b23c2bc6505b86a184c0530db4893d9be7b914c9e";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html blaze-markup
         bytestring conduit containers exceptions fast-logger lifted-base
         monad-control monad-logger mtl old-locale path-pieces resource-pool
         resourcet scientific silently tagged template-haskell text time
         transformers transformers-base unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         conduit containers fast-logger hspec lifted-base monad-control
         monad-logger mtl old-locale path-pieces resource-pool resourcet
         scientific tagged template-haskell text time transformers
         unordered-containers vector
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, multi-backend data serialization";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent_2_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, blaze-markup, bytestring, conduit, containers
     , exceptions, fast-logger, hspec, lifted-base, monad-control
     , monad-logger, mtl, old-locale, path-pieces, resource-pool
     , resourcet, scientific, silently, tagged, template-haskell, text
     , time, transformers, transformers-base, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "persistent";
       version = "2.2";
       sha256 = "174047d7f140571081459713fbdeeabbd4a52bbc02dbf35969a0daec491a8512";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html blaze-markup
         bytestring conduit containers exceptions fast-logger lifted-base
         monad-control monad-logger mtl old-locale path-pieces resource-pool
         resourcet scientific silently tagged template-haskell text time
         transformers transformers-base unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         conduit containers fast-logger hspec lifted-base monad-control
         monad-logger mtl old-locale path-pieces resource-pool resourcet
         scientific tagged template-haskell text time transformers
         unordered-containers vector
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, multi-backend data serialization";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent_2_2_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, blaze-markup, bytestring, conduit, containers
     , exceptions, fast-logger, hspec, lifted-base, monad-control
     , monad-logger, mtl, old-locale, path-pieces, resource-pool
     , resourcet, scientific, silently, tagged, template-haskell, text
     , time, transformers, transformers-base, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "persistent";
       version = "2.2.1";
       sha256 = "4aac9c1e86eda1218c5c771271787b402ac70412843c5c72b2e4373f9061da69";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html blaze-markup
         bytestring conduit containers exceptions fast-logger lifted-base
         monad-control monad-logger mtl old-locale path-pieces resource-pool
         resourcet scientific silently tagged template-haskell text time
         transformers transformers-base unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         conduit containers fast-logger hspec lifted-base monad-control
         monad-logger mtl old-locale path-pieces resource-pool resourcet
         scientific tagged template-haskell text time transformers
         unordered-containers vector
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, multi-backend data serialization";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent_2_2_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, blaze-markup, bytestring, conduit, containers
     , exceptions, fast-logger, hspec, http-api-data, lifted-base
     , monad-control, monad-logger, mtl, old-locale, path-pieces
     , resource-pool, resourcet, scientific, silently, tagged
     , template-haskell, text, time, transformers, transformers-base
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "persistent";
       version = "2.2.2";
       sha256 = "34ff5847796668f5f3648d58c5bda3d8be7a48c4ac3e08b7343fa51c59f8c595";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html blaze-markup
         bytestring conduit containers exceptions fast-logger http-api-data
         lifted-base monad-control monad-logger mtl old-locale path-pieces
         resource-pool resourcet scientific silently tagged template-haskell
         text time transformers transformers-base unordered-containers
         vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         conduit containers fast-logger hspec http-api-data lifted-base
         monad-control monad-logger mtl old-locale path-pieces resource-pool
         resourcet scientific tagged template-haskell text time transformers
         unordered-containers vector
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, multi-backend data serialization";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent_2_2_2_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, blaze-markup, bytestring, conduit, containers
     , exceptions, fast-logger, hspec, http-api-data, lifted-base
     , monad-control, monad-logger, mtl, old-locale, path-pieces
     , resource-pool, resourcet, scientific, silently, tagged
     , template-haskell, text, time, transformers, transformers-base
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "persistent";
       version = "2.2.2.1";
       sha256 = "3ec5e17662d84fe6cf58cd5cd356285a42fd995edbd73b703aa718c5638a8a4a";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html blaze-markup
         bytestring conduit containers exceptions fast-logger http-api-data
         lifted-base monad-control monad-logger mtl old-locale path-pieces
         resource-pool resourcet scientific silently tagged template-haskell
         text time transformers transformers-base unordered-containers
         vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         conduit containers fast-logger hspec http-api-data lifted-base
         monad-control monad-logger mtl old-locale path-pieces resource-pool
         resourcet scientific tagged template-haskell text time transformers
         unordered-containers vector
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, multi-backend data serialization";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent_2_2_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, blaze-markup, bytestring, conduit, containers
     , exceptions, fast-logger, hspec, http-api-data, lifted-base
     , monad-control, monad-logger, mtl, old-locale, path-pieces
     , resource-pool, resourcet, scientific, silently, tagged
     , template-haskell, text, time, transformers, transformers-base
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "persistent";
       version = "2.2.3";
       sha256 = "93f3cb4201e58dfe8566ac9577a467c122ffa98e05c9566d836c4db5ff25d2d4";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html blaze-markup
         bytestring conduit containers exceptions fast-logger http-api-data
         lifted-base monad-control monad-logger mtl old-locale path-pieces
         resource-pool resourcet scientific silently tagged template-haskell
         text time transformers transformers-base unordered-containers
         vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         conduit containers fast-logger hspec http-api-data lifted-base
         monad-control monad-logger mtl old-locale path-pieces resource-pool
         resourcet scientific tagged template-haskell text time transformers
         unordered-containers vector
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, multi-backend data serialization";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-html, blaze-markup, bytestring, conduit, containers
     , exceptions, fast-logger, hspec, http-api-data, lifted-base
     , monad-control, monad-logger, mtl, old-locale, path-pieces
     , resource-pool, resourcet, scientific, silently, tagged
     , template-haskell, text, time, transformers, transformers-base
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "persistent";
       version = "2.2.4";
       sha256 = "ae56121abbef8ecca7aa7c62b2e77a47e583d4dded0f8e4bfe1cd6b1fea70bbe";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html blaze-markup
         bytestring conduit containers exceptions fast-logger http-api-data
         lifted-base monad-control monad-logger mtl old-locale path-pieces
         resource-pool resourcet scientific silently tagged template-haskell
         text time transformers transformers-base unordered-containers
         vector
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring blaze-html bytestring
         conduit containers fast-logger hspec http-api-data lifted-base
         monad-control monad-logger mtl old-locale path-pieces resource-pool
         resourcet scientific tagged template-haskell text time transformers
         unordered-containers vector
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, multi-backend data serialization";
       license = stdenv.lib.licenses.mit;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-cereal" = callPackage
    ({ mkDerivation, base, cereal, persistent, text }:
     mkDerivation {
       pname = "persistent-cereal";
       version = "0.1.0";
       sha256 = "ce645be2e87c2e8a51cc1022edeac91f4fa54dc235b91ddcd452d87937725325";
       libraryHaskellDepends = [ base cereal persistent text ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/co-dan/persistent-cereal";
       description = "Helper functions for writing Persistent instances";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "persistent-equivalence" = callPackage
    ({ mkDerivation, array, base, diffarray }:
     mkDerivation {
       pname = "persistent-equivalence";
       version = "0.3";
       sha256 = "1fa360e15d1c6e768d0d85928defdd4673ffb9b4dcb2c7d8a2746abe5600d692";
       libraryHaskellDepends = [ array base diffarray ];
       jailbreak = true;
       description = "Persistent equivalence relations (aka union-find)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "persistent-hssqlppp" = callPackage
    ({ mkDerivation, base, bytestring, hssqlppp, monad-control, mtl
     , persistent, persistent-template, template-haskell, text, th-lift
     }:
     mkDerivation {
       pname = "persistent-hssqlppp";
       version = "0.1";
       sha256 = "422d31468a82d3ef718b4bacd3814419a9bdc0fbf57ffd5e95c24e8a8bba8edc";
       libraryHaskellDepends = [
         base bytestring hssqlppp monad-control mtl persistent
         persistent-template template-haskell text th-lift
       ];
       description = "Declare Persistent entities using SQL SELECT query syntax";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "persistent-instances-iproute" = callPackage
    ({ mkDerivation, base, bytestring, iproute, persistent }:
     mkDerivation {
       pname = "persistent-instances-iproute";
       version = "0.1.0.1";
       sha256 = "d6033ee04377f760a76d96f06a3389329b95cf0934097e815240803dd108b35a";
       libraryHaskellDepends = [ base bytestring iproute persistent ];
       description = "Persistent instances for types in iproute";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "persistent-iproute" = callPackage
    ({ mkDerivation, aeson, aeson-iproute, base, bytestring
     , http-api-data, iproute, path-pieces, persistent, text
     }:
     mkDerivation {
       pname = "persistent-iproute";
       version = "0.2.1";
       sha256 = "6788ed3e45195a58af71338f1fddecfbe44e079d0a164afac8bf15934199db33";
       libraryHaskellDepends = [
         aeson aeson-iproute base bytestring http-api-data iproute
         path-pieces persistent text
       ];
       homepage = "https://github.com/greydot/persistent-iproute";
       description = "Persistent instances for types in iproute";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "persistent-map" = callPackage
    ({ mkDerivation, base, binary, containers, directory, EdisonAPI
     , EdisonCore, filepath, LRU, mtl, stm-io-hooks
     }:
     mkDerivation {
       pname = "persistent-map";
       version = "0.3.5";
       sha256 = "78c3c958d530de04c536fbcbf4a35dd212a64d19d88122e5a6fdf93ebb91c02a";
       libraryHaskellDepends = [
         base binary containers directory EdisonAPI EdisonCore filepath LRU
         mtl stm-io-hooks
       ];
       jailbreak = true;
       homepage = "http://darcs.monoid.at/persistent-map";
       description = "A thread-safe (STM) persistency interface for finite map types";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "persistent-mongoDB_2_1_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bson, bytestring, cereal
     , conduit, containers, monad-control, mongoDB, network, path-pieces
     , persistent, pool-conduit, resourcet, text, time, transformers
     }:
     mkDerivation {
       pname = "persistent-mongoDB";
       version = "2.1.2";
       sha256 = "c8edb63d6d672a35473aaabf9918a8bc7c8f354833346694bfb85362f19e1a77";
       libraryHaskellDepends = [
         aeson attoparsec base bson bytestring cereal conduit containers
         monad-control mongoDB network path-pieces persistent pool-conduit
         resourcet text time transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using mongoDB";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-mongoDB_2_1_2_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bson, bytestring, cereal
     , conduit, containers, monad-control, mongoDB, network, path-pieces
     , persistent, resource-pool, resourcet, text, time, transformers
     }:
     mkDerivation {
       pname = "persistent-mongoDB";
       version = "2.1.2.1";
       sha256 = "ca1cfb2fd068bc56740c5c881610dd4a25c143783399911d9d85ba000b6a128c";
       libraryHaskellDepends = [
         aeson attoparsec base bson bytestring cereal conduit containers
         monad-control mongoDB network path-pieces persistent resource-pool
         resourcet text time transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using mongoDB";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-mongoDB_2_1_2_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bson, bytestring, cereal
     , conduit, containers, monad-control, mongoDB, network, path-pieces
     , persistent, resource-pool, resourcet, text, time, transformers
     }:
     mkDerivation {
       pname = "persistent-mongoDB";
       version = "2.1.2.2";
       sha256 = "33b2c59c0fcd5205dbc1539402fd1929a5bed345ae1206956e885c7723f7f2de";
       libraryHaskellDepends = [
         aeson attoparsec base bson bytestring cereal conduit containers
         monad-control mongoDB network path-pieces persistent resource-pool
         resourcet text time transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using mongoDB";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-mongoDB" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bson, bytestring, cereal
     , conduit, containers, http-api-data, monad-control, mongoDB
     , network, path-pieces, persistent, resource-pool, resourcet, text
     , time, transformers
     }:
     mkDerivation {
       pname = "persistent-mongoDB";
       version = "2.1.4";
       sha256 = "06b9d86c6f6b68025a86bd9cc62595bda303007f4da721764241d160f23766a2";
       libraryHaskellDepends = [
         aeson attoparsec base bson bytestring cereal conduit containers
         http-api-data monad-control mongoDB network path-pieces persistent
         resource-pool resourcet text time transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using mongoDB";
       license = stdenv.lib.licenses.mit;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-mysql_2_1_2" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, mysql, mysql-simple
     , persistent, resourcet, text, transformers
     }:
     mkDerivation {
       pname = "persistent-mysql";
       version = "2.1.2";
       sha256 = "5b9b4c1119df8ffdc210507d3efefc2d3f6e22666a1434f03241cc8d33e3221a";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger mysql mysql-simple persistent resourcet
         text transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using MySQL database server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-mysql_2_1_2_1" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, mysql, mysql-simple
     , persistent, resourcet, text, transformers
     }:
     mkDerivation {
       pname = "persistent-mysql";
       version = "2.1.2.1";
       sha256 = "4b9c95d45409dfab939163b56c2c9967040e1d6e2c37d4117da6a9d31fae311d";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger mysql mysql-simple persistent resourcet
         text transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using MySQL database server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-mysql_2_1_3" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, mysql, mysql-simple
     , persistent, resourcet, text, transformers
     }:
     mkDerivation {
       pname = "persistent-mysql";
       version = "2.1.3";
       sha256 = "90bfb3c6fd2a49fda426da15291ea98f69c3c9455b0440e6bbe69bf4fb973acc";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger mysql mysql-simple persistent resourcet
         text transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using MySQL database server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-mysql_2_1_3_1" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, mysql, mysql-simple
     , persistent, resourcet, text, transformers
     }:
     mkDerivation {
       pname = "persistent-mysql";
       version = "2.1.3.1";
       sha256 = "a13d94dc532d5f7b29f50e85e4fa2a7ef6596c971c3a5f0ffb38f19bb31f30e0";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger mysql mysql-simple persistent resourcet
         text transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using MySQL database server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-mysql_2_2" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, mysql, mysql-simple
     , persistent, resourcet, text, transformers
     }:
     mkDerivation {
       pname = "persistent-mysql";
       version = "2.2";
       sha256 = "e9bb569739cb268b6a6895490ce4235bc789cd1fddc98ac3ac79cac7b7930a26";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger mysql mysql-simple persistent resourcet
         text transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using MySQL database server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-mysql" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, mysql, mysql-simple
     , persistent, resourcet, text, transformers
     }:
     mkDerivation {
       pname = "persistent-mysql";
       version = "2.3.0.2";
       sha256 = "7e1c21ee07df97172528c83709a4435040e477e46e1d558f3dd5bcda84c4f033";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger mysql mysql-simple persistent resourcet
         text transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using MySQL database server";
       license = stdenv.lib.licenses.mit;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-odbc" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, containers
     , convertible, HDBC, HDBC-odbc, monad-control, monad-logger
     , persistent, persistent-template, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "persistent-odbc";
       version = "0.2.0.1";
       sha256 = "b751d48392f61d7b2f3b0cda149dedd04eb1a24912c2075c8640de7313956c67";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring conduit containers convertible HDBC HDBC-odbc
         monad-control monad-logger persistent persistent-template resourcet
         text time transformers
       ];
       homepage = "https://github.com/gbwey/persistent-odbc";
       description = "Backend for the persistent library using ODBC";
       license = stdenv.lib.licenses.mit;
     }) {};

  "persistent-postgresql_2_1_1" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, persistent
     , postgresql-libpq, postgresql-simple, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "persistent-postgresql";
       version = "2.1.1";
       sha256 = "00bd5fdb57664d55a4591baad91196f90efab12879be6c4d77ee582c4cfbdb55";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger persistent postgresql-libpq
         postgresql-simple resourcet text time transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using postgresql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-postgresql_2_1_2" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, persistent
     , postgresql-libpq, postgresql-simple, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "persistent-postgresql";
       version = "2.1.2";
       sha256 = "e7ceeb5d4a2f6159a11db1b36e3c30df99abe2163afa563dc3a1d461e24bbdd3";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger persistent postgresql-libpq
         postgresql-simple resourcet text time transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using postgresql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-postgresql_2_1_2_1" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, persistent
     , postgresql-libpq, postgresql-simple, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "persistent-postgresql";
       version = "2.1.2.1";
       sha256 = "4ad3f9a1b3b8fbcc7e6fdb2b3e132fb1842a11b06573745de19985b357e2e860";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger persistent postgresql-libpq
         postgresql-simple resourcet text time transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using postgresql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-postgresql_2_1_2_2" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, persistent
     , postgresql-libpq, postgresql-simple, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "persistent-postgresql";
       version = "2.1.2.2";
       sha256 = "cb968c8a26166a7255c4e7050c516348fd4a7bbd59d86c67cfc3ec1def871d42";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger persistent postgresql-libpq
         postgresql-simple resourcet text time transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using postgresql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-postgresql_2_1_3" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, persistent
     , postgresql-libpq, postgresql-simple, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "persistent-postgresql";
       version = "2.1.3";
       sha256 = "3aa2248c2b94324c482ad2880e015d9d401e7eeb30bd42e707382cbe9ebbfb41";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger persistent postgresql-libpq
         postgresql-simple resourcet text time transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using postgresql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-postgresql_2_1_4" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, persistent
     , postgresql-libpq, postgresql-simple, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "persistent-postgresql";
       version = "2.1.4";
       sha256 = "af5e709e623e258053e8e73c9c3172027e200e60a70d27d825329385d8be35f5";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger persistent postgresql-libpq
         postgresql-simple resourcet text time transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using postgresql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-postgresql_2_1_5" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, persistent
     , postgresql-libpq, postgresql-simple, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "persistent-postgresql";
       version = "2.1.5";
       sha256 = "518bcaee89ae5b5d375bbbf37eea58b9a672d76a020c588a87ea75ea059f22d0";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger persistent postgresql-libpq
         postgresql-simple resourcet text time transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using postgresql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-postgresql_2_1_5_3" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, persistent
     , postgresql-libpq, postgresql-simple, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "persistent-postgresql";
       version = "2.1.5.3";
       sha256 = "747bba0351970a711bfec261500f6722d6e63cabae10b563bc4f41b14e1f22c7";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger persistent postgresql-libpq
         postgresql-simple resourcet text time transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using postgresql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-postgresql_2_1_6" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, persistent
     , postgresql-libpq, postgresql-simple, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "persistent-postgresql";
       version = "2.1.6";
       sha256 = "869e3d8e3b234a80a39eae7d89a314f39ebafff51a275adc79eee7b03bff6de8";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger persistent postgresql-libpq
         postgresql-simple resourcet text time transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using postgresql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-postgresql_2_2" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, persistent
     , postgresql-libpq, postgresql-simple, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "persistent-postgresql";
       version = "2.2";
       sha256 = "7ef167d5e4860d4e75dc6e46e7c27ea0d3f7af09f16ce090aa7c70b4a460bc79";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger persistent postgresql-libpq
         postgresql-simple resourcet text time transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using postgresql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-postgresql_2_2_1" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, persistent
     , postgresql-libpq, postgresql-simple, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "persistent-postgresql";
       version = "2.2.1";
       sha256 = "9e532a929ee64af60efa4abcf8e182bd5608d621ca8624938f2da2b367c67e4b";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger persistent postgresql-libpq
         postgresql-simple resourcet text time transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using postgresql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-postgresql_2_2_1_1" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, persistent
     , postgresql-libpq, postgresql-simple, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "persistent-postgresql";
       version = "2.2.1.1";
       sha256 = "b7f45537194d11e0efb9648d721cc6836df8730acd225bd090e7c740034812a8";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger persistent postgresql-libpq
         postgresql-simple resourcet text time transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using postgresql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-postgresql_2_2_1_2" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, persistent
     , postgresql-libpq, postgresql-simple, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "persistent-postgresql";
       version = "2.2.1.2";
       sha256 = "475523d2ac2c9719bf7e4034f97aed79e96c63001ef735b8148b657049e7e83a";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger persistent postgresql-libpq
         postgresql-simple resourcet text time transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using postgresql";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-postgresql" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , containers, monad-control, monad-logger, persistent
     , postgresql-libpq, postgresql-simple, resourcet, text, time
     , transformers
     }:
     mkDerivation {
       pname = "persistent-postgresql";
       version = "2.2.2";
       sha256 = "7ec31242349f8ea7da149991fbe3366a6a83f3e3915392c997b3c34fc27671cd";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit containers
         monad-control monad-logger persistent postgresql-libpq
         postgresql-simple resourcet text time transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using postgresql";
       license = stdenv.lib.licenses.mit;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-protobuf" = callPackage
    ({ mkDerivation, base, bytestring, persistent, protocol-buffers
     , protocol-buffers-descriptor, template-haskell, text
     }:
     mkDerivation {
       pname = "persistent-protobuf";
       version = "0.1.5";
       sha256 = "3fe99d09d3953165e491eaa2d5981046a9bdc86fe9037e42657c99fdb4bacd10";
       libraryHaskellDepends = [
         base bytestring persistent protocol-buffers
         protocol-buffers-descriptor template-haskell text
       ];
       jailbreak = true;
       homepage = "https://github.com/mstone/persistent-protobuf";
       description = "Template-Haskell helpers for integrating protobufs with persistent";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "persistent-ratelimit" = callPackage
    ({ mkDerivation, base, time, yesod }:
     mkDerivation {
       pname = "persistent-ratelimit";
       version = "0.2.0.0";
       sha256 = "e3b14ed8c78999ebe797e84cac75bc66ed7bd264b9ccef92279193be31ed114e";
       libraryHaskellDepends = [ base time yesod ];
       homepage = "https://github.com/jprider63/persistent-ratelimit";
       description = "A library for rate limiting activities with a persistent backend";
       license = stdenv.lib.licenses.mit;
     }) {};

  "persistent-redis" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, binary, bytestring, hedis
     , monad-control, mtl, path-pieces, persistent, persistent-template
     , scientific, template-haskell, text, time, transformers
     , utf8-string
     }:
     mkDerivation {
       pname = "persistent-redis";
       version = "0.3.2";
       sha256 = "332cc47c58c3df48fa30a66ab76f806e389e60d808059f79bb3500e18893bc5c";
       libraryHaskellDepends = [
         aeson attoparsec base binary bytestring hedis monad-control mtl
         path-pieces persistent scientific text time transformers
         utf8-string
       ];
       testHaskellDepends = [
         aeson attoparsec base binary bytestring hedis monad-control mtl
         path-pieces persistent persistent-template scientific
         template-haskell text time transformers utf8-string
       ];
       jailbreak = true;
       description = "Backend for persistent library using Redis";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-refs" = callPackage
    ({ mkDerivation, base, containers, mtl, ref-fd, transformers }:
     mkDerivation {
       pname = "persistent-refs";
       version = "0.4";
       sha256 = "46b310e034e23993e7da740d388e06e410483ada05cbcc8c0a4953ee19f8d0d3";
       libraryHaskellDepends = [
         base containers mtl ref-fd transformers
       ];
       homepage = "https://github.com/acfoltzer/persistent-refs";
       description = "Haskell references backed by an IntMap for persistence and reversibility";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "persistent-sqlite_2_1_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, containers
     , monad-control, monad-logger, persistent, resourcet, text
     , transformers
     }:
     mkDerivation {
       pname = "persistent-sqlite";
       version = "2.1.1";
       sha256 = "3c797eb43456d159c304b174554d91e9efc31d761dbcc5dd03019bcb7b54d7c3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring conduit containers monad-control monad-logger
         persistent resourcet text transformers
       ];
       executableHaskellDepends = [ base ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using sqlite3";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-sqlite_2_1_1_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, containers
     , hspec, monad-control, monad-logger, old-locale, persistent
     , persistent-template, resourcet, text, time, transformers
     }:
     mkDerivation {
       pname = "persistent-sqlite";
       version = "2.1.1.1";
       sha256 = "2a95017f380490732773752b4e59c359373f4ee3422a202b4b2e623499daf40a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring conduit containers monad-control monad-logger
         old-locale persistent resourcet text time transformers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base hspec persistent persistent-template time transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using sqlite3";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-sqlite_2_1_1_2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, containers
     , hspec, monad-control, monad-logger, old-locale, persistent
     , persistent-template, resourcet, text, time, transformers
     }:
     mkDerivation {
       pname = "persistent-sqlite";
       version = "2.1.1.2";
       sha256 = "0a4a8d10d5a15104dc1ad07c1e66802980316c7320e8fb8e3a916879f22bd74e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring conduit containers monad-control monad-logger
         old-locale persistent resourcet text time transformers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base hspec persistent persistent-template time transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using sqlite3";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-sqlite_2_1_3" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, containers
     , hspec, monad-control, monad-logger, old-locale, persistent
     , persistent-template, resourcet, text, time, transformers
     }:
     mkDerivation {
       pname = "persistent-sqlite";
       version = "2.1.3";
       sha256 = "ee9d2918a56e01978b32de53a8655d32b6149c20d6bbc5bbd9cf79a87884ceef";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring conduit containers monad-control monad-logger
         old-locale persistent resourcet text time transformers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base hspec persistent persistent-template time transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using sqlite3";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-sqlite_2_1_4" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, containers
     , hspec, monad-control, monad-logger, old-locale, persistent
     , persistent-template, resourcet, text, time, transformers
     }:
     mkDerivation {
       pname = "persistent-sqlite";
       version = "2.1.4";
       sha256 = "7c3a2d0638f208a80bc2a7dc4a3eaf92655f239d9356d0c2b89cc2bbe7e00409";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring conduit containers monad-control monad-logger
         old-locale persistent resourcet text time transformers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base hspec persistent persistent-template time transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using sqlite3";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-sqlite_2_1_4_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, containers
     , hspec, monad-control, monad-logger, old-locale, persistent
     , persistent-template, resourcet, text, time, transformers
     }:
     mkDerivation {
       pname = "persistent-sqlite";
       version = "2.1.4.1";
       sha256 = "50402b82e0f4753d9f14ab39f1238d75824fa5661c9f0b0e77fa87ff8f0c9553";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring conduit containers monad-control monad-logger
         old-locale persistent resourcet text time transformers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base hspec persistent persistent-template time transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using sqlite3";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-sqlite_2_1_4_2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, containers
     , hspec, monad-control, monad-logger, old-locale, persistent
     , persistent-template, resourcet, text, time, transformers
     }:
     mkDerivation {
       pname = "persistent-sqlite";
       version = "2.1.4.2";
       sha256 = "0ac7e708c06ae1b63bb068c248fb3ccba0beb99da52702efa6c0a4bca047123c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring conduit containers monad-control monad-logger
         old-locale persistent resourcet text time transformers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base hspec persistent persistent-template time transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using sqlite3";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-sqlite" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, containers
     , hspec, monad-control, monad-logger, old-locale, persistent
     , persistent-template, resourcet, text, time, transformers
     }:
     mkDerivation {
       pname = "persistent-sqlite";
       version = "2.2";
       sha256 = "f11005a23df9ad0740111e675aab42f40eda7e37f4996ebae15e1fe48692c794";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring conduit containers monad-control monad-logger
         old-locale persistent resourcet text time transformers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base hspec persistent persistent-template time transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Backend for the persistent library using sqlite3";
       license = stdenv.lib.licenses.mit;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-template_2_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, ghc-prim
     , hspec, monad-control, monad-logger, path-pieces, persistent
     , QuickCheck, tagged, template-haskell, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "persistent-template";
       version = "2.1";
       sha256 = "be650875064a4301d19b601db2f835b2efeb952f8c4498e4a6e74d342af64366";
       libraryHaskellDepends = [
         aeson base bytestring containers ghc-prim monad-control
         monad-logger path-pieces persistent tagged template-haskell text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring hspec persistent QuickCheck text transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, non-relational, multi-backend persistence";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-template_2_1_0_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, ghc-prim
     , hspec, monad-control, monad-logger, path-pieces, persistent
     , QuickCheck, tagged, template-haskell, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "persistent-template";
       version = "2.1.0.1";
       sha256 = "1d8f726ee33a9eb7bbc68daa681287f2516f833c1ab5c4b4829f990e12a64a92";
       libraryHaskellDepends = [
         aeson base bytestring containers ghc-prim monad-control
         monad-logger path-pieces persistent tagged template-haskell text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring hspec persistent QuickCheck text transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, non-relational, multi-backend persistence";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-template_2_1_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, ghc-prim
     , hspec, monad-control, monad-logger, path-pieces, persistent
     , QuickCheck, tagged, template-haskell, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "persistent-template";
       version = "2.1.1";
       sha256 = "ac3740a450927bd82fcd763af0e7f4b1a4e339e23a1db00fc21ae386faed75af";
       revision = "1";
       editedCabalFile = "19fd43b237aa43be6327fda6415564650504e2887d3e7bd9ee3042082d1b283c";
       libraryHaskellDepends = [
         aeson base bytestring containers ghc-prim monad-control
         monad-logger path-pieces persistent tagged template-haskell text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring hspec persistent QuickCheck text transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, non-relational, multi-backend persistence";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-template_2_1_3" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, ghc-prim
     , hspec, monad-control, monad-logger, path-pieces, persistent
     , QuickCheck, tagged, template-haskell, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "persistent-template";
       version = "2.1.3";
       sha256 = "57283604bc92b0d7e666bdd265a211aff67d8e653c448694b759e438a18914ac";
       libraryHaskellDepends = [
         aeson base bytestring containers ghc-prim monad-control
         monad-logger path-pieces persistent tagged template-haskell text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring hspec persistent QuickCheck text transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, non-relational, multi-backend persistence";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-template_2_1_3_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, ghc-prim
     , hspec, monad-control, monad-logger, path-pieces, persistent
     , QuickCheck, tagged, template-haskell, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "persistent-template";
       version = "2.1.3.1";
       sha256 = "653ed7208bbc64bd79bd3cf9fbe4b1b3a3198bc009d788f4eb08162739a01f27";
       libraryHaskellDepends = [
         aeson base bytestring containers ghc-prim monad-control
         monad-logger path-pieces persistent tagged template-haskell text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring hspec persistent QuickCheck text transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, non-relational, multi-backend persistence";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-template_2_1_3_3" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, ghc-prim
     , hspec, monad-control, monad-logger, path-pieces, persistent
     , QuickCheck, tagged, template-haskell, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "persistent-template";
       version = "2.1.3.3";
       sha256 = "c54b6ff0daf2821e769785f6a4179626278a0bbfc3555cb15406340659b33bdd";
       libraryHaskellDepends = [
         aeson base bytestring containers ghc-prim monad-control
         monad-logger path-pieces persistent tagged template-haskell text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring hspec persistent QuickCheck text transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, non-relational, multi-backend persistence";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-template_2_1_3_4" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, ghc-prim
     , hspec, monad-control, monad-logger, path-pieces, persistent
     , QuickCheck, tagged, template-haskell, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "persistent-template";
       version = "2.1.3.4";
       sha256 = "4f28c9ef478e3835de5bc0105907582b2e0229cecc84ffa895c67c1a59ae2172";
       libraryHaskellDepends = [
         aeson base bytestring containers ghc-prim monad-control
         monad-logger path-pieces persistent tagged template-haskell text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring hspec persistent QuickCheck text transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, non-relational, multi-backend persistence";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-template_2_1_3_6" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, ghc-prim
     , hspec, monad-control, monad-logger, path-pieces, persistent
     , QuickCheck, tagged, template-haskell, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "persistent-template";
       version = "2.1.3.6";
       sha256 = "281260c21baafc02b1c8ddf4b555dc1e3da6e5422867cfc862e0c972d5070993";
       libraryHaskellDepends = [
         aeson base bytestring containers ghc-prim monad-control
         monad-logger path-pieces persistent tagged template-haskell text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring hspec persistent QuickCheck text transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, non-relational, multi-backend persistence";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-template_2_1_3_7" = callPackage
    ({ mkDerivation, aeson, aeson-extra, base, bytestring, containers
     , ghc-prim, hspec, monad-control, monad-logger, path-pieces
     , persistent, QuickCheck, tagged, template-haskell, text
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "persistent-template";
       version = "2.1.3.7";
       sha256 = "60a47ee01553c9dd00a387e82490972a13fd104238ae77327729d77303d7de40";
       libraryHaskellDepends = [
         aeson aeson-extra base bytestring containers ghc-prim monad-control
         monad-logger path-pieces persistent tagged template-haskell text
         transformers unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring hspec persistent QuickCheck text transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, non-relational, multi-backend persistence";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-template_2_1_4" = callPackage
    ({ mkDerivation, aeson, aeson-extra, base, bytestring, containers
     , ghc-prim, hspec, http-api-data, monad-control, monad-logger
     , path-pieces, persistent, QuickCheck, tagged, template-haskell
     , text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "persistent-template";
       version = "2.1.4";
       sha256 = "ed9e415d49288c7857febf978e4d97195c95113b9def30655894b48560999bce";
       revision = "1";
       editedCabalFile = "ecb26fe04083fc0e1e9abb16639b60195a49abac88e93b69360cae6c12a488b5";
       libraryHaskellDepends = [
         aeson aeson-extra base bytestring containers ghc-prim http-api-data
         monad-control monad-logger path-pieces persistent tagged
         template-haskell text transformers unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring hspec persistent QuickCheck text transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, non-relational, multi-backend persistence";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-template" = callPackage
    ({ mkDerivation, aeson, aeson-compat, base, bytestring, containers
     , ghc-prim, hspec, http-api-data, monad-control, monad-logger
     , path-pieces, persistent, QuickCheck, tagged, template-haskell
     , text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "persistent-template";
       version = "2.1.5";
       sha256 = "d732a0e8114dae29874f3536592effc1626aea15ebef47f3355a4b426020acd1";
       libraryHaskellDepends = [
         aeson aeson-compat base bytestring containers ghc-prim
         http-api-data monad-control monad-logger path-pieces persistent
         tagged template-haskell text transformers unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring hspec persistent QuickCheck text transformers
       ];
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Type-safe, non-relational, multi-backend persistence";
       license = stdenv.lib.licenses.mit;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persistent-vector" = callPackage
    ({ mkDerivation, base, deepseq, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "persistent-vector";
       version = "0.1.1";
       sha256 = "420a660c3a74612bda8c8ecee8d897e61f5aca957622c121998f8825af00bbd0";
       libraryHaskellDepends = [ base deepseq ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       homepage = "https://github.com/travitch/persistent-vector";
       description = "A persistent sequence based on array mapped tries";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "persistent-zookeeper" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring, binary
     , bytestring, conduit, containers, hspec, hzk, monad-control, mtl
     , path-pieces, persistent, persistent-template, resource-pool
     , resourcet, scientific, template-haskell, text, time, transformers
     , transformers-base, utf8-string
     }:
     mkDerivation {
       pname = "persistent-zookeeper";
       version = "0.2.0";
       sha256 = "3fc55c8eb914d52f94cfcbcbbca76eaaed1d765015b753cc73fe7bd8334f4987";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring binary bytestring conduit
         containers hzk monad-control mtl path-pieces persistent
         persistent-template resource-pool resourcet scientific
         template-haskell text time transformers transformers-base
         utf8-string
       ];
       testHaskellDepends = [
         aeson attoparsec base base64-bytestring binary bytestring conduit
         containers hspec hzk monad-control mtl path-pieces persistent
         persistent-template resource-pool resourcet scientific
         template-haskell text time transformers transformers-base
         utf8-string
       ];
       jailbreak = true;
       description = "Backend for persistent library using Zookeeper";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "persona" = callPackage
    ({ mkDerivation, aeson, base, data-default-class, jose, lens
     , network-uri, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "persona";
       version = "0.1.0.0";
       sha256 = "d01e98c5fc79ef678c3133c4f0d5c31fc414220194108bd163682e3f470d35f0";
       libraryHaskellDepends = [
         aeson base data-default-class jose lens network-uri text time
         unordered-containers
       ];
       homepage = "https://github.com/frasertweedale/hs-persona";
       description = "Persona (BrowserID) library";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "persona-idp" = callPackage
    ({ mkDerivation, aeson, asn1-types, base, blaze-markup, bytestring
     , crypto-random, directory, filepath, hamlet, http-types, jose
     , lens, optparse-applicative, pem, persona, scotty, shakespeare
     , text, time, transformers, unix, wai, x509
     }:
     mkDerivation {
       pname = "persona-idp";
       version = "0.1.0.2";
       sha256 = "d6ac0052bed0ef7b2c340aec078ac7785eb2484c88a8fa5f5ee9810a6af25420";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson asn1-types base blaze-markup bytestring crypto-random
         directory filepath hamlet http-types jose lens optparse-applicative
         pem persona scotty shakespeare text time transformers unix wai x509
       ];
       homepage = "https://github.com/frasertweedale/hs-persona-idp";
       description = "Persona (BrowserID) Identity Provider";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "pesca" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "pesca";
       version = "4.0.1";
       sha256 = "f7696fdf108f0c9a57761cdcc1ce19434923c0dd7ccb205c6819aff5b5ac9c89";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base process ];
       homepage = "http://www.cs.chalmers.se/~aarne/pesca/";
       description = "Proof Editor for Sequent Calculus";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "peyotls" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, bytable
     , bytestring, cipher-aes, crypto-numbers, crypto-pubkey
     , crypto-pubkey-types, crypto-random, cryptohash, handle-like
     , monad-control, monads-tf, network, pem, peyotls-codec, random
     , stm, transformers-base, x509, x509-store, x509-validation
     }:
     mkDerivation {
       pname = "peyotls";
       version = "0.1.6.10";
       sha256 = "9c738ac0cc1bdc8548679c8bafcc8e9cba21e8c9a805708431d98d6f03cc3874";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base bytable bytestring cipher-aes
         crypto-numbers crypto-pubkey crypto-pubkey-types crypto-random
         cryptohash handle-like monad-control monads-tf pem peyotls-codec
         stm transformers-base x509 x509-store x509-validation
       ];
       testHaskellDepends = [
         base bytestring crypto-random handle-like network random stm x509
         x509-store
       ];
       jailbreak = true;
       homepage = "https://github.com/YoshikuniJujo/peyotls/wiki";
       description = "Pretty Easy YOshikuni-made TLS library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "peyotls-codec" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, bytable
     , bytestring, crypto-pubkey, crypto-pubkey-types, monads-tf, word24
     , x509, x509-store
     }:
     mkDerivation {
       pname = "peyotls-codec";
       version = "0.3.1.0";
       sha256 = "fae2e01a02d6643068f57b7daec26d760d437500551547c69cf43c3896a84198";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base bytable bytestring crypto-pubkey
         crypto-pubkey-types monads-tf word24 x509 x509-store
       ];
       jailbreak = true;
       homepage = "https://github.com/YoshikuniJujo/peyotls/wiki";
       description = "Codec parts of Pretty Easy YOshikuni-made TLS library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pez" = callPackage
    ({ mkDerivation, base, failure, fclabels, QuickCheck
     , test-framework, test-framework-quickcheck2, thrist
     }:
     mkDerivation {
       pname = "pez";
       version = "0.1.0";
       sha256 = "e46cf8c7ccc6e5b4ed668343ace3984e989e2da5ada20f69a1691f0443445570";
       libraryHaskellDepends = [ base failure fclabels thrist ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://brandon.si/code/pez-zipper-library-released/";
       description = "A Pretty Extraordinary Zipper library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pg-harness" = callPackage
    ({ mkDerivation, async, base, bytestring, HTTP, ini
     , postgresql-simple, random, scotty, text, transformers
     }:
     mkDerivation {
       pname = "pg-harness";
       version = "0.2.1";
       sha256 = "0ec3c6361ae4e96060557a4a6a6426c45ee4ef9dc09e4063f16c61791064a62b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring HTTP ];
       executableHaskellDepends = [
         async base ini postgresql-simple random scotty text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/BardurArantsson/pg-harness";
       description = "REST service and library for creating/consuming temporary PostgreSQL databases";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pg-harness-client" = callPackage
    ({ mkDerivation, base, bytestring, HTTP }:
     mkDerivation {
       pname = "pg-harness-client";
       version = "0.4.0";
       sha256 = "ecf29ea6d36375a970ccdf6afa33ecac1571d53bd917f2c043f6c2689fced345";
       libraryHaskellDepends = [ base bytestring HTTP ];
       homepage = "https://github.com/BardurArantsson/pg-harness";
       description = "Client library for pg-harness-server";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "pg-harness-server" = callPackage
    ({ mkDerivation, async, base, ini, postgresql-simple, random
     , scotty, text, transformers
     }:
     mkDerivation {
       pname = "pg-harness-server";
       version = "0.4.0";
       sha256 = "c3a46ce4954e3a0bcbdf0cdc032fe1db1bb1b92902fb3811d41327a13f93de31";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async base ini postgresql-simple random scotty text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/BardurArantsson/pg-harness";
       description = "REST service for creating temporary PostgreSQL databases";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pgdl" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, configurator
     , directory, filepath, HTTP, http-conduit, network-uri, process
     , tagsoup, text, vty, vty-ui
     }:
     mkDerivation {
       pname = "pgdl";
       version = "8.5";
       sha256 = "9c577d2d149ed3645edb4e3a9fcbe1fbe6072cf2124b6ee76c45724b390d63a2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring Cabal configurator directory filepath HTTP
         http-conduit network-uri process tagsoup text vty vty-ui
       ];
       description = "simply download a video (or a file) from a webpage and xdg-open it";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "pgm" = callPackage
    ({ mkDerivation, array, base, bytestring, parsec }:
     mkDerivation {
       pname = "pgm";
       version = "0.1.4";
       sha256 = "bb36ff802ff49df4ad7d52e900773b1ccabf93956011a5d3fc2e778d036473e8";
       libraryHaskellDepends = [ array base bytestring parsec ];
       homepage = "https://github.com/astanin/haskell-pgm";
       description = "Pure Haskell implementation of PGM image format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pgp-wordlist" = callPackage
    ({ mkDerivation, base, bytestring, containers, HUnit, tasty
     , tasty-hunit, tasty-quickcheck, text, vector
     }:
     mkDerivation {
       pname = "pgp-wordlist";
       version = "0.1.0.1";
       sha256 = "a3dde976bc94fc83e8dce20cdafe673f5afdc741ac0360098ee8b415a0436d88";
       libraryHaskellDepends = [ base bytestring containers text vector ];
       testHaskellDepends = [
         base bytestring HUnit tasty tasty-hunit tasty-quickcheck text
       ];
       homepage = "https://github.com/quchen/pgp-wordlist";
       description = "Translate between binary data and a human-readable collection of words";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pgsql-simple" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, binary
     , blaze-builder, blaze-textual, bytestring, containers
     , MonadCatchIO-transformers, mtl, network, old-locale, pcre-light
     , text, time, utf8-string
     }:
     mkDerivation {
       pname = "pgsql-simple";
       version = "0.1.2";
       sha256 = "a5ce00a41529789c07109b09a4fed48301f1d1631b111b49511e9173977969fc";
       libraryHaskellDepends = [
         attoparsec base base16-bytestring binary blaze-builder
         blaze-textual bytestring containers MonadCatchIO-transformers mtl
         network old-locale pcre-light text time utf8-string
       ];
       jailbreak = true;
       homepage = "https://github.com/chrisdone/pgsql-simple";
       description = "A mid-level PostgreSQL client library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pgstream" = callPackage
    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
     , conduit, conduit-extra, deepseq, mtl, parallel, postgresql-binary
     , postgresql-libpq, resource-pool, resourcet, scientific, stm
     , stm-chans, stm-conduit, stringsearch, template-haskell, text
     , time, transformers, uuid, vector
     }:
     mkDerivation {
       pname = "pgstream";
       version = "0.1.0.3";
       sha256 = "8f694b3f0e537fe61ae4d9904d4200f0c4e0c4010583b6e25157a481e2d66a7d";
       revision = "1";
       editedCabalFile = "6b08ae7064272e58cb3d6cd8df606d3d376de019febcffd042f8bbded7300426";
       libraryHaskellDepends = [
         async attoparsec base blaze-builder bytestring conduit
         conduit-extra deepseq mtl parallel postgresql-binary
         postgresql-libpq resource-pool resourcet scientific stm stm-chans
         stm-conduit stringsearch template-haskell text time transformers
         uuid vector
       ];
       jailbreak = true;
       description = "Streaming Postgres bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "phantom-state" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "phantom-state";
       version = "0.2.0.2";
       sha256 = "d536663dbfc4c0039e2d964ae1a52339f0c8ab30de0b8b78d4524d9b8e04cf11";
       libraryHaskellDepends = [ base transformers ];
       description = "Phantom State Transformer. Like State Monad, but without values.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "phasechange" = callPackage
    ({ mkDerivation, array, base, ghc-prim, monad-st, primitive, vector
     }:
     mkDerivation {
       pname = "phasechange";
       version = "0.1";
       sha256 = "56ddf396aba263db0090cade0893b6a94197627c98525474fe372f95acafa444";
       libraryHaskellDepends = [
         array base ghc-prim monad-st primitive vector
       ];
       jailbreak = true;
       homepage = "http://github.com/glehel/phasechange";
       description = "Freezing, thawing, and copy elision";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "phash" = callPackage
    ({ mkDerivation, base, doctest, HUnit, pHash, smallcheck, tasty
     , tasty-hunit, tasty-smallcheck
     }:
     mkDerivation {
       pname = "phash";
       version = "0.0.5";
       sha256 = "7b199d520b4b08562532ab968853c701ecb868df35862ba6db5c8be299fdcdae";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ pHash ];
       testHaskellDepends = [
         base doctest HUnit smallcheck tasty tasty-hunit tasty-smallcheck
       ];
       testSystemDepends = [ pHash ];
       homepage = "http://github.com/michaelxavier/phash";
       description = "Haskell bindings to pHash, the open source perceptual hash library";
       license = stdenv.lib.licenses.gpl3;
     }) {pHash = null;};

  "phizzle" = callPackage
    ({ mkDerivation, aeson, base, bytestring, network, network-uri
     , regex-pcre, text
     }:
     mkDerivation {
       pname = "phizzle";
       version = "0.1.0.2";
       sha256 = "45a1a4947b6e94dd0a32968a8584a12ed276a8355690cf5cb0314a14de0dc2cf";
       libraryHaskellDepends = [
         aeson base bytestring network network-uri regex-pcre text
       ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/b-mcg/phizzle#readme";
       description = "Library for checking if a given link is in a phishtank json file";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "phoityne" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, cmdargs, conduit
     , conduit-extra, ConfigFile, containers, directory, filepath, gtk3
     , hslogger, HStringTemplate, MissingH, mtl, parsec, process
     , resourcet, safe, text, transformers
     }:
     mkDerivation {
       pname = "phoityne";
       version = "0.0.3.0";
       sha256 = "97823be82846237159a13767ae9a9b29acf8dbc68a95ff099b942b3bcae0790f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal cmdargs conduit conduit-extra ConfigFile
         containers directory filepath gtk3 hslogger HStringTemplate
         MissingH mtl parsec process resourcet safe text transformers
       ];
       description = "ghci debug viewer with simple editor";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "phone-numbers" = callPackage
    ({ mkDerivation, base, bytestring, phonenumber }:
     mkDerivation {
       pname = "phone-numbers";
       version = "0.0.3";
       sha256 = "ccd7b831b990d6d2d5377d7102cd7ad470fc375fe60d3b6861f62beefadbac81";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ phonenumber ];
       homepage = "https://github.com/christian-marie/phone-numbers";
       description = "Haskell bindings to the libphonenumber library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {phonenumber = null;};

  "phone-push" = callPackage
    ({ mkDerivation, base, base16-bytestring, binary, bytestring
     , conduit, convertible, HsOpenSSL, http-conduit, network, time
     , transformers
     }:
     mkDerivation {
       pname = "phone-push";
       version = "0.1.3";
       sha256 = "116a6f763c94b8848f443f0fe6605db35d7e09c040b6173f652d6b3d646baa59";
       libraryHaskellDepends = [
         base base16-bytestring binary bytestring conduit convertible
         HsOpenSSL http-conduit network time transformers
       ];
       homepage = "https://github.com/gurgeh/haskell-phone-push";
       description = "Push notifications for Android and iOS";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "phonetic-code" = callPackage
    ({ mkDerivation, array, base, containers, regex-compat }:
     mkDerivation {
       pname = "phonetic-code";
       version = "0.1.1.1";
       sha256 = "9c99a1b367cb002e520a4def1fd1af8aae9f0bc6457b137400c99e713b965b5e";
       libraryHaskellDepends = [ array base containers regex-compat ];
       homepage = "http://wiki.cs.pdx.edu/bartforge/phonetic-code";
       description = "Phonetic codes: Soundex and Phonix";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "phooey" = callPackage
    ({ mkDerivation, array, base, mtl, reactive, TypeCompose, wx
     , wxcore
     }:
     mkDerivation {
       pname = "phooey";
       version = "2.0.0.1";
       sha256 = "9247806312d6155e2734765931ebacad2e8a2306dc325903261a1d5ff1d14029";
       libraryHaskellDepends = [
         array base mtl reactive TypeCompose wx wxcore
       ];
       jailbreak = true;
       homepage = "http://haskell.org/haskellwiki/Phooey";
       description = "Functional user interfaces";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "photoname" = callPackage
    ({ mkDerivation, base, directory, exif, filepath, HUnit, mtl
     , old-locale, parsec, process, regex-posix, time, unix
     }:
     mkDerivation {
       pname = "photoname";
       version = "3.1";
       sha256 = "37935445c01a19e9a6505b7d660ddf01543af14ddc26eb5d2689fb4bdd778434";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory exif filepath mtl old-locale parsec time unix
       ];
       testHaskellDepends = [
         base directory exif filepath HUnit mtl old-locale parsec process
         regex-posix time unix
       ];
       homepage = "http://hub.darcs.net/dino/photoname";
       description = "Rename photo image files based on EXIF shoot date";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "phraskell" = callPackage
    ({ mkDerivation, base, mtl, SDL, transformers }:
     mkDerivation {
       pname = "phraskell";
       version = "0.1.4";
       sha256 = "33cd40212e997fac0d780c1eed85cff909eb09c5d56648eb65f8b0b7aadd9fad";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base mtl SDL transformers ];
       jailbreak = true;
       homepage = "https://github.com/skypers/phraskell";
       description = "A fractal viewer";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "phybin" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, directory
     , fgl, filepath, graphviz, hierarchical-clustering, HUnit, parsec
     , prettyclass, process, split, test-framework, test-framework-hunit
     , test-framework-th, text, time, vector
     }:
     mkDerivation {
       pname = "phybin";
       version = "0.3";
       sha256 = "e915cd0e344eeb344334a2533605e6448e854b70f444e76662fc4d2b9d67dfec";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base bytestring containers directory fgl filepath graphviz
         hierarchical-clustering HUnit parsec prettyclass process split text
         time vector
       ];
       executableHaskellDepends = [
         async base bytestring containers directory fgl filepath graphviz
         hierarchical-clustering HUnit parsec prettyclass process split text
         time vector
       ];
       testHaskellDepends = [
         async base bytestring containers directory fgl filepath graphviz
         hierarchical-clustering HUnit parsec prettyclass process split
         test-framework test-framework-hunit test-framework-th text time
         vector
       ];
       jailbreak = true;
       homepage = "http://www.cs.indiana.edu/~rrnewton/projects/phybin/";
       description = "Utility for clustering phylogenetic trees in Newick format based on Robinson-Foulds distance";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pi-calculus" = callPackage
    ({ mkDerivation, AES, base, binary, byteable, bytestring
     , containers, cryptohash, HTTP, io-streams, mtl, network, parsec
     , RSA, transformers
     }:
     mkDerivation {
       pname = "pi-calculus";
       version = "0.0.5";
       sha256 = "585803a452b83148eb695def6d4ecd1edb5e6e3243e3573166ff63a1f5ccb3f0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         AES base binary byteable bytestring containers cryptohash HTTP
         io-streams mtl network parsec RSA transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/renzyq19/pi-calculus";
       description = "Applied pi-calculus interpreter";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pia-forward" = callPackage
    ({ mkDerivation, aeson, base, bytestring, data-default, directory
     , filepath, http-client, http-client-tls, network-info, process
     , random, text, text-format, time, xdg-basedir
     }:
     mkDerivation {
       pname = "pia-forward";
       version = "0.1.0.1";
       sha256 = "59b49b7506a597802e6798d2cd4e892ace4ad69e08021bde37ddadb962743e0b";
       revision = "1";
       editedCabalFile = "7ace7bfcb4b05c4099a28ec12b7e12682669ddfe6d4e5f68c4d74c05914b7582";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring data-default directory filepath http-client
         http-client-tls network-info process random text text-format time
         xdg-basedir
       ];
       jailbreak = true;
       homepage = "https://github.com/enolan/pia-forward";
       description = "Set up port forwarding with the Private Internet Access VPN service";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "pianola" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-iteratee, base, bytestring
     , comonad, comonad-transformers, containers, either, errors
     , filepath, free, iteratee, logict, msgpack, mtl, network, pipes
     , streams, text, transformers
     }:
     mkDerivation {
       pname = "pianola";
       version = "0.1.1";
       sha256 = "5821a3cfa64a7e9c984aa5a90bfad842097e88cb85c4e80b4d23f4a93d18c60b";
       libraryHaskellDepends = [
         attoparsec attoparsec-iteratee base bytestring comonad
         comonad-transformers containers either errors filepath free
         iteratee logict msgpack mtl network pipes streams text transformers
       ];
       testHaskellDepends = [
         base containers errors filepath network streams text transformers
       ];
       description = "Remotely controlling Java Swing applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "picologic" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec, picosat, pretty
     , QuickCheck
     }:
     mkDerivation {
       pname = "picologic";
       version = "0.1.2";
       sha256 = "449f6ead23c54d1751d66437a06950a5b2a478348c53e6b927ec9a2bb9e9e40f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl parsec picosat pretty
       ];
       testHaskellDepends = [
         base containers mtl picosat pretty QuickCheck
       ];
       homepage = "https://github.com/sdiehl/picologic";
       description = "Utilities for symbolic predicate logic expressions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "picoparsec_0_1_2_1" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , monoid-subclasses, QuickCheck, quickcheck-instances
     , quickcheck-unicode, scientific, tasty, tasty-quickcheck, text
     , vector
     }:
     mkDerivation {
       pname = "picoparsec";
       version = "0.1.2.1";
       sha256 = "9181928e694a3defcc00b95f485bf978583bd3f676a7eb7e7d0c640bf3a593da";
       libraryHaskellDepends = [
         array base bytestring containers deepseq monoid-subclasses
         scientific text
       ];
       testHaskellDepends = [
         array base bytestring deepseq monoid-subclasses QuickCheck
         quickcheck-instances quickcheck-unicode scientific tasty
         tasty-quickcheck text vector
       ];
       homepage = "https://bitbucket.org/blamario/picoparsec";
       description = "Fast combinator parsing for bytestrings and text";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "picoparsec_0_1_2_2" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , monoid-subclasses, QuickCheck, quickcheck-instances
     , quickcheck-unicode, scientific, tasty, tasty-quickcheck, text
     , vector
     }:
     mkDerivation {
       pname = "picoparsec";
       version = "0.1.2.2";
       sha256 = "e931e9c383b9f8525d631f455ffd1cff87c959f4df2d526fbd8e52a7290bc5bd";
       libraryHaskellDepends = [
         array base bytestring containers deepseq monoid-subclasses
         scientific text
       ];
       testHaskellDepends = [
         array base bytestring deepseq monoid-subclasses QuickCheck
         quickcheck-instances quickcheck-unicode scientific tasty
         tasty-quickcheck text vector
       ];
       homepage = "https://bitbucket.org/blamario/picoparsec";
       description = "Fast combinator parsing for bytestrings and text";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "picoparsec" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , monoid-subclasses, QuickCheck, quickcheck-instances
     , quickcheck-unicode, scientific, tasty, tasty-quickcheck, text
     , vector
     }:
     mkDerivation {
       pname = "picoparsec";
       version = "0.1.2.3";
       sha256 = "8ec7ed678efaf62de15b7c2f1d21f1ddf8b92f5fa233eed9534c12e8812e9150";
       libraryHaskellDepends = [
         array base bytestring containers deepseq monoid-subclasses
         scientific text
       ];
       testHaskellDepends = [
         array base bytestring deepseq monoid-subclasses QuickCheck
         quickcheck-instances quickcheck-unicode scientific tasty
         tasty-quickcheck text vector
       ];
       homepage = "https://bitbucket.org/blamario/picoparsec";
       description = "Fast combinator parsing for bytestrings and text";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "picosat" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "picosat";
       version = "0.1.3";
       sha256 = "374d64964bbb35d24bbc3908d9de38f0087d425b6f7ab90c88f870b865564fd2";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/sdiehl/haskell-picosat";
       description = "Bindings to the PicoSAT solver";
       license = stdenv.lib.licenses.mit;
     }) {};

  "piet" = callPackage
    ({ mkDerivation, array, base, containers, Imlib, mtl }:
     mkDerivation {
       pname = "piet";
       version = "0.1";
       sha256 = "e9b33432edf176fbcb12b7ed07bb7b4fa5072e989cd25e234643321196ae6029";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base containers Imlib mtl ];
       description = "A Piet interpreter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "piki" = callPackage
    ({ mkDerivation, base, mtl, parsec, text }:
     mkDerivation {
       pname = "piki";
       version = "0.5.2";
       sha256 = "36ca3ea0a98896eb9208dcfc156fa0405b97b36f0740ef9ac8140201ad124c67";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base mtl parsec text ];
       homepage = "http://www.mew.org/~kazu/proj/piki/";
       description = "Yet another text-to-html converter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pinboard" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, either
     , http-client, http-client-tls, http-types, mtl, network
     , old-locale, profunctors, random, text, time, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "pinboard";
       version = "0.9.3";
       sha256 = "82d5200e79ea18df196a5d8543d32f1dcf7e3ff43579590dcba80e78c712c288";
       libraryHaskellDepends = [
         aeson base bytestring containers either http-client http-client-tls
         http-types mtl network old-locale profunctors random text time
         transformers unordered-containers vector
       ];
       homepage = "https://github.com/jonschoning/pinboard";
       description = "Access to the Pinboard API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pinch" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, deepseq
     , ghc-prim, hashable, hspec, hspec-discover, QuickCheck, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "pinch";
       version = "0.2.0.0";
       sha256 = "6f37594c6df1fb0539c3d44413db57869b5d450a201655141784c01c177dc5aa";
       libraryHaskellDepends = [
         array base bytestring containers deepseq ghc-prim hashable text
         unordered-containers vector
       ];
       testHaskellDepends = [
         base bytestring containers hspec hspec-discover QuickCheck text
         unordered-containers vector
       ];
       homepage = "https://github.com/abhinav/pinch";
       description = "An alternative implementation of Thrift for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pinchot_0_6_0_0" = callPackage
    ({ mkDerivation, base, containers, Earley, lens, template-haskell
     , transformers
     }:
     mkDerivation {
       pname = "pinchot";
       version = "0.6.0.0";
       sha256 = "53cada3eace3bd2ffa297944adb1260ad71ebd8761defe0fd67053327e2d75a4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers Earley lens template-haskell transformers
       ];
       homepage = "http://www.github.com/massysett/pinchot";
       description = "Build parsers and ASTs for context-free grammars";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pinchot" = callPackage
    ({ mkDerivation, base, containers, Earley, lens, template-haskell
     , transformers
     }:
     mkDerivation {
       pname = "pinchot";
       version = "0.10.0.0";
       sha256 = "59a9e3b5e5eb323b11fba24d90d7f371e22653d46bf7a31b9676220a0e78a797";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers Earley lens template-haskell transformers
       ];
       homepage = "http://www.github.com/massysett/pinchot";
       description = "Build parsers and ASTs for context-free grammars";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipe-enumerator" = callPackage
    ({ mkDerivation, base, enumerator, pipes, transformers }:
     mkDerivation {
       pname = "pipe-enumerator";
       version = "0.3.0.2";
       sha256 = "6cfee3e8792fbd9f1a061d800df3a57452eeb2757be731a592c0de822600d340";
       libraryHaskellDepends = [ base enumerator pipes transformers ];
       homepage = "https://github.com/zadarnowski/pipe-enumerator";
       description = "A bidirectional bridge between pipes and iteratees";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipeclip" = callPackage
    ({ mkDerivation, base, bytestring, editor-open, Hclip, safe }:
     mkDerivation {
       pname = "pipeclip";
       version = "0.1.0.1";
       sha256 = "cfb5db0d91da9d776695189b29579e5b7b2b0262def877aa9524219ced83abc2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring editor-open Hclip safe
       ];
       homepage = "https://github.com/pharpend/pipeclip";
       description = "Open your editor, pipe the output to the system clipboard";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "pipes_4_1_4" = callPackage
    ({ mkDerivation, base, mmorph, mtl, QuickCheck, test-framework
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "pipes";
       version = "4.1.4";
       sha256 = "eb5e9df366582e4e78fb10af7516e25691faf884c445cbb4dbb504475188672f";
       revision = "1";
       editedCabalFile = "b8c2ec8d8f28c6d6d547f841dff6882d0fd9142404bcad8766326b04fef38405";
       libraryHaskellDepends = [ base mmorph mtl transformers ];
       testHaskellDepends = [
         base mtl QuickCheck test-framework test-framework-quickcheck2
         transformers
       ];
       description = "Compositional pipelines";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes_4_1_5" = callPackage
    ({ mkDerivation, base, mmorph, mtl, QuickCheck, test-framework
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "pipes";
       version = "4.1.5";
       sha256 = "dd414af023884309114aa8fad502830fd0baf6b3fe40d26f4fca9adc485529b0";
       revision = "1";
       editedCabalFile = "c23c260bff1178965d87e6fc9f7263877b5f2adc4c0e4c1bd59c55971fff9eb4";
       libraryHaskellDepends = [ base mmorph mtl transformers ];
       testHaskellDepends = [
         base mtl QuickCheck test-framework test-framework-quickcheck2
         transformers
       ];
       description = "Compositional pipelines";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes_4_1_6" = callPackage
    ({ mkDerivation, base, mmorph, mtl, QuickCheck, test-framework
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "pipes";
       version = "4.1.6";
       sha256 = "2d6a5060380497a16287d156c69cbd55d2d3efc6d57d5079f794f90c944e7435";
       libraryHaskellDepends = [ base mmorph mtl transformers ];
       testHaskellDepends = [
         base mtl QuickCheck test-framework test-framework-quickcheck2
         transformers
       ];
       description = "Compositional pipelines";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes_4_1_7" = callPackage
    ({ mkDerivation, base, mmorph, mtl, QuickCheck, test-framework
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "pipes";
       version = "4.1.7";
       sha256 = "104620e6868cc2c4f84c85416ecfce32d53fbbbecaacc7466a0566f574f9d616";
       libraryHaskellDepends = [ base mmorph mtl transformers ];
       testHaskellDepends = [
         base mtl QuickCheck test-framework test-framework-quickcheck2
         transformers
       ];
       description = "Compositional pipelines";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes" = callPackage
    ({ mkDerivation, base, mmorph, mtl, QuickCheck, test-framework
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "pipes";
       version = "4.1.8";
       sha256 = "5a5cf658f5bd6d6cf8298841d89a1819f85d02b233937ff19e5ad55c126ece34";
       libraryHaskellDepends = [ base mmorph mtl transformers ];
       testHaskellDepends = [
         base mtl QuickCheck test-framework test-framework-quickcheck2
         transformers
       ];
       description = "Compositional pipelines";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-aeson_0_4_1_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, pipes
     , pipes-attoparsec, pipes-bytestring, pipes-parse, transformers
     }:
     mkDerivation {
       pname = "pipes-aeson";
       version = "0.4.1.2";
       sha256 = "877eb5602325a309755e94b13868426f100655d60c8b9b4d9d0b10c7c18a4c71";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring pipes pipes-attoparsec
         pipes-bytestring pipes-parse transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/k0001/pipes-aeson";
       description = "Encode and decode JSON streams using Aeson and Pipes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-aeson_0_4_1_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, pipes
     , pipes-attoparsec, pipes-bytestring, pipes-parse, transformers
     }:
     mkDerivation {
       pname = "pipes-aeson";
       version = "0.4.1.3";
       sha256 = "4cca4b42530c2f51e10464a2cba8879165b8734cf66492956ec013b948752531";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring pipes pipes-attoparsec
         pipes-bytestring pipes-parse transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/k0001/pipes-aeson";
       description = "Encode and decode JSON streams using Aeson and Pipes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-aeson_0_4_1_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, pipes
     , pipes-attoparsec, pipes-bytestring, pipes-parse, transformers
     }:
     mkDerivation {
       pname = "pipes-aeson";
       version = "0.4.1.4";
       sha256 = "59d9f8bd3078073d23591e66c94fc8258bc6c16465c7a80bd0ca9cc4fa449133";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring pipes pipes-attoparsec
         pipes-bytestring pipes-parse transformers
       ];
       homepage = "https://github.com/k0001/pipes-aeson";
       description = "Encode and decode JSON streams using Aeson and Pipes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-aeson" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, pipes
     , pipes-attoparsec, pipes-bytestring, pipes-parse, transformers
     }:
     mkDerivation {
       pname = "pipes-aeson";
       version = "0.4.1.5";
       sha256 = "74605983d914128d437cfac5e34ebdecb81426c29337af2b7d1e7a1970173595";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring pipes pipes-attoparsec
         pipes-bytestring pipes-parse transformers
       ];
       homepage = "https://github.com/k0001/pipes-aeson";
       description = "Encode and decode JSON streams using Aeson and Pipes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-async" = callPackage
    ({ mkDerivation, base, hspec, lifted-async, lifted-base
     , monad-control, pipes, pipes-safe, stm, transformers-base
     }:
     mkDerivation {
       pname = "pipes-async";
       version = "0.1.1";
       sha256 = "e22358175e3c2c8f16bf17842e63e891931e792c3aafd2167bfc39baac1b14ac";
       libraryHaskellDepends = [
         base lifted-async lifted-base monad-control pipes pipes-safe stm
         transformers-base
       ];
       testHaskellDepends = [
         base hspec lifted-async lifted-base monad-control pipes pipes-safe
         stm transformers-base
       ];
       jailbreak = true;
       homepage = "https://github.com/jwiegley/pipes-async";
       description = "A higher-level interface to using concurrency with pipes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-attoparsec_0_5_1_1" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, HUnit, mmorph, pipes
     , pipes-parse, tasty, tasty-hunit, text, transformers
     }:
     mkDerivation {
       pname = "pipes-attoparsec";
       version = "0.5.1.1";
       sha256 = "1f0b3a7d1b625d45e57c9cae299225d9ba6c310b488e1f8ef2914069eed048db";
       libraryHaskellDepends = [
         attoparsec base bytestring pipes pipes-parse text transformers
       ];
       testHaskellDepends = [
         attoparsec base HUnit mmorph pipes pipes-parse tasty tasty-hunit
         text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/k0001/pipes-attoparsec";
       description = "Attoparsec and Pipes integration";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-attoparsec" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, HUnit, mmorph, pipes
     , pipes-parse, tasty, tasty-hunit, text, transformers
     }:
     mkDerivation {
       pname = "pipes-attoparsec";
       version = "0.5.1.2";
       sha256 = "9b56bdd47c4180dd359af29c3346c645888e1fa442065fa88a4626c40cf210e2";
       libraryHaskellDepends = [
         attoparsec base bytestring pipes pipes-parse text transformers
       ];
       testHaskellDepends = [
         attoparsec base HUnit mmorph pipes pipes-parse tasty tasty-hunit
         text transformers
       ];
       homepage = "https://github.com/k0001/pipes-attoparsec";
       description = "Attoparsec and Pipes integration";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-attoparsec-streaming" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, pipes-core
     , transformers
     }:
     mkDerivation {
       pname = "pipes-attoparsec-streaming";
       version = "0.1.0.0";
       sha256 = "a7854c053559450c898008432a82bfba85c3325334ff1462630315282549992a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring pipes-core transformers
       ];
       executableHaskellDepends = [
         attoparsec base bytestring pipes-core transformers
       ];
       jailbreak = true;
       description = "Streaming parsing in the pipes-core framework with Attoparsec";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-bgzf" = callPackage
    ({ mkDerivation, base, bytestring, mtl, parallel, pipes
     , streaming-commons
     }:
     mkDerivation {
       pname = "pipes-bgzf";
       version = "0.2.0.1";
       sha256 = "43ec9888b51def483a701e56443b62c00ec37aa2d9e0ee3b314fa084fce7c013";
       libraryHaskellDepends = [
         base bytestring mtl parallel pipes streaming-commons
       ];
       description = "Blocked GZip";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-binary_0_4_0_4" = callPackage
    ({ mkDerivation, base, binary, bytestring, ghc-prim
     , lens-family-core, pipes, pipes-bytestring, pipes-parse
     , smallcheck, tasty, tasty-hunit, tasty-smallcheck, transformers
     }:
     mkDerivation {
       pname = "pipes-binary";
       version = "0.4.0.4";
       sha256 = "d194288868fb79f7fd4c14c88e71cd93ec004ed4ac5d1ec7e9e5e6f5dbde20b1";
       libraryHaskellDepends = [
         base binary bytestring ghc-prim pipes pipes-bytestring pipes-parse
         transformers
       ];
       testHaskellDepends = [
         base binary bytestring ghc-prim lens-family-core pipes pipes-parse
         smallcheck tasty tasty-hunit tasty-smallcheck transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/k0001/pipes-binary";
       description = "Encode and decode binary streams using the pipes and binary libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-binary_0_4_0_5" = callPackage
    ({ mkDerivation, base, binary, bytestring, ghc-prim
     , lens-family-core, pipes, pipes-bytestring, pipes-parse
     , smallcheck, tasty, tasty-hunit, tasty-smallcheck, transformers
     }:
     mkDerivation {
       pname = "pipes-binary";
       version = "0.4.0.5";
       sha256 = "334c01f02eb5a7b38f5e4110094a3166983e3d01bcdb4455fd34976066096ff8";
       libraryHaskellDepends = [
         base binary bytestring ghc-prim pipes pipes-bytestring pipes-parse
         transformers
       ];
       testHaskellDepends = [
         base binary bytestring ghc-prim lens-family-core pipes pipes-parse
         smallcheck tasty tasty-hunit tasty-smallcheck transformers
       ];
       homepage = "https://github.com/k0001/pipes-binary";
       description = "Encode and decode binary streams using the pipes and binary libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-binary" = callPackage
    ({ mkDerivation, base, binary, bytestring, ghc-prim
     , lens-family-core, pipes, pipes-bytestring, pipes-parse
     , smallcheck, tasty, tasty-hunit, tasty-smallcheck, transformers
     }:
     mkDerivation {
       pname = "pipes-binary";
       version = "0.4.1";
       sha256 = "1b6e79748f2579285ba416c02c1461fee394309f79b94f9d5c874bbf6f79d637";
       libraryHaskellDepends = [
         base binary bytestring ghc-prim pipes pipes-bytestring pipes-parse
         transformers
       ];
       testHaskellDepends = [
         base binary bytestring ghc-prim lens-family-core pipes pipes-parse
         smallcheck tasty tasty-hunit tasty-smallcheck transformers
       ];
       homepage = "https://github.com/k0001/pipes-binary";
       description = "Encode and decode binary streams using the pipes and binary libraries";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-bytestring" = callPackage
    ({ mkDerivation, base, bytestring, pipes, pipes-group, pipes-parse
     , transformers
     }:
     mkDerivation {
       pname = "pipes-bytestring";
       version = "2.1.1";
       sha256 = "bfb6c273a080a9dad8319ba1a78b979d6f29f7593a7cc5750b9d0481f5dac8fe";
       libraryHaskellDepends = [
         base bytestring pipes pipes-group pipes-parse transformers
       ];
       description = "ByteString support for pipes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-cacophony" = callPackage
    ({ mkDerivation, async, base, bytestring, cacophony, hlint, mtl
     , pipes, QuickCheck, tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "pipes-cacophony";
       version = "0.1.3";
       sha256 = "166d95fe84ba7edd62b3d9861b9d3e0e16fd18ec4d99e3b0b44abaf531094e89";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring cacophony pipes ];
       testHaskellDepends = [
         async base bytestring cacophony hlint mtl pipes QuickCheck tasty
         tasty-quickcheck
       ];
       homepage = "https://github.com/centromere/pipes-cacophony";
       description = "Pipes for Noise-secured network connections";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "pipes-cellular" = callPackage
    ({ mkDerivation, base, bytestring, data-cell, pipes }:
     mkDerivation {
       pname = "pipes-cellular";
       version = "0.0.0.1";
       sha256 = "ac4145eab90f0ff1ec66502bee3d87e4620bca0fe49e2153ab6eccc4f6f70a48";
       libraryHaskellDepends = [ base bytestring data-cell pipes ];
       homepage = "https://github.com/zadarnowski/pipes-cellular";
       description = "Pipes-based combinators for cellular data processing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-cellular-csv" = callPackage
    ({ mkDerivation, base, bytestring, data-cell, pipes, pipes-cellular
     }:
     mkDerivation {
       pname = "pipes-cellular-csv";
       version = "1.0.0.0";
       sha256 = "896d53f45dd86e77adbd06f7fd6e7d3118c2125986ca05693225e89c53d5f1d3";
       libraryHaskellDepends = [
         base bytestring data-cell pipes pipes-cellular
       ];
       homepage = "https://github.com/zadarnowski/pipes-cellular-csv";
       description = "Efficient pipes-based cellular CSV codec";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-cereal" = callPackage
    ({ mkDerivation, base, bytestring, cereal, mtl, pipes
     , pipes-bytestring, pipes-parse
     }:
     mkDerivation {
       pname = "pipes-cereal";
       version = "0.1.0";
       sha256 = "874d90435aac869871c169777ba937ac2579868c9076d9292d534b9f163a43b6";
       libraryHaskellDepends = [
         base bytestring cereal mtl pipes pipes-bytestring pipes-parse
       ];
       jailbreak = true;
       description = "Encode and decode binary streams using the pipes and cereal libraries";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-cereal-plus" = callPackage
    ({ mkDerivation, base, bytestring, cereal-plus, errors, mtl, pipes
     , pipes-bytestring, text
     }:
     mkDerivation {
       pname = "pipes-cereal-plus";
       version = "0.4.0";
       sha256 = "19c345ddd422da208e561fe35552caaa474f63a1ad400cc5671b52a0117538f4";
       libraryHaskellDepends = [
         base bytestring cereal-plus errors mtl pipes pipes-bytestring text
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/pipes-cereal-plus";
       description = "A streaming serialization library on top of \"pipes\" and \"cereal-plus\"";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-cliff" = callPackage
    ({ mkDerivation, async, base, bytestring, pipes, pipes-safe
     , process, stm
     }:
     mkDerivation {
       pname = "pipes-cliff";
       version = "0.10.0.4";
       sha256 = "3d92b54e773e98996cbc1c753892e7400540d925f913d187b940e7425dfdef33";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base bytestring pipes pipes-safe process stm
       ];
       homepage = "http://www.github.com/massysett/pipes-cliff";
       description = "Streaming to and from subprocesses using Pipes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-concurrency_2_0_2" = callPackage
    ({ mkDerivation, async, base, pipes, stm }:
     mkDerivation {
       pname = "pipes-concurrency";
       version = "2.0.2";
       sha256 = "a8423a1771769917d4989e3c137f6069f62c8ac456f90dd413f0a2d9105c8e3c";
       libraryHaskellDepends = [ base pipes stm ];
       testHaskellDepends = [ async base pipes stm ];
       jailbreak = true;
       description = "Concurrency for the pipes ecosystem";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-concurrency_2_0_3" = callPackage
    ({ mkDerivation, async, base, pipes, stm }:
     mkDerivation {
       pname = "pipes-concurrency";
       version = "2.0.3";
       sha256 = "e56a51f71f254dd71b11387c6d0514fb7a951a0d666c63df8c707b433fb54e4b";
       libraryHaskellDepends = [ base pipes stm ];
       testHaskellDepends = [ async base pipes stm ];
       jailbreak = true;
       description = "Concurrency for the pipes ecosystem";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-concurrency_2_0_4" = callPackage
    ({ mkDerivation, async, base, pipes, stm }:
     mkDerivation {
       pname = "pipes-concurrency";
       version = "2.0.4";
       sha256 = "195ff8fe0551bc03cca2e150e1bf235276c8f5b3c286ff3fddefa5074d6a85d3";
       libraryHaskellDepends = [ base pipes stm ];
       testHaskellDepends = [ async base pipes stm ];
       jailbreak = true;
       description = "Concurrency for the pipes ecosystem";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-concurrency" = callPackage
    ({ mkDerivation, async, base, pipes, stm }:
     mkDerivation {
       pname = "pipes-concurrency";
       version = "2.0.5";
       sha256 = "da7cfd1817f60bba99b28b485ad8341131202512532cafdd2e81945e01ab2b6c";
       libraryHaskellDepends = [ base pipes stm ];
       testHaskellDepends = [ async base pipes stm ];
       description = "Concurrency for the pipes ecosystem";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-conduit" = callPackage
    ({ mkDerivation, base, conduit, mtl, pipes-core }:
     mkDerivation {
       pname = "pipes-conduit";
       version = "0.0.1";
       sha256 = "08366060768aa35dfff4e8eb166d3794df72c14b15f4876d0755b8112ba4fedb";
       libraryHaskellDepends = [ base conduit mtl pipes-core ];
       jailbreak = true;
       homepage = "https://github.com/pcapriotti/pipes-extra";
       description = "Conduit adapters";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-core" = callPackage
    ({ mkDerivation, base, categories, lifted-base, monad-control
     , transformers, void
     }:
     mkDerivation {
       pname = "pipes-core";
       version = "0.1.0";
       sha256 = "d73f8ad3c10f7bd0c3d0c20791aa6167cc001b9fbd28f264a4c847b90af17fa9";
       libraryHaskellDepends = [
         base categories lifted-base monad-control transformers void
       ];
       jailbreak = true;
       homepage = "https://github.com/pcapriotti/pipes-core";
       description = "Compositional pipelines";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-courier" = callPackage
    ({ mkDerivation, base, courier, pipes }:
     mkDerivation {
       pname = "pipes-courier";
       version = "0.1.0.0";
       sha256 = "ee4992048b8d42de4c36aa223dee8eb74cd2cbca7ea17deb3acaac5f99a84bec";
       libraryHaskellDepends = [ base courier pipes ];
       jailbreak = true;
       homepage = "http://github.com/kvanberendonck/pipes-courier";
       description = "Pipes utilities for interfacing with the courier message-passing framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-csv" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, cassava, HUnit
     , MissingH, pipes, pipes-bytestring, test-framework
     , test-framework-hunit, unordered-containers, vector
     }:
     mkDerivation {
       pname = "pipes-csv";
       version = "1.4.3";
       sha256 = "9485f5ddd56ec9bb10d26cdf2b5b67754726e36b167652b11cb0a42acbda68b3";
       libraryHaskellDepends = [
         base blaze-builder bytestring cassava pipes unordered-containers
         vector
       ];
       testHaskellDepends = [
         base bytestring cassava HUnit MissingH pipes pipes-bytestring
         test-framework test-framework-hunit vector
       ];
       description = "Fast, streaming csv parser";
       license = stdenv.lib.licenses.mit;
       maintainers = with stdenv.lib.maintainers; [ jb55 ];
     }) {};

  "pipes-errors" = callPackage
    ({ mkDerivation, base, errors, pipes }:
     mkDerivation {
       pname = "pipes-errors";
       version = "0.3";
       sha256 = "e6586706e39cf93326a073c93e049a2abdfe7942d425e572601a813d346477ed";
       libraryHaskellDepends = [ base errors pipes ];
       homepage = "https://github.com/jdnavarro/pipes-errors";
       description = "Integration between pipes and errors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-extra" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, mtl, pipes-core
     , test-framework, test-framework-hunit, test-framework-th-prime
     , transformers
     }:
     mkDerivation {
       pname = "pipes-extra";
       version = "0.2.0";
       sha256 = "d9ede8b4a837bdecf8fb4e87a1c0d31b5ded403d0e8d900a0e2ae9e493962b7b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring pipes-core transformers
       ];
       testHaskellDepends = [
         base bytestring HUnit mtl pipes-core test-framework
         test-framework-hunit test-framework-th-prime
       ];
       jailbreak = true;
       homepage = "https://github.com/pcapriotti/pipes-extra";
       description = "Various basic utilities for Pipes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-extras" = callPackage
    ({ mkDerivation, base, foldl, HUnit, pipes, test-framework
     , test-framework-hunit, transformers
     }:
     mkDerivation {
       pname = "pipes-extras";
       version = "1.0.2";
       sha256 = "01bc6c13920874cffc3b8587e45bb7ecb4feef1892c8b2ba5975f5216cf6b6cf";
       libraryHaskellDepends = [ base foldl pipes transformers ];
       testHaskellDepends = [
         base HUnit pipes test-framework test-framework-hunit transformers
       ];
       description = "Extra utilities for pipes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-fastx" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, pipes
     , pipes-attoparsec, pipes-bytestring
     }:
     mkDerivation {
       pname = "pipes-fastx";
       version = "0.3.0.0";
       sha256 = "31264ba760bae1df3170a7d8da32f3e3fcb289545a33f369a94732e55e08ba75";
       libraryHaskellDepends = [
         attoparsec base bytestring pipes pipes-attoparsec pipes-bytestring
       ];
       description = "Streaming parsers for Fasta and Fastq";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-files" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, directory, doctest
     , exceptions, filepath, free, hierarchy, hspec, hspec-expectations
     , mmorph, monad-control, mtl, pipes, pipes-safe, posix-paths
     , process, regex-posix, semigroups, text, time, transformers
     , transformers-base, transformers-compat, unix, unix-compat
     }:
     mkDerivation {
       pname = "pipes-files";
       version = "0.1.1";
       sha256 = "a895f464790996ca19195fe605040520660087a36e8c6316fe6647bc23d516aa";
       libraryHaskellDepends = [
         attoparsec base bytestring directory exceptions filepath free
         hierarchy mmorph monad-control mtl pipes pipes-safe posix-paths
         regex-posix semigroups text time transformers transformers-base
         transformers-compat unix unix-compat
       ];
       testHaskellDepends = [
         base bytestring directory doctest filepath hierarchy hspec
         hspec-expectations mtl pipes pipes-safe process semigroups text
         transformers unix
       ];
       jailbreak = true;
       homepage = "https://github.com/jwiegley/pipes-files";
       description = "Fast traversal of directory trees using pipes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "pipes-group_1_0_2" = callPackage
    ({ mkDerivation, base, free, pipes, pipes-parse, transformers }:
     mkDerivation {
       pname = "pipes-group";
       version = "1.0.2";
       sha256 = "e056ab94a9211698505491a7958c56aa52b682b4bdc32fa0a369bc7c16906106";
       libraryHaskellDepends = [
         base free pipes pipes-parse transformers
       ];
       description = "Group streams into substreams";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-group" = callPackage
    ({ mkDerivation, base, doctest, free, lens-family-core, pipes
     , pipes-parse, transformers
     }:
     mkDerivation {
       pname = "pipes-group";
       version = "1.0.3";
       sha256 = "f0f20cc29410d84faeae1fe055d3d1041a205c27403d627bd865489c7f7ec200";
       libraryHaskellDepends = [
         base free pipes pipes-parse transformers
       ];
       testHaskellDepends = [ base doctest lens-family-core ];
       description = "Group streams into substreams";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-http" = callPackage
    ({ mkDerivation, base, bytestring, http-client, http-client-tls
     , pipes
     }:
     mkDerivation {
       pname = "pipes-http";
       version = "1.0.2";
       sha256 = "f32f2962ba04ccb28cef3866d002fbc17a8d818ef637c236c72148f66f580a43";
       libraryHaskellDepends = [
         base bytestring http-client http-client-tls pipes
       ];
       description = "HTTP client with pipes interface";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-illumina" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, pipes
     , pipes-bgzf
     }:
     mkDerivation {
       pname = "pipes-illumina";
       version = "0.1.0.0";
       sha256 = "76cba39a2276c7d6c0fb0b1036e87f5619edd6746760ea4848d1d6edf2cc46a7";
       libraryHaskellDepends = [
         base bytestring directory filepath pipes pipes-bgzf
       ];
       homepage = "http://github.com/rcallahan/pipes-illumina";
       description = "Illumina NGS data processing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-interleave" = callPackage
    ({ mkDerivation, base, containers, pipes }:
     mkDerivation {
       pname = "pipes-interleave";
       version = "0.2.1";
       sha256 = "79a85c313d44cf5ce698ce796b2aefeba0d5c856834aa52ae3566292fb4244f7";
       libraryHaskellDepends = [ base containers pipes ];
       homepage = "http://github.com/bgamari/pipes-interleave";
       description = "Interleave and merge streams of elements";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-mongodb" = callPackage
    ({ mkDerivation, base, monad-control, mongoDB, pipes, text }:
     mkDerivation {
       pname = "pipes-mongodb";
       version = "0.1.0.0";
       sha256 = "0821194bdf7f377beeb20fc8f697ed5388a221b6e8e42c513eea67a91c198340";
       libraryHaskellDepends = [ base monad-control mongoDB pipes ];
       testHaskellDepends = [ base monad-control mongoDB pipes text ];
       doCheck = false;
       homepage = "http://github.com/jb55/pipes-mongodb";
       description = "Stream results from MongoDB";
       license = stdenv.lib.licenses.mit;
       maintainers = with stdenv.lib.maintainers; [ jb55 ];
     }) {};

  "pipes-network" = callPackage
    ({ mkDerivation, base, bytestring, network, network-simple, pipes
     , pipes-safe, transformers
     }:
     mkDerivation {
       pname = "pipes-network";
       version = "0.6.4";
       sha256 = "57d48f8b1a129eae2715ed06714026d06d5ad5c0edf88c7eec1c6022cbf64bf1";
       libraryHaskellDepends = [
         base bytestring network network-simple pipes pipes-safe
         transformers
       ];
       homepage = "https://github.com/k0001/pipes-network";
       description = "Use network sockets together with the pipes library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-network-tls" = callPackage
    ({ mkDerivation, base, bytestring, network, network-simple
     , network-simple-tls, pipes, pipes-network, pipes-safe, tls
     , transformers
     }:
     mkDerivation {
       pname = "pipes-network-tls";
       version = "0.2.1";
       sha256 = "0cb66f74c14478dc62531677e6316fb086116127a9a8ab6a414dab3df4087c4c";
       libraryHaskellDepends = [
         base bytestring network network-simple network-simple-tls pipes
         pipes-network pipes-safe tls transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/k0001/pipes-network-tls";
       description = "TLS-secured network connections support for pipes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-p2p" = callPackage
    ({ mkDerivation, async, base, binary, bytestring, errors
     , exceptions, mtl, network, network-simple-sockaddr, pipes
     , pipes-concurrency, pipes-network
     }:
     mkDerivation {
       pname = "pipes-p2p";
       version = "0.4";
       sha256 = "cc7260b39163c3971575b57b11747637c7150995c7cf4abcaf2b2af06d4b48d3";
       libraryHaskellDepends = [
         async base binary bytestring errors exceptions mtl network
         network-simple-sockaddr pipes pipes-concurrency pipes-network
       ];
       homepage = "https://github.com/jdnavarro/pipes-p2p";
       description = "P2P network nodes with pipes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-p2p-examples" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, errors, mtl
     , network, network-simple-sockaddr, pipes, pipes-network, pipes-p2p
     }:
     mkDerivation {
       pname = "pipes-p2p-examples";
       version = "0.3";
       sha256 = "95737ad1ecd18ed9dea25ed551668b31fd3bb4974e533c7e45b9665f0098cd21";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring containers errors mtl network
         network-simple-sockaddr pipes pipes-network pipes-p2p
       ];
       jailbreak = true;
       homepage = "https://github.com/jdnavarro/pipes-p2p-examples";
       description = "Examples using pipes-p2p";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-parse_3_0_2" = callPackage
    ({ mkDerivation, base, pipes, transformers }:
     mkDerivation {
       pname = "pipes-parse";
       version = "3.0.2";
       sha256 = "08b44b02f5137f35f1570a1f1b1adc7ef9f48b86516c9edaae104c3b1184b4b4";
       libraryHaskellDepends = [ base pipes transformers ];
       description = "Parsing infrastructure for the pipes ecosystem";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-parse_3_0_3" = callPackage
    ({ mkDerivation, base, pipes, transformers }:
     mkDerivation {
       pname = "pipes-parse";
       version = "3.0.3";
       sha256 = "f55298ad7a4d02c2cfb0bfc02a5cfd3785c987e06202d61409c10618e0a35a03";
       libraryHaskellDepends = [ base pipes transformers ];
       description = "Parsing infrastructure for the pipes ecosystem";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-parse" = callPackage
    ({ mkDerivation, base, pipes, transformers }:
     mkDerivation {
       pname = "pipes-parse";
       version = "3.0.4";
       sha256 = "be1d15fc1fd4b3a8631f3202967fbdcd916f8567eedcf7ee17801296830c3705";
       libraryHaskellDepends = [ base pipes transformers ];
       description = "Parsing infrastructure for the pipes ecosystem";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-postgresql-simple" = callPackage
    ({ mkDerivation, async, base, bytestring, exceptions, mtl, pipes
     , pipes-concurrency, pipes-safe, postgresql-simple, stm, text
     , transformers
     }:
     mkDerivation {
       pname = "pipes-postgresql-simple";
       version = "0.1.2.0";
       sha256 = "81f11a44938d2ba1744f0ba82053a3a5aaaa0cfc716f5a4762ff4bde7415328a";
       libraryHaskellDepends = [
         async base bytestring exceptions mtl pipes pipes-concurrency
         pipes-safe postgresql-simple stm text transformers
       ];
       description = "Convert various postgresql-simple calls to work with pipes";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pipes-rt" = callPackage
    ({ mkDerivation, base, mwc-random, pipes, time }:
     mkDerivation {
       pname = "pipes-rt";
       version = "0.5.0";
       sha256 = "d930d70ef13bf77f92f6575edc9e371335b1cfc4ab56b527e8ca3c8568e48ff2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mwc-random pipes time ];
       executableHaskellDepends = [ base pipes time ];
       homepage = "http://github.com/ImAlsoGreg/pipes-rt";
       description = "A few pipes to control the timing of yields";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-safe_2_2_2" = callPackage
    ({ mkDerivation, base, containers, exceptions, pipes, transformers
     }:
     mkDerivation {
       pname = "pipes-safe";
       version = "2.2.2";
       sha256 = "05548546c63521aacec35a952e03c748df6251ff188bde292d8e4dc20b77e0ea";
       libraryHaskellDepends = [
         base containers exceptions pipes transformers
       ];
       description = "Safety for the pipes ecosystem";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-safe" = callPackage
    ({ mkDerivation, base, containers, exceptions, monad-control, mtl
     , pipes, transformers, transformers-base
     }:
     mkDerivation {
       pname = "pipes-safe";
       version = "2.2.3";
       sha256 = "d17b8169e2cee683953b020894c4d34fbb1babe063e4309169bef1a90d1e99a7";
       libraryHaskellDepends = [
         base containers exceptions monad-control mtl pipes transformers
         transformers-base
       ];
       description = "Safety for the pipes ecosystem";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-shell" = callPackage
    ({ mkDerivation, async, base, bytestring, directory, hspec, pipes
     , pipes-bytestring, pipes-safe, process, stm, stm-chans, text
     }:
     mkDerivation {
       pname = "pipes-shell";
       version = "0.1.4";
       sha256 = "05d31328239853915e18020e952c487cb9edf8027d52ad81f284930339d3ada4";
       libraryHaskellDepends = [
         async base bytestring pipes pipes-bytestring pipes-safe process stm
         stm-chans text
       ];
       testHaskellDepends = [
         async base bytestring directory hspec pipes pipes-bytestring
         pipes-safe process stm stm-chans text
       ];
       jailbreak = true;
       description = "Create proper Pipes from System.Process";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-sqlite-simple" = callPackage
    ({ mkDerivation, base, pipes, pipes-safe, sqlite-simple, text }:
     mkDerivation {
       pname = "pipes-sqlite-simple";
       version = "0.2";
       sha256 = "9835f4f06e2f8c9e62d628533efef22234a9aa83298f369c3669d2a96726cf2f";
       libraryHaskellDepends = [
         base pipes pipes-safe sqlite-simple text
       ];
       description = "Functions that smash Pipes and sqlite-simple together";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-text_0_0_0_16" = callPackage
    ({ mkDerivation, base, bytestring, pipes, pipes-bytestring
     , pipes-group, pipes-parse, pipes-safe, streaming-commons, text
     , transformers
     }:
     mkDerivation {
       pname = "pipes-text";
       version = "0.0.0.16";
       sha256 = "db5f553d78486d7aae2742e3d310b6144e0f53f9ac2a258cff01920702ec6635";
       libraryHaskellDepends = [
         base bytestring pipes pipes-bytestring pipes-group pipes-parse
         pipes-safe streaming-commons text transformers
       ];
       homepage = "https://github.com/michaelt/text-pipes";
       description = "Text pipes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-text_0_0_1_0" = callPackage
    ({ mkDerivation, base, bytestring, pipes, pipes-bytestring
     , pipes-group, pipes-parse, pipes-safe, streaming-commons, text
     , transformers
     }:
     mkDerivation {
       pname = "pipes-text";
       version = "0.0.1.0";
       sha256 = "7c600b6b2b3841c60c5b0cfe2c3654c776bdaa92c6e3397603033232bb939ac9";
       libraryHaskellDepends = [
         base bytestring pipes pipes-bytestring pipes-group pipes-parse
         pipes-safe streaming-commons text transformers
       ];
       homepage = "https://github.com/michaelt/text-pipes";
       description = "Text pipes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-text" = callPackage
    ({ mkDerivation, base, bytestring, pipes, pipes-bytestring
     , pipes-group, pipes-parse, pipes-safe, streaming-commons, text
     , transformers
     }:
     mkDerivation {
       pname = "pipes-text";
       version = "0.0.2.1";
       sha256 = "4bb6f008ad1a56e8a685ca960ddd777647183c15989883d14f84e5a5aa21b3e3";
       libraryHaskellDepends = [
         base bytestring pipes pipes-bytestring pipes-group pipes-parse
         pipes-safe streaming-commons text transformers
       ];
       homepage = "https://github.com/michaelt/text-pipes";
       description = "properly streaming text";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-transduce" = callPackage
    ({ mkDerivation, base, bifunctors, bytestring, conceit, doctest
     , foldl, free, pipes, pipes-bytestring, pipes-concurrency
     , pipes-group, pipes-parse, pipes-safe, pipes-text, tasty
     , tasty-hunit, text, transformers, void
     }:
     mkDerivation {
       pname = "pipes-transduce";
       version = "0.3.4.0";
       sha256 = "82c850ba718f4467e2742418249a584b1d3521815083a87cbe51543bc3486833";
       libraryHaskellDepends = [
         base bifunctors bytestring conceit foldl free pipes
         pipes-bytestring pipes-concurrency pipes-group pipes-parse
         pipes-safe pipes-text text transformers void
       ];
       testHaskellDepends = [
         base doctest foldl free pipes tasty tasty-hunit text
       ];
       description = "Interfacing pipes with foldl folds";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-vector" = callPackage
    ({ mkDerivation, base, monad-primitive, pipes, primitive
     , transformers, vector
     }:
     mkDerivation {
       pname = "pipes-vector";
       version = "0.6.2";
       sha256 = "960b6d75cbf53dffb1da6d1e570fd6eed6f5bc4a18418ab814d9be0eb55ed186";
       libraryHaskellDepends = [
         base monad-primitive pipes primitive transformers vector
       ];
       description = "Various proxies for streaming data into vectors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-wai_3_0_2" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, http-types, pipes
     , transformers, wai
     }:
     mkDerivation {
       pname = "pipes-wai";
       version = "3.0.2";
       sha256 = "88ab3d4f3d04c3465eb3161fce60c3a21ef1599a51549e2f0e69274b2d59ca71";
       libraryHaskellDepends = [
         base blaze-builder bytestring http-types pipes transformers wai
       ];
       jailbreak = true;
       homepage = "http://github.com/brewtown/pipes-wai";
       description = "A port of wai-conduit for the pipes ecosystem";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pipes-wai" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, http-types, pipes
     , transformers, wai
     }:
     mkDerivation {
       pname = "pipes-wai";
       version = "3.2.0";
       sha256 = "04a670df140c12b64f6f0d04b3c5571527f144ee429e7030bb62ec8785056d2a";
       libraryHaskellDepends = [
         base blaze-builder bytestring http-types pipes transformers wai
       ];
       homepage = "http://github.com/iand675/pipes-wai";
       description = "A port of wai-conduit for the pipes ecosystem";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pipes-websockets" = callPackage
    ({ mkDerivation, base, pipes, pipes-concurrency, text, transformers
     , websockets
     }:
     mkDerivation {
       pname = "pipes-websockets";
       version = "0.1.0.0";
       sha256 = "b86dcf98d0536c7d6830b64a84d14a89aaa68659abd715b5891e98975de9bac2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base pipes pipes-concurrency text transformers websockets
       ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/silky/pipes-websockets#readme";
       description = "WebSockets in the Pipes framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-zeromq4" = callPackage
    ({ mkDerivation, base, bytestring, pipes, pipes-safe, semigroups
     , zeromq4-haskell
     }:
     mkDerivation {
       pname = "pipes-zeromq4";
       version = "0.2.0.0";
       sha256 = "24f3ae9640eb6e2180edb8e0fc12bc420c7fa83aa32605900de1d961d93e92fe";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring pipes pipes-safe semigroups zeromq4-haskell
       ];
       executableHaskellDepends = [
         base bytestring pipes pipes-safe semigroups zeromq4-haskell
       ];
       jailbreak = true;
       homepage = "https://github.com/peddie/pipes-zeromq4";
       description = "Pipes integration for ZeroMQ messaging";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pipes-zlib" = callPackage
    ({ mkDerivation, base, bytestring, pipes, transformers, zlib
     , zlib-bindings
     }:
     mkDerivation {
       pname = "pipes-zlib";
       version = "0.4.3";
       sha256 = "ac6a4a6b3f9e5b7962d5913f438478a04ae31cc4fca0eb7d25b4db1a32e03112";
       libraryHaskellDepends = [
         base bytestring pipes transformers zlib zlib-bindings
       ];
       homepage = "https://github.com/k0001/pipes-zlib";
       description = "Zlib and GZip compression and decompression for Pipes streams";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pisigma" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, haskeline
     , haskeline-class, mpppc, mtl, parsec, text, utf8-string
     }:
     mkDerivation {
       pname = "pisigma";
       version = "0.2.1";
       sha256 = "bf93645e6f28c9b4c8ff6f7b4d18aace862bd6a19f8a1cd1d8ec78f4a063e4d7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring containers haskeline haskeline-class mpppc
         mtl parsec text utf8-string
       ];
       jailbreak = true;
       description = "A dependently typed core language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pit" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath
     , optparse-applicative, process, temporary, text
     , unordered-containers, yaml
     }:
     mkDerivation {
       pname = "pit";
       version = "0.3.1";
       sha256 = "173d97df8161007ca7da65dd60765c3aaf211b90f0117c89ceb86c34fb851983";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring directory filepath process temporary text
         unordered-containers yaml
       ];
       executableHaskellDepends = [
         base bytestring optparse-applicative text unordered-containers yaml
       ];
       jailbreak = true;
       homepage = "https://github.com/chiro/haskell-pit";
       description = "Account management tool";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pitchtrack" = callPackage
    ({ mkDerivation, base, bytestring, dywapitchtrack, hspec, pipes
     , pipes-bytestring, process, transformers
     }:
     mkDerivation {
       pname = "pitchtrack";
       version = "0.1.0.1";
       sha256 = "17407f7ab1723fdbebbc7c727391d3177e6d5f568b4b129a17640525bac40200";
       libraryHaskellDepends = [
         base bytestring dywapitchtrack pipes pipes-bytestring process
         transformers
       ];
       testHaskellDepends = [
         base bytestring dywapitchtrack hspec pipes pipes-bytestring process
         transformers
       ];
       description = "Pitch tracking library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pivotal-tracker" = callPackage
    ({ mkDerivation, aeson, aeson-casing, base, either, servant
     , servant-client, text, time, transformers
     }:
     mkDerivation {
       pname = "pivotal-tracker";
       version = "0.1.0.1";
       sha256 = "e9686d2d3537cbe53e1196724d1c55334ce0de02fe4d3e6678fff1fdf3a7ff46";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-casing base servant servant-client text time
         transformers
       ];
       executableHaskellDepends = [
         base either servant text transformers
       ];
       description = "A library and a CLI tool for accessing Pivotal Tracker API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pkcs1" = callPackage
    ({ mkDerivation, base, bytestring, random }:
     mkDerivation {
       pname = "pkcs1";
       version = "1.0.2";
       sha256 = "c918a00c72fd244d80556b4eeec4047c9c4ba67c39e48891f96357938d7c2895";
       libraryHaskellDepends = [ base bytestring random ];
       homepage = "http://sep07.mroot.net/";
       description = "RSA encryption with PKCS1 padding";
       license = "GPL";
     }) {};

  "pkcs10" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-parse, asn1-types, base
     , bytestring, cryptonite, pem, QuickCheck, tasty, tasty-hunit
     , tasty-quickcheck, transformers, x509
     }:
     mkDerivation {
       pname = "pkcs10";
       version = "0.1.0.5";
       sha256 = "c07fe8bcf0904e80bfab4816172c827ed07fe01f5d7dc172dc96a2e9da9afc58";
       libraryHaskellDepends = [
         asn1-encoding asn1-parse asn1-types base bytestring cryptonite pem
         x509
       ];
       testHaskellDepends = [
         asn1-encoding asn1-parse asn1-types base bytestring cryptonite pem
         QuickCheck tasty tasty-hunit tasty-quickcheck transformers x509
       ];
       homepage = "https://github.com/fcomb/pkcs10-hs#readme";
       description = "PKCS#10 library";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "pkcs7" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, HUnit, QuickCheck }:
     mkDerivation {
       pname = "pkcs7";
       version = "1.0.0.1";
       sha256 = "a22c63e56ca355df2075689753381f61cdfaf215e73755f55589b09a93bf9044";
       libraryHaskellDepends = [ base bytestring ];
       testHaskellDepends = [ base bytestring Cabal HUnit QuickCheck ];
       homepage = "https://github.com/kisom/pkcs7";
       description = "PKCS #7 padding in Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pkggraph" = callPackage
    ({ mkDerivation, base, Cabal, split }:
     mkDerivation {
       pname = "pkggraph";
       version = "0.1";
       sha256 = "dfcd7fff0981df289e58bbaa82e4f4dc5cf30eebbe8aab3399e715f340a43505";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base Cabal split ];
       description = "Package dependency graph for installed packages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pktree" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "pktree";
       version = "0.2";
       sha256 = "0c98043079c2743133c1ab5a8231f829b7889de73de91611ae0af73cc3d34d9c";
       libraryHaskellDepends = [ base containers ];
       homepage = "https://github.com/singpolyma/pktree-haskell";
       description = "Implementation of the PKTree spatial index data structure";
       license = "unknown";
     }) {};

  "placeholders" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "placeholders";
       version = "0.1";
       sha256 = "652a78553dcaf6e11b4cd8f0e60010b32da299fbe57721df4bf9157e852d0346";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/ahammar/placeholders";
       description = "Placeholders for use while developing Haskell code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "plailude" = callPackage
    ({ mkDerivation, base, bytestring, mtl, time, unix }:
     mkDerivation {
       pname = "plailude";
       version = "0.6.0";
       sha256 = "31083b4d1442000e0964d2b198942d61f9ce40726c593cf66901b171c19f188e";
       libraryHaskellDepends = [ base bytestring mtl time unix ];
       jailbreak = true;
       homepage = "https://secure.plaimi.net/works/plailude";
       description = "plaimi's prelude";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "plan-b" = callPackage
    ({ mkDerivation, base, exceptions, hspec, path, path-io
     , transformers
     }:
     mkDerivation {
       pname = "plan-b";
       version = "0.1.0";
       sha256 = "46aa687c41c5b61302f5b968b8f3f7e2fd488013d6a2c05daa93f422bd50b107";
       libraryHaskellDepends = [
         base exceptions path path-io transformers
       ];
       testHaskellDepends = [ base hspec path path-io ];
       homepage = "https://github.com/mrkkrp/plan-b";
       description = "Failure-tolerant file and directory editing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "planar-graph" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , containers, data-clist, deepseq
     }:
     mkDerivation {
       pname = "planar-graph";
       version = "1.0.0.0";
       sha256 = "37c6625eb40c5e7023417c74d2429a1a12f9b075780365a005a5fac99109eab0";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring containers data-clist
         deepseq
       ];
       jailbreak = true;
       description = "A representation of planar graphs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "plat" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, utf8-string }:
     mkDerivation {
       pname = "plat";
       version = "0.1.0.1";
       sha256 = "0d27e0a1c845df818fd9f0e2443f198861d3fe5bc7858ae4c647e7ef85735e1b";
       libraryHaskellDepends = [
         base bytestring containers mtl utf8-string
       ];
       description = "Simple templating library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "playlists" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, doctest, filepath
     , hlint, hspec, optparse-applicative, text, word8
     }:
     mkDerivation {
       pname = "playlists";
       version = "0.3.0.0";
       sha256 = "8bb2141f2e996d7d4ab376e53fd00c0abfdfc05b00abc53b8c44573720e089bc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring filepath text word8
       ];
       executableHaskellDepends = [
         base bytestring optparse-applicative text
       ];
       testHaskellDepends = [ base bytestring doctest hlint hspec ];
       jailbreak = true;
       homepage = "https://github.com/pjones/playlists";
       description = "Library and executable for working with playlist files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "plist" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, hxt }:
     mkDerivation {
       pname = "plist";
       version = "0.0.6";
       sha256 = "ebe594efb0327e451d6336a0f8993b9914906eca5147aef76dd1634bf70d5d77";
       libraryHaskellDepends = [ base base64-bytestring bytestring hxt ];
       description = "Generate and parse Mac OS X property list format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "plist-buddy" = callPackage
    ({ mkDerivation, base, base16-bytestring, base64-bytestring
     , bytestring, cryptohash, directory, hspec, mtl, posix-pty, process
     , QuickCheck, text, time, xml
     }:
     mkDerivation {
       pname = "plist-buddy";
       version = "0.1.0.0";
       sha256 = "481cb13bacb3a0e5a9eee75bd78b793b30b048140d3d7a19eabc9ef6b33cc774";
       libraryHaskellDepends = [
         base base16-bytestring base64-bytestring bytestring cryptohash
         directory mtl posix-pty process text time xml
       ];
       testHaskellDepends = [
         base bytestring directory hspec mtl posix-pty process QuickCheck
         text time
       ];
       description = "Remote monad for editing plists";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "plivo" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, errors
     , http-streams, http-types, io-streams, network-uri, old-locale
     , time, unexceptionalio
     }:
     mkDerivation {
       pname = "plivo";
       version = "0.2.0.0";
       sha256 = "e0e6ae8a8b62eb7ab62ba55c9e7408f8a12fc00c568bf867bd0af6bf2c97069b";
       revision = "1";
       editedCabalFile = "7ef78cd34067e8d72872b32bcad9d01537710c11efce159c990aeb4670e4efb3";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring errors http-streams http-types
         io-streams network-uri old-locale time unexceptionalio
       ];
       jailbreak = true;
       homepage = "https://github.com/singpolyma/plivo-haskell";
       description = "Plivo API wrapper for Haskell";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "plot_0_2_3_4" = callPackage
    ({ mkDerivation, array, base, cairo, colour, hmatrix, mtl, pango
     , transformers
     }:
     mkDerivation {
       pname = "plot";
       version = "0.2.3.4";
       sha256 = "031e6a3eecdc5f0d5455e1818c1597988984a1baf77f0f50affd76923ed894b5";
       libraryHaskellDepends = [
         array base cairo colour hmatrix mtl pango transformers
       ];
       homepage = "http://github.com/amcphail/plot";
       description = "A plotting library, exportable as eps/pdf/svg/png or renderable with gtk";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "plot" = callPackage
    ({ mkDerivation, array, base, cairo, colour, hmatrix, mtl, pango
     , transformers
     }:
     mkDerivation {
       pname = "plot";
       version = "0.2.3.5";
       sha256 = "db5d69d5249e562eaedaa0887075dc43142ddb20260ddc746b501b8b2ed58483";
       libraryHaskellDepends = [
         array base cairo colour hmatrix mtl pango transformers
       ];
       homepage = "http://github.com/amcphail/plot";
       description = "A plotting library, exportable as eps/pdf/svg/png or renderable with gtk";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "plot-gtk_0_2_0_2" = callPackage
    ({ mkDerivation, base, glib, gtk, hmatrix, mtl, plot, process }:
     mkDerivation {
       pname = "plot-gtk";
       version = "0.2.0.2";
       sha256 = "b6fab12df045798e95ee7e55ff19cea709d179d66e7a3770194daba0b394e3a2";
       libraryHaskellDepends = [ base glib gtk hmatrix mtl plot process ];
       jailbreak = true;
       homepage = "http://code.haskell.org/plot";
       description = "GTK plots and interaction with GHCi";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "plot-gtk" = callPackage
    ({ mkDerivation, base, glib, gtk, hmatrix, mtl, plot, process }:
     mkDerivation {
       pname = "plot-gtk";
       version = "0.2.0.4";
       sha256 = "9c0a445162ae66c2badd8b6b0a760f5ee4ac4861852764eb4a550787de2c07bb";
       libraryHaskellDepends = [ base glib gtk hmatrix mtl plot process ];
       homepage = "http://code.haskell.org/plot";
       description = "GTK plots and interaction with GHCi";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "plot-gtk-ui" = callPackage
    ({ mkDerivation, base, cairo, colour, fixed-vector, gtk, hmatrix
     , plot, text, vector
     }:
     mkDerivation {
       pname = "plot-gtk-ui";
       version = "0.3.0.1";
       sha256 = "41c788c5093333bcc9b320bd21dc3e43f8677d9f5d94a66b106fc303649a5b79";
       libraryHaskellDepends = [
         base cairo colour fixed-vector gtk hmatrix plot text vector
       ];
       homepage = "https://github.com/sumitsahrawat/plot-gtk-ui";
       description = "A quick way to use Mathematica like Manipulation abilities";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "plot-gtk3_0_1" = callPackage
    ({ mkDerivation, base, glib, gtk3, hmatrix, mtl, plot, process }:
     mkDerivation {
       pname = "plot-gtk3";
       version = "0.1";
       sha256 = "60db8d558eecfcd2acee2e311ba1846c0b14e4e8a5e4cd0295b68fccedf58637";
       libraryHaskellDepends = [
         base glib gtk3 hmatrix mtl plot process
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/plot";
       description = "GTK3 plots and interaction with GHCi";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "plot-gtk3_0_1_0_1" = callPackage
    ({ mkDerivation, base, glib, gtk3, hmatrix, mtl, plot, process }:
     mkDerivation {
       pname = "plot-gtk3";
       version = "0.1.0.1";
       sha256 = "8e882d83020d8fb5a7ee8c9d443648f17d777745d0cc848bd04d8b8c164ffa74";
       libraryHaskellDepends = [
         base glib gtk3 hmatrix mtl plot process
       ];
       homepage = "http://code.haskell.org/plot";
       description = "GTK3 plots and interaction with GHCi";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "plot-gtk3" = callPackage
    ({ mkDerivation, base, glib, gtk3, hmatrix, mtl, plot, process }:
     mkDerivation {
       pname = "plot-gtk3";
       version = "0.1.0.2";
       sha256 = "79098174d2a1bf5f715bc6b68bf0086036603d77a6c55cc95babc201355dd1d9";
       libraryHaskellDepends = [
         base glib gtk3 hmatrix mtl plot process
       ];
       homepage = "http://code.haskell.org/plot";
       description = "GTK3 plots and interaction with GHCi";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "plot-lab" = callPackage
    ({ mkDerivation, base, colour, gtk, hmatrix, plot, text, vector }:
     mkDerivation {
       pname = "plot-lab";
       version = "0.0.1.9";
       sha256 = "9855b4d2c239b3d69c2b1c315066443bf1b4247a3f57fdf7faa5169970af45e1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base colour gtk hmatrix plot text vector
       ];
       jailbreak = true;
       homepage = "https://github.com/sumitsahrawat/plot-lab";
       description = "A plotting tool with Mathematica like Manipulation abilities";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "plotfont" = callPackage
    ({ mkDerivation, base, containers, tasty, tasty-hunit }:
     mkDerivation {
       pname = "plotfont";
       version = "0.1.0.1";
       sha256 = "63f09f22e05a1d9119baaecfd5c9db9580b756430d050953fe348d6e28a80fcb";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       description = "Plotter-like fonts i.e. a series of straight lines which make letter shapes.";
       license = "GPL";
     }) {};

  "plotserver-api" = callPackage
    ({ mkDerivation, base, curl, split }:
     mkDerivation {
       pname = "plotserver-api";
       version = "0.22";
       sha256 = "7d68e2686f8fb9f80a7da12cf57bce11cc9ac23f306263fa523234db121b799f";
       libraryHaskellDepends = [ base curl split ];
       description = "Plotserver API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "plugins" = callPackage
    ({ mkDerivation, array, base, Cabal, containers, directory
     , filepath, ghc, ghc-paths, ghc-prim, haskell-src, process, random
     }:
     mkDerivation {
       pname = "plugins";
       version = "1.5.5.0";
       sha256 = "57012217c22dce398b3574f45af22404be38de96145e5862d1453c599816f6a2";
       revision = "1";
       editedCabalFile = "84dab5882c330bdc39bcecdbc9d8834c4c964241cd4a1ce87d4987947add924a";
       libraryHaskellDepends = [
         array base Cabal containers directory filepath ghc ghc-paths
         ghc-prim haskell-src process random
       ];
       homepage = "http://hub.darcs.net/stepcut/plugins";
       description = "Dynamic linking for Haskell and C objects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "plugins-auto" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, hinotify
     , mtl, plugins, process, template-haskell
     }:
     mkDerivation {
       pname = "plugins-auto";
       version = "0.0.4";
       sha256 = "c4435da42a036841b8b31b6408f881975033be9b309aca51312b9f56484b2abe";
       libraryHaskellDepends = [
         base containers filepath hinotify mtl plugins template-haskell
       ];
       testHaskellDepends = [ base directory process ];
       description = "Automatic recompilation and reloading of haskell modules";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "plugins-multistage" = callPackage
    ({ mkDerivation, base, directory, ghc, process, QuickCheck, tasty
     , tasty-quickcheck, tasty-th, template-haskell, th-desugar
     }:
     mkDerivation {
       pname = "plugins-multistage";
       version = "0.6.1";
       sha256 = "58b191e351aa5206cfd477cff698a4d8427982602c9d88629dfca59cae5c914f";
       libraryHaskellDepends = [
         base directory ghc process template-haskell th-desugar
       ];
       testHaskellDepends = [
         base QuickCheck tasty tasty-quickcheck tasty-th template-haskell
       ];
       description = "Dynamic linking for embedded DSLs with staged compilation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "plumbers" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "plumbers";
       version = "0.0.3";
       sha256 = "09575ecd8fd1754d91aefa8ed717e2921276f363be58407f509377288f403cbf";
       libraryHaskellDepends = [ base template-haskell ];
       description = "Pointless plumbing combinators";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ply-loader" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, cereal, directory
     , filepath, lens, linear, parallel-io, transformers, vector
     }:
     mkDerivation {
       pname = "ply-loader";
       version = "0.4.1";
       sha256 = "e1e16f2451f9be85cdc684e57854ef1f626e353e847dca2854cd6ff988152342";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring cereal directory filepath lens linear
         parallel-io transformers vector
       ];
       executableHaskellDepends = [ base bytestring linear vector ];
       description = "PLY file loader";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "png-file" = callPackage
    ({ mkDerivation, array, base, binary-file, bytestring, monads-tf
     , template-haskell, zlib
     }:
     mkDerivation {
       pname = "png-file";
       version = "0.0.1.3";
       sha256 = "467be3c535e0d7fd1a26cd287c1b335d22c3aa68263578b642b28e190146b2c1";
       libraryHaskellDepends = [
         array base binary-file bytestring monads-tf template-haskell zlib
       ];
       homepage = "https://skami.iocikun.jp/haskell/packages/png-file";
       description = "read/write png file";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pngload" = callPackage
    ({ mkDerivation, array, base, bytestring, haskell98, mtl, parsec
     , zlib
     }:
     mkDerivation {
       pname = "pngload";
       version = "0.1";
       sha256 = "fa1aafcf54f87a70e0f92803f77dbec28720ac651ce480f7d564b15ee2531fc9";
       libraryHaskellDepends = [
         array base bytestring haskell98 mtl parsec zlib
       ];
       description = "Pure Haskell loader for PNG images";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pngload-fixed" = callPackage
    ({ mkDerivation, array, base, bytestring, mtl, parsec, zlib }:
     mkDerivation {
       pname = "pngload-fixed";
       version = "1.0";
       sha256 = "7d9ddcb918e536c758b62461951ec3e5b0f08305fb0ae55c2c5d223a8f75330a";
       libraryHaskellDepends = [ array base bytestring mtl parsec zlib ];
       description = "Pure Haskell loader for PNG images";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pnm" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "pnm";
       version = "0.1.0.0";
       sha256 = "dc0bb9b0eede26d88484bfde4460fc09f7be649379e807c6accc0c6636d6dc40";
       libraryHaskellDepends = [ base bytestring ];
       description = "PNM image format header parsing and pretty printing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pocket-dns" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cabal-test-bin
     , data-default, dns, hspec, hspec-contrib, hspec-server
     , hspec-test-sandbox, http-conduit, iproute, monad-control, network
     , optparse-applicative, persistent, persistent-sqlite
     , persistent-template, persistent-zookeeper, shakespeare, shelly
     , test-sandbox, text, transformers, unordered-containers, yaml
     }:
     mkDerivation {
       pname = "pocket-dns";
       version = "0.1.1";
       sha256 = "5063e5cabd13684631933ad9eafeabd3c6a454a9897dde5bcdea496a8c7c669c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring data-default dns iproute monad-control
         network optparse-applicative persistent persistent-sqlite
         persistent-template persistent-zookeeper text transformers
         unordered-containers yaml
       ];
       executableHaskellDepends = [
         aeson base bytestring data-default dns http-conduit iproute
         monad-control network optparse-applicative persistent
         persistent-sqlite persistent-template persistent-zookeeper shelly
         text unordered-containers yaml
       ];
       testHaskellDepends = [
         base cabal-test-bin hspec hspec-contrib hspec-server
         hspec-test-sandbox shakespeare test-sandbox text transformers
       ];
       description = "Multi-backend (zookeeper and sqlite) DNS Server using persistent-library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pointed_4_1" = callPackage
    ({ mkDerivation, base, comonad, containers, data-default-class
     , semigroupoids, semigroups, stm, tagged, transformers
     }:
     mkDerivation {
       pname = "pointed";
       version = "4.1";
       sha256 = "cf4cb662ea5d3ebdcc42ab953b92dcfb4571a579e0ec193e5ed084ae03b580d0";
       libraryHaskellDepends = [
         base comonad containers data-default-class semigroupoids semigroups
         stm tagged transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/pointed/";
       description = "Pointed and copointed data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pointed_4_1_1" = callPackage
    ({ mkDerivation, base, comonad, containers, data-default-class
     , semigroupoids, semigroups, stm, tagged, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "pointed";
       version = "4.1.1";
       sha256 = "723d717372f321f4f95b122a6c7f2f6d9d4a6c9117befc0cbc1b93aed8e871a0";
       libraryHaskellDepends = [
         base comonad containers data-default-class semigroupoids semigroups
         stm tagged transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/pointed/";
       description = "Pointed and copointed data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pointed_4_2" = callPackage
    ({ mkDerivation, base, comonad, containers, data-default-class
     , kan-extensions, semigroupoids, semigroups, stm, tagged
     , transformers, transformers-compat
     }:
     mkDerivation {
       pname = "pointed";
       version = "4.2";
       sha256 = "75d58d1d9b16fed2d9aff69a893d9986aeaeb98f1fa94540136031bf85de8ae7";
       libraryHaskellDepends = [
         base comonad containers data-default-class kan-extensions
         semigroupoids semigroups stm tagged transformers
         transformers-compat
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/pointed/";
       description = "Pointed and copointed data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pointed_4_2_0_1" = callPackage
    ({ mkDerivation, base, comonad, containers, data-default-class
     , hashable, kan-extensions, semigroupoids, semigroups, stm, tagged
     , transformers, transformers-compat, unordered-containers
     }:
     mkDerivation {
       pname = "pointed";
       version = "4.2.0.1";
       sha256 = "07ded6424d617b8543971ad41bb8fad42ada2688a3b5fbc68a94d25d3a7251fb";
       libraryHaskellDepends = [
         base comonad containers data-default-class hashable kan-extensions
         semigroupoids semigroups stm tagged transformers
         transformers-compat unordered-containers
       ];
       homepage = "http://github.com/ekmett/pointed/";
       description = "Pointed and copointed data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pointed" = callPackage
    ({ mkDerivation, base, comonad, containers, data-default-class
     , hashable, kan-extensions, semigroupoids, semigroups, stm, tagged
     , transformers, transformers-compat, unordered-containers
     }:
     mkDerivation {
       pname = "pointed";
       version = "4.2.0.2";
       sha256 = "4b8a8a5ad5a54715f6a58090d820657a2f2de4176d899ad736ebd0e54de7da7a";
       libraryHaskellDepends = [
         base comonad containers data-default-class hashable kan-extensions
         semigroupoids semigroups stm tagged transformers
         transformers-compat unordered-containers
       ];
       homepage = "http://github.com/ekmett/pointed/";
       description = "Pointed and copointed data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pointed_5" = callPackage
    ({ mkDerivation, base, comonad, containers, data-default-class
     , hashable, kan-extensions, semigroupoids, semigroups, stm, tagged
     , transformers, transformers-compat, unordered-containers
     }:
     mkDerivation {
       pname = "pointed";
       version = "5";
       sha256 = "8906b8af5125ab3376794a290c5484dbec5a35d0bd0a57e94392ec0e12535d17";
       libraryHaskellDepends = [
         base comonad containers data-default-class hashable kan-extensions
         semigroupoids semigroups stm tagged transformers
         transformers-compat unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/pointed/";
       description = "Pointed and copointed data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pointedlist" = callPackage
    ({ mkDerivation, base, binary }:
     mkDerivation {
       pname = "pointedlist";
       version = "0.6.1";
       sha256 = "743cb0f89cbb128f8aa24c4519b262b561bf2cd607f83e94f9241e8af1cfba9b";
       libraryHaskellDepends = [ base binary ];
       description = "A zipper-like comonad which works as a list, tracking a position";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pointfree" = callPackage
    ({ mkDerivation, array, base, containers, haskell-src-exts, HUnit
     , QuickCheck, transformers
     }:
     mkDerivation {
       pname = "pointfree";
       version = "1.1.1.1";
       sha256 = "b7c12470eab0a9390f2de69f8860296cb7260ce57a40cb868aec717720479e7a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers haskell-src-exts transformers
       ];
       executableHaskellDepends = [
         array base containers haskell-src-exts transformers
       ];
       testHaskellDepends = [
         array base containers haskell-src-exts HUnit QuickCheck
         transformers
       ];
       description = "Tool for refactoring expressions into pointfree form";
       license = "unknown";
     }) {};

  "pointful" = callPackage
    ({ mkDerivation, base, containers, haskell-src-exts, mtl, syb
     , transformers
     }:
     mkDerivation {
       pname = "pointful";
       version = "1.0.7";
       sha256 = "4a884725d0e4e5771ae1d653fd1b4948ccd8d290910a22a1318bb32a53fcef15";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers haskell-src-exts mtl syb transformers
       ];
       executableHaskellDepends = [
         base containers haskell-src-exts mtl syb transformers
       ];
       homepage = "http://github.com/23Skidoo/pointful";
       description = "Pointful refactoring tool";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pointless-fun" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "pointless-fun";
       version = "1.1.0.6";
       sha256 = "d05c59dac408a81766d676da2fb98025e75e0c3d0a07bdb458759d5c41e3b054";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.haskell.org/~wren/";
       description = "Some common point-free combinators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pointless-haskell" = callPackage
    ({ mkDerivation, base, GHood, process, syb }:
     mkDerivation {
       pname = "pointless-haskell";
       version = "0.0.9";
       sha256 = "dde39a8cd4964490e32dbfaa88be442d690ef5d7138ad61bb32a44df4cb30b38";
       libraryHaskellDepends = [ base GHood process syb ];
       homepage = "http://haskell.di.uminho.pt/wiki/Pointless+Haskell";
       description = "Pointless Haskell library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pointless-lenses" = callPackage
    ({ mkDerivation, base, containers, derive, pointless-haskell
     , process, QuickCheck
     }:
     mkDerivation {
       pname = "pointless-lenses";
       version = "0.0.9";
       sha256 = "0b680789e5c0b25ef07942d0514c7519897bbdf23f19ac2b7897669bfae209fc";
       libraryHaskellDepends = [
         base containers derive pointless-haskell process QuickCheck
       ];
       homepage = "http://haskell.di.uminho.pt/wiki/Pointless+Lenses";
       description = "Pointless Lenses library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pointless-rewrite" = callPackage
    ({ mkDerivation, base, containers, mtl, pointless-haskell
     , pointless-lenses, process
     }:
     mkDerivation {
       pname = "pointless-rewrite";
       version = "0.0.3";
       sha256 = "16b8e1ea165c22f1a025c249fb5f4ec096b50f5e9492f48688fe978bf83b8335";
       libraryHaskellDepends = [
         base containers mtl pointless-haskell pointless-lenses process
       ];
       description = "Pointless Rewrite library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "poker-eval" = callPackage
    ({ mkDerivation, array, base, mtl, poker-eval, random, vector }:
     mkDerivation {
       pname = "poker-eval";
       version = "0.3.1";
       sha256 = "3bc3e82be000adea7a6d779b4d08fb0d9589e57cd12578d69031f06b65d2316c";
       libraryHaskellDepends = [ array base mtl random vector ];
       librarySystemDepends = [ poker-eval ];
       description = "Binding to libpoker-eval";
       license = stdenv.lib.licenses.publicDomain;
     }) {inherit (pkgs) poker-eval;};

  "pokitdok" = callPackage
    ({ mkDerivation, aeson, base, base64-string, bytestring
     , case-insensitive, directory, hex, HTTP, http-client, http-conduit
     , http-types, strict, text, time
     }:
     mkDerivation {
       pname = "pokitdok";
       version = "4.1.0.2";
       sha256 = "3cc85d3ef6cce75b57208c5a6a5689032a1a913af9b21d689c30c274ecb2f322";
       libraryHaskellDepends = [
         aeson base base64-string bytestring case-insensitive directory hex
         HTTP http-client http-conduit http-types strict text time
       ];
       jailbreak = true;
       homepage = "https://platform.pokitdok.com";
       description = "PokitDok Platform API Client for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "polar" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "polar";
       version = "0.0.1";
       sha256 = "70ce94da46b0eee4c9f9d3966f39165c8707bc7299930e7e517d9fc2fab50ab8";
       libraryHaskellDepends = [ base ];
       homepage = "http://space.k-hornz.de/polar";
       description = "Complex numbers in polar form";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "polar-configfile" = callPackage
    ({ mkDerivation, base, containers, HUnit, MissingH, mtl, parsec }:
     mkDerivation {
       pname = "polar-configfile";
       version = "0.4.1.0";
       sha256 = "ae0d19890ee5e24a0d36eacacf22fad1eff68c471bcdd8b84fa727aedf7135d2";
       libraryHaskellDepends = [ base containers MissingH mtl parsec ];
       testHaskellDepends = [ base containers HUnit MissingH mtl parsec ];
       description = "Fork of ConfigFile for Polar Game Engine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "polar-shader" = callPackage
    ({ mkDerivation, base, containers, hspec, lens, mtl }:
     mkDerivation {
       pname = "polar-shader";
       version = "0.1.0.4";
       sha256 = "7f19c299d8e8c1672f6d98a475bfe969feefc8f862c47c39c2088de6ebfe12d4";
       libraryHaskellDepends = [ base containers lens mtl ];
       testHaskellDepends = [ base containers hspec ];
       description = "High-level shader compiler for Polar Game Engine";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "polh-lexicon" = callPackage
    ({ mkDerivation, base, binary, containers, dawg, directory
     , filepath, mtl, polysoup, text, text-binary, transformers
     }:
     mkDerivation {
       pname = "polh-lexicon";
       version = "0.2.2";
       sha256 = "74c7ab4fc5aba7c185816fea98e46df89f226f70902981f0d0c814d94767cc56";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary containers dawg directory filepath mtl polysoup text
         text-binary transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/kawu/polh/tree/master/lexicon";
       description = "A library for manipulating the historical dictionary of Polish (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "polimorf" = callPackage
    ({ mkDerivation, base, binary, containers, text, text-binary }:
     mkDerivation {
       pname = "polimorf";
       version = "0.7.3";
       sha256 = "b97d5a48cb731584d463574b2b2603f4c73126c05cf70b47bb5c5a0e6890676f";
       libraryHaskellDepends = [
         base binary containers text text-binary
       ];
       jailbreak = true;
       homepage = "https://github.com/kawu/polimorf";
       description = "Working with the PoliMorf dictionary";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "poll" = callPackage
    ({ mkDerivation, base, enumset, utility-ht }:
     mkDerivation {
       pname = "poll";
       version = "0.0";
       sha256 = "77102fd6a79b75c98cdce10a40a746430a7a85d6cccebe70dff81b5072f68c6c";
       libraryHaskellDepends = [ base enumset utility-ht ];
       description = "Bindings to poll.h";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "poly-arity_0_0_4_1" = callPackage
    ({ mkDerivation, base, constraints, HList, hspec, QuickCheck
     , quickcheck-instances
     }:
     mkDerivation {
       pname = "poly-arity";
       version = "0.0.4.1";
       sha256 = "975b761a7c81144c2455fd6c05bb7d1891782659d4fc0a01e57941c57145d497";
       revision = "2";
       editedCabalFile = "0bce1ff7388433830c7824530bb9c4fe3f4545bad44683dec2a5780028d870af";
       libraryHaskellDepends = [ base constraints HList ];
       testHaskellDepends = [
         base hspec QuickCheck quickcheck-instances
       ];
       description = "Tools for working with functions of undetermined arity";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "poly-arity_0_0_5" = callPackage
    ({ mkDerivation, base, constraints, HList, hspec, QuickCheck
     , quickcheck-instances
     }:
     mkDerivation {
       pname = "poly-arity";
       version = "0.0.5";
       sha256 = "d0787fa2a151080e2138b64dd4adc4dc8e41857e22fa494703f9f876e6cd25bb";
       libraryHaskellDepends = [ base constraints HList ];
       testHaskellDepends = [
         base hspec QuickCheck quickcheck-instances
       ];
       description = "Tools for working with functions of undetermined arity";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "poly-arity_0_0_6" = callPackage
    ({ mkDerivation, base, constraints, HList, hspec, QuickCheck
     , quickcheck-instances
     }:
     mkDerivation {
       pname = "poly-arity";
       version = "0.0.6";
       sha256 = "c5d67bf9c164dcd9dcf858bc07c758a760687ccf439df206142dcb5c4729e3f8";
       libraryHaskellDepends = [ base constraints HList ];
       testHaskellDepends = [
         base hspec QuickCheck quickcheck-instances
       ];
       description = "Tools for working with functions of undetermined arity";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "poly-arity" = callPackage
    ({ mkDerivation, base, constraints, HList }:
     mkDerivation {
       pname = "poly-arity";
       version = "0.0.7";
       sha256 = "8a11a127ef8aa3d9cbf773623930c710a7c0e92ac602957c891ed6a385540b66";
       libraryHaskellDepends = [ base constraints HList ];
       description = "Tools for working with functions of undetermined arity";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "poly-control" = callPackage
    ({ mkDerivation, base, lens }:
     mkDerivation {
       pname = "poly-control";
       version = "1.0.0";
       sha256 = "268f2355f258e4659d940356aaed8cf1559c1268c21bd4f53e705cdeafd39d10";
       libraryHaskellDepends = [ base lens ];
       homepage = "https://github.com/wdanilo/poly-control";
       description = "This package provides abstraction for polymorphic controls, like PolyMonads or PolyApplicatives";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "polyToMonoid" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "polyToMonoid";
       version = "0.1";
       sha256 = "484abd269cfb9d3fcd8970b8d53fba49ce340b359569e90532c6b49bb3620a19";
       libraryHaskellDepends = [ base ];
       description = "Polyvariadic functions mapping to a given monoid";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "polymap" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "polymap";
       version = "0.1.1.0";
       sha256 = "9cda6cf03591ac30fdd8bd6796f87016e45dfa10a720d091622e02036fe809b7";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [ base ];
       description = "Polygonal maps";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "polynom" = callPackage
    ({ mkDerivation, algebra, base, base-unicode-symbols, clist
     , containers, peano, smallcheck, tasty, tasty-smallcheck
     , transformers
     }:
     mkDerivation {
       pname = "polynom";
       version = "0.1.0.0";
       sha256 = "904326a098409341a6b710f2fe36b48918cc41b954b98034fb6b68e5eb92efb1";
       libraryHaskellDepends = [
         algebra base base-unicode-symbols containers
       ];
       testHaskellDepends = [
         algebra base base-unicode-symbols clist containers peano smallcheck
         tasty tasty-smallcheck transformers
       ];
       description = "Polynomial types and operations";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "polynomial" = callPackage
    ({ mkDerivation, base, deepseq, pretty, vector, vector-space
     , vector-th-unbox
     }:
     mkDerivation {
       pname = "polynomial";
       version = "0.7.2";
       sha256 = "e19fff25579b5882da6d7ec0f3e344b88ee320ae8284fc1afefed04385ba3ff0";
       libraryHaskellDepends = [
         base deepseq pretty vector vector-space vector-th-unbox
       ];
       homepage = "https://github.com/mokus0/polynomial";
       description = "Polynomials";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "polynomials-bernstein" = callPackage
    ({ mkDerivation, base, vector }:
     mkDerivation {
       pname = "polynomials-bernstein";
       version = "1.1.2";
       sha256 = "6950f2e791533a40e7e41ff98679f680f27c7b66258b57871027bf0e5adc7062";
       libraryHaskellDepends = [ base vector ];
       description = "A solver for systems of polynomial equations in bernstein form";
       license = "GPL";
     }) {};

  "polyparse_1_9" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "polyparse";
       version = "1.9";
       sha256 = "9f12d6821594166af881941d6c346a6ad617eae18a0ee8659044ef163694708a";
       revision = "2";
       editedCabalFile = "22ad056c349dd388c388919882b6d9839b8536042525647b56b0a19c6cb4dc03";
       libraryHaskellDepends = [ base bytestring text ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~malcolm/polyparse/";
       description = "A variety of alternative parser combinator libraries";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "polyparse_1_10" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "polyparse";
       version = "1.10";
       sha256 = "4246d0ee52ac6943946c18b9f73c93d858a230c348552b897bc70915d26ee75b";
       revision = "2";
       editedCabalFile = "121610cddbe1e3182c6c14da74267fba6974811af78383a6e60f1f6b1d3a9e13";
       libraryHaskellDepends = [ base bytestring text ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~malcolm/polyparse/";
       description = "A variety of alternative parser combinator libraries";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "polyparse" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "polyparse";
       version = "1.11";
       sha256 = "30ef045a25bd7de0f3507ed1161aab35b5711120d315b15f23558205903b81fc";
       libraryHaskellDepends = [ base bytestring text ];
       homepage = "http://code.haskell.org/~malcolm/polyparse/";
       description = "A variety of alternative parser combinator libraries";
       license = "LGPL";
     }) {};

  "polyseq" = callPackage
    ({ mkDerivation, array, base, bytestring, cgi, containers
     , free-theorems, haskell-src, mtl, network, old-locale, old-time
     , parsec, pretty, syb, utf8-string, xhtml
     }:
     mkDerivation {
       pname = "polyseq";
       version = "0.1.2.1";
       sha256 = "e094f5f5fb5b945faa099de0fd63a4a5d075c77e2485adefff624e39a9f561d0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring cgi containers free-theorems haskell-src mtl
         network old-locale old-time parsec pretty syb utf8-string xhtml
       ];
       executableHaskellDepends = [ cgi free-theorems utf8-string xhtml ];
       description = "Taming Selective Strictness";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "polysoup" = callPackage
    ({ mkDerivation, base, containers, deepseq, polyparse, tagsoup }:
     mkDerivation {
       pname = "polysoup";
       version = "0.6.2";
       sha256 = "bdb28b4e47cba223a9c9f3c3454b87e3210cdcd67af2cf570edcd4d8bc84e295";
       libraryHaskellDepends = [
         base containers deepseq polyparse tagsoup
       ];
       homepage = "https://github.com/kawu/polysoup";
       description = "Online XML parsing with polyparse and tagsoup";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "polytypeable" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "polytypeable";
       version = "0.1.0.0";
       sha256 = "082ba98603b3473c23ed99d9086275e9b581c718e74b4d4729f1fa936a53626d";
       libraryHaskellDepends = [ base ];
       description = "Typeable for polymorphic types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "polytypeable-utils" = callPackage
    ({ mkDerivation, base, haskell98, polytypeable }:
     mkDerivation {
       pname = "polytypeable-utils";
       version = "0.1.0.0";
       sha256 = "41206586c2a95b64bc59085dad383c47656f4c7125a82de59f52578d5f5577c1";
       libraryHaskellDepends = [ base haskell98 polytypeable ];
       description = "Utilities for polytypeable";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ponder" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "ponder";
       version = "0.0.1";
       sha256 = "10448688a4368e74dc7b06825ac4b0fa68b144f67e6de278874990370cf804db";
       libraryHaskellDepends = [ base mtl ];
       jailbreak = true;
       homepage = "https://gihub.com/matt76k/ponder";
       description = "PEG parser combinator";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pong-server" = callPackage
    ({ mkDerivation, base, hspec, network, QuickCheck }:
     mkDerivation {
       pname = "pong-server";
       version = "0.0.2.0";
       sha256 = "2964703036c52a24afc15522f3ad0a5eee5ee14f3153dd35a9e3ddd7501761ad";
       libraryHaskellDepends = [ base network ];
       testHaskellDepends = [ base hspec network QuickCheck ];
       homepage = "http://github.com/RobertFischer/pong-server#readme";
       description = "A simple embedded pingable server that runs in the background";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "pontarius-mediaserver" = callPackage
    ({ mkDerivation, base, HDBC, HDBC-sqlite3, hlogger, pontarius-xmpp
     , pontarius-xpmn, xml-types
     }:
     mkDerivation {
       pname = "pontarius-mediaserver";
       version = "0.0.2.0";
       sha256 = "caf6a65f9d607ffc928f43a361fb14bacab7fcf5dedec87ce9466cb5e2ca1e03";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base HDBC HDBC-sqlite3 hlogger pontarius-xmpp pontarius-xpmn
         xml-types
       ];
       jailbreak = true;
       homepage = "http://www.pontarius.org/projects/pontarius-mediaserver/";
       description = "Extended Personal Media Network (XPMN) media server";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pontarius-xmpp" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring, binary
     , bytestring, Cabal, conduit, configurator, containers, crypto-api
     , crypto-random, cryptohash, cryptohash-cryptoapi, data-default
     , derive, directory, dns, doctest, exceptions, filepath, hslogger
     , hspec, hspec-expectations, HUnit, iproute, lens, lens-family
     , lifted-base, mtl, network, profunctors, pureMD5, QuickCheck
     , quickcheck-instances, random, ranges, resourcet, smallcheck
     , split, stm, stringprep, tasty, tasty-hspec, tasty-hunit
     , tasty-quickcheck, tasty-th, template-haskell, text, tls
     , transformers, unbounded-delays, void, x509-system, xml-conduit
     , xml-picklers, xml-types
     }:
     mkDerivation {
       pname = "pontarius-xmpp";
       version = "0.5.1";
       sha256 = "4bcfeb21bd86d912dbfc8c1574f76ee3b099fda2e35302a7f6fd4dca4f33a475";
       libraryHaskellDepends = [
         attoparsec base base64-bytestring binary bytestring conduit
         containers crypto-api crypto-random cryptohash cryptohash-cryptoapi
         data-default dns exceptions hslogger iproute lens-family
         lifted-base mtl network profunctors pureMD5 random resourcet split
         stm stringprep template-haskell text tls transformers
         unbounded-delays void x509-system xml-conduit xml-picklers
         xml-types
       ];
       testHaskellDepends = [
         async base Cabal conduit configurator containers data-default
         derive directory doctest filepath hslogger hspec hspec-expectations
         HUnit lens mtl network QuickCheck quickcheck-instances ranges
         smallcheck stm stringprep tasty tasty-hspec tasty-hunit
         tasty-quickcheck tasty-th text tls transformers xml-picklers
         xml-types
       ];
       homepage = "https://github.com/pontarius/pontarius-xmpp/";
       description = "An XMPP client library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pontarius-xpmn" = callPackage
    ({ mkDerivation, base, containers, pontarius-xmpp, random, text
     , xml-types
     }:
     mkDerivation {
       pname = "pontarius-xpmn";
       version = "0.0.1.0";
       sha256 = "be8184cc9a48fedcf140f1f46be75b04b43211867b723428ee9876fd1c12a2d9";
       libraryHaskellDepends = [
         base containers pontarius-xmpp random text xml-types
       ];
       jailbreak = true;
       homepage = "http://www.pontarius.org/projects/pontarius-xpmn/";
       description = "Extended Personal Media Network (XPMN) library";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pony" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "pony";
       version = "1.0";
       sha256 = "debbb4d8e0cbb4e928c8186bcebe0e3ff9ff5640e85dae8a492d4d3e81f20b29";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       homepage = "http://www.ascii-art.de/ascii/uvw/unicorn.txt";
       description = "Can I have a pony?";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pool" = callPackage
    ({ mkDerivation, base, monad-control, transformers }:
     mkDerivation {
       pname = "pool";
       version = "0.1.2.1";
       sha256 = "2ca0a2a97c481716f0dc86162b16e37fbace71507c1d9fbec8f9ce313bb79cbb";
       revision = "1";
       editedCabalFile = "c79e139723764f4d4ba584c6cf6f73174700271910b15ed0f25a150a53a8c951";
       libraryHaskellDepends = [ base monad-control transformers ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Thread-safe resource pools. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pool-conduit" = callPackage
    ({ mkDerivation, base, monad-control, resource-pool, resourcet
     , transformers
     }:
     mkDerivation {
       pname = "pool-conduit";
       version = "0.1.2.3";
       sha256 = "db2df6c6c9fba57089a6da3e8ea83a1722fe6e0d26b5d4994fa84a00575dd2d7";
       revision = "1";
       editedCabalFile = "b894f71054b3824a0a05753e8273efbc7c1dc48efa9c6d56625ba4411a74afa5";
       libraryHaskellDepends = [
         base monad-control resource-pool resourcet transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/persistent";
       description = "Resource pool allocations via ResourceT. (deprecated)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pooled-io" = callPackage
    ({ mkDerivation, base, concurrent-split, containers, deepseq
     , transformers, unsafe, utility-ht
     }:
     mkDerivation {
       pname = "pooled-io";
       version = "0.0.2.1";
       sha256 = "7d405a8876d55a9c077a304dd378854bc9e6e20f643c357c82bd3f38297ff9d0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base concurrent-split containers deepseq transformers unsafe
         utility-ht
       ];
       homepage = "http://hub.darcs.net/thielema/pooled-io/";
       description = "Run jobs on a limited number of threads and support data dependencies";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pop3-client" = callPackage
    ({ mkDerivation, base, mtl, network }:
     mkDerivation {
       pname = "pop3-client";
       version = "0.1.4";
       sha256 = "bb13211cbd8b9708c38d192aea60498aed3c77d31ae4d4f1a93297c75d77cc4d";
       libraryHaskellDepends = [ base mtl network ];
       homepage = "https://github.com/tmrudick/haskell-pop3-client/";
       description = "POP3 Client Library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "popenhs" = callPackage
    ({ mkDerivation, base, directory, haskell98, unix }:
     mkDerivation {
       pname = "popenhs";
       version = "1.0.0";
       sha256 = "a42e60a9a7cc16e2f158e5bfdcc395f886af9ea3934f2b2d633f25facb43eb06";
       libraryHaskellDepends = [ base directory haskell98 unix ];
       homepage = "http://www.haskell.org/~petersen/haskell/popenhs/";
       description = "popenhs is a popen-like library for Haskell";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "poppler" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, containers, gdk2
     , gdk_pixbuf, glib, gtk, gtk2hs-buildtools, mtl, pango, poppler
     }:
     mkDerivation {
       pname = "poppler";
       version = "0.13.1";
       sha256 = "525c9fb4748b561e807d07e0b21afef5dd44ded3628aae8c1d28f6336b32f3d6";
       libraryHaskellDepends = [
         array base bytestring cairo containers glib gtk mtl
       ];
       libraryPkgconfigDepends = [ gdk2 gdk_pixbuf pango poppler ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs";
       description = "Binding to the Poppler";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gdk2 = null; inherit (pkgs) gdk_pixbuf; 
         inherit (pkgs.gnome) pango; inherit (pkgs) poppler;};

  "populate-setup-exe-cache" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "populate-setup-exe-cache";
       version = "1.0";
       sha256 = "7ef4a88087b944e04e083eb7da93a16c76b364e5f80ee3fbeb6c73fcdc10e71b";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/mietek/populate-setup-exe-cache/";
       description = "Empty Cabal package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "portable-lines" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "portable-lines";
       version = "0.1";
       sha256 = "5053f5bc42d4362062e0ec55dd111b0f6611be280c7f871876732853f4b824d1";
       libraryHaskellDepends = [ base bytestring ];
       description = "Alternative 'lines' implementation that understands CR-LF and CR";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "portaudio" = callPackage
    ({ mkDerivation, base, containers, portaudio }:
     mkDerivation {
       pname = "portaudio";
       version = "0.2.4";
       sha256 = "636a8435b09c1f02df1e0be78afef0cdd3519754a56992a49dd509438475b46f";
       libraryHaskellDepends = [ base containers ];
       librarySystemDepends = [ portaudio ];
       homepage = "http://code.haskell.org/portaudio";
       description = "Haskell bindings for the PortAudio library";
       license = "unknown";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) portaudio;};

  "porte" = callPackage
    ({ mkDerivation, base, bytestring, containers
     , extensible-exceptions, stringsearch
     }:
     mkDerivation {
       pname = "porte";
       version = "0.0.4";
       sha256 = "4d3c0b25d2c0dcc36b98fb692100179dd776d142d677c51430106ff0d79a87b1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers extensible-exceptions stringsearch
       ];
       description = "FreeBSD ports index search and analysis tool";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "porter" = callPackage
    ({ mkDerivation, haskell2010 }:
     mkDerivation {
       pname = "porter";
       version = "0.1";
       sha256 = "d35647399892ec686726b96f0974113c3d19f7e19919fa7779aac0f10f7e812b";
       libraryHaskellDepends = [ haskell2010 ];
       description = "Implementation of the Porter stemming algorithm";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ports" = callPackage
    ({ mkDerivation, base, haskell98, unix }:
     mkDerivation {
       pname = "ports";
       version = "0.4.3.2";
       sha256 = "359fe87c5561b1268bfa5580b7e11a67e0b79076221744b2d821b930c9cbbec7";
       libraryHaskellDepends = [ base haskell98 unix ];
       homepage = "http://www.cse.unsw.edu.au/~chak/haskell/ports/";
       description = "The Haskell Ports Library";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ports-tools" = callPackage
    ({ mkDerivation, base, directory, process }:
     mkDerivation {
       pname = "ports-tools";
       version = "0.0.1";
       sha256 = "8629558bcbfec5e6efbb5a36b30e889decc8feea0be2485b2aeeb388115a472f";
       libraryHaskellDepends = [ base directory process ];
       homepage = "http://github.com/ppenzin/hs-ports-tools/";
       description = "Library to interact with port tools on FreeBSD";
       license = "unknown";
     }) {};

  "positive" = callPackage
    ({ mkDerivation, base, nats, semigroups }:
     mkDerivation {
       pname = "positive";
       version = "0.4.1";
       sha256 = "cf41c077a0a9f173ec06ec052618d03b380bf8a03b68f18eddfce98450a79b0c";
       libraryHaskellDepends = [ base nats semigroups ];
       description = "Positive integers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "posix-acl" = callPackage
    ({ mkDerivation, acl, base, bytestring, containers, lifted-base
     , monad-control, transformers, transformers-base, unix
     }:
     mkDerivation {
       pname = "posix-acl";
       version = "0.2.0.0";
       sha256 = "3b1f8858ae8acb6d3c50a3900406b0b7b018709447c4c17aee8d2f83f12a38e2";
       libraryHaskellDepends = [
         base bytestring containers lifted-base monad-control transformers
         transformers-base unix
       ];
       librarySystemDepends = [ acl ];
       jailbreak = true;
       homepage = "https://github.com/tensor5/posix-acl";
       description = "Support for Posix ACL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) acl;};

  "posix-escape" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "posix-escape";
       version = "0.1";
       sha256 = "1c115a945e654221edc215dbace74bf80839a9a4181fb8817735766c32433d7b";
       libraryHaskellDepends = [ base ];
       description = "Quote arguments to be passed through the Unix shell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "posix-filelock" = callPackage
    ({ mkDerivation, base, transformers, unix }:
     mkDerivation {
       pname = "posix-filelock";
       version = "0.1";
       sha256 = "b3e251e6f59a5d90091e0d73b54290a3ece13780a6a620191fc18146f8cad980";
       libraryHaskellDepends = [ base transformers unix ];
       homepage = "https://github.com/singpolyma/posix-filelock-haskell";
       description = "Nice wrapper around POSIX fcntl advisory locks";
       license = "unknown";
     }) {};

  "posix-paths" = callPackage
    ({ mkDerivation, base, bytestring, doctest, HUnit, QuickCheck, unix
     }:
     mkDerivation {
       pname = "posix-paths";
       version = "0.2.1.0";
       sha256 = "2086e66f6aef0629d586c63d461a0c45232dc6c3afc939898106bcc632c0faa0";
       libraryHaskellDepends = [ base bytestring unix ];
       testHaskellDepends = [
         base bytestring doctest HUnit QuickCheck unix
       ];
       description = "POSIX filepath/directory functionality";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "posix-pty" = callPackage
    ({ mkDerivation, base, bytestring, process, unix, util }:
     mkDerivation {
       pname = "posix-pty";
       version = "0.2.1";
       sha256 = "16e941681511ef1d59300314d4f6f85192b00787fc2605fbd18a300192c4edc1";
       libraryHaskellDepends = [ base bytestring process unix ];
       librarySystemDepends = [ util ];
       homepage = "https://bitbucket.org/merijnv/posix-pty";
       description = "Pseudo terminal interaction with subprocesses";
       license = stdenv.lib.licenses.bsd3;
     }) {util = null;};

  "posix-realtime_0_0_0_3" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "posix-realtime";
       version = "0.0.0.3";
       sha256 = "58098617abab258ab1bd488e66091f6f525c16b6bba45314cad767b83d75f53c";
       libraryHaskellDepends = [ base unix ];
       description = "POSIX Realtime functionality";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "posix-realtime" = callPackage
    ({ mkDerivation, base, bytestring, unix }:
     mkDerivation {
       pname = "posix-realtime";
       version = "0.0.0.4";
       sha256 = "692cbab92e272e00b9402389c199be27add8c6f82b675c512085a36acc4ddf07";
       libraryHaskellDepends = [ base bytestring unix ];
       description = "POSIX Realtime functionality";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "posix-timer" = callPackage
    ({ mkDerivation, base, transformers-base, unix }:
     mkDerivation {
       pname = "posix-timer";
       version = "0.3";
       sha256 = "eda33946cff1a22dc56583dc534e2c551dab4eed7ddf124b84ff19b22e4a927c";
       libraryHaskellDepends = [ base transformers-base unix ];
       homepage = "https://github.com/mvv/posix-timer";
       description = "Bindings to POSIX clock and timer functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "posix-waitpid" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "posix-waitpid";
       version = "0.1";
       sha256 = "1336c1c5bfcc9250fb1f22cf46ef24730f29b2d2ae30dca0111aec37de1d7eec";
       libraryHaskellDepends = [ base unix ];
       description = "Low-level wrapping of POSIX waitpid(2)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "possible" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "possible";
       version = "0.1.0.5";
       sha256 = "fd6f97933c6c4feeb6f2a6aa2c8c0e0b66ee46cf8dab95b96a8ce7e2fcf83ec6";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/tolysz/possible";
       description = "Three valued Data.Maybe";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "post-mess-age_0_1_0_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "post-mess-age";
       version = "0.1.0.0";
       sha256 = "9c1c68511f86b5ed585b33b3ee4d4f3cf15ac8e6434148b5d1d8f2afcf8887e6";
       libraryHaskellDepends = [ base ];
       description = "Send messages to a Handle concurrently without getting them mixed";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "post-mess-age" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "post-mess-age";
       version = "0.2.0.0";
       sha256 = "4e0dc10e5c802360bff40e46517810785a92df55e75a4db89f784cef2c78af87";
       libraryHaskellDepends = [ base ];
       description = "Send messages to a handle concurrently without getting them mixed";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "postcodes" = callPackage
    ({ mkDerivation, aeson, base, bytestring, HTTP }:
     mkDerivation {
       pname = "postcodes";
       version = "0.1.1";
       sha256 = "28ae447aa1bf88b8aaf93e5e05fc704a605a46d4a0cc202568d5cb10e82d0dfc";
       libraryHaskellDepends = [ aeson base bytestring HTTP ];
       homepage = "https://github.com/mattyhall/haskell-postcodes";
       description = "A library that gets postcode information from the uk-postcodes.com";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "postgresql-binary_0_5_0" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, bytestring, HTF
     , loch-th, placeholders, postgresql-libpq, QuickCheck
     , quickcheck-instances, scientific, text, time, transformers, uuid
     }:
     mkDerivation {
       pname = "postgresql-binary";
       version = "0.5.0";
       sha256 = "1a1abfc26611ca72effb92d36302028606737493f2632dbc5cd1a009b43d0658";
       libraryHaskellDepends = [
         attoparsec base base-prelude bytestring loch-th placeholders
         scientific text time transformers uuid
       ];
       testHaskellDepends = [
         base base-prelude bytestring HTF postgresql-libpq QuickCheck
         quickcheck-instances scientific text time uuid
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/postgresql-binary";
       description = "Encoders and decoders for the PostgreSQL's binary format";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postgresql-binary_0_5_1" = callPackage
    ({ mkDerivation, attoparsec, base, base-prelude, bytestring, HTF
     , loch-th, placeholders, postgresql-libpq, QuickCheck
     , quickcheck-instances, scientific, text, time, transformers, uuid
     }:
     mkDerivation {
       pname = "postgresql-binary";
       version = "0.5.1";
       sha256 = "98b4784de32aa07f913f1ef1af0760026f2d4d044489fd89a11effdc23a5c727";
       libraryHaskellDepends = [
         attoparsec base base-prelude bytestring loch-th placeholders
         scientific text time transformers uuid
       ];
       testHaskellDepends = [
         base base-prelude bytestring HTF postgresql-libpq QuickCheck
         quickcheck-instances scientific text time uuid
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/postgresql-binary";
       description = "Encoders and decoders for the PostgreSQL's binary format";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postgresql-binary_0_5_2" = callPackage
    ({ mkDerivation, attoparsec, base-prelude, bytestring, HTF, loch-th
     , placeholders, postgresql-libpq, QuickCheck, quickcheck-instances
     , scientific, text, time, transformers, uuid
     }:
     mkDerivation {
       pname = "postgresql-binary";
       version = "0.5.2";
       sha256 = "105fe04abd5b8acca368c8428527d57981a67f8e4d1252b8e58c0fe3401e90bb";
       libraryHaskellDepends = [
         attoparsec base-prelude bytestring loch-th placeholders scientific
         text time transformers uuid
       ];
       testHaskellDepends = [
         base-prelude bytestring HTF postgresql-libpq QuickCheck
         quickcheck-instances scientific text time uuid
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/postgresql-binary";
       description = "Encoders and decoders for the PostgreSQL's binary format";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postgresql-binary_0_5_2_1" = callPackage
    ({ mkDerivation, attoparsec, base-prelude, bytestring, HTF, loch-th
     , placeholders, postgresql-libpq, QuickCheck, quickcheck-instances
     , scientific, text, time, transformers, uuid
     }:
     mkDerivation {
       pname = "postgresql-binary";
       version = "0.5.2.1";
       sha256 = "15d4e95ac124bde7ab14e135d1f4983e33929df3bd55b935ceef0ad312d4bf09";
       libraryHaskellDepends = [
         attoparsec base-prelude bytestring loch-th placeholders scientific
         text time transformers uuid
       ];
       testHaskellDepends = [
         base-prelude bytestring HTF postgresql-libpq QuickCheck
         quickcheck-instances scientific text time uuid
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/postgresql-binary";
       description = "Encoders and decoders for the PostgreSQL's binary format";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postgresql-binary_0_7_4_1" = callPackage
    ({ mkDerivation, aeson, base, base-prelude, binary-parser
     , bytestring, conversion, conversion-bytestring, conversion-text
     , either, foldl, loch-th, placeholders, postgresql-libpq
     , QuickCheck, quickcheck-instances, scientific, tasty, tasty-hunit
     , tasty-quickcheck, tasty-smallcheck, text, time, transformers
     , uuid, vector
     }:
     mkDerivation {
       pname = "postgresql-binary";
       version = "0.7.4.1";
       sha256 = "77651101348f02653e4bccc02374c2aa33d850322458aa54e0ae8766da318673";
       libraryHaskellDepends = [
         aeson base base-prelude binary-parser bytestring foldl loch-th
         placeholders scientific text time transformers uuid vector
       ];
       testHaskellDepends = [
         base base-prelude bytestring conversion conversion-bytestring
         conversion-text either loch-th placeholders postgresql-libpq
         QuickCheck quickcheck-instances scientific tasty tasty-hunit
         tasty-quickcheck tasty-smallcheck text time transformers uuid
         vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/postgresql-binary";
       description = "Encoders and decoders for the PostgreSQL's binary format";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postgresql-binary_0_7_5_1" = callPackage
    ({ mkDerivation, aeson, base, base-prelude, binary-parser
     , bytestring, conversion, conversion-bytestring, conversion-text
     , either, foldl, loch-th, placeholders, postgresql-libpq
     , QuickCheck, quickcheck-instances, scientific, tasty, tasty-hunit
     , tasty-quickcheck, tasty-smallcheck, text, time, transformers
     , uuid, vector
     }:
     mkDerivation {
       pname = "postgresql-binary";
       version = "0.7.5.1";
       sha256 = "d35b169d7bd2d5f81106643e59725859446739dc69c6695136ff535cf7f55948";
       libraryHaskellDepends = [
         aeson base base-prelude binary-parser bytestring foldl loch-th
         placeholders scientific text time transformers uuid vector
       ];
       testHaskellDepends = [
         base base-prelude bytestring conversion conversion-bytestring
         conversion-text either loch-th placeholders postgresql-libpq
         QuickCheck quickcheck-instances scientific tasty tasty-hunit
         tasty-quickcheck tasty-smallcheck text time transformers uuid
         vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/postgresql-binary";
       description = "Encoders and decoders for the PostgreSQL's binary format";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postgresql-binary_0_7_8" = callPackage
    ({ mkDerivation, aeson, base, base-prelude, binary-parser
     , bytestring, conversion, conversion-bytestring, conversion-text
     , either, foldl, json-ast, loch-th, placeholders, postgresql-libpq
     , QuickCheck, quickcheck-instances, rebase, scientific, tasty
     , tasty-hunit, tasty-quickcheck, tasty-smallcheck, text, time
     , transformers, uuid, vector
     }:
     mkDerivation {
       pname = "postgresql-binary";
       version = "0.7.8";
       sha256 = "a05472d7b485c0e953b1136f74ff6fe35d663f265b4f08be8450a5a3a6b30534";
       libraryHaskellDepends = [
         aeson base base-prelude binary-parser bytestring foldl loch-th
         placeholders scientific text time transformers uuid vector
       ];
       testHaskellDepends = [
         aeson base bytestring conversion conversion-bytestring
         conversion-text either json-ast loch-th placeholders
         postgresql-libpq QuickCheck quickcheck-instances rebase scientific
         tasty tasty-hunit tasty-quickcheck tasty-smallcheck text time
         transformers uuid vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/postgresql-binary";
       description = "Encoders and decoders for the PostgreSQL's binary format";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postgresql-binary_0_7_9" = callPackage
    ({ mkDerivation, aeson, base, base-prelude, binary-parser
     , bytestring, conversion, conversion-bytestring, conversion-text
     , either, foldl, json-ast, loch-th, placeholders, postgresql-libpq
     , QuickCheck, quickcheck-instances, rebase, scientific, tasty
     , tasty-hunit, tasty-quickcheck, tasty-smallcheck, text, time
     , transformers, uuid, vector
     }:
     mkDerivation {
       pname = "postgresql-binary";
       version = "0.7.9";
       sha256 = "72ff406d9be3afbf459879e8ab51701e9b41edb88a457d666b7eaf079dc824ad";
       libraryHaskellDepends = [
         aeson base base-prelude binary-parser bytestring foldl loch-th
         placeholders scientific text time transformers uuid vector
       ];
       testHaskellDepends = [
         aeson base bytestring conversion conversion-bytestring
         conversion-text either json-ast loch-th placeholders
         postgresql-libpq QuickCheck quickcheck-instances rebase scientific
         tasty tasty-hunit tasty-quickcheck tasty-smallcheck text time
         transformers uuid vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/postgresql-binary";
       description = "Encoders and decoders for the PostgreSQL's binary format";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postgresql-binary" = callPackage
    ({ mkDerivation, aeson, base, base-prelude, binary-parser
     , bytestring, conversion, conversion-bytestring, conversion-text
     , either, foldl, json-ast, loch-th, placeholders, postgresql-libpq
     , QuickCheck, quickcheck-instances, rebase, scientific, tasty
     , tasty-hunit, tasty-quickcheck, tasty-smallcheck, text, time
     , transformers, uuid, vector
     }:
     mkDerivation {
       pname = "postgresql-binary";
       version = "0.8.1";
       sha256 = "e5745c009806fb10705f1f5f23c2af4028b47a7178e1ea09e102cf697cc2581b";
       libraryHaskellDepends = [
         aeson base base-prelude binary-parser bytestring foldl loch-th
         placeholders scientific text time transformers uuid vector
       ];
       testHaskellDepends = [
         aeson base bytestring conversion conversion-bytestring
         conversion-text either json-ast loch-th placeholders
         postgresql-libpq QuickCheck quickcheck-instances rebase scientific
         tasty tasty-hunit tasty-quickcheck tasty-smallcheck text time
         transformers uuid vector
       ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/postgresql-binary";
       description = "Encoders and decoders for the PostgreSQL's binary format";
       license = stdenv.lib.licenses.mit;
     }) {};

  "postgresql-config" = callPackage
    ({ mkDerivation, aeson, base, bytestring, monad-control, mtl
     , postgresql-simple, resource-pool, time
     }:
     mkDerivation {
       pname = "postgresql-config";
       version = "0.1.0";
       sha256 = "6429a9c8f0a75d32dbc23c01441726d3cdb4fbc47a2b9ce28b7334cd85fcb3dc";
       libraryHaskellDepends = [
         aeson base bytestring monad-control mtl postgresql-simple
         resource-pool time
       ];
       homepage = "https://bitbucket.org/s9gf4ult/postgresql-config";
       description = "Types for easy adding postgresql configuration to your program";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "postgresql-connector" = callPackage
    ({ mkDerivation, base, bytestring, exceptions, lens, mtl
     , postgresql-simple, resource-pool, resourcet, time
     , transformers-base
     }:
     mkDerivation {
       pname = "postgresql-connector";
       version = "0.2.3";
       sha256 = "a313e76b55f8ca08db74e84f8c4676ec42fecd5480060d4644bffc9582081c99";
       libraryHaskellDepends = [
         base bytestring exceptions lens mtl postgresql-simple resource-pool
         resourcet time transformers-base
       ];
       homepage = "http://github.com/mfine/postgresql-connector";
       description = "Initial project postgresql-connector from stack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "postgresql-copy-escape" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "postgresql-copy-escape";
       version = "0.1";
       sha256 = "f5d2dc28c1cdad9716ccf8dd1753f94803a6d23cc472ce55117e8f8c64877718";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "https://github.com/joeyadams/hs-postgresql-copy-escape";
       description = "Format data to feed to a PostgreSQL COPY FROM statement";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "postgresql-cube" = callPackage
    ({ mkDerivation, base, bytestring, postgresql-simple }:
     mkDerivation {
       pname = "postgresql-cube";
       version = "0.1.0.0";
       sha256 = "83a5b20cfc5e966d32f647d6f2bd532c7bd344e5af95eb3b2e29cd6c7b468a4a";
       libraryHaskellDepends = [ base bytestring postgresql-simple ];
       description = "Cube support for postgresql-simple";
       license = stdenv.lib.licenses.mit;
     }) {};

  "postgresql-error-codes" = callPackage
    ({ mkDerivation, bytestring }:
     mkDerivation {
       pname = "postgresql-error-codes";
       version = "1";
       sha256 = "7e9e1c5aa7d54a0fb0ac713369726c9259e424b7e1fd091924a2212b7f63e8dd";
       libraryHaskellDepends = [ bytestring ];
       homepage = "https://github.com/nikita-volkov/postgresql-error-codes";
       description = "PostgreSQL error codes";
       license = stdenv.lib.licenses.mit;
     }) {};

  "postgresql-libpq_0_9_0_1" = callPackage
    ({ mkDerivation, base, bytestring, postgresql }:
     mkDerivation {
       pname = "postgresql-libpq";
       version = "0.9.0.1";
       sha256 = "a3ff3c0a7dea0be15eee821eee4682b73c3cd38aa5196d04a858aa5ce74dbf39";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ postgresql ];
       homepage = "http://github.com/lpsmith/postgresql-libpq";
       description = "low-level binding to libpq";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) postgresql;};

  "postgresql-libpq_0_9_0_2" = callPackage
    ({ mkDerivation, base, bytestring, postgresql }:
     mkDerivation {
       pname = "postgresql-libpq";
       version = "0.9.0.2";
       sha256 = "dc36a100a4f4ceed1266897a742ae6d0784ef435901972fc1e6c1b19e8af36f4";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ postgresql ];
       homepage = "http://github.com/lpsmith/postgresql-libpq";
       description = "low-level binding to libpq";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) postgresql;};

  "postgresql-libpq" = callPackage
    ({ mkDerivation, base, bytestring, postgresql }:
     mkDerivation {
       pname = "postgresql-libpq";
       version = "0.9.1.1";
       sha256 = "e483aed7fe8628cee17342a1bd0a315d998488609ad08a833c01785a88785871";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ postgresql ];
       homepage = "http://github.com/lpsmith/postgresql-libpq";
       description = "low-level binding to libpq";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) postgresql;};

  "postgresql-orm" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring
     , bytestring-builder, directory, filepath, ghc-prim, mtl
     , old-locale, postgresql-simple, process, text, time, transformers
     , unix, unordered-containers, vector
     }:
     mkDerivation {
       pname = "postgresql-orm";
       version = "0.4.1";
       sha256 = "649d995c7eb7890b2826cda2d930651a0906e9ce0173342180d83e5527dc7b5a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring bytestring-builder directory
         filepath ghc-prim mtl old-locale postgresql-simple process text
         time transformers unix unordered-containers vector
       ];
       executableHaskellDepends = [
         base blaze-builder bytestring bytestring-builder directory filepath
         ghc-prim mtl old-locale postgresql-simple process time
       ];
       description = "An ORM (Object Relational Mapping) and migrations DSL for PostgreSQL";
       license = "GPL";
     }) {};

  "postgresql-query" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
     , containers, data-default, either, exceptions, file-embed
     , haskell-src-meta, hreader, hset, inflections, monad-control
     , monad-logger, mtl, postgresql-simple, QuickCheck
     , quickcheck-assertions, quickcheck-instances, resource-pool
     , semigroups, tasty, tasty-hunit, tasty-quickcheck, tasty-th
     , template-haskell, text, th-lift, th-lift-instances, time
     , transformers, transformers-base, transformers-compat
     }:
     mkDerivation {
       pname = "postgresql-query";
       version = "2.3.0";
       sha256 = "bd3aaf1bcb3d424090962ace0b973f0b65aeee21aab44c9a1cb8c622936479d7";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder bytestring containers
         data-default either exceptions file-embed haskell-src-meta hreader
         hset inflections monad-control monad-logger mtl postgresql-simple
         resource-pool semigroups template-haskell text th-lift
         th-lift-instances time transformers transformers-base
         transformers-compat
       ];
       testHaskellDepends = [
         attoparsec base inflections QuickCheck quickcheck-assertions
         quickcheck-instances tasty tasty-hunit tasty-quickcheck tasty-th
         text time
       ];
       homepage = "https://bitbucket.org/s9gf4ult/postgresql-query";
       description = "Sql interpolating quasiquote plus some kind of primitive ORM using it";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "postgresql-schema_0_1_9" = callPackage
    ({ mkDerivation, base, basic-prelude, optparse-applicative
     , postgresql-simple, shelly, text, time, time-locale-compat
     }:
     mkDerivation {
       pname = "postgresql-schema";
       version = "0.1.9";
       sha256 = "18d0262e69b6d02beaf016fd1ee6c25533a59e688bd21f1acc5b07c6a787d7ec";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base basic-prelude postgresql-simple shelly text
       ];
       executableHaskellDepends = [
         base basic-prelude optparse-applicative shelly text time
         time-locale-compat
       ];
       homepage = "https://github.com/mfine/postgresql-schema";
       description = "PostgreSQL Schema Management";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postgresql-schema" = callPackage
    ({ mkDerivation, base, basic-prelude, optparse-applicative
     , postgresql-simple, shelly, text, time, time-locale-compat
     }:
     mkDerivation {
       pname = "postgresql-schema";
       version = "0.1.10";
       sha256 = "29307e09916a7fd9aec965ed2f62663e26b5e66b5ab441d3ed52713d551ae27a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base basic-prelude postgresql-simple shelly text
       ];
       executableHaskellDepends = [
         base basic-prelude optparse-applicative shelly text time
         time-locale-compat
       ];
       homepage = "https://github.com/mfine/postgresql-schema";
       description = "PostgreSQL Schema Management";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "postgresql-simple_0_4_8_0" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , blaze-builder, blaze-textual, bytestring, case-insensitive
     , containers, cryptohash, hashable, HUnit, postgresql-libpq
     , scientific, template-haskell, text, time, transformers, uuid
     , vector
     }:
     mkDerivation {
       pname = "postgresql-simple";
       version = "0.4.8.0";
       sha256 = "d5a2d1355acfd5cbfec633494267bc50c6806d424991d8a345ea54d93fa3ae26";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder blaze-textual bytestring
         case-insensitive containers hashable postgresql-libpq scientific
         template-haskell text time transformers uuid vector
       ];
       testHaskellDepends = [
         aeson base base16-bytestring bytestring containers cryptohash HUnit
         text time vector
       ];
       doHaddock = false;
       doCheck = false;
       description = "Mid-Level PostgreSQL client library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postgresql-simple_0_4_9_0" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , blaze-builder, blaze-textual, bytestring, case-insensitive
     , containers, cryptohash, hashable, HUnit, postgresql-libpq
     , scientific, template-haskell, text, time, transformers, uuid
     , vector
     }:
     mkDerivation {
       pname = "postgresql-simple";
       version = "0.4.9.0";
       sha256 = "9a532d8d9818a73bad1d93771a0413a5431bbe03153df49d98fff05378f56355";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder blaze-textual bytestring
         case-insensitive containers hashable postgresql-libpq scientific
         template-haskell text time transformers uuid vector
       ];
       testHaskellDepends = [
         aeson base base16-bytestring bytestring containers cryptohash HUnit
         text time vector
       ];
       doCheck = false;
       description = "Mid-Level PostgreSQL client library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postgresql-simple_0_4_10_0" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , blaze-builder, blaze-textual, bytestring, case-insensitive
     , containers, cryptohash, hashable, HUnit, postgresql-libpq
     , scientific, template-haskell, text, time, transformers, uuid
     , vector
     }:
     mkDerivation {
       pname = "postgresql-simple";
       version = "0.4.10.0";
       sha256 = "20c74c6326051cec10986e6e68670be78c46497043fbe3a637656a379acc282b";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder blaze-textual bytestring
         case-insensitive containers hashable postgresql-libpq scientific
         template-haskell text time transformers uuid vector
       ];
       testHaskellDepends = [
         aeson base base16-bytestring bytestring containers cryptohash HUnit
         text time vector
       ];
       doCheck = false;
       description = "Mid-Level PostgreSQL client library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postgresql-simple" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , bytestring, bytestring-builder, case-insensitive, containers
     , cryptohash, hashable, HUnit, postgresql-libpq, scientific
     , template-haskell, text, time, transformers, uuid-types, vector
     }:
     mkDerivation {
       pname = "postgresql-simple";
       version = "0.5.1.2";
       sha256 = "d289eb7835b001550b9f9887e1fae050957797ead62394a85e6f5ae700976756";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring bytestring-builder
         case-insensitive containers hashable postgresql-libpq scientific
         template-haskell text time transformers uuid-types vector
       ];
       testHaskellDepends = [
         aeson base base16-bytestring bytestring containers cryptohash HUnit
         text time vector
       ];
       doCheck = false;
       description = "Mid-Level PostgreSQL client library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "postgresql-simple-migration" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, cryptohash
     , directory, hspec, postgresql-simple, time
     }:
     mkDerivation {
       pname = "postgresql-simple-migration";
       version = "0.1.3.0";
       sha256 = "5f0aca18d1382d680121280b19f32401ce0b53c3d951de9736d890715f2be763";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring bytestring cryptohash directory
         postgresql-simple time
       ];
       executableHaskellDepends = [
         base base64-bytestring bytestring cryptohash directory
         postgresql-simple time
       ];
       testHaskellDepends = [ base bytestring hspec postgresql-simple ];
       jailbreak = true;
       homepage = "https://github.com/ameingast/postgresql-simple-migration";
       description = "PostgreSQL Schema Migrations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "postgresql-simple-sop" = callPackage
    ({ mkDerivation, base, generics-sop, postgresql-simple }:
     mkDerivation {
       pname = "postgresql-simple-sop";
       version = "0.2";
       sha256 = "7ead6d5aa2be6b5b9b8c583f0f0b9646de17d2f261aec56e19dc92486ad3f416";
       libraryHaskellDepends = [ base generics-sop postgresql-simple ];
       homepage = "https://github.com/openbrainsrc/postgresql-simple-sop";
       description = "Generic functions for postgresql-simple";
       license = stdenv.lib.licenses.mit;
     }) {};

  "postgresql-simple-typed" = callPackage
    ({ mkDerivation, base, postgresql-libpq, postgresql-simple
     , template-haskell, transformers, typedquery, utf8-string
     }:
     mkDerivation {
       pname = "postgresql-simple-typed";
       version = "0.1.0.1";
       sha256 = "4c30a001b15267cd8a8480bf03d8312b3038c4cd70936029ca9a7147ba06fe65";
       libraryHaskellDepends = [
         base postgresql-libpq postgresql-simple template-haskell
         transformers typedquery utf8-string
       ];
       homepage = "https://github.com/tolysz/postgresql-simple-typed";
       description = "Typed extension for PostgreSQL simple";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postgresql-simple-url" = callPackage
    ({ mkDerivation, base, network-uri, postgresql-simple, split, tasty
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "postgresql-simple-url";
       version = "0.1.0.1";
       sha256 = "cf165ec652e1192f392349e09e413a776921ddef71d95bac0d23e9f81cfbe8a0";
       revision = "6";
       editedCabalFile = "316507c07968bf66036b35f24ee6899bfcca65978730197a2687c9ccc3b2a48d";
       libraryHaskellDepends = [
         base network-uri postgresql-simple split
       ];
       testHaskellDepends = [
         base postgresql-simple tasty tasty-quickcheck
       ];
       homepage = "https://github.com/futurice/postgresql-simple-url";
       description = "Parse postgres:// url into ConnectInfo";
       license = stdenv.lib.licenses.mit;
     }) {};

  "postgresql-typed" = callPackage
    ({ mkDerivation, aeson, array, attoparsec, base, binary, bytestring
     , containers, cryptohash, haskell-src-meta, network, old-locale
     , QuickCheck, scientific, template-haskell, text, time, utf8-string
     , uuid
     }:
     mkDerivation {
       pname = "postgresql-typed";
       version = "0.4.2.2";
       sha256 = "80b2be671ad75782e19a808cbdecb1e814e2450b7645d2da0280c12802df188c";
       revision = "1";
       editedCabalFile = "a774fcb5f4d1cd12b2495cd376a5a010b6c1eac422601bbc4c379b1df99b4f5f";
       libraryHaskellDepends = [
         aeson array attoparsec base binary bytestring containers cryptohash
         haskell-src-meta network old-locale scientific template-haskell
         text time utf8-string uuid
       ];
       testHaskellDepends = [ base bytestring network QuickCheck time ];
       homepage = "https://github.com/dylex/postgresql-typed";
       description = "A PostgreSQL access library with compile-time SQL type inference";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postgrest" = callPackage
    ({ mkDerivation, aeson, base, base64-string, bytestring
     , case-insensitive, cassava, containers, errors, hasql
     , hasql-backend, hasql-postgres, heredoc, hlint, hspec, hspec-wai
     , hspec-wai-json, HTTP, http-types, jwt, MissingH
     , optparse-applicative, packdeps, parsec, process, Ranged-sets
     , regex-tdfa, safe, scientific, string-conversions, text, time
     , transformers, unix, unordered-containers, vector, wai, wai-cors
     , wai-extra, wai-middleware-static, warp
     }:
     mkDerivation {
       pname = "postgrest";
       version = "0.3.0.2";
       sha256 = "5ce3b9b85a51ca6cb3aecc9e1ba84047ab276915c1c0293d2bf91d252c4ee366";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring case-insensitive cassava containers errors
         hasql hasql-backend hasql-postgres HTTP http-types jwt MissingH
         optparse-applicative parsec Ranged-sets regex-tdfa safe scientific
         string-conversions text time unordered-containers vector wai
         wai-cors wai-extra wai-middleware-static
       ];
       executableHaskellDepends = [
         aeson base bytestring case-insensitive cassava containers errors
         hasql hasql-backend hasql-postgres HTTP http-types jwt MissingH
         optparse-applicative parsec Ranged-sets regex-tdfa safe scientific
         string-conversions text time transformers unix unordered-containers
         vector wai wai-cors wai-extra wai-middleware-static warp
       ];
       testHaskellDepends = [
         aeson base base64-string bytestring case-insensitive cassava
         containers errors hasql hasql-backend hasql-postgres heredoc hlint
         hspec hspec-wai hspec-wai-json HTTP http-types jwt MissingH
         optparse-applicative packdeps parsec process Ranged-sets regex-tdfa
         safe scientific string-conversions text time unordered-containers
         vector wai wai-cors wai-extra wai-middleware-static
       ];
       jailbreak = true;
       homepage = "https://github.com/begriffs/postgrest";
       description = "REST API for any Postgres database";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postie" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, cprng-aes
     , data-default-class, mtl, network, pipes, pipes-bytestring
     , pipes-parse, stringsearch, tls, transformers, uuid
     }:
     mkDerivation {
       pname = "postie";
       version = "0.5.0.0";
       sha256 = "93e32bd30b22c7f6474958abc3f65bf467c1fea403aa130996dab396233f0fc7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring cprng-aes data-default-class mtl network
         pipes pipes-parse stringsearch tls transformers uuid
       ];
       executableHaskellDepends = [
         base bytestring data-default-class pipes pipes-bytestring tls
       ];
       description = "SMTP server library to receive emails from within Haskell programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "postmark" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , http-client-tls, http-types, network-api-support, text
     }:
     mkDerivation {
       pname = "postmark";
       version = "0.1.1";
       sha256 = "5c3d4c458d6b2683a2ec36380c216b05c297ba053cac4ede801531dba35f01ca";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers http-client-tls
         http-types network-api-support text
       ];
       executableHaskellDepends = [ base text ];
       homepage = "https://github.com/apiengine/postmark";
       description = "Library for postmarkapp.com HTTP Api";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "postmaster" = callPackage
    ({ mkDerivation, adns, base, bytestring, containers, directory
     , hopenssl, hsdns, hsemail, hsyslog, mtl, network, old-time
     , openssl, parsec, unix
     }:
     mkDerivation {
       pname = "postmaster";
       version = "0.3";
       sha256 = "719e1de0449e4185ab370abfe3e5f61e874e9fe9fd3742d97e24358b335df0fb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory hopenssl hsdns hsemail hsyslog
         mtl network old-time parsec unix
       ];
       executableSystemDepends = [ adns openssl ];
       homepage = "http://github.com/peti/postmaster";
       description = "Postmaster ESMTP Server";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) adns; inherit (pkgs) openssl;};

  "potato-tool" = callPackage
    ({ mkDerivation, base, binary, bytestring, split }:
     mkDerivation {
       pname = "potato-tool";
       version = "0.1.0.2";
       sha256 = "7d1d49dc205f471b724bd61f7c39ec34437b164955b780d51ffe7fc82cf225b5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base binary bytestring split ];
       homepage = "https://github.com/RossMeikleham/Potato_Tool";
       description = "Command line Dreamcast VMU filesystem toolset";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "potrace" = callPackage
    ({ mkDerivation, base, bindings-potrace, bytestring, containers
     , data-default, JuicyPixels, vector
     }:
     mkDerivation {
       pname = "potrace";
       version = "0.1.0.0";
       sha256 = "cfc20b5b20e7fda80a23561be517a195f1ee9288552c23dd1ad77bf9e5703dbb";
       libraryHaskellDepends = [
         base bindings-potrace bytestring containers data-default
         JuicyPixels vector
       ];
       description = "Trace bitmap images to paths using potrace";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "potrace-diagrams" = callPackage
    ({ mkDerivation, base, diagrams-lib, JuicyPixels, potrace }:
     mkDerivation {
       pname = "potrace-diagrams";
       version = "0.1.0.0";
       sha256 = "3b98805a7a6a5458750af09ae783e265cc8c19f0fe2ec3c0ff8ca0318b02477b";
       libraryHaskellDepends = [ base diagrams-lib JuicyPixels potrace ];
       homepage = "http://projects.haskell.org/diagrams/";
       description = "Potrace bindings for the diagrams library";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "powermate" = callPackage
    ({ mkDerivation, base, directory, network, unix }:
     mkDerivation {
       pname = "powermate";
       version = "0.1";
       sha256 = "40671ae08feb11a63d5f77dee6d3fc99101b577e09bfa1ef53bc894d1e891aa7";
       libraryHaskellDepends = [ base directory network unix ];
       homepage = "http://neugierig.org/software/darcs/powermate/";
       description = "PowerMate bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "powerpc" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "powerpc";
       version = "0.0.1";
       sha256 = "de623ca9fdfb4c4a039862c72740af10b4d2f799768b8555e313c044d1c6767c";
       libraryHaskellDepends = [ base ];
       homepage = "http://tomahawkins.org";
       description = "Tools for PowerPC programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ppm" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "ppm";
       version = "2009.5.13";
       sha256 = "9e390ca9a9e6e740fa71d2b72fa2c9c3d521118b0ebb35f10fabbbe543ecfb5b";
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://github.com/nfjinjing/ppm/tree/master";
       description = "a tiny PPM image generator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pqc" = callPackage
    ({ mkDerivation, base, ChasingBottoms, QuickCheck, random, stm }:
     mkDerivation {
       pname = "pqc";
       version = "0.8";
       sha256 = "844d3c456cdfae4316cae120520690a522508f4bb861ff232b5a26db29c4e1d8";
       libraryHaskellDepends = [ base QuickCheck random stm ];
       testHaskellDepends = [ base ChasingBottoms ];
       homepage = "http://hub.darcs.net/shelarcy/pqc";
       description = "Parallel batch driver for QuickCheck";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pqueue_1_2_1" = callPackage
    ({ mkDerivation, base, deepseq }:
     mkDerivation {
       pname = "pqueue";
       version = "1.2.1";
       sha256 = "c6cfbf9e10f8b9b156e2c9e4c9cef1a3eace853a33563bfff14b5ae280f134ba";
       revision = "1";
       editedCabalFile = "ea1de2ab89c2b8b16eb189910b568409e2a5b4af283cf19e179a6fd95fe15fa3";
       libraryHaskellDepends = [ base deepseq ];
       jailbreak = true;
       description = "Reliable, persistent, fast priority queues";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pqueue_1_3_0" = callPackage
    ({ mkDerivation, base, deepseq }:
     mkDerivation {
       pname = "pqueue";
       version = "1.3.0";
       sha256 = "0110e274ac6d0e9280a9c05b83859d0bfa1f0463d95db27adfbeb694ed6f5659";
       libraryHaskellDepends = [ base deepseq ];
       description = "Reliable, persistent, fast priority queues";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pqueue" = callPackage
    ({ mkDerivation, base, deepseq }:
     mkDerivation {
       pname = "pqueue";
       version = "1.3.1";
       sha256 = "f4ff225585d00d8813466ac70a767a05c079dcbfb4fcf353dc2341cf0560dc10";
       libraryHaskellDepends = [ base deepseq ];
       description = "Reliable, persistent, fast priority queues";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pqueue-mtl" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, MaybeT, mtl
     , stateful-mtl, uvector
     }:
     mkDerivation {
       pname = "pqueue-mtl";
       version = "1.0.7";
       sha256 = "cfac9866233d902349a8c2880d89aba97b9efe8967f9bb987445e04567086f46";
       libraryHaskellDepends = [
         base containers ghc-prim MaybeT mtl stateful-mtl uvector
       ];
       jailbreak = true;
       description = "Fully encapsulated monad transformers with queuelike functionality";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "practice-room" = callPackage
    ({ mkDerivation, base, bytestring, data-default, directory, json
     , mps
     }:
     mkDerivation {
       pname = "practice-room";
       version = "0.0.2";
       sha256 = "e2c2174198f6be20a02ea211e6de704d2e6ff062e31a1e3fa722470e66ce2a1c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring data-default directory json mps
       ];
       homepage = "http://github.com/nfjinjing/practice-room";
       description = "Practice Room";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "precis" = callPackage
    ({ mkDerivation, base, Cabal, containers, cpphs, directory
     , filepath, haskell-src-exts, xhtml
     }:
     mkDerivation {
       pname = "precis";
       version = "0.5.0";
       sha256 = "6d194a8cbd29c493c1f10e9db24fdd1af44f5236027d44a9e028a27281a10c34";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers cpphs directory filepath haskell-src-exts
         xhtml
       ];
       jailbreak = true;
       homepage = "http://code.google.com/p/copperbox/";
       description = "Diff Cabal packages";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pred-trie_0_2_0" = callPackage
    ({ mkDerivation, base, hspec, QuickCheck, quickcheck-instances
     , semigroups
     }:
     mkDerivation {
       pname = "pred-trie";
       version = "0.2.0";
       sha256 = "7ac5133255cb4f56198e07780a5ffe1020a210d518381e8e581b7d28c731a085";
       libraryHaskellDepends = [ base semigroups ];
       testHaskellDepends = [
         base hspec QuickCheck quickcheck-instances
       ];
       description = "Predicative tries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pred-trie" = callPackage
    ({ mkDerivation, attoparsec, base, composition-extra, deepseq
     , errors, hashable, mtl, poly-arity, QuickCheck
     , quickcheck-instances, semigroups, tasty, tasty-hunit
     , tasty-quickcheck, text, tries, unordered-containers
     }:
     mkDerivation {
       pname = "pred-trie";
       version = "0.5.0";
       sha256 = "c78d3825c80a4a7542fa888c87f91bf86d7153a944d1364f46789e51c4aaefff";
       libraryHaskellDepends = [
         base composition-extra hashable mtl poly-arity QuickCheck
         semigroups tries unordered-containers
       ];
       testHaskellDepends = [
         attoparsec base composition-extra deepseq errors hashable mtl
         poly-arity QuickCheck quickcheck-instances semigroups tasty
         tasty-hunit tasty-quickcheck text tries unordered-containers
       ];
       description = "Predicative tries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "predicates" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "predicates";
       version = "0.1";
       sha256 = "0ebe07b68b049970bd219df01498e4746bffb84e80e803b0ff6abd426b27c653";
       libraryHaskellDepends = [ base ];
       description = "A couple of convenience functions for forming predicates";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "prednote_0_32_0_6" = callPackage
    ({ mkDerivation, base, bytestring, containers, contravariant
     , QuickCheck, rainbow, split, tasty, tasty-quickcheck, tasty-th
     , text, transformers
     }:
     mkDerivation {
       pname = "prednote";
       version = "0.32.0.6";
       sha256 = "723522808727d02d26bfc48a86e0d5e8f7c7f723334fa6847f5542d744a5b52a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers contravariant rainbow split text
         transformers
       ];
       testHaskellDepends = [
         base bytestring containers contravariant QuickCheck rainbow split
         tasty tasty-quickcheck tasty-th text transformers
       ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/prednote";
       description = "Evaluate and display trees of predicates";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "prednote_0_36_0_2" = callPackage
    ({ mkDerivation, base, bytestring, containers, contravariant
     , QuickCheck, rainbow, split, tasty, tasty-quickcheck, tasty-th
     , text, transformers
     }:
     mkDerivation {
       pname = "prednote";
       version = "0.36.0.2";
       sha256 = "8b0349beeb9cea711cefed0813efe9f494188653304aade67c81fe8d08c9a6da";
       libraryHaskellDepends = [
         base bytestring containers contravariant rainbow split text
         transformers
       ];
       testHaskellDepends = [
         base bytestring containers contravariant QuickCheck rainbow split
         tasty tasty-quickcheck tasty-th text transformers
       ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/prednote";
       description = "Evaluate and display trees of predicates";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "prednote" = callPackage
    ({ mkDerivation, base, bytestring, containers, contravariant
     , QuickCheck, rainbow, split, tasty, tasty-quickcheck, tasty-th
     , text, transformers
     }:
     mkDerivation {
       pname = "prednote";
       version = "0.36.0.4";
       sha256 = "acb4f240e01afdbab0020ee09d3abd2f80cfdcfdbf8cd5abe49b3477a2ca2b8d";
       libraryHaskellDepends = [
         base bytestring containers contravariant rainbow split text
         transformers
       ];
       testHaskellDepends = [
         base bytestring containers contravariant QuickCheck rainbow split
         tasty tasty-quickcheck tasty-th text transformers
       ];
       homepage = "http://www.github.com/massysett/prednote";
       description = "Evaluate and display trees of predicates";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "prednote-test" = callPackage
    ({ mkDerivation, barecheck, base, containers, prednote, QuickCheck
     , quickpull, rainbow, rainbow-tests, text
     }:
     mkDerivation {
       pname = "prednote-test";
       version = "0.26.0.4";
       sha256 = "52c663a1bee7fa294eb157a0a9770f7de12198923dcbdbd419ddf465e908bd2a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         barecheck base containers prednote QuickCheck quickpull rainbow
         rainbow-tests text
       ];
       executableHaskellDepends = [
         barecheck base containers prednote QuickCheck quickpull rainbow
         rainbow-tests text
       ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/prednote";
       description = "Tests and QuickCheck generators to accompany prednote";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "prefix-units_0_1_0_2" = callPackage
    ({ mkDerivation, base, Cabal, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "prefix-units";
       version = "0.1.0.2";
       sha256 = "5b652995252e71affe34d20456d8ab36c4e75ad4b7e4d70c684a51ac97d0651d";
       revision = "1";
       editedCabalFile = "492d6b953a52678e44a880c5272c30175eed27c3f2bd4de82fc29eee4b4db00a";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base Cabal HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       homepage = "https://github.com/iustin/prefix-units";
       description = "A basic library for SI/binary prefix units";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "prefix-units" = callPackage
    ({ mkDerivation, base, Cabal, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "prefix-units";
       version = "0.2.0";
       sha256 = "050abdf827a5bd014a2628b195fbd59bb226020612c99e86a082ac1c8274e384";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base Cabal HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       homepage = "https://github.com/iustin/prefix-units";
       description = "A basic library for SI/binary prefix units";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "prefork" = callPackage
    ({ mkDerivation, async, base, blaze-builder, bytestring, cab
     , cmdargs, containers, data-default, directory, filepath, hspec
     , http-types, network, process, stm, system-argv0, system-filepath
     , unix, wai, warp
     }:
     mkDerivation {
       pname = "prefork";
       version = "0.0.9";
       sha256 = "883b866c1c9b3adf2aa1b368db8ac1619666bd0506d3c3f5486e79c49eef2a7f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers data-default process stm system-argv0
         system-filepath unix
       ];
       executableHaskellDepends = [
         async base blaze-builder bytestring cmdargs containers http-types
         network stm unix wai warp
       ];
       testHaskellDepends = [
         base cab containers directory filepath hspec process stm unix
       ];
       jailbreak = true;
       description = "A library for building a prefork-style server quickly";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pregame" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, containers
     , data-default, lens, mtl, parallel, safe, stm, text, transformers
     , tuple, vector
     }:
     mkDerivation {
       pname = "pregame";
       version = "0.1.4.3";
       sha256 = "c46be43886c12e04954a7674ea4fbc8be0f79a75d19effb9b420d41e5e754253";
       libraryHaskellDepends = [
         base bytestring cmdargs containers data-default lens mtl parallel
         safe stm text transformers tuple vector
       ];
       jailbreak = true;
       homepage = "https://github.com/jxv/pregame";
       description = "Prelude counterpart";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "prelude-edsl" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "prelude-edsl";
       version = "0.3.1";
       sha256 = "7b6233ca1eeb916185f87a7ba9ba8007a3b3f3307b795e52b32444fbcce44658";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/emilaxelsson/prelude-edsl";
       description = "An EDSL-motivated subset of the Prelude";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "prelude-extras_0_4" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "prelude-extras";
       version = "0.4";
       sha256 = "56c9963dc814429451ca66539765c377e932bc5413a637e251aa2af66f62fa57";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/ekmett/prelude-extras";
       description = "Haskell 98 - higher order versions of Prelude classes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "prelude-extras_0_4_0_2" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "prelude-extras";
       version = "0.4.0.2";
       sha256 = "975212ddf8d5b2c5b83347f5d8abef4a2c1ea6e6d9535be33ee478ed6192f5e0";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/ekmett/prelude-extras";
       description = "Higher order versions of Prelude classes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "prelude-extras" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "prelude-extras";
       version = "0.4.0.3";
       sha256 = "09bb087f0870a353ec1e7e1a08017b9a766d430d956afb88ca000a6a876bf877";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/ekmett/prelude-extras";
       description = "Higher order versions of Prelude classes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "prelude-generalize" = callPackage
    ({ mkDerivation, base, comonad, logict, transformers }:
     mkDerivation {
       pname = "prelude-generalize";
       version = "0.4";
       sha256 = "54a2ea7783f18d89060faff8c2198717de60de4d7d5cb15ff927e97fec158540";
       libraryHaskellDepends = [ base comonad logict transformers ];
       jailbreak = true;
       description = "Another kind of alternate Prelude file";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "prelude-plus" = callPackage
    ({ mkDerivation, base, utf8-string }:
     mkDerivation {
       pname = "prelude-plus";
       version = "0.0.0.6";
       sha256 = "5b4ec409806660b7f06e51e9df2e06caf88219a78785202424fd050750012b8d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base utf8-string ];
       description = "Prelude for rest of us";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "prelude-prime" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "prelude-prime";
       version = "0.1";
       sha256 = "2773edf62ec4ba5e3d6f70ad1a752fa5ed3638ec2ec0ff63d7c8e255540872ab";
       libraryHaskellDepends = [ base ];
       description = "A slightly better (but conservative) Prelude";
       license = stdenv.lib.licenses.mit;
     }) {};

  "prelude-safeenum" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "prelude-safeenum";
       version = "0.1.1.2";
       sha256 = "d4f9f195d31198fa1a5e1edfb50684971cc5dc2695bf38c1e7e2dabdce329727";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.haskell.org/~wren/";
       description = "A redefinition of the Prelude's Enum class in order to render it safe";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "preprocess-haskell" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, basic-prelude
     , bytestring, Cabal, containers, cpphs, deepseq, directory
     , file-embed, foldl, haskell-src-exts, here, system-filepath
     , temporary, text, turtle, unix
     }:
     mkDerivation {
       pname = "preprocess-haskell";
       version = "0.0.1.1";
       sha256 = "99201cdb7fca6a54f46f66881d8c2226e6caf941509d0e6f728470b954ccf4c9";
       libraryHaskellDepends = [
         base base-unicode-symbols basic-prelude bytestring Cabal containers
         cpphs deepseq directory file-embed foldl haskell-src-exts here
         system-filepath temporary text turtle unix
       ];
       jailbreak = true;
       description = "Preprocess Haskell Repositories";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "preprocessor-tools" = callPackage
    ({ mkDerivation, base, mtl, parsec, syb }:
     mkDerivation {
       pname = "preprocessor-tools";
       version = "1.0.1";
       sha256 = "c946c99fe8c9effba27946cd2c26173d2346340528d800a228796d68f8aeee59";
       libraryHaskellDepends = [ base mtl parsec syb ];
       homepage = "http://www.eecs.harvard.edu/~tov/pubs/haskell-session-types/";
       description = "A framework for extending Haskell's syntax via quick-and-dirty preprocessors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "presburger" = callPackage
    ({ mkDerivation, base, containers, pretty, QuickCheck }:
     mkDerivation {
       pname = "presburger";
       version = "1.3.1";
       sha256 = "86021abbd457b3bac9cb0f09ce741c4c03de433ca8834532d68d84f90cc3d097";
       revision = "1";
       editedCabalFile = "7c88061e13bab0e63240c05dad36b9518ad50d7ad4ade0f8911efa7826eb4b5d";
       libraryHaskellDepends = [ base containers pretty ];
       testHaskellDepends = [ base QuickCheck ];
       homepage = "http://github.com/yav/presburger";
       description = "A decision procedure for quantifier-free linear arithmetic";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "present" = callPackage
    ({ mkDerivation, aeson, atto-lisp, base, bytestring, data-default
     , mtl, semigroups, text
     }:
     mkDerivation {
       pname = "present";
       version = "2.2";
       sha256 = "e48643a4eacee99f87b605613c752d40b4955e348b601b090cf0a8f675dd3ffd";
       revision = "1";
       editedCabalFile = "87a451bb6a37e2441a9cc49e4b1ebb18a8699bcd28da970f210eb1fcabd769c1";
       libraryHaskellDepends = [
         aeson atto-lisp base bytestring data-default mtl semigroups text
       ];
       jailbreak = true;
       description = "Make presentations for data types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "press" = callPackage
    ({ mkDerivation, base, containers, json, mtl, parsec }:
     mkDerivation {
       pname = "press";
       version = "0.1.2";
       sha256 = "eefdd90cdc01ccc18b39f0d1cdc7058ae4becb291df68ebfff6aa1afd2014329";
       libraryHaskellDepends = [ base containers json mtl parsec ];
       homepage = "http://github.com/bickfordb/text-press";
       description = "Text template library targeted at the web / HTML generation";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "presto-hdbc" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, convertible
     , either, either-unwrap, errors, HDBC, HTTP, http-streams
     , io-streams, lens, mtl, network-uri, safe, scientific, text
     , transformers
     }:
     mkDerivation {
       pname = "presto-hdbc";
       version = "0.1.0.3";
       sha256 = "57c51ac8421cfd352dc5afcc430f81f747970d51405f17f8254a0e7c11b4a38c";
       libraryHaskellDepends = [
         aeson aeson-pretty base bytestring convertible either either-unwrap
         errors HDBC HTTP http-streams io-streams lens mtl network-uri safe
         scientific text transformers
       ];
       jailbreak = true;
       description = "An HDBC connector for Presto";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "prettify" = callPackage
    ({ mkDerivation, base, containers, semigroups }:
     mkDerivation {
       pname = "prettify";
       version = "1.0";
       sha256 = "e8e1b49ec028793e95c82057ea6a00a534c396d837f2cb5fb2a6cdc7c47f7ca1";
       libraryHaskellDepends = [ base containers semigroups ];
       description = "Haskell2010 structured text formatting";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pretty_1_1_3_2" = callPackage
    ({ mkDerivation, base, deepseq, ghc-prim, QuickCheck }:
     mkDerivation {
       pname = "pretty";
       version = "1.1.3.2";
       sha256 = "715f2de429fa581859bee06e4d1ed3d076a0e1b00107bf2127be01c2c2d9c14c";
       libraryHaskellDepends = [ base deepseq ghc-prim ];
       testHaskellDepends = [ base deepseq ghc-prim QuickCheck ];
       homepage = "http://github.com/haskell/pretty";
       description = "Pretty-printing library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pretty-class" = callPackage
    ({ mkDerivation, base, pretty }:
     mkDerivation {
       pname = "pretty-class";
       version = "1.0.1.1";
       sha256 = "558d1b506ff58afb0a5fb9d85ea93a94687cc1aabcc5a112a6ee4375a7b8aee1";
       libraryHaskellDepends = [ base pretty ];
       homepage = "https://github.com/ddssff/pretty-class";
       description = "Pretty printing class similar to Show";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pretty-compact" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "pretty-compact";
       version = "1.0";
       sha256 = "5659d0a11a2a4651b1d2b9dc0c9359c767c7aceba5b0ea56035742c778dbde4c";
       libraryHaskellDepends = [ base ];
       description = "Pretty-printing library";
       license = "GPL";
     }) {};

  "pretty-error" = callPackage
    ({ mkDerivation, base, basic-prelude, bytestring, pretty-show }:
     mkDerivation {
       pname = "pretty-error";
       version = "0.1.0.0";
       sha256 = "ada53c7d0e9ab16b24bc70a0b64a9f95d707d4aa267c3c659dab0fd31c680e36";
       libraryHaskellDepends = [
         base basic-prelude bytestring pretty-show
       ];
       homepage = "https://github.com/jml/pretty-error";
       description = "Pretty error messages for runtime invariants";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "pretty-hex" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "pretty-hex";
       version = "1.0";
       sha256 = "ff9a5f2023d6a4454f06cc395726b4cac3f9d0ea03759b14ccf7d62df79e9c7a";
       libraryHaskellDepends = [ base bytestring ];
       description = "A library for hex dumps of ByteStrings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pretty-ncols" = callPackage
    ({ mkDerivation, base, pretty }:
     mkDerivation {
       pname = "pretty-ncols";
       version = "0.1";
       sha256 = "58b9f368a13fd226f29b56aaa715ac7945aebfaca9a21f96412fc92c1f476d2f";
       libraryHaskellDepends = [ base pretty ];
       description = "A implementation of multi-column layout w/ Text.PrettyPrint";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pretty-show_1_6_8" = callPackage
    ({ mkDerivation, array, base, filepath, ghc-prim, happy
     , haskell-lexer, pretty
     }:
     mkDerivation {
       pname = "pretty-show";
       version = "1.6.8";
       sha256 = "3a0b58ab971f2e6a798380129a562804d46d401306329d8a0969addd4438cb6d";
       revision = "1";
       editedCabalFile = "7ed7626bea0aaf184c7ca6d66715ec8b71b27262018156c5f171949d7d331c69";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base filepath ghc-prim haskell-lexer pretty
       ];
       libraryToolDepends = [ happy ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://wiki.github.com/yav/pretty-show";
       description = "Tools for working with derived `Show` instances and generic inspection of values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pretty-show_1_6_8_2" = callPackage
    ({ mkDerivation, array, base, filepath, ghc-prim, happy
     , haskell-lexer, pretty
     }:
     mkDerivation {
       pname = "pretty-show";
       version = "1.6.8.2";
       sha256 = "1bc3bcf3f3aa7de90b156de2dffceb2ca48b7462c84450f42167e13ae5b725e9";
       revision = "1";
       editedCabalFile = "3454673131f18cc65fb3fbca43d5d010f6b228abc0b7e501e67ef90ffded4218";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base filepath ghc-prim haskell-lexer pretty
       ];
       libraryToolDepends = [ happy ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://wiki.github.com/yav/pretty-show";
       description = "Tools for working with derived `Show` instances and generic inspection of values";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pretty-show" = callPackage
    ({ mkDerivation, array, base, filepath, ghc-prim, happy
     , haskell-lexer, pretty
     }:
     mkDerivation {
       pname = "pretty-show";
       version = "1.6.9";
       sha256 = "06bb89709abf23cbf59d50400654cc7a616649f851f9640268b2b5f225a1e477";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base filepath ghc-prim haskell-lexer pretty
       ];
       libraryToolDepends = [ happy ];
       executableHaskellDepends = [ base ];
       homepage = "http://wiki.github.com/yav/pretty-show";
       description = "Tools for working with derived `Show` instances and generic inspection of values";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pretty-sop" = callPackage
    ({ mkDerivation, base, generics-sop, pretty-show }:
     mkDerivation {
       pname = "pretty-sop";
       version = "0.2.0.0";
       sha256 = "931e60782ff551f864b2548fcb39c2e05e502a4b2ef76108a6f66b672c88590f";
       libraryHaskellDepends = [ base generics-sop pretty-show ];
       description = "A generic pretty-printer using generics-sop";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pretty-tree" = callPackage
    ({ mkDerivation, base, boxes, containers }:
     mkDerivation {
       pname = "pretty-tree";
       version = "0.1.0.0";
       sha256 = "dc8d57a0beb5e1c861a78d9fec3216ea9d1001d084281b63a5803125b129c831";
       libraryHaskellDepends = [ base boxes containers ];
       description = "Pretty-print trees";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "prettyFunctionComposing" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "prettyFunctionComposing";
       version = "1.0.1";
       sha256 = "0b254954b19b3217eb4f1d6dc84cf5b8ffaa3dfe67ce2cb00a506546a56f6930";
       libraryHaskellDepends = [ base ];
       description = "prettier function composition by (°)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "prettyclass" = callPackage
    ({ mkDerivation, base, pretty }:
     mkDerivation {
       pname = "prettyclass";
       version = "1.0.0.0";
       sha256 = "e537446e7a346e5e0872ed8281db2bb0220c737f10757848c901da1399548986";
       libraryHaskellDepends = [ base pretty ];
       description = "Pretty printing class similar to Show";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "prim-uniq" = callPackage
    ({ mkDerivation, base, dependent-sum, primitive }:
     mkDerivation {
       pname = "prim-uniq";
       version = "0.1.0.1";
       sha256 = "fb059785133fe5ecaa57c6c840192f252c4c5a1a598160d5704ac2a83e895aff";
       libraryHaskellDepends = [ base dependent-sum primitive ];
       homepage = "https://github.com/mokus0/prim-uniq";
       description = "Opaque unique identifiers in primitive state monads";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "primes" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "primes";
       version = "0.2.1.0";
       sha256 = "74d66558fb638ea4d31eae2fe1a294cb5a9d64491314305d74a11d93f277c65b";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/sebfisch/primes";
       description = "Efficient, purely functional generation of prime numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "primitive_0_5_1_0" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "primitive";
       version = "0.5.1.0";
       sha256 = "8817a5f307c4605709b37857c048caa22fcc7550d681d64a2eea756126721529";
       revision = "1";
       editedCabalFile = "ee8bf53215343bfc18dc8d310fd0e03ad3eaab8b85afdbc97dea3b047e0d98ec";
       libraryHaskellDepends = [ base ghc-prim ];
       jailbreak = true;
       homepage = "https://github.com/haskell/primitive";
       description = "Primitive memory-related operations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "primitive_0_5_4_0" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "primitive";
       version = "0.5.4.0";
       sha256 = "203c2a288a65ef6b75d2150d6f91f8204aa437add108d8e16cb9f581867ced15";
       revision = "1";
       editedCabalFile = "df0a129c168c61a06a02123898de081b1d0b254cce6d7ab24b8f43ec37baef9e";
       libraryHaskellDepends = [ base ghc-prim ];
       testHaskellDepends = [ base ghc-prim ];
       homepage = "https://github.com/haskell/primitive";
       description = "Primitive memory-related operations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "primitive_0_6" = callPackage
    ({ mkDerivation, base, ghc-prim, transformers }:
     mkDerivation {
       pname = "primitive";
       version = "0.6";
       sha256 = "34a5f39213c68369e7edc2a3ea175d3f4edbf89e9f0777784710eff6f2d69722";
       libraryHaskellDepends = [ base ghc-prim transformers ];
       testHaskellDepends = [ base ghc-prim ];
       homepage = "https://github.com/haskell/primitive";
       description = "Primitive memory-related operations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "primitive" = callPackage
    ({ mkDerivation, base, ghc-prim, transformers }:
     mkDerivation {
       pname = "primitive";
       version = "0.6.1.0";
       sha256 = "93731fa72eaf74e8e83453f080828e18cec9fbc82bee91b49ba8b61c043d38c8";
       revision = "1";
       editedCabalFile = "6ec7c2455c437aba71f856b797e7db440c83719509aa63a9a3d1b4652ca3683d";
       libraryHaskellDepends = [ base ghc-prim transformers ];
       testHaskellDepends = [ base ghc-prim ];
       homepage = "https://github.com/haskell/primitive";
       description = "Primitive memory-related operations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "primitive-simd" = callPackage
    ({ mkDerivation, base, ghc-prim, primitive, vector }:
     mkDerivation {
       pname = "primitive-simd";
       version = "0.1.0.0";
       sha256 = "d131c7a6aedc55c113e71fbc22cd79e2105186fb5e359236de04abe46433b58d";
       libraryHaskellDepends = [ base ghc-prim primitive vector ];
       description = "SIMD data types and functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "primula-board" = callPackage
    ({ mkDerivation, base, ConfigFile, containers, directory, happstack
     , happstack-helpers, happstack-server, happstack-state, hsp
     , MissingH, mtl, old-locale, old-time, random, regex-posix, split
     , time
     }:
     mkDerivation {
       pname = "primula-board";
       version = "0.0.1";
       sha256 = "49c31b0404b74fa2b8dbe7ef18d806428fbb3917e96df513289bdf16411c0142";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base ConfigFile containers directory happstack happstack-helpers
         happstack-server happstack-state hsp MissingH mtl old-locale
         old-time random regex-posix split time
       ];
       homepage = "http://kagami.touhou.ru/projects/show/primula";
       description = "ImageBoard on Happstack and HSP";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "primula-bot" = callPackage
    ({ mkDerivation, base, ConfigFile, directory, HTTP, mtl, network
     , parsec, utf8-string, XMPP
     }:
     mkDerivation {
       pname = "primula-bot";
       version = "0.0.2";
       sha256 = "3d80fe707025faeb176cddd5274e4383dc3d16978014345aff01f5b839957d48";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base ConfigFile directory HTTP mtl network parsec utf8-string XMPP
       ];
       jailbreak = true;
       homepage = "http://kagami.touhou.ru/projects/show/primula";
       description = "Jabber-bot for primula-board ImageBoard";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "print-debugger" = callPackage
    ({ mkDerivation, base, split }:
     mkDerivation {
       pname = "print-debugger";
       version = "1.1.9";
       sha256 = "e89a0e2d8bc5bf67ca3c079ad690b48602241afb0de557fa6abefc099c6e8481";
       libraryHaskellDepends = [ base split ];
       homepage = "https://github.com/JohnReedLOL/HaskellPrintDebugger";
       description = "Debug print formatting library";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "printf-mauke" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default
     , template-haskell, utf8-string
     }:
     mkDerivation {
       pname = "printf-mauke";
       version = "0.6.0";
       sha256 = "1fa0f6c024f4a1d5d3b8da3a8de29b48b5735391a00581077a476cd816a9ddbb";
       libraryHaskellDepends = [
         base bytestring containers data-default template-haskell
         utf8-string
       ];
       description = "A Perl printf like formatter";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "printxosd" = callPackage
    ({ mkDerivation, base, xosd }:
     mkDerivation {
       pname = "printxosd";
       version = "0.1";
       sha256 = "31c459dafe68ff0a4911fd22f757cf95ff2d0b8fc3f5b44572163524ee32d6d7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base xosd ];
       homepage = "http://code.haskell.org/~dons/code/printxosd";
       description = "Simple tool to display some text on an on-screen display";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "priority-queue" = callPackage
    ({ mkDerivation, base, containers, queue, reord, stateref }:
     mkDerivation {
       pname = "priority-queue";
       version = "0.2.2";
       sha256 = "8e969f0126c24703d435c67d2afe9dbcbbd238f8e3dd191440550cea018d515b";
       libraryHaskellDepends = [ base containers queue reord stateref ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~mokus/priority-queue";
       description = "Simple implementation of a priority queue";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "priority-sync" = callPackage
    ({ mkDerivation, base, containers, parallel, PSQueue, random, stm
     }:
     mkDerivation {
       pname = "priority-sync";
       version = "0.2.1.1";
       sha256 = "cfb44d10f756c3e4959d6924f5db05a8e3813c12181ad44416a7396ed41acfb9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers parallel PSQueue random stm
       ];
       executableHaskellDepends = [ base ];
       description = "Cooperative task prioritization";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "privileged-concurrency" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "privileged-concurrency";
       version = "0.3";
       sha256 = "c760e05e350ad4af188d031cb12749b2d1468046d9f06e6cdcb77a9a50286464";
       libraryHaskellDepends = [ base stm ];
       description = "Provides privilege separated versions of the concurrency primitives";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "prizm" = callPackage
    ({ mkDerivation, base, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "prizm";
       version = "0.3.1.2";
       sha256 = "6909454f9aa0a10aed4dfb3d4625df3a2271bed80c1a5f6922c32387228c1758";
       libraryHaskellDepends = [ base text ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       homepage = "https://github.com/ixmatus/prizm";
       description = "Compute with colors and differenct color spaces";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "probability" = callPackage
    ({ mkDerivation, base, containers, random, transformers, utility-ht
     }:
     mkDerivation {
       pname = "probability";
       version = "0.2.5";
       sha256 = "1dccf0a260f37f0725f02d2f1d4f1cd61da67477dacc77caf5007584ec53a9c0";
       libraryHaskellDepends = [
         base containers random transformers utility-ht
       ];
       homepage = "http://www.haskell.org/haskellwiki/Probabilistic_Functional_Programming";
       description = "Probabilistic Functional Programming";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "probable" = callPackage
    ({ mkDerivation, base, mtl, mwc-random, primitive, statistics
     , transformers, vector
     }:
     mkDerivation {
       pname = "probable";
       version = "0.1.1";
       sha256 = "9923eff95f7404fcfc04f514888dc6d8d5e4b57b56c0a55c6502b3ace03dd7d8";
       libraryHaskellDepends = [
         base mtl mwc-random primitive statistics transformers vector
       ];
       homepage = "http://github.com/alpmestan/probable";
       description = "Easy and reasonably efficient probabilistic programming and random generation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "proc" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, process
     , regex-tdfa, split, strict, xformat
     }:
     mkDerivation {
       pname = "proc";
       version = "0.0.9";
       sha256 = "8a8e6685d3b917d9db2ccbd55028af49bf0a2a51f27a7dcf7901413230c96c5c";
       libraryHaskellDepends = [
         base containers directory filepath process regex-tdfa split strict
         xformat
       ];
       description = "Parse process information for Linux";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "process_1_4_2_0" = callPackage
    ({ mkDerivation, base, deepseq, directory, filepath, unix }:
     mkDerivation {
       pname = "process";
       version = "1.4.2.0";
       sha256 = "1c2ba524a238e464ae9c22582bea92da2d4c5227e1704a984bb8631dcb562bec";
       libraryHaskellDepends = [ base deepseq directory filepath unix ];
       testHaskellDepends = [ base ];
       description = "Process libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "process-conduit" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , control-monad-loop, hspec, mtl, process, resourcet, shakespeare
     , shakespeare-text, template-haskell, text
     }:
     mkDerivation {
       pname = "process-conduit";
       version = "1.2.0.1";
       sha256 = "886d9a901620da5d43a3d42dd13e02ef12503f7612a8c4b4117ecc2d2bf7cb42";
       libraryHaskellDepends = [
         base bytestring conduit control-monad-loop mtl process resourcet
         shakespeare shakespeare-text template-haskell text
       ];
       testHaskellDepends = [
         base bytestring conduit conduit-extra hspec resourcet
       ];
       homepage = "http://github.com/snoyberg/process-conduit";
       description = "Conduits for processes (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "process-extras_0_2_0" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, process, text }:
     mkDerivation {
       pname = "process-extras";
       version = "0.2.0";
       sha256 = "efb8adfb50a272026a5b4d85c010e5b84d0ffc7ce93b07a569e6e314b6702457";
       libraryHaskellDepends = [ base bytestring deepseq process text ];
       homepage = "https://github.com/davidlazar/process-extras";
       description = "Process extras";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "process-extras_0_3_3_4" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, ListLike, process, text
     }:
     mkDerivation {
       pname = "process-extras";
       version = "0.3.3.4";
       sha256 = "77d550a6aa270e41f55193025201f70410b8728028c72450837e329e3f3dd8b2";
       revision = "1";
       editedCabalFile = "2ab4fd50b430fda365a8d22012f2ad28ce27a96346c5ff7f7683bb5cbc85e761";
       libraryHaskellDepends = [
         base bytestring deepseq ListLike process text
       ];
       homepage = "https://github.com/seereason/process-extras";
       description = "Process extras";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "process-extras_0_3_3_5" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, ListLike, process, text
     }:
     mkDerivation {
       pname = "process-extras";
       version = "0.3.3.5";
       sha256 = "da546fabdb83755618cdd10cbe6510d995d1834a130a1d0342856fd80fd9dea1";
       revision = "1";
       editedCabalFile = "beaa9e19a781212403fe07d03b9aabf7d2ef482d9b7e9c51c1f2e8a1efb7e7a0";
       libraryHaskellDepends = [
         base bytestring deepseq ListLike process text
       ];
       homepage = "https://github.com/seereason/process-extras";
       description = "Process extras";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "process-extras_0_3_3_6" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, ListLike, process, text
     }:
     mkDerivation {
       pname = "process-extras";
       version = "0.3.3.6";
       sha256 = "a1638f8bf59873a271f86a948f9355a55f6f84bc580e7a0e673ca250ed966ed1";
       revision = "1";
       editedCabalFile = "b04a582a1803030f005ac9bc2f82f3eca132ce1a51661613a2986435bf7259ad";
       libraryHaskellDepends = [
         base bytestring deepseq ListLike process text
       ];
       homepage = "https://github.com/seereason/process-extras";
       description = "Process extras";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "process-extras_0_3_3_7" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, ListLike, process, text
     }:
     mkDerivation {
       pname = "process-extras";
       version = "0.3.3.7";
       sha256 = "50e0cfdfb1225e99c04e839270cf2b06502494b8f1953d12a04f1ddaf04fa9e1";
       revision = "1";
       editedCabalFile = "b671c93f8c252555f6a8a0dcd2335b6409a823ae36310f7518bbc7a55d593812";
       libraryHaskellDepends = [
         base bytestring deepseq ListLike process text
       ];
       homepage = "https://github.com/seereason/process-extras";
       description = "Process extras";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "process-extras" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, generic-deriving
     , ListLike, process, text
     }:
     mkDerivation {
       pname = "process-extras";
       version = "0.3.3.8";
       sha256 = "d9e26f829d5eab2e2df113383b814bf71c835ff874fdecdc5a125115da485ec3";
       libraryHaskellDepends = [
         base bytestring deepseq generic-deriving ListLike process text
       ];
       homepage = "https://github.com/seereason/process-extras";
       description = "Process extras";
       license = stdenv.lib.licenses.mit;
     }) {};

  "process-iterio" = callPackage
    ({ mkDerivation, base, bytestring, cpphs, iterIO, process
     , transformers
     }:
     mkDerivation {
       pname = "process-iterio";
       version = "0.0.0";
       sha256 = "5f8ca1642316447957241f2117ea0d8a71ba5705eda276b875c593edc0916da2";
       libraryHaskellDepends = [
         base bytestring cpphs iterIO process transformers
       ];
       testHaskellDepends = [
         base bytestring cpphs iterIO process transformers
       ];
       homepage = "https://github.com/garious/process-iterio";
       description = "IterIO Process Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "process-leksah" = callPackage
    ({ mkDerivation, base, directory, filepath, unix }:
     mkDerivation {
       pname = "process-leksah";
       version = "1.0.1.4";
       sha256 = "7bf15534c348f865997ea661b2967cecba3427a463242a72d442486de1f229a1";
       libraryHaskellDepends = [ base directory filepath unix ];
       jailbreak = true;
       description = "Process libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "process-listlike" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, ListLike, process, text
     }:
     mkDerivation {
       pname = "process-listlike";
       version = "1.0";
       sha256 = "f908c20a2a637fc1d431519c7db0eebd4661721474afbd385433f5eb2e485f79";
       revision = "3";
       editedCabalFile = "75f8f07195965b0a2ca36725792b095896801d4e4133c7c67a72600bdbeb63b1";
       libraryHaskellDepends = [
         base bytestring deepseq ListLike process text
       ];
       jailbreak = true;
       homepage = "https://github.com/ddssff/process-listlike";
       description = "Process extras";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "process-progress" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, HUnit, ListLike, mtl
     , process, process-listlike, text, time, unix, utf8-string
     }:
     mkDerivation {
       pname = "process-progress";
       version = "0.14";
       sha256 = "364eb3e2c4a491b8012c0a38d9c843a8e10faff9ecba1262820a74672a5abf4d";
       libraryHaskellDepends = [
         base bytestring deepseq HUnit ListLike mtl process process-listlike
         text time unix utf8-string
       ];
       homepage = "https://src.seereason.com/process-progress";
       description = "Run a process and do reportsing on its progress";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "process-qq" = callPackage
    ({ mkDerivation, base, bytestring, enumerator, mtl, process
     , shakespeare-text, template-haskell, text
     }:
     mkDerivation {
       pname = "process-qq";
       version = "0.2.0";
       sha256 = "4abc38000634e7f32b79d383a65158b0ea55d282e8a963b7acc9c999066b2591";
       libraryHaskellDepends = [
         base bytestring enumerator mtl process shakespeare-text
         template-haskell text
       ];
       jailbreak = true;
       homepage = "http://github.com/tanakh/process-qq";
       description = "Quasi-Quoters for exec process";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "process-streaming" = callPackage
    ({ mkDerivation, attoparsec, base, bifunctors, bytestring, conceit
     , containers, directory, doctest, exceptions, filepath, foldl, free
     , kan-extensions, lens-family-core, pipes, pipes-attoparsec
     , pipes-bytestring, pipes-concurrency, pipes-group, pipes-parse
     , pipes-safe, pipes-text, pipes-transduce, process, profunctors
     , semigroups, tasty, tasty-hunit, text, transformers
     , transformers-compat, void
     }:
     mkDerivation {
       pname = "process-streaming";
       version = "0.9.1.0";
       sha256 = "cd1efb0a5a24a9b3c13fc24bba2054ae0be494b645a5091f733b06854a275a9c";
       libraryHaskellDepends = [
         base bifunctors bytestring conceit free kan-extensions pipes
         pipes-bytestring pipes-concurrency pipes-parse pipes-safe
         pipes-text pipes-transduce process profunctors text transformers
         transformers-compat void
       ];
       testHaskellDepends = [
         attoparsec base bifunctors bytestring containers directory doctest
         exceptions filepath foldl free lens-family-core pipes
         pipes-attoparsec pipes-bytestring pipes-concurrency pipes-group
         pipes-parse pipes-safe pipes-text pipes-transduce process
         semigroups tasty tasty-hunit text transformers transformers-compat
         void
       ];
       description = "Streaming interface to system processes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "processing" = callPackage
    ({ mkDerivation, base, blaze-html, containers, directory, filepath
     , mainland-pretty, multiset, QuickCheck, quickcheck-instances
     , template-haskell, text, transformers
     }:
     mkDerivation {
       pname = "processing";
       version = "1.2.0.1";
       sha256 = "ea1670341c6d4cd8b85a1deb30b7be17c324e4dcc563b820a1628d4250f3b9ab";
       libraryHaskellDepends = [
         base blaze-html containers directory filepath mainland-pretty
         multiset QuickCheck quickcheck-instances template-haskell text
         transformers
       ];
       jailbreak = true;
       description = "Web graphic applications with processing.js.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "processor-creative-kit" = callPackage
    ({ mkDerivation, array, attoparsec, base, bytestring, containers
     , deepseq, mtl
     }:
     mkDerivation {
       pname = "processor-creative-kit";
       version = "0.1.0.1";
       sha256 = "0722225ebe81121f8fe3182e17c2de558935fb6d3a055117116bed0099ff50cb";
       libraryHaskellDepends = [
         array attoparsec base bytestring containers deepseq mtl
       ];
       homepage = "https://github.com/takenobu-hs/processor-creative-kit";
       description = "a creation kit for instruction sets and cpu simulators and development tools";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "procrastinating-structure" = callPackage
    ({ mkDerivation, base, procrastinating-variable }:
     mkDerivation {
       pname = "procrastinating-structure";
       version = "1.0.1";
       sha256 = "830e033110a1f4d20f81188e7931d0810f69d44b81421667783df9eaaab8d588";
       libraryHaskellDepends = [ base procrastinating-variable ];
       description = "Pure structures that can be incrementally created in impure code";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "procrastinating-variable" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "procrastinating-variable";
       version = "1.0.2";
       sha256 = "844d49ca18c3a357ab746761194763633e20406a4cf5cdbef3901c79a605fd8a";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/gcross/procrastinating-variable";
       description = "Haskell values that cannot be evaluated immediately";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "procstat" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring }:
     mkDerivation {
       pname = "procstat";
       version = "0.1.0.1";
       sha256 = "b5641816f111ec9493666d52716bac1cd00780b235b8e78fded65931982ca7d5";
       libraryHaskellDepends = [ attoparsec base bytestring ];
       jailbreak = true;
       homepage = "http://closure.ath.cx/procstat";
       description = "get information on processes in Linux";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "proctest" = callPackage
    ({ mkDerivation, base, bytestring, hspec, HUnit, process
     , QuickCheck, text
     }:
     mkDerivation {
       pname = "proctest";
       version = "0.1.3.0";
       sha256 = "b62dfdd378553d6111a8f226246d93e6ae803e56ea5dbd29e33ff5ac86183f0a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring HUnit process text ];
       executableHaskellDepends = [
         base bytestring hspec HUnit process QuickCheck text
       ];
       homepage = "https://github.com/nh2/proctest";
       description = "An IO library for testing interactive command line programs";
       license = stdenv.lib.licenses.mit;
     }) {};

  "product-profunctors_0_6" = callPackage
    ({ mkDerivation, base, contravariant, profunctors, template-haskell
     }:
     mkDerivation {
       pname = "product-profunctors";
       version = "0.6";
       sha256 = "84722f4da5a750903180c9b8e0ae2e8d34abfb99669d7ea02f377ea8c11614e2";
       revision = "5";
       editedCabalFile = "9d053153873ef7585e00c194523cdc5278bc9f6bf8f97cffbf1d67a9b790e449";
       libraryHaskellDepends = [
         base contravariant profunctors template-haskell
       ];
       testHaskellDepends = [ base profunctors ];
       jailbreak = true;
       homepage = "https://github.com/tomjaguarpaw/product-profunctors";
       description = "product-profunctors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "product-profunctors_0_6_1" = callPackage
    ({ mkDerivation, base, contravariant, profunctors, template-haskell
     }:
     mkDerivation {
       pname = "product-profunctors";
       version = "0.6.1";
       sha256 = "c294fd05540f9aeff9acd965b72de1855bcb06c16692e3047f4fbf669f951c5e";
       revision = "3";
       editedCabalFile = "01edcbebd6228c9fc9dbfbb173651e45cbca28cbd1dc55386a59dd24fb0a6ccd";
       libraryHaskellDepends = [
         base contravariant profunctors template-haskell
       ];
       testHaskellDepends = [ base profunctors ];
       jailbreak = true;
       homepage = "https://github.com/tomjaguarpaw/product-profunctors";
       description = "product-profunctors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "product-profunctors_0_6_3" = callPackage
    ({ mkDerivation, base, contravariant, profunctors, template-haskell
     }:
     mkDerivation {
       pname = "product-profunctors";
       version = "0.6.3";
       sha256 = "28dcb36dd2ae7eade22bec22a2afc5008a2f23e9d52e2f31fb92316fd5c87156";
       libraryHaskellDepends = [
         base contravariant profunctors template-haskell
       ];
       testHaskellDepends = [ base profunctors ];
       jailbreak = true;
       homepage = "https://github.com/tomjaguarpaw/product-profunctors";
       description = "product-profunctors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "product-profunctors" = callPackage
    ({ mkDerivation, base, contravariant, profunctors, template-haskell
     }:
     mkDerivation {
       pname = "product-profunctors";
       version = "0.6.3.1";
       sha256 = "44e082ea161dc3f2b844fd59afbadfaeea3bd88ee4a07ba0fbaf369cc6e4311d";
       revision = "1";
       editedCabalFile = "a249282eea8fad3325c86ec23d4b6af68ce46c2bd2a99d7be3272cfc94359ce1";
       libraryHaskellDepends = [
         base contravariant profunctors template-haskell
       ];
       testHaskellDepends = [ base profunctors ];
       homepage = "https://github.com/tomjaguarpaw/product-profunctors";
       description = "product-profunctors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "prof2dot" = callPackage
    ({ mkDerivation, base, containers, filepath, haskell98, parsec }:
     mkDerivation {
       pname = "prof2dot";
       version = "0.4.1";
       sha256 = "cf3288aab7a6e9843d71fb627640baec3c8e0e2a9edaa59f8ce7d9ebacf6c1b1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers filepath haskell98 parsec
       ];
       homepage = "http://antiope.com/downloads.html";
       description = "Convert GHC profiles into GraphViz's dot format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "prof2pretty" = callPackage
    ({ mkDerivation, base, containers, filepath, haskell-src-exts
     , semigroups, uniplate, zenc
     }:
     mkDerivation {
       pname = "prof2pretty";
       version = "0.1.0.0";
       sha256 = "991828364a58ade8c77e3200b79b4d7e4800c2f91d38dfe5cb64bacfc0cb8e80";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers filepath haskell-src-exts semigroups uniplate zenc
       ];
       homepage = "https://gitorious.org/prof2pretty";
       description = "generate pretty source from time/allocation profiles";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "profiteur" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, filepath
     , text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "profiteur";
       version = "0.3.0.1";
       sha256 = "a0e2ea372a6259dcd25b69160e9afef9039c25e0acbafd8824eb907117dd5b86";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson attoparsec base bytestring filepath text unordered-containers
         vector
       ];
       homepage = "http://github.com/jaspervdj/profiteur";
       description = "Treemap visualiser for GHC prof files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "profunctor-extras" = callPackage
    ({ mkDerivation, base, profunctors }:
     mkDerivation {
       pname = "profunctor-extras";
       version = "4.0";
       sha256 = "8a3c51ef41d686e39f87875dd48e72e5aa83956125bdf9922edf531c292a4482";
       libraryHaskellDepends = [ base profunctors ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://github.com/ekmett/profunctor-extras/";
       description = "This package has been absorbed into profunctors 4.0";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "profunctors_4_3_2" = callPackage
    ({ mkDerivation, base, comonad, distributive, semigroupoids, tagged
     , transformers
     }:
     mkDerivation {
       pname = "profunctors";
       version = "4.3.2";
       sha256 = "9b20c243382bde44df5a96793eaa74eda440ca371563f7a7185543f1e54abb19";
       revision = "2";
       editedCabalFile = "29704ee7b31e17980aa98484f0a8ed6c72ba973674d0f2911dabbf9032bd543d";
       libraryHaskellDepends = [
         base comonad distributive semigroupoids tagged transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/profunctors/";
       description = "Profunctors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "profunctors_4_4_1" = callPackage
    ({ mkDerivation, base, comonad, distributive, semigroupoids, tagged
     , transformers
     }:
     mkDerivation {
       pname = "profunctors";
       version = "4.4.1";
       sha256 = "85980e45caf1a13b58461614d261febd1c7cdfefabf734b654dd3314d822b8f4";
       revision = "2";
       editedCabalFile = "eb0755c9ed86f258928347c9480d154d2b2e5ab14f2cd7af64b062697665760d";
       libraryHaskellDepends = [
         base comonad distributive semigroupoids tagged transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/profunctors/";
       description = "Profunctors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "profunctors_5_1_1" = callPackage
    ({ mkDerivation, base, comonad, distributive, tagged, transformers
     }:
     mkDerivation {
       pname = "profunctors";
       version = "5.1.1";
       sha256 = "873f4478cdadd574c070c00fa790e4b0d8fb6f00577f142bf6e9dacbd48d8253";
       libraryHaskellDepends = [
         base comonad distributive tagged transformers
       ];
       homepage = "http://github.com/ekmett/profunctors/";
       description = "Profunctors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "profunctors_5_1_2" = callPackage
    ({ mkDerivation, base, bifunctors, comonad, contravariant
     , distributive, tagged, transformers
     }:
     mkDerivation {
       pname = "profunctors";
       version = "5.1.2";
       sha256 = "e0cc9129a4c1d2027cdada0a4cd26e540666a929ebe4e17ce5e2cec02d589682";
       libraryHaskellDepends = [
         base bifunctors comonad contravariant distributive tagged
         transformers
       ];
       homepage = "http://github.com/ekmett/profunctors/";
       description = "Profunctors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "profunctors" = callPackage
    ({ mkDerivation, base, base-orphans, bifunctors, comonad
     , contravariant, distributive, tagged, transformers
     }:
     mkDerivation {
       pname = "profunctors";
       version = "5.2";
       sha256 = "87a7e25c4745ea8ff479dd1212ec2e57710abb3d3dd30f948fa16be1d3ee05a4";
       libraryHaskellDepends = [
         base base-orphans bifunctors comonad contravariant distributive
         tagged transformers
       ];
       homepage = "http://github.com/ekmett/profunctors/";
       description = "Profunctors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "progress" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "progress";
       version = "1.0";
       sha256 = "24f1a304d6857eed5de60655d78d0693f049c6f00099e12c7d375b31cd264c31";
       libraryHaskellDepends = [ base time ];
       description = "Simple progress tracking & projection library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "progressbar" = callPackage
    ({ mkDerivation, base, io-reactive }:
     mkDerivation {
       pname = "progressbar";
       version = "0.0.1";
       sha256 = "da0e18e771284738de24858b87c96b135c591df5158b1a212b9edcc6fad5ce27";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base io-reactive ];
       executableHaskellDepends = [ base ];
       description = "Progressbar API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "progression" = callPackage
    ({ mkDerivation, base, containers, criterion, directory, filepath
     , haskeline, process, txt-sushi
     }:
     mkDerivation {
       pname = "progression";
       version = "0.5.0.2";
       sha256 = "ead69c1123064a4e9265ea5c1b501e180beeafec2fa8d41a8ac54b98ca0e4007";
       libraryHaskellDepends = [
         base containers criterion directory filepath haskeline process
         txt-sushi
       ];
       jailbreak = true;
       homepage = "http://chplib.wordpress.com/2010/02/04/progression-supporting-optimisation-in-haskell/";
       description = "Automates the recording and graphing of criterion benchmarks";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "progressive" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , filepath, ghc-prim, process, text
     }:
     mkDerivation {
       pname = "progressive";
       version = "0.1.0.1";
       sha256 = "705d1b59f80ceafa64aa21738f8f7802afc0b257da92c632819c8b9e027d4bdf";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring containers directory filepath ghc-prim
         process text
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/gchrupala/progression";
       description = "Multilabel classification model which learns sequentially (online)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "proj4-hs-bindings" = callPackage
    ({ mkDerivation, base, ghc-prim, proj }:
     mkDerivation {
       pname = "proj4-hs-bindings";
       version = "0.1";
       sha256 = "506518c9a449b263ad14f1712f106efb611f0ef3f16b3b40a05c87bac2939333";
       libraryHaskellDepends = [ base ghc-prim ];
       librarySystemDepends = [ proj ];
       description = "Haskell bindings for the Proj4 C dynamic library";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) proj;};

  "project-template_0_1_4_2" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, conduit
     , conduit-extra, containers, hspec, mtl, QuickCheck, resourcet
     , system-fileio, system-filepath, text, transformers
     }:
     mkDerivation {
       pname = "project-template";
       version = "0.1.4.2";
       sha256 = "792a42909acfb0c1810beff32906c7dd338cc127002d0d05a160bbf38c1ec282";
       libraryHaskellDepends = [
         base base64-bytestring bytestring conduit conduit-extra containers
         mtl resourcet system-fileio system-filepath text transformers
       ];
       testHaskellDepends = [
         base base64-bytestring bytestring conduit containers hspec
         QuickCheck resourcet system-filepath text transformers
       ];
       homepage = "https://github.com/fpco/haskell-ide";
       description = "Specify Haskell project templates and generate files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "project-template" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, conduit
     , conduit-extra, containers, directory, filepath, hspec, mtl
     , QuickCheck, resourcet, text, transformers
     }:
     mkDerivation {
       pname = "project-template";
       version = "0.2.0";
       sha256 = "aeabd7d1785b31abaffc78f02d9dda67d57d01822755f09614bfc65e99506310";
       libraryHaskellDepends = [
         base base64-bytestring bytestring conduit conduit-extra containers
         directory filepath mtl resourcet text transformers
       ];
       testHaskellDepends = [
         base base64-bytestring bytestring conduit containers hspec
         QuickCheck resourcet text transformers
       ];
       homepage = "https://github.com/fpco/haskell-ide";
       description = "Specify Haskell project templates and generate files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "projection" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "projection";
       version = "0.1";
       sha256 = "8109a1ef47cec2f34dc3c8e04baa3ea121a73a0086f055757e1e71916ecb3f3d";
       revision = "1";
       editedCabalFile = "805db4a9404200c6d8c00b7e96f95c9c71e3595b6601f75efed7237ad5bed30b";
       libraryHaskellDepends = [ base ];
       description = "Projection function for arbitrarily nested binary product types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "projectroot" = callPackage
    ({ mkDerivation, base, directory, hspec, QuickCheck }:
     mkDerivation {
       pname = "projectroot";
       version = "0.2.0.1";
       sha256 = "53753086543ed199cf6f0d76852660f5d74c0874bfdee21c0f4e0d845b7e1ab8";
       libraryHaskellDepends = [ base directory ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "https://github.com/yamadapc/haskell-projectroot";
       description = "Bindings to the projectroot C logic";
       license = stdenv.lib.licenses.mit;
     }) {};

  "prolog" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec, syb
     , template-haskell, th-lift, transformers
     }:
     mkDerivation {
       pname = "prolog";
       version = "0.2.0.1";
       sha256 = "e06a107cc13fad311883294b5fe6d8ed941e4f614b6350354b1c3b06f3687a1c";
       libraryHaskellDepends = [
         base containers mtl parsec syb template-haskell th-lift
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/Erdwolf/prolog";
       description = "A Prolog interpreter written in Haskell";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "prolog-graph" = callPackage
    ({ mkDerivation, base, cmdargs, fgl, graphviz, mtl, prolog
     , prolog-graph-lib, text
     }:
     mkDerivation {
       pname = "prolog-graph";
       version = "0.1.0.2";
       sha256 = "22a14159c4bb39052e3cb99b9378538dd22dc1b031abf10c121ce26035f87cf0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs fgl graphviz mtl prolog prolog-graph-lib text
       ];
       jailbreak = true;
       homepage = "https://github.com/Erdwolf/prolog";
       description = "A command line tool to visualize query resolution in Prolog";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "prolog-graph-lib" = callPackage
    ({ mkDerivation, base, fgl, graphviz, mtl, prolog, text }:
     mkDerivation {
       pname = "prolog-graph-lib";
       version = "0.2.0.1";
       sha256 = "d99ec8b2f245ad6bf0b152024f119b08fdc1436ea30edfe63e5b57583124aa0b";
       libraryHaskellDepends = [ base fgl graphviz mtl prolog text ];
       homepage = "https://github.com/Erdwolf/prolog";
       description = "Generating images of resolution trees for Prolog queries";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "prologue" = callPackage
    ({ mkDerivation, base, bifunctors, binary, cond, container, convert
     , data-default, data-layer, errors, functor-utils, impossible, lens
     , lens-utils, mtl, pretty-show, string-qq, text, transformers
     , transformers-base, tuple, typelevel, vector
     }:
     mkDerivation {
       pname = "prologue";
       version = "1.0.7";
       sha256 = "37e8c186881e2cce7702812f64cc6fd27273cb9d3f34f59ffaaf0a365235935b";
       libraryHaskellDepends = [
         base bifunctors binary cond container convert data-default
         data-layer errors functor-utils impossible lens lens-utils mtl
         pretty-show string-qq text transformers transformers-base tuple
         typelevel vector
       ];
       homepage = "https://github.com/wdanilo/prologue";
       description = "Better, more general Prelude exporting common utilities";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "prometheus-client" = callPackage
    ({ mkDerivation, atomic-primops, base, bytestring, containers
     , doctest, hspec, mtl, QuickCheck, random-shuffle, stm, time
     , transformers, utf8-string
     }:
     mkDerivation {
       pname = "prometheus-client";
       version = "0.1.0.1";
       sha256 = "bdc0b7a6df25037dbc10d16960922ce8f3582d7eb79c5d60360e61da3220772f";
       libraryHaskellDepends = [
         atomic-primops base bytestring containers mtl stm time transformers
         utf8-string
       ];
       testHaskellDepends = [
         atomic-primops base bytestring containers doctest hspec mtl
         QuickCheck random-shuffle stm time transformers utf8-string
       ];
       homepage = "https://github.com/fimad/prometheus-haskell";
       description = "Haskell client library for http://prometheus.io.";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "prometheus-metrics-ghc" = callPackage
    ({ mkDerivation, base, doctest, prometheus-client, utf8-string }:
     mkDerivation {
       pname = "prometheus-metrics-ghc";
       version = "0.1.0.1";
       sha256 = "17842db364e459d59e5f298345828843622b4e095b37b8ad7c556a2722854795";
       libraryHaskellDepends = [ base prometheus-client utf8-string ];
       testHaskellDepends = [ base doctest prometheus-client ];
       homepage = "https://github.com/fimad/prometheus-haskell";
       description = "Metrics exposing GHC runtime information for use with prometheus-client";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "promise" = callPackage
    ({ mkDerivation, async, base }:
     mkDerivation {
       pname = "promise";
       version = "0.1.0.0";
       sha256 = "cf59d01629e18c5f961481b483849136e97783aaf11c4b8a615795c06bbefac3";
       libraryHaskellDepends = [ async base ];
       jailbreak = true;
       homepage = "http://github.com/jfischoff/promise";
       description = "A monadic interface for async";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "promises" = callPackage
    ({ mkDerivation, base, primitive }:
     mkDerivation {
       pname = "promises";
       version = "0.3";
       sha256 = "bf7c901915c122e7ab270f4c90cf02e83a703bf78f246948dc2452dcd294f260";
       libraryHaskellDepends = [ base primitive ];
       homepage = "http://github.com/ekmett/promises/";
       description = "Lazy demand-driven promises";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "prompt" = callPackage
    ({ mkDerivation, base, mtl, transformers, transformers-compat }:
     mkDerivation {
       pname = "prompt";
       version = "0.1.1.0";
       sha256 = "8f48a1728988c80d35cef283f092df7c03915b4a8a196f3c8641e91c83de5e8d";
       libraryHaskellDepends = [
         base mtl transformers transformers-compat
       ];
       homepage = "https://github.com/mstksg/prompt";
       description = "Monad (and transformer) for deferred-effect pure prompt-response queries";
       license = stdenv.lib.licenses.mit;
     }) {};

  "propane" = callPackage
    ({ mkDerivation, base, colour, containers, directory, filepath
     , repa, repa-devil, spawn
     }:
     mkDerivation {
       pname = "propane";
       version = "0.1";
       sha256 = "44d28ef334678a4d5566f380153546a83718c8d12276118c1a501c35bbe6f4cf";
       libraryHaskellDepends = [
         base colour containers directory filepath repa repa-devil spawn
       ];
       description = "Functional synthesis of images and animations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "propellor" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
     , directory, exceptions, filepath, hslogger, IfElse, MissingH, mtl
     , network, process, stm, text, time, transformers, unix
     , unix-compat
     }:
     mkDerivation {
       pname = "propellor";
       version = "2.15.4";
       sha256 = "1113810f1cd23c8d84b61bdd783359ec51000d030b6c25892548447f1e0edeb5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal async base bytestring containers directory exceptions
         filepath hslogger IfElse MissingH mtl network process stm text time
         transformers unix unix-compat
       ];
       executableHaskellDepends = [
         ansi-terminal async base bytestring containers directory exceptions
         filepath hslogger IfElse MissingH mtl network process stm text time
         transformers unix unix-compat
       ];
       homepage = "https://propellor.branchable.com/";
       description = "property-based host configuration management in haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "properties" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "properties";
       version = "0.0.2";
       sha256 = "91f356964f9411f36121d4dbfa23a2721a559f71727483bcb139e9fbfa2f4311";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "check quickCheck properties in real time";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "property-list" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, cereal
     , containers, free, oneOfN, recursion-schemes, syb
     , template-haskell, text, time, time-locale-compat, transformers
     , vector, xml
     }:
     mkDerivation {
       pname = "property-list";
       version = "0.1.0.5";
       sha256 = "b3009043d57ecfa092049fb2b0241066928145a083df6abee2d3f9b3cc3e6973";
       libraryHaskellDepends = [
         base base64-bytestring bytestring cereal containers free oneOfN
         recursion-schemes syb template-haskell text time time-locale-compat
         transformers vector xml
       ];
       homepage = "https://github.com/mokus0/property-list";
       description = "Apple property list parser";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "proplang" = callPackage
    ({ mkDerivation, base, glade, glib, gtk }:
     mkDerivation {
       pname = "proplang";
       version = "0.1";
       sha256 = "95f0c50263e67f327537aa64a4d7e92576e8d43350dcd1f16dec49d0360ea0ee";
       libraryHaskellDepends = [ base glade glib gtk ];
       homepage = "http://www-users.cs.york.ac.uk/~ndm/proplang/";
       description = "A library for functional GUI development";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "props" = callPackage
    ({ mkDerivation, base, doctest, QuickCheck }:
     mkDerivation {
       pname = "props";
       version = "0.1.2";
       sha256 = "7d49cedca59b9fa00c13912a0e9e63502814044c0e74fa6262af9740215e7381";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base doctest QuickCheck ];
       homepage = "http://github.com/deviant-logic/props";
       description = "Reusable quickcheck properties";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "prosper" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cereal, containers
     , HsOpenSSL, http-streams, io-streams, mtl, text, transformers
     , vector
     }:
     mkDerivation {
       pname = "prosper";
       version = "0.1.1";
       sha256 = "eb41df9ee8f6fab2b793215c6c590f34f625d54c95576cda70056913461cd000";
       libraryHaskellDepends = [
         aeson base bytestring cereal containers HsOpenSSL http-streams
         io-streams mtl text transformers vector
       ];
       homepage = "https://api.prosper.com";
       description = "Bindings to the Prosper marketplace API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "proteaaudio" = callPackage
    ({ mkDerivation, alsaLib, base, c2hs }:
     mkDerivation {
       pname = "proteaaudio";
       version = "0.6.2";
       sha256 = "96d690393cd95ed803b79399996355f54e9480e38f8440d1744eee932f785e81";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ alsaLib ];
       libraryToolDepends = [ c2hs ];
       description = "A wrapper for the proteaaudio library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) alsaLib;};

  "protobuf" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers
     , data-binary-ieee754, deepseq, hex, HUnit, mtl, QuickCheck, tagged
     , tasty, tasty-hunit, tasty-quickcheck, text, unordered-containers
     }:
     mkDerivation {
       pname = "protobuf";
       version = "0.2.1.0";
       sha256 = "b1a5441cef1e9cbde062dc3dc0bcc3e49da0539e80f2100fae98796964961045";
       libraryHaskellDepends = [
         base bytestring cereal data-binary-ieee754 deepseq mtl text
         unordered-containers
       ];
       testHaskellDepends = [
         base bytestring cereal containers hex HUnit mtl QuickCheck tagged
         tasty tasty-hunit tasty-quickcheck text unordered-containers
       ];
       homepage = "https://github.com/alphaHeavy/protobuf";
       description = "Google Protocol Buffers via GHC.Generics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "protobuf-native" = callPackage
    ({ mkDerivation, base, bytestring, cereal, cplusplus-th, criterion
     , hprotoc-fork, protobuf, protocol-buffers-fork, QuickCheck
     , template-haskell, text, utf8-string
     }:
     mkDerivation {
       pname = "protobuf-native";
       version = "1.0.0.1";
       sha256 = "d9a099f92b0aaf89dbabe360165c49003d28cc001bba3ae9a45d8e4caaa46c4c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cplusplus-th template-haskell text
       ];
       executableHaskellDepends = [ base bytestring ];
       testHaskellDepends = [
         base bytestring cereal cplusplus-th criterion hprotoc-fork protobuf
         protocol-buffers-fork QuickCheck text utf8-string
       ];
       jailbreak = true;
       homepage = "https://github.com/nicta/protobuf-native";
       description = "Protocol Buffers via C++";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "protocol-buffers_2_1_4" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, filepath, mtl, parsec, syb, utf8-string
     }:
     mkDerivation {
       pname = "protocol-buffers";
       version = "2.1.4";
       sha256 = "ad92eb27e09c70a26353377a09b5d61715aa452215e6221e33fcd0065c15c96a";
       libraryHaskellDepends = [
         array base binary bytestring containers directory filepath mtl
         parsec syb utf8-string
       ];
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "protocol-buffers_2_1_5" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, filepath, mtl, parsec, syb, utf8-string
     }:
     mkDerivation {
       pname = "protocol-buffers";
       version = "2.1.5";
       sha256 = "1028200fcef97d76f28e9ff22100066ad6b797c56fbf0222735b1ed4ece060dd";
       libraryHaskellDepends = [
         array base binary bytestring containers directory filepath mtl
         parsec syb utf8-string
       ];
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "protocol-buffers_2_1_6" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, filepath, mtl, parsec, syb, utf8-string
     }:
     mkDerivation {
       pname = "protocol-buffers";
       version = "2.1.6";
       sha256 = "81f732202f7bf3e2fc697e5c5be13c46e5ef3af1d3b82d7b4394cf6fea942ebe";
       libraryHaskellDepends = [
         array base binary bytestring containers directory filepath mtl
         parsec syb utf8-string
       ];
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "protocol-buffers_2_1_7" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, filepath, mtl, parsec, syb, utf8-string
     }:
     mkDerivation {
       pname = "protocol-buffers";
       version = "2.1.7";
       sha256 = "4f7f2128305ef3d691bd316f60e8e1799f391230c42edb680be5667b4027cb5a";
       libraryHaskellDepends = [
         array base binary bytestring containers directory filepath mtl
         parsec syb utf8-string
       ];
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "protocol-buffers_2_1_9" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, filepath, mtl, parsec, syb, utf8-string
     }:
     mkDerivation {
       pname = "protocol-buffers";
       version = "2.1.9";
       sha256 = "bcef7e31d467c92429092b2900411569eb2eb2a9f3799409560b20e53afd0f10";
       libraryHaskellDepends = [
         array base binary bytestring containers directory filepath mtl
         parsec syb utf8-string
       ];
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "protocol-buffers" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, filepath, mtl, parsec, syb, utf8-string
     }:
     mkDerivation {
       pname = "protocol-buffers";
       version = "2.1.12";
       sha256 = "c863ce1729a4b8e8f5698f990942f1ddf569527893adb79b170a322eb3b8554e";
       libraryHaskellDepends = [
         array base binary bytestring containers directory filepath mtl
         parsec syb utf8-string
       ];
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "protocol-buffers_2_2_0" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, filepath, mtl, parsec, syb, utf8-string
     }:
     mkDerivation {
       pname = "protocol-buffers";
       version = "2.2.0";
       sha256 = "069a9ded2e9f7840ec51aef66eaabcdb428ceed8eee2b913590d5ee245506967";
       libraryHaskellDepends = [
         array base binary bytestring containers directory filepath mtl
         parsec syb utf8-string
       ];
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "protocol-buffers-descriptor_2_1_4" = callPackage
    ({ mkDerivation, base, bytestring, containers, protocol-buffers }:
     mkDerivation {
       pname = "protocol-buffers-descriptor";
       version = "2.1.4";
       sha256 = "7e7ff115ed7fefcaa00917ba76052d50d4f5dd786956a646d1b3180212a207d4";
       libraryHaskellDepends = [
         base bytestring containers protocol-buffers
       ];
       jailbreak = true;
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "protocol-buffers-descriptor_2_1_5" = callPackage
    ({ mkDerivation, base, bytestring, containers, protocol-buffers }:
     mkDerivation {
       pname = "protocol-buffers-descriptor";
       version = "2.1.5";
       sha256 = "cd653ce9ad16eadb080d6e19647da5fe5ccde7e3e2fb85464cbc460d44ca44f0";
       libraryHaskellDepends = [
         base bytestring containers protocol-buffers
       ];
       jailbreak = true;
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "protocol-buffers-descriptor_2_1_6" = callPackage
    ({ mkDerivation, base, bytestring, containers, protocol-buffers }:
     mkDerivation {
       pname = "protocol-buffers-descriptor";
       version = "2.1.6";
       sha256 = "7558c7193cb74e90f1f02956d4ecddd5405fc956d64b422e7f105aa512e4332f";
       libraryHaskellDepends = [
         base bytestring containers protocol-buffers
       ];
       jailbreak = true;
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "protocol-buffers-descriptor_2_1_7" = callPackage
    ({ mkDerivation, base, bytestring, containers, protocol-buffers }:
     mkDerivation {
       pname = "protocol-buffers-descriptor";
       version = "2.1.7";
       sha256 = "971a4c4f0e92c98a5e01f52496a3ff9c9d1aef4d5c5fc5223b063c1c25763566";
       libraryHaskellDepends = [
         base bytestring containers protocol-buffers
       ];
       jailbreak = true;
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "protocol-buffers-descriptor_2_1_9" = callPackage
    ({ mkDerivation, base, bytestring, containers, protocol-buffers }:
     mkDerivation {
       pname = "protocol-buffers-descriptor";
       version = "2.1.9";
       sha256 = "73ce09dc61ce920401cf98d689255d2bbde2cda19c179c3c757c4e1ecc28455a";
       libraryHaskellDepends = [
         base bytestring containers protocol-buffers
       ];
       jailbreak = true;
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "protocol-buffers-descriptor" = callPackage
    ({ mkDerivation, base, bytestring, containers, protocol-buffers }:
     mkDerivation {
       pname = "protocol-buffers-descriptor";
       version = "2.1.12";
       sha256 = "b8898165f0915b2b2865f6373c79d8c71c0fcbaa139c1f319a7d7f9168fc5c61";
       libraryHaskellDepends = [
         base bytestring containers protocol-buffers
       ];
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "protocol-buffers-descriptor_2_2_0" = callPackage
    ({ mkDerivation, base, bytestring, containers, protocol-buffers }:
     mkDerivation {
       pname = "protocol-buffers-descriptor";
       version = "2.2.0";
       sha256 = "62b6d996c8ee7e11fad73744b3267c92b60ec4ddb59f4c37a53b97ce9836c09a";
       libraryHaskellDepends = [
         base bytestring containers protocol-buffers
       ];
       jailbreak = true;
       homepage = "https://github.com/k-bx/protocol-buffers";
       description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "protocol-buffers-descriptor-fork" = callPackage
    ({ mkDerivation, base, bytestring, containers
     , protocol-buffers-fork
     }:
     mkDerivation {
       pname = "protocol-buffers-descriptor-fork";
       version = "2.0.16";
       sha256 = "0b2fb09ae6eb60f5b92956fbeb7e8042f24c24f9d57942be9146587034f6c6f2";
       libraryHaskellDepends = [
         base bytestring containers protocol-buffers-fork
       ];
       homepage = "http://darcs.factisresearch.com/pub/protocol-buffers-fork/";
       description = "Text.DescriptorProto.Options and code generated from the Google Protocol Buffer specification";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "protocol-buffers-fork" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, filepath, mtl, syb, utf8-string
     }:
     mkDerivation {
       pname = "protocol-buffers-fork";
       version = "2.0.16";
       sha256 = "3f669bf641ab6de2dc3ed2a642316ab92aa343959ec8ca03daad8fd706613318";
       libraryHaskellDepends = [
         array base binary bytestring containers directory filepath mtl syb
         utf8-string
       ];
       homepage = "http://darcs.factisresearch.com/pub/protocol-buffers-fork/";
       description = "Parse Google Protocol Buffer specifications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "proton-haskell" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, HUnit
     , test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "proton-haskell";
       version = "0.7";
       sha256 = "119e3687f72085659ffc7d324e3fa3bc458b2c5e0b7bc69e9d0fe17c3b82c4be";
       libraryHaskellDepends = [ base containers directory filepath ];
       testHaskellDepends = [
         base containers directory filepath HUnit test-framework
         test-framework-hunit
       ];
       homepage = "http://github.com/jasonrbriggs/proton";
       description = "Simple XML templating library";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "prototype" = callPackage
    ({ mkDerivation, base, monads-tf }:
     mkDerivation {
       pname = "prototype";
       version = "0.5.3";
       sha256 = "278e62454660796001cf2f4f3aa88820a1f8760996ba5fc7fb4f08e31bb4f1cf";
       libraryHaskellDepends = [ base monads-tf ];
       description = "prototype-based programming on Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "prove-everywhere-server" = callPackage
    ({ mkDerivation, aeson, base, bytestring, case-insensitive
     , http-types, optparse-applicative, parsec, parsers, process, safe
     , text, time, unordered-containers, wai, warp
     }:
     mkDerivation {
       pname = "prove-everywhere-server";
       version = "0.1.1";
       sha256 = "5d0e5627aa1ee65b32c0551991bb9ec55414ea57293dd69ac24bb424f3f1f388";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring case-insensitive http-types
         optparse-applicative parsec parsers process safe text time
         unordered-containers wai warp
       ];
       jailbreak = true;
       homepage = "https://github.com/prove-everywhere/server";
       description = "The server for ProveEverywhere";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "proxied" = callPackage
    ({ mkDerivation, base, generic-deriving, tagged }:
     mkDerivation {
       pname = "proxied";
       version = "0.1.1";
       sha256 = "dc4f7f3553dfcc2ff40dd967d5c04bed58ac3d8d210b77a62df45623b36be087";
       libraryHaskellDepends = [ base generic-deriving tagged ];
       homepage = "https://github.com/RyanGlScott/proxied";
       description = "Make functions consume Proxy instead of undefined";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "proxy-kindness" = callPackage
    ({ mkDerivation, base, tagged }:
     mkDerivation {
       pname = "proxy-kindness";
       version = "0.1";
       sha256 = "27a2dfe755ed9fe4ebf0599ee3243d5c9d34730d2289e6e8696f776aa191ff72";
       libraryHaskellDepends = [ base tagged ];
       jailbreak = true;
       homepage = "https://github.com/jberryman/proxy-kindness";
       description = "A library for kind-polymorphic manipulation and inspection of Proxy values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "psc-ide_0_5_0" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, directory
     , either, filepath, hspec, http-client, lens, lens-aeson, mtl
     , network, optparse-applicative, parsec, purescript, regex-tdfa
     , text, wreq
     }:
     mkDerivation {
       pname = "psc-ide";
       version = "0.5.0";
       sha256 = "083cf4bf7a51aeefc28488813b95243667c3c142dc8e5e3c6f3d8ada3803f87b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers directory either filepath
         http-client lens lens-aeson mtl parsec purescript regex-tdfa text
         wreq
       ];
       executableHaskellDepends = [
         base directory mtl network optparse-applicative text
       ];
       testHaskellDepends = [ base containers hspec mtl ];
       homepage = "http://github.com/kRITZCREEK/psc-ide";
       description = "Language support for the PureScript programming language";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "psc-ide" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, directory
     , edit-distance, either, filepath, fsnotify, hspec, http-client
     , lens, lens-aeson, monad-logger, mtl, network
     , optparse-applicative, parsec, purescript, regex-tdfa, stm, text
     , wreq
     }:
     mkDerivation {
       pname = "psc-ide";
       version = "0.6.1";
       sha256 = "d2dc589b62f279e97cbe8ad87db2c907c3f1c2bb8e9f0e60978d547cee4a06b5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers directory edit-distance either
         filepath fsnotify http-client lens lens-aeson monad-logger mtl
         parsec purescript regex-tdfa stm text wreq
       ];
       executableHaskellDepends = [
         base directory filepath monad-logger mtl network
         optparse-applicative stm text
       ];
       testHaskellDepends = [
         base containers hspec monad-logger mtl stm
       ];
       homepage = "http://github.com/kRITZCREEK/psc-ide";
       description = "Language support for the PureScript programming language";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pseudo-boolean" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, bytestring-builder
     , containers, deepseq, dlist, hashable, HUnit, parsec, QuickCheck
     , tasty, tasty-hunit, tasty-quickcheck, tasty-th, temporary
     }:
     mkDerivation {
       pname = "pseudo-boolean";
       version = "0.1.3.0";
       sha256 = "88eb7ed7ced6ce2df62044fccb7be2269ff19a9fa5e3901b84bf896837ee1b0e";
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-builder containers deepseq
         dlist hashable parsec
       ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
         tasty-th temporary
       ];
       homepage = "https://github.com/msakai/pseudo-boolean";
       description = "Reading/Writing OPB/WBO files used in pseudo boolean competition";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pseudo-trie" = callPackage
    ({ mkDerivation, base, semigroups }:
     mkDerivation {
       pname = "pseudo-trie";
       version = "0.0.4.3";
       sha256 = "6bc3d45069da2d418e00a1403a80be933a2cb1fe86e6d549f8c40568f29b1208";
       revision = "1";
       editedCabalFile = "4566dd5a8847365d789eda525e2a8a61475cda0476102bda375affd3305387f5";
       libraryHaskellDepends = [ base semigroups ];
       description = "A tagged rose-tree with short circuited unique leaves";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pseudomacros" = callPackage
    ({ mkDerivation, base, template-haskell, time }:
     mkDerivation {
       pname = "pseudomacros";
       version = "0.0.2";
       sha256 = "8919dff4d679bf4c39db0d14f6c04b77ef5cca6b53f4ff043885ee633b3e4f84";
       libraryHaskellDepends = [ base template-haskell time ];
       description = "cpp-style built-in macros using Template Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "psqueues_0_2_0_2" = callPackage
    ({ mkDerivation, array, base, deepseq, ghc-prim, hashable, HUnit
     , QuickCheck, tagged, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "psqueues";
       version = "0.2.0.2";
       sha256 = "e3480634db33346e00bcb47e17ed719827efb17736c0452193a73345223568d7";
       libraryHaskellDepends = [ base deepseq ghc-prim hashable ];
       testHaskellDepends = [
         array base deepseq ghc-prim hashable HUnit QuickCheck tagged
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       description = "Pure priority search queues";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "psqueues_0_2_0_3" = callPackage
    ({ mkDerivation, array, base, deepseq, ghc-prim, hashable, HUnit
     , QuickCheck, tagged, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "psqueues";
       version = "0.2.0.3";
       sha256 = "ac8a60de9979f80948d0becfb35cdafe7e1fdfce062c0468e4e2abced9a85c69";
       libraryHaskellDepends = [ base deepseq ghc-prim hashable ];
       testHaskellDepends = [
         array base deepseq ghc-prim hashable HUnit QuickCheck tagged
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       description = "Pure priority search queues";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "psqueues" = callPackage
    ({ mkDerivation, array, base, deepseq, ghc-prim, hashable, HUnit
     , QuickCheck, tagged, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "psqueues";
       version = "0.2.2.0";
       sha256 = "14b12f505eea093f25190a9d74109f0178e611701849b83a3878811affe0b52a";
       libraryHaskellDepends = [ base deepseq ghc-prim hashable ];
       testHaskellDepends = [
         array base deepseq ghc-prim hashable HUnit QuickCheck tagged
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       description = "Pure priority search queues";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pub" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, ConfigFile, containers
     , groom, hedis, hslogger, mtl, network, pipes, pipes-bytestring
     , safe, system-filepath, text, time, transformers
     }:
     mkDerivation {
       pname = "pub";
       version = "2.0.2";
       sha256 = "88897bf7ff1e150c78727235b21e78c50b8a977055a1fc9f5174fe497089445f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs ConfigFile containers groom hedis hslogger
         mtl network pipes pipes-bytestring safe system-filepath text time
         transformers
       ];
       jailbreak = true;
       description = "Pipe stdin to a redis pub/sub channel";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "publicsuffix_0_20151212" = callPackage
    ({ mkDerivation, base, filepath, hspec, template-haskell }:
     mkDerivation {
       pname = "publicsuffix";
       version = "0.20151212";
       sha256 = "7c45ec12c38607dea637a87f1e5de578e1d398f93377ad9e108afa0f53a16512";
       libraryHaskellDepends = [ base filepath template-haskell ];
       testHaskellDepends = [ base hspec ];
       homepage = "https://github.com/wereHamster/publicsuffix-haskell/";
       description = "The publicsuffix list exposed as proper Haskell types";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "publicsuffix" = callPackage
    ({ mkDerivation, base, filepath, hspec, template-haskell }:
     mkDerivation {
       pname = "publicsuffix";
       version = "0.20160209";
       sha256 = "60d856fc6d6d82ff96d742e253ecf638f625c4693b7d8be250501e9f334a2246";
       libraryHaskellDepends = [ base filepath template-haskell ];
       testHaskellDepends = [ base hspec ];
       homepage = "https://github.com/wereHamster/publicsuffix-haskell/";
       description = "The publicsuffix list exposed as proper Haskell types";
       license = stdenv.lib.licenses.mit;
     }) {};

  "publicsuffixlist" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, data-default
     , HUnit, idna, text, utf8-string
     }:
     mkDerivation {
       pname = "publicsuffixlist";
       version = "0.1";
       sha256 = "b37fbe099748e2a3a5a3b6661911d72749c2ec24d88ee686ae125de91fac7955";
       libraryHaskellDepends = [
         base bytestring cereal containers data-default text utf8-string
       ];
       testHaskellDepends = [
         base bytestring cereal containers data-default HUnit idna text
         utf8-string
       ];
       homepage = "https://github.com/litherum/publicsuffixlist";
       description = "Is a given string a domain suffix?";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "publicsuffixlistcreate" = callPackage
    ({ mkDerivation, base, bytestring, cereal, conduit, containers
     , data-default, HUnit, idna, publicsuffixlist, text
     }:
     mkDerivation {
       pname = "publicsuffixlistcreate";
       version = "0.0.2";
       sha256 = "23e6751badb4e35b3d621ca5b68818c15c8ca9d062c60d47d4f73bdba3cb8a6c";
       libraryHaskellDepends = [
         base bytestring conduit containers data-default idna
         publicsuffixlist text
       ];
       testHaskellDepends = [ base cereal HUnit publicsuffixlist ];
       jailbreak = true;
       homepage = "https://github.com/litherum/publicsuffixlist";
       description = "Create the publicsuffixlist package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pubnub" = callPackage
    ({ mkDerivation, aeson, async, base, base64-bytestring, bytestring
     , Cabal, cipher-aes, conduit, conduit-extra, crypto-api
     , crypto-cipher-types, data-default, http-client, http-conduit
     , http-types, HUnit, lifted-base, mtl, QuickCheck, SHA, smallcheck
     , tasty, tasty-hunit, tasty-quickcheck, tasty-smallcheck, text
     , time, transformers, uuid, vector
     }:
     mkDerivation {
       pname = "pubnub";
       version = "1.1.1";
       sha256 = "68c30c83902520791e50f4095711f99fd66611e6a218ce3cbe8f0cae5f718c32";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base base64-bytestring bytestring cipher-aes conduit
         conduit-extra crypto-api crypto-cipher-types data-default
         http-client http-conduit http-types lifted-base mtl SHA text time
         transformers uuid vector
       ];
       executableHaskellDepends = [
         aeson async base bytestring Cabal HUnit QuickCheck smallcheck tasty
         tasty-hunit tasty-quickcheck tasty-smallcheck text
       ];
       testHaskellDepends = [
         base Cabal HUnit QuickCheck smallcheck tasty tasty-hunit
         tasty-quickcheck tasty-smallcheck
       ];
       jailbreak = true;
       homepage = "http://github.com/pubnub/haskell";
       description = "PubNub Haskell SDK";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pubsub" = callPackage
    ({ mkDerivation, base, fastcgi, feed, HTTP, json, mime, network
     , random, utf8-string, xml
     }:
     mkDerivation {
       pname = "pubsub";
       version = "0.11";
       sha256 = "a85ea9dbdb2eba32c247fbc65d2355184a8e962548939c92081814fc17f3aa27";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base feed HTTP json mime network random utf8-string xml
       ];
       executableHaskellDepends = [ fastcgi ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/pubsub/";
       description = "A library for Google/SixApart pubsub hub interaction";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "puffytools" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring
     , console-program, containers, directory, MissingH, old-locale
     , QuickCheck, random-fu, safe, test-framework
     , test-framework-quickcheck2, text, time, vector
     }:
     mkDerivation {
       pname = "puffytools";
       version = "0.0.0.1";
       sha256 = "31b1268aa769ff474c47f08235350f193ac336b73409490e3118667a8766185f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty base bytestring containers directory MissingH
         random-fu safe text time vector
       ];
       executableHaskellDepends = [
         base bytestring console-program directory old-locale text time
         vector
       ];
       testHaskellDepends = [
         aeson base bytestring QuickCheck test-framework
         test-framework-quickcheck2 text time vector
       ];
       jailbreak = true;
       homepage = "https://github.com/pharpend/puffytools";
       description = "A CLI assistant";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pugixml" = callPackage
    ({ mkDerivation, base, bytestring, data-default-class, tasty
     , tasty-hunit, template-haskell
     }:
     mkDerivation {
       pname = "pugixml";
       version = "0.3.2";
       sha256 = "91247ef3eb722e917e5ec4b078b66ff3be0dee41848694ae644799d0d8e97b5f";
       libraryHaskellDepends = [
         base bytestring data-default-class template-haskell
       ];
       testHaskellDepends = [ base bytestring tasty tasty-hunit ];
       jailbreak = true;
       homepage = "https://github.com/philopon/pugixml-hs";
       description = "pugixml binding";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "pugs-DrIFT" = callPackage
    ({ mkDerivation, base, bytestring, containers, hashable, hashtables
     , HsSyck, mtl, old-time, pretty, random, stm, utf8-string
     }:
     mkDerivation {
       pname = "pugs-DrIFT";
       version = "2.2.3.20150815";
       sha256 = "10585b9889b5ab22736d7009b4565286f5e30edcc6c886f3ffd72fae96133e78";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers hashable hashtables HsSyck mtl old-time
         pretty random stm utf8-string
       ];
       executableHaskellDepends = [
         base bytestring containers hashable hashtables HsSyck mtl old-time
         pretty random stm utf8-string
       ];
       homepage = "http://pugscode.org/";
       description = "DrIFT with pugs-specific rules";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pugs-HsSyck" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "pugs-HsSyck";
       version = "0.41";
       sha256 = "e166bdd74b2b7a32b946adb196b04a7d9b0c8802d238f716a4f5fb811a740d81";
       libraryHaskellDepends = [ base bytestring ];
       description = "Fast, lightweight YAML loader and dumper";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pugs-compat" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , hashtables, mtl, network, process, random, regex-base
     , regex-pcre-builtin, stm, stringtable-atom, syb, time, unix
     , utf8-string
     }:
     mkDerivation {
       pname = "pugs-compat";
       version = "0.0.6.20150815";
       sha256 = "7eff41b243368d7e3e1b72ebb82b6f19033ad95358f19a5c0b354f081621dc40";
       libraryHaskellDepends = [
         array base bytestring containers directory hashtables mtl network
         process random regex-base regex-pcre-builtin stm stringtable-atom
         syb time unix utf8-string
       ];
       description = "Portable Haskell/POSIX layer for Pugs";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "pugs-hsregex" = callPackage
    ({ mkDerivation, array, base, haskell98 }:
     mkDerivation {
       pname = "pugs-hsregex";
       version = "1.0";
       sha256 = "718c000d32502a98d4026e695de0b60a09533fd19d5ea611179a3b75fec6a8df";
       libraryHaskellDepends = [ array base haskell98 ];
       homepage = "http://repetae.net/john/computer/haskell/hsregex/";
       description = "Haskell PCRE binding";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pulse-simple" = callPackage
    ({ mkDerivation, base, bytestring, libpulseaudio }:
     mkDerivation {
       pname = "pulse-simple";
       version = "0.1.14";
       sha256 = "84429d8b05f34be7f34cca59f361ededbc8c82e0c27f4acb8a155750ba6541ab";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ libpulseaudio ];
       description = "binding to Simple API of pulseaudio";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) libpulseaudio;};

  "punkt" = callPackage
    ({ mkDerivation, array, base, mtl, regex-tdfa, regex-tdfa-text
     , tasty, tasty-hunit, tasty-quickcheck, text, unordered-containers
     }:
     mkDerivation {
       pname = "punkt";
       version = "0.1.1";
       sha256 = "2b41929f615677277d15cbcd74725fe2edb0dd196a81667dd0df94fad6bc1942";
       libraryHaskellDepends = [
         array base mtl regex-tdfa regex-tdfa-text text unordered-containers
       ];
       testHaskellDepends = [
         base mtl regex-tdfa tasty tasty-hunit tasty-quickcheck text
       ];
       homepage = "https://github.com/bryant/punkt";
       description = "Multilingual unsupervised sentence tokenization with Punkt";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "punycode" = callPackage
    ({ mkDerivation, base, bytestring, cereal, encoding, HUnit, mtl
     , QuickCheck, text
     }:
     mkDerivation {
       pname = "punycode";
       version = "2.0";
       sha256 = "59072915dbd5f94d5cc2e6ac84061b329ab84a9f22fd18a591ad5fdba37b52a4";
       libraryHaskellDepends = [ base bytestring cereal mtl text ];
       testHaskellDepends = [
         base bytestring cereal encoding HUnit mtl QuickCheck text
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/litherum/punycode";
       description = "Encode unicode strings to ascii forms according to RFC 3492";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "puppetresources" = callPackage
    ({ mkDerivation, base, bytestring, containers, Diff, hsfacter
     , hslogger, language-puppet, mtl, text
     }:
     mkDerivation {
       pname = "puppetresources";
       version = "0.4.2";
       sha256 = "2b8bc4fc8cb08f919b8ca77feb14131f581832a06983b8025a509ed9afe39a18";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers Diff hsfacter hslogger language-puppet
         mtl text
       ];
       homepage = "http://lpuppet.banquise.net";
       description = "A program that displays the puppet resources associated to a node given .pp files.";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pure-cdb" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , mtl, test-simple, Unixutils, vector
     }:
     mkDerivation {
       pname = "pure-cdb";
       version = "0.1.2";
       sha256 = "25228a3052ad7f6cfc003569668c94c5ecaa7665a5e205b54f221bf42ff3f840";
       libraryHaskellDepends = [
         base binary bytestring containers directory mtl vector
       ];
       testHaskellDepends = [
         base bytestring containers mtl test-simple Unixutils vector
       ];
       homepage = "https://github.com/bosu/pure-cdb";
       description = "Another pure-haskell CDB (Constant Database) implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pure-fft" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "pure-fft";
       version = "0.2.0";
       sha256 = "91243a564912cf9f36e2eec381d715537e9bd43817b88b063ba0affedc56f9ff";
       libraryHaskellDepends = [ base ];
       description = "Fast Fourier Transform";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pure-io" = callPackage
    ({ mkDerivation, base, containers, mtl, safe }:
     mkDerivation {
       pname = "pure-io";
       version = "0.2.1";
       sha256 = "a9ef0f324ce29fecdcdb11f2ce0088bcf282951727d983824e05f12e519bfb5f";
       libraryHaskellDepends = [ base containers mtl safe ];
       description = "Pure IO monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pure-priority-queue" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "pure-priority-queue";
       version = "0.14";
       sha256 = "772cb853676ec634ee733745d77250a570d5cc3a0fc734a97bf758d3e5b4bb88";
       libraryHaskellDepends = [ base containers ];
       jailbreak = true;
       description = "A pure priority queue";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pure-priority-queue-tests" = callPackage
    ({ mkDerivation, base, containers, pure-priority-queue, QuickCheck
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "pure-priority-queue-tests";
       version = "0.12";
       sha256 = "6dc0c3c8486f7585194e3fa779d585b6fddca5da00776bc7edffde566f6ea29f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers pure-priority-queue QuickCheck test-framework
         test-framework-quickcheck2
       ];
       jailbreak = true;
       description = "Tests for the pure-priority-queue package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pure-zlib" = callPackage
    ({ mkDerivation, base, bytestring, containers, fingertree, HUnit
     , monadLib, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "pure-zlib";
       version = "0.4";
       sha256 = "0a9722791fb96fadec325b2e5b1e1f8c1a2ebedd53d0b7db5e6ec84eaf6cd3c1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers fingertree monadLib
       ];
       executableHaskellDepends = [ base bytestring ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "http://github.com/GaloisInc/pure-zlib";
       description = "A Haskell-only implementation of zlib / DEFLATE";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pureMD5" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, crypto-api
     , tagged
     }:
     mkDerivation {
       pname = "pureMD5";
       version = "2.1.2.1";
       sha256 = "6768174686d5eaef76b487f6f8160a932c48012668fbe542e7aba489134956ff";
       libraryHaskellDepends = [
         base binary bytestring cereal crypto-api tagged
       ];
       description = "A Haskell-only implementation of the MD5 digest (hash) algorithm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "purescript_0_7_2_0" = callPackage
    ({ mkDerivation, aeson, aeson-better-errors, ansi-wl-pprint, base
     , bower-json, boxes, bytestring, containers, directory, dlist
     , filepath, Glob, haskeline, HUnit, language-javascript, mtl
     , optparse-applicative, parsec, pattern-arrows, process, safe
     , semigroups, split, syb, text, time, transformers
     , transformers-compat, unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "purescript";
       version = "0.7.2.0";
       sha256 = "d3a8f4bdbb658e33576cec3b940fe53c1b1b1ad5b0047654b55203a682053d37";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-better-errors base bower-json boxes bytestring
         containers directory dlist filepath Glob language-javascript mtl
         parsec pattern-arrows process safe semigroups split syb text time
         transformers transformers-compat unordered-containers utf8-string
         vector
       ];
       executableHaskellDepends = [
         aeson ansi-wl-pprint base bytestring containers directory filepath
         Glob haskeline mtl optparse-applicative parsec process split time
         transformers transformers-compat
       ];
       testHaskellDepends = [
         base containers directory filepath Glob haskeline HUnit mtl
         optparse-applicative parsec process time transformers
         transformers-compat
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.purescript.org/";
       description = "PureScript Programming Language Compiler";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "purescript_0_7_3_0" = callPackage
    ({ mkDerivation, aeson, aeson-better-errors, ansi-wl-pprint, base
     , bower-json, boxes, bytestring, containers, directory, dlist
     , filepath, Glob, haskeline, HUnit, language-javascript, mtl
     , optparse-applicative, parsec, pattern-arrows, process, safe
     , semigroups, split, syb, text, time, transformers
     , transformers-compat, unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "purescript";
       version = "0.7.3.0";
       sha256 = "27d9e4bd3061a2b64e10d4d7c140b2debd786772309aa36e0b7fdaa49b42b5c0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-better-errors base bower-json boxes bytestring
         containers directory dlist filepath Glob language-javascript mtl
         parsec pattern-arrows process safe semigroups split syb text time
         transformers transformers-compat unordered-containers utf8-string
         vector
       ];
       executableHaskellDepends = [
         aeson ansi-wl-pprint base bytestring containers directory filepath
         Glob haskeline mtl optparse-applicative parsec process split time
         transformers transformers-compat
       ];
       testHaskellDepends = [
         base containers directory filepath Glob haskeline HUnit mtl
         optparse-applicative parsec process time transformers
         transformers-compat
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.purescript.org/";
       description = "PureScript Programming Language Compiler";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "purescript_0_7_4_1" = callPackage
    ({ mkDerivation, aeson, aeson-better-errors, ansi-wl-pprint, base
     , bower-json, boxes, bytestring, containers, directory, dlist
     , filepath, Glob, haskeline, HUnit, language-javascript, mtl
     , optparse-applicative, parsec, pattern-arrows, process, safe
     , semigroups, split, syb, text, time, transformers
     , transformers-compat, unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "purescript";
       version = "0.7.4.1";
       sha256 = "82d41cbde580e86620d18d03f38508b2d5f0c1ce4719ac62f3ea2bbe35ee4b9f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-better-errors base bower-json boxes bytestring
         containers directory dlist filepath Glob language-javascript mtl
         parsec pattern-arrows process safe semigroups split syb text time
         transformers transformers-compat unordered-containers utf8-string
         vector
       ];
       executableHaskellDepends = [
         aeson ansi-wl-pprint base bytestring containers directory filepath
         Glob haskeline mtl optparse-applicative parsec process split time
         transformers transformers-compat
       ];
       testHaskellDepends = [
         base containers directory filepath Glob haskeline HUnit mtl
         optparse-applicative parsec process time transformers
         transformers-compat
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.purescript.org/";
       description = "PureScript Programming Language Compiler";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "purescript_0_7_5_3" = callPackage
    ({ mkDerivation, aeson, aeson-better-errors, ansi-wl-pprint, base
     , bower-json, boxes, bytestring, containers, directory, dlist
     , filepath, Glob, haskeline, HUnit, language-javascript
     , lifted-base, monad-control, mtl, optparse-applicative, parsec
     , pattern-arrows, process, safe, semigroups, split, syb, text, time
     , transformers, transformers-base, transformers-compat
     , unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "purescript";
       version = "0.7.5.3";
       sha256 = "7388010e4d4ca350114c71b59b1f86062edf62b05b14c968464243814f68b4a4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-better-errors base bower-json boxes bytestring
         containers directory dlist filepath Glob language-javascript
         lifted-base monad-control mtl parsec pattern-arrows process safe
         semigroups split syb text time transformers transformers-base
         transformers-compat unordered-containers utf8-string vector
       ];
       executableHaskellDepends = [
         aeson ansi-wl-pprint base bytestring containers directory filepath
         Glob haskeline mtl optparse-applicative parsec process split time
         transformers transformers-compat
       ];
       testHaskellDepends = [
         base containers directory filepath Glob haskeline HUnit mtl
         optparse-applicative parsec process time transformers
         transformers-compat
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.purescript.org/";
       description = "PureScript Programming Language Compiler";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "purescript_0_7_5_4" = callPackage
    ({ mkDerivation, aeson, aeson-better-errors, ansi-wl-pprint, base
     , bower-json, boxes, bytestring, containers, directory, dlist
     , filepath, Glob, haskeline, HUnit, language-javascript
     , lifted-base, monad-control, mtl, optparse-applicative, parsec
     , pattern-arrows, process, safe, semigroups, split, syb, text, time
     , transformers, transformers-base, transformers-compat
     , unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "purescript";
       version = "0.7.5.4";
       sha256 = "36e3301e0f7d3cce24272b853acc93bba826f42dc3071dc4f7a7a65d1c7cddb5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-better-errors base bower-json boxes bytestring
         containers directory dlist filepath Glob language-javascript
         lifted-base monad-control mtl parsec pattern-arrows process safe
         semigroups split syb text time transformers transformers-base
         transformers-compat unordered-containers utf8-string vector
       ];
       executableHaskellDepends = [
         aeson ansi-wl-pprint base bytestring containers directory filepath
         Glob haskeline mtl optparse-applicative parsec process split time
         transformers transformers-compat
       ];
       testHaskellDepends = [
         base containers directory filepath Glob haskeline HUnit mtl
         optparse-applicative parsec process time transformers
         transformers-compat
       ];
       doCheck = false;
       homepage = "http://www.purescript.org/";
       description = "PureScript Programming Language Compiler";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "purescript_0_7_6_1" = callPackage
    ({ mkDerivation, aeson, aeson-better-errors, ansi-wl-pprint, base
     , base-compat, bower-json, boxes, bytestring, containers, directory
     , dlist, filepath, Glob, haskeline, HUnit, language-javascript
     , lifted-base, monad-control, mtl, optparse-applicative, parallel
     , parsec, pattern-arrows, process, safe, semigroups, split, syb
     , text, time, transformers, transformers-base, transformers-compat
     , unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "purescript";
       version = "0.7.6.1";
       sha256 = "c496d71ff11daed7b481fd563c93ee1e55415eeae2f9f759934c07468333f770";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-better-errors base base-compat bower-json boxes
         bytestring containers directory dlist filepath Glob
         language-javascript lifted-base monad-control mtl parallel parsec
         pattern-arrows process safe semigroups split syb text time
         transformers transformers-base transformers-compat
         unordered-containers utf8-string vector
       ];
       executableHaskellDepends = [
         aeson ansi-wl-pprint base base-compat boxes bytestring containers
         directory filepath Glob haskeline mtl optparse-applicative parsec
         process split time transformers transformers-compat
       ];
       testHaskellDepends = [
         base base-compat boxes containers directory filepath Glob haskeline
         HUnit mtl optparse-applicative parsec process time transformers
         transformers-compat
       ];
       doCheck = false;
       homepage = "http://www.purescript.org/";
       description = "PureScript Programming Language Compiler";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "purescript" = callPackage
    ({ mkDerivation, aeson, aeson-better-errors, ansi-wl-pprint, base
     , base-compat, bower-json, boxes, bytestring, containers, directory
     , dlist, filepath, Glob, haskeline, HUnit, language-javascript
     , lifted-base, monad-control, mtl, optparse-applicative, parallel
     , parsec, pattern-arrows, process, safe, semigroups, split, syb
     , text, time, transformers, transformers-base, transformers-compat
     , unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "purescript";
       version = "0.8.0.0";
       sha256 = "a263933c4ae407f2c97e230d08ab343f597e101a597f7fa01151b0b476ce43d0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-better-errors base base-compat bower-json boxes
         bytestring containers directory dlist filepath Glob
         language-javascript lifted-base monad-control mtl parallel parsec
         pattern-arrows process safe semigroups split syb text time
         transformers transformers-base transformers-compat
         unordered-containers utf8-string vector
       ];
       executableHaskellDepends = [
         aeson ansi-wl-pprint base base-compat boxes bytestring containers
         directory filepath Glob haskeline mtl optparse-applicative parsec
         process split time transformers transformers-compat utf8-string
       ];
       testHaskellDepends = [
         aeson aeson-better-errors base base-compat boxes bytestring
         containers directory filepath Glob haskeline HUnit mtl
         optparse-applicative parsec process time transformers
         transformers-compat
       ];
       doCheck = false;
       homepage = "http://www.purescript.org/";
       description = "PureScript Programming Language Compiler";
       license = stdenv.lib.licenses.mit;
     }) {};

  "purescript-bundle-fast" = callPackage
    ({ mkDerivation, base, containers, directory, filepath
     , optparse-applicative, text, vector
     }:
     mkDerivation {
       pname = "purescript-bundle-fast";
       version = "0.1.0.1";
       sha256 = "dc51a7d37608062267b79c15516c631019dcfca3f27865bf1ff9deb22c592d69";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath optparse-applicative text vector
       ];
       homepage = "https://github.com/bitc/purescript-bundle-fast";
       description = "A fast alternative to Purescript's `psc-bundle` to be used during development";
       license = stdenv.lib.licenses.mit;
     }) {};

  "push-notify" = callPackage
    ({ mkDerivation, aeson, async, attoparsec-conduit, base
     , base16-bytestring, bytestring, cereal, certificate, conduit
     , connection, containers, convertible, cprng-aes, data-default
     , http-client, http-conduit, http-types, monad-control, mtl
     , network, resourcet, retry, stm, text, time, tls, tls-extra
     , transformers, unordered-containers, xml-conduit
     }:
     mkDerivation {
       pname = "push-notify";
       version = "0.1.0.1";
       sha256 = "5a3e29c0f88329a54a2951b6097342126f3b06170aeed3193029485f8a6649b1";
       libraryHaskellDepends = [
         aeson async attoparsec-conduit base base16-bytestring bytestring
         cereal certificate conduit connection containers convertible
         cprng-aes data-default http-client http-conduit http-types
         monad-control mtl network resourcet retry stm text time tls
         tls-extra transformers unordered-containers xml-conduit
       ];
       homepage = "http://gsoc2013cwithmobiledevices.blogspot.com.ar/";
       description = "A server-side library for sending push notifications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "push-notify-ccs" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, bytestring
     , cprng-aes, crypto-random, data-default, hslogger, mtl, network
     , pontarius-xmpp, push-notify, retry, stm, text, tls, tls-extra
     , unordered-containers, xml-types
     }:
     mkDerivation {
       pname = "push-notify-ccs";
       version = "0.1.0.1";
       sha256 = "80afd1275933f8f30e1236e75849b7832636385248d0aa3d1d60693617fbf7b9";
       libraryHaskellDepends = [
         aeson async attoparsec base bytestring cprng-aes crypto-random
         data-default hslogger mtl network pontarius-xmpp push-notify retry
         stm text tls tls-extra unordered-containers xml-types
       ];
       homepage = "http://gsoc2013cwithmobiledevices.blogspot.com.ar/";
       description = "A server-side library for sending/receiving push notifications through CCS (Google Cloud Messaging)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "push-notify-general" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, data-default
     , hashable, http-client, http-conduit, http-types, push-notify
     , push-notify-ccs, text, unordered-containers, xml-conduit, yesod
     }:
     mkDerivation {
       pname = "push-notify-general";
       version = "0.1.0.1";
       sha256 = "b0dddd9a7c72c2703ec583ac35369a4fd18a8c5568abe5bb1d5ad43ec619dc6f";
       libraryHaskellDepends = [
         aeson base bytestring containers data-default hashable http-client
         http-conduit http-types push-notify push-notify-ccs text
         unordered-containers xml-conduit yesod
       ];
       homepage = "http://gsoc2013cwithmobiledevices.blogspot.com.ar/";
       description = "A general library for sending/receiving push notif. through dif. services.";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pusher-haskell" = callPackage
    ({ mkDerivation, aeson, base, bytestring, hspec, HTTP, MissingH
     , mtl, SHA, time
     }:
     mkDerivation {
       pname = "pusher-haskell";
       version = "0.1.0.0";
       sha256 = "26cee78343604825ff8b2426ab55a7f05787409050ffd29a6f4dd539d411b27a";
       libraryHaskellDepends = [
         aeson base bytestring HTTP MissingH mtl SHA time
       ];
       testHaskellDepends = [ base hspec ];
       jailbreak = true;
       homepage = "http://www.github.com/sidraval/pusher-haskell";
       description = "A Pusher.com client written in Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pusher-http-haskell_0_3_0_1" = callPackage
    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
     , containers, cryptohash, hashable, hspec, http-client, http-types
     , mtl, QuickCheck, snap-core, snap-server, text, time, transformers
     , unordered-containers, yaml
     }:
     mkDerivation {
       pname = "pusher-http-haskell";
       version = "0.3.0.1";
       sha256 = "b71151cf6b8e39e0025930d393bde031693270b536e37af23b9c425b290bf3dc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base16-bytestring bytestring cryptohash hashable
         http-client http-types mtl QuickCheck text time transformers
         unordered-containers
       ];
       executableHaskellDepends = [
         aeson base bytestring containers mtl snap-core snap-server text
         transformers unordered-containers yaml
       ];
       testHaskellDepends = [
         aeson base bytestring hspec http-client http-types mtl QuickCheck
         text transformers unordered-containers
       ];
       homepage = "https://github.com/pusher-community/pusher-http-haskell";
       description = "Haskell client library for the Pusher HTTP API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pusher-http-haskell" = callPackage
    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
     , containers, cryptohash, hashable, hspec, http-client, http-types
     , mtl, QuickCheck, snap-core, snap-server, text, time, transformers
     , unordered-containers, yaml
     }:
     mkDerivation {
       pname = "pusher-http-haskell";
       version = "0.3.0.2";
       sha256 = "72ce2a76a802d6c866ea0630fde7711b0298929113609998e0ec1dd733fb8098";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base16-bytestring bytestring cryptohash hashable
         http-client http-types mtl QuickCheck text time transformers
         unordered-containers
       ];
       executableHaskellDepends = [
         aeson base bytestring containers mtl snap-core snap-server text
         transformers unordered-containers yaml
       ];
       testHaskellDepends = [
         aeson base bytestring hspec http-client http-types mtl QuickCheck
         text transformers unordered-containers
       ];
       homepage = "https://github.com/pusher-community/pusher-http-haskell";
       description = "Haskell client library for the Pusher HTTP API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "pushme" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, deepseq
     , hslogger, io-storage, lens, old-locale, optparse-applicative
     , parallel-io, pointless-fun, regex-posix, shelly, system-fileio
     , system-filepath, text, text-format, time, unix
     , unordered-containers, yaml
     }:
     mkDerivation {
       pname = "pushme";
       version = "1.5.0";
       sha256 = "8d44eb63f4bee35e9474851816085317316008152ca16203338b9b0d2e28c332";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring containers deepseq hslogger io-storage lens
         old-locale optparse-applicative parallel-io pointless-fun
         regex-posix shelly system-fileio system-filepath text text-format
         time unix unordered-containers yaml
       ];
       homepage = "https://github.com/jwiegley/pushme";
       description = "Tool to synchronize multiple directories with rsync, zfs or git-annex";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "putlenses" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, lens, mtl, QuickCheck
     , random, safe, split, template-haskell, transformers
     }:
     mkDerivation {
       pname = "putlenses";
       version = "0.1.3";
       sha256 = "d7b9ee24bdb23e40fddfaf2446d035920a108e1e12683dc7a9e3e5d09ceb7094";
       libraryHaskellDepends = [
         base containers ghc-prim lens mtl QuickCheck random safe split
         template-haskell transformers
       ];
       jailbreak = true;
       description = "Put-based lens library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "puzzle-draw" = callPackage
    ({ mkDerivation, aeson, base, blaze-svg, bytestring, containers
     , deepseq, diagrams-lib, diagrams-svg, filepath, hashable, mtl
     , optparse-applicative, parsec, SVGFonts, tasty, tasty-hunit, text
     , unordered-containers, vector-space, yaml
     }:
     mkDerivation {
       pname = "puzzle-draw";
       version = "0.1.0.4";
       sha256 = "118edc89b2a1bcdb9c5ce93c475eeb173709308d25e668875374a69214116c49";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base containers diagrams-lib diagrams-svg filepath hashable
         mtl optparse-applicative parsec SVGFonts text unordered-containers
         vector-space yaml
       ];
       executableHaskellDepends = [
         aeson base diagrams-lib diagrams-svg filepath optparse-applicative
         yaml
       ];
       testHaskellDepends = [
         base blaze-svg bytestring containers deepseq diagrams-lib
         diagrams-svg tasty tasty-hunit text yaml
       ];
       description = "Creating graphics for pencil puzzles";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "puzzle-draw-cmdline" = callPackage
    ({ mkDerivation, aeson, base, diagrams-lib, diagrams-svg, filepath
     , optparse-applicative, puzzle-draw, yaml
     }:
     mkDerivation {
       pname = "puzzle-draw-cmdline";
       version = "0.1.0.4";
       sha256 = "aeffe77abfc9a6563ee5ed81f93f00e0b7d21d6dae4dc3882b6a2564a27a604b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base diagrams-lib diagrams-svg filepath optparse-applicative
         puzzle-draw yaml
       ];
       jailbreak = true;
       description = "Creating graphics for pencil puzzles, command line tools";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "pvd" = callPackage
    ({ mkDerivation, array, base, Codec-Image-DevIL, containers
     , haskell98, libdevil, mtl, network, stm, X11
     }:
     mkDerivation {
       pname = "pvd";
       version = "1.1.1";
       sha256 = "79c3140a36e87a44eee930e5ef0360be127543951f3b46579ccbd36607d414a2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base Codec-Image-DevIL containers haskell98 mtl network stm
         X11
       ];
       executableSystemDepends = [ libdevil ];
       homepage = "http://code.haskell.org/pvd";
       description = "A photo viewer daemon application with remote controlling abilities";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libdevil;};

  "pwstore-cli" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, HUnit, process
     , pwstore-fast, test-framework, test-framework-hunit, text
     }:
     mkDerivation {
       pname = "pwstore-cli";
       version = "0.4";
       sha256 = "59a2d7d748858d20365c5c1cf95ff4c843ae47a29229499aa038bab848108bb3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs pwstore-fast text
       ];
       testHaskellDepends = [
         base bytestring HUnit process pwstore-fast test-framework
         test-framework-hunit
       ];
       homepage = "http://hub.darcs.net/rycee/pwstore-cli";
       description = "Command line interface for the pwstore library";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "pwstore-fast" = callPackage
    ({ mkDerivation, base, base64-bytestring, binary, byteable
     , bytestring, cryptohash, random
     }:
     mkDerivation {
       pname = "pwstore-fast";
       version = "2.4.4";
       sha256 = "7219af66b6f762d9dd5376b3b25393d4d6626e390e9d9c9f87f6e3f13ea7fbb2";
       libraryHaskellDepends = [
         base base64-bytestring binary byteable bytestring cryptohash random
       ];
       homepage = "https://github.com/PeterScott/pwstore";
       description = "Secure password storage";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pwstore-purehaskell" = callPackage
    ({ mkDerivation, base, base64-bytestring, byteable, bytestring
     , random, SHA
     }:
     mkDerivation {
       pname = "pwstore-purehaskell";
       version = "2.1.4";
       sha256 = "2cdd7039f1b6880d8f4f2eac44f4f4ce10c7c8286a6493f45a4c47c41fadf4bc";
       libraryHaskellDepends = [
         base base64-bytestring byteable bytestring random SHA
       ];
       homepage = "https://github.com/PeterScott/pwstore";
       description = "Secure password storage, in pure Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "pxsl-tools" = callPackage
    ({ mkDerivation, base, containers, mtl, parsec }:
     mkDerivation {
       pname = "pxsl-tools";
       version = "1.0.1";
       sha256 = "dc311c012b0b6b482cdd26337f44cff8259269d3dd83f482ab4049965fa085e0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers mtl parsec ];
       homepage = "http://community.moertel.com/ss/space/PXSL";
       description = "Parsimonious XML Shorthand Language--to-XML compiler";
       license = "GPL";
     }) {};

  "pyffi" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, pureMD5
     , python, template-haskell
     }:
     mkDerivation {
       pname = "pyffi";
       version = "0.4.0.2";
       sha256 = "1095168ed4d95618613799aa7375a8752436b0eee568834ea8b469081aa0ff32";
       libraryHaskellDepends = [
         aeson base bytestring containers pureMD5 template-haskell
       ];
       libraryPkgconfigDepends = [ python ];
       jailbreak = true;
       homepage = "http://github.com/Russell91/json-python";
       description = "Call python inline from haskell";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) python;};

  "pyfi" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, pureMD5
     , python, template-haskell
     }:
     mkDerivation {
       pname = "pyfi";
       version = "0.4.0.4";
       sha256 = "fcc5be24ad5a32e208a5f3d3908056f1ee93814d2234f6b7176eb61018b40577";
       libraryHaskellDepends = [
         aeson base bytestring containers pureMD5 template-haskell
       ];
       libraryPkgconfigDepends = [ python ];
       jailbreak = true;
       homepage = "http://github.com/Russell91/pyfi";
       description = "Call python inline from haskell";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) python;};

  "python-pickle" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, cereal, cmdargs
     , containers, mtl
     }:
     mkDerivation {
       pname = "python-pickle";
       version = "0.2.0";
       sha256 = "e5406a2e8fa753e61656e4ecc27291919a2ec404d280400c31dbc9a431aff75c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring cereal containers mtl
       ];
       executableHaskellDepends = [ base bytestring cmdargs ];
       jailbreak = true;
       description = "Serialization/deserialization using Python Pickle format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "qc-oi-testgenerator" = callPackage
    ({ mkDerivation, base, fclabels, QuickCheck, template-haskell }:
     mkDerivation {
       pname = "qc-oi-testgenerator";
       version = "1.2.0.3";
       sha256 = "6f6bcb3f94db90eee136ea483b223e0fe952663474d90f47dfd888af60512f8f";
       libraryHaskellDepends = [
         base fclabels QuickCheck template-haskell
       ];
       jailbreak = true;
       homepage = "http://www.iai.uni-bonn.de/~jv/GV14.html";
       description = "Compile time generation of operation invariance tests for QuickCheck";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "qd" = callPackage
    ({ mkDerivation, base, floatshow, qd }:
     mkDerivation {
       pname = "qd";
       version = "1.0.2.1";
       sha256 = "28a47bce34fb2d56d034be0a1fffc18f9dbf3e502a4ea12c8ed8b0c56e6e1b36";
       libraryHaskellDepends = [ base floatshow ];
       librarySystemDepends = [ qd ];
       description = "double-double and quad-double number type via libqd";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {qd = null;};

  "qd-vec" = callPackage
    ({ mkDerivation, base, qd, Vec }:
     mkDerivation {
       pname = "qd-vec";
       version = "1.1";
       sha256 = "cc7a5105235245e19a78fec0965eaf1d9e29564f43c40d6f42934da9c19b4552";
       libraryHaskellDepends = [ base qd Vec ];
       description = "'Vec' instances for 'qd' types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "qed" = callPackage
    ({ mkDerivation, base, deepseq, directory, exceptions, extra
     , filepath, haskell-src-exts, transformers, uniplate
     }:
     mkDerivation {
       pname = "qed";
       version = "0.0";
       sha256 = "282422e8e277ef9dd3175f1b9a97f6843187a12928886c8783f0eeb5a1819ace";
       libraryHaskellDepends = [
         base deepseq directory exceptions extra filepath haskell-src-exts
         transformers uniplate
       ];
       testHaskellDepends = [ base transformers ];
       homepage = "https://github.com/ndmitchell/qed#readme";
       description = "Simple prover";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "qhull-simple" = callPackage
    ({ mkDerivation, base, qhull, vector }:
     mkDerivation {
       pname = "qhull-simple";
       version = "0.1";
       sha256 = "5c0bb4d8285e664683e636326f82f57b053527f5f31c1644d5dea65f185e0a3c";
       libraryHaskellDepends = [ base vector ];
       librarySystemDepends = [ qhull ];
       homepage = "http://nonempty.org/software/haskell-qhull-simple";
       description = "Simple bindings to Qhull, a library for computing convex hulls";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) qhull;};

  "qrcode" = callPackage
    ({ mkDerivation, array, base, containers, mtl, vector }:
     mkDerivation {
       pname = "qrcode";
       version = "0.1.2";
       sha256 = "2da96151e20a732b696004ada7605a036a598e6d1c60aca67d4ce26c3eedd6f1";
       libraryHaskellDepends = [ array base containers mtl vector ];
       description = "QR Code library in pure Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "qt" = callPackage
    ({ mkDerivation, base, OpenGL, qtc_core, qtc_gui, qtc_network
     , qtc_opengl, qtc_script, qtc_tools
     }:
     mkDerivation {
       pname = "qt";
       version = "1.1.6.1";
       sha256 = "64d3d24dbdace1a10aaafb24f943b3d4ac8dd0e6eaf1750c4347995a9a153f82";
       libraryHaskellDepends = [ base OpenGL ];
       librarySystemDepends = [
         qtc_core qtc_gui qtc_network qtc_opengl qtc_script qtc_tools
       ];
       homepage = "http://github.com/keerastudios/hsQt";
       description = "Qt bindings";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {qtc_core = null; qtc_gui = null; qtc_network = null; 
         qtc_opengl = null; qtc_script = null; qtc_tools = null;};

  "quadratic-irrational" = callPackage
    ({ mkDerivation, arithmoi, base, containers, directory, doctest
     , filepath, mtl, numbers, QuickCheck, tasty, tasty-quickcheck
     , transformers
     }:
     mkDerivation {
       pname = "quadratic-irrational";
       version = "0.0.5";
       sha256 = "bfd9b93b693bcf30acd3bbfc093fda16fc8952779c8698b03b5d937e110e2afd";
       libraryHaskellDepends = [
         arithmoi base containers mtl transformers
       ];
       testHaskellDepends = [
         base directory doctest filepath mtl numbers QuickCheck tasty
         tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "https://github.com/ion1/quadratic-irrational";
       description = "An implementation of quadratic irrationals";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quandl-api_0_2_0_0" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring
     , http-conduit, http-types, old-locale, syb, text, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "quandl-api";
       version = "0.2.0.0";
       sha256 = "73ac498a3b6486083a3f77439db8044d9082bb558a1d5772e20d2dad7982cfc0";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring http-conduit http-types
         old-locale syb text time unordered-containers
       ];
       homepage = "https://github.com/pvdbrand/quandl-api";
       description = "Quandl.com API library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quandl-api" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring
     , http-conduit, http-types, syb, text, time, time-locale-compat
     , unordered-containers
     }:
     mkDerivation {
       pname = "quandl-api";
       version = "0.2.1.0";
       sha256 = "0e6b4479d01fd6d5e1f69a512345c7672fc5bc40651f8d1283832a5fcfe3b206";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring http-conduit http-types syb
         text time time-locale-compat unordered-containers
       ];
       homepage = "https://github.com/pvdbrand/quandl-api";
       description = "Quandl.com API library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quantfin" = callPackage
    ({ mkDerivation, base, containers, mersenne-random-pure64, mtl
     , random, random-fu, random-source, rvar, transformers, vector
     }:
     mkDerivation {
       pname = "quantfin";
       version = "0.2.0.0";
       sha256 = "2a9ba531decec76ceb81f12ac8a58a1418678c47714ce728cd3c8cffecac3c69";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mersenne-random-pure64 mtl random random-fu
         random-source rvar transformers vector
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/boundedvariation/quantfin";
       description = "Quant finance library in pure Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quantities" = callPackage
    ({ mkDerivation, base, containers, doctest, Glob, hlint, hspec, mtl
     , parsec, process, regex-compat
     }:
     mkDerivation {
       pname = "quantities";
       version = "0.4.0";
       sha256 = "603ef0d1bb4102533ef4221cc5ac533050fb430a3413ec8c7a1bfe707fc7491c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers mtl parsec ];
       executableHaskellDepends = [ base containers mtl parsec ];
       testHaskellDepends = [
         base containers doctest Glob hlint hspec mtl parsec process
         regex-compat
       ];
       homepage = "http://github.com/jdreaver/quantities";
       description = "Unit conversion and manipulation library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quantum-arrow" = callPackage
    ({ mkDerivation, base, MonadRandom, mtl, QuickCheck, random }:
     mkDerivation {
       pname = "quantum-arrow";
       version = "0.0.5";
       sha256 = "9c3f37a790d9372357252dabee6313a9be8c3643a7f5010478407ccb2558e5a7";
       libraryHaskellDepends = [ base MonadRandom mtl QuickCheck random ];
       jailbreak = true;
       homepage = "http://github.com/luqui/quantum-arrow";
       description = "An embedding of quantum computation as a Haskell arrow";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "qudb" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, directory, happy
     , mtl, snappy
     }:
     mkDerivation {
       pname = "qudb";
       version = "0.0.1";
       sha256 = "9801d7120676a593253fd9821dd90b9472cad58159348dc53ca86c5cc68cfb32";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring directory mtl snappy
       ];
       executableToolDepends = [ alex happy ];
       homepage = "https://github.com/jstepien/qudb";
       description = "Quite Useless DB";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quenya-verb" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cmdargs, cond, containers
     , directory, iproute, MissingH, network, safe, scotty, text
     , transformers, wai, wai-extra, wai-middleware-static, warp
     }:
     mkDerivation {
       pname = "quenya-verb";
       version = "0.0.1";
       sha256 = "5def72995937385178337e3307236e5fd71cb46709a61ce7a90064543d2e817f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring cmdargs cond containers directory iproute
         MissingH network safe scotty text transformers wai wai-extra
         wai-middleware-static warp
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       description = "Quenya verb conjugator";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "querystring-pickle" = callPackage
    ({ mkDerivation, base, bytestring, QuickCheck, test-framework
     , test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "querystring-pickle";
       version = "0.2.0";
       sha256 = "2eb3f87b9bae027d8e557c28e539e971adb62558489e18191a570f1c8e397ea1";
       libraryHaskellDepends = [ base bytestring text ];
       testHaskellDepends = [
         base bytestring QuickCheck test-framework
         test-framework-quickcheck2
       ];
       description = "Picklers for de/serialising Generic data types to and from query strings";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "questioner" = callPackage
    ({ mkDerivation, ansi-terminal, base, readline, terminal-size }:
     mkDerivation {
       pname = "questioner";
       version = "0.1.1.0";
       sha256 = "83ab4047671f59832eaa377e3fb3fce547439550f57479dd09e0ad4975250617";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base readline terminal-size
       ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/yamadapc/haskell-questioner.git";
       description = "A package for prompting values from the command-line";
       license = stdenv.lib.licenses.mit;
     }) {};

  "queue" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "queue";
       version = "0.1.2";
       sha256 = "c799ec386f79c4b3ab0c81feabe5335f7808044c0a525340e3c26b21e7d6a23b";
       libraryHaskellDepends = [ base stm ];
       homepage = "http://code.haskell.org/~mokus/queue";
       description = "Abstraction typeclasses for queue-like things";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "queuelike" = callPackage
    ({ mkDerivation, array, base, containers, mtl, stateful-mtl }:
     mkDerivation {
       pname = "queuelike";
       version = "1.0.9";
       sha256 = "3f38e9218db0fb4549fa116d2e7606d7ad0c42f8242292ecfd2cf3522c4d7a5b";
       libraryHaskellDepends = [ array base containers mtl stateful-mtl ];
       description = "A library of queuelike data structures, both functional and stateful";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quick-generator" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "quick-generator";
       version = "0.3";
       sha256 = "d63ce00477ad46d970ab422f239c955331e7f560d22b94eca8730130eaf68cad";
       libraryHaskellDepends = [ base QuickCheck ];
       description = "Generator random test data for QuickCheck";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quick-schema" = callPackage
    ({ mkDerivation, aeson, base, hashable, hspec, QuickCheck
     , scientific, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "quick-schema";
       version = "0.1.0.0";
       sha256 = "99d2e8e25a822063c997681180c4bcb602895785c9740a9756f92c9f5bdc8e6d";
       libraryHaskellDepends = [
         aeson base hashable scientific text unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base hspec QuickCheck scientific text unordered-containers
         vector
       ];
       homepage = "https://github.com/benweitzman/quick-schema";
       description = "Slimmed down json schema language and validator";
       license = stdenv.lib.licenses.mit;
     }) {};

  "quickcheck-assertions_0_1_1" = callPackage
    ({ mkDerivation, base, hspec, ieee754, QuickCheck }:
     mkDerivation {
       pname = "quickcheck-assertions";
       version = "0.1.1";
       sha256 = "416831634cef13831540a3acd951ccf43e4fc3bd86a366983dcf3ac54fc83643";
       libraryHaskellDepends = [ base ieee754 QuickCheck ];
       testHaskellDepends = [ base hspec ieee754 QuickCheck ];
       homepage = "https://github.com/s9gf4ult/quickcheck-assertions";
       description = "HUnit like assertions for QuickCheck";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quickcheck-assertions" = callPackage
    ({ mkDerivation, base, hspec, ieee754, QuickCheck }:
     mkDerivation {
       pname = "quickcheck-assertions";
       version = "0.2.0";
       sha256 = "600fbafab414f5fba7df40a10635aa407d3af8de3938a6c2866bf80f0952f740";
       libraryHaskellDepends = [ base ieee754 QuickCheck ];
       testHaskellDepends = [ base hspec ieee754 QuickCheck ];
       homepage = "https://github.com/s9gf4ult/quickcheck-assertions";
       description = "HUnit like assertions for QuickCheck";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "quickcheck-instances_0_3_9" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, hashable
     , old-time, QuickCheck, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "quickcheck-instances";
       version = "0.3.9";
       sha256 = "a618b0bce74594b060eb38e6fcc1479e71b91579a20374abb298a837435b15a8";
       libraryHaskellDepends = [
         array base bytestring containers hashable old-time QuickCheck text
         time unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/aslatter/qc-instances";
       description = "Common quickcheck instances";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quickcheck-instances_0_3_10" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, hashable
     , old-time, QuickCheck, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "quickcheck-instances";
       version = "0.3.10";
       sha256 = "deec709154ec4a1aca82ce62e288d69816534d8719264c98d00ef090f5bb130b";
       libraryHaskellDepends = [
         array base bytestring containers hashable old-time QuickCheck text
         time unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/aslatter/qc-instances";
       description = "Common quickcheck instances";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quickcheck-instances_0_3_11" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, hashable
     , old-time, QuickCheck, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "quickcheck-instances";
       version = "0.3.11";
       sha256 = "02962005e51d77b84e94dd0a8f3f1be89af6e8099d25e6c0bf417f364c323a10";
       revision = "1";
       editedCabalFile = "b87744a86ad200cf18eb3df19a1729cd93df3e87eea5e861881135e03d9c4f4c";
       libraryHaskellDepends = [
         array base bytestring containers hashable old-time QuickCheck text
         time unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/aslatter/qc-instances";
       description = "Common quickcheck instances";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quickcheck-instances" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, hashable
     , old-time, QuickCheck, scientific, text, time
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "quickcheck-instances";
       version = "0.3.12";
       sha256 = "ddd5b988da50eff7f56737bff516fba52309f7461297698f04f1e8aaee9f9bf3";
       libraryHaskellDepends = [
         array base bytestring containers hashable old-time QuickCheck
         scientific text time unordered-containers vector
       ];
       homepage = "https://github.com/aslatter/qc-instances";
       description = "Common quickcheck instances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quickcheck-io_0_1_1" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck }:
     mkDerivation {
       pname = "quickcheck-io";
       version = "0.1.1";
       sha256 = "a23a6e011aafd211c2521ddb9f61ffb5d256837148b5f5c35a152bdb37d6039b";
       revision = "1";
       editedCabalFile = "fbefc480103a2c6661d5e735f53aa387ae2c8b2e482ffab87955be34b9a69be6";
       libraryHaskellDepends = [ base HUnit QuickCheck ];
       jailbreak = true;
       description = "Use HUnit assertions as QuickCheck properties";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quickcheck-io" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck }:
     mkDerivation {
       pname = "quickcheck-io";
       version = "0.1.2";
       sha256 = "50275e5253dcf0c838e340fa19eb841804deb634aeedbf33f0b46a97b89bc1cd";
       libraryHaskellDepends = [ base HUnit QuickCheck ];
       homepage = "https://github.com/hspec/quickcheck-io#readme";
       description = "Use HUnit assertions as QuickCheck properties";
       license = stdenv.lib.licenses.mit;
     }) {};

  "quickcheck-poly" = callPackage
    ({ mkDerivation, base, haskell98, hint, MonadCatchIO-mtl
     , QuickCheck, regex-compat, regex-tdfa
     }:
     mkDerivation {
       pname = "quickcheck-poly";
       version = "0.2.0.1";
       sha256 = "ca167f3608b701642f8e5134080f15fb3200c622abc41b7b9ac14bb3b47cb146";
       libraryHaskellDepends = [
         base haskell98 hint MonadCatchIO-mtl QuickCheck regex-compat
         regex-tdfa
       ];
       description = "Automating QuickCheck for polymorphic and overlaoded properties";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quickcheck-properties" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "quickcheck-properties";
       version = "0.1";
       sha256 = "3c89ed3fb03199853455806aac3852da8fe2973ae1c78320b901aacb030f2643";
       libraryHaskellDepends = [ base ];
       description = "QuickCheck properties for standard type classes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quickcheck-property-comb" = callPackage
    ({ mkDerivation, base, mtl, QuickCheck }:
     mkDerivation {
       pname = "quickcheck-property-comb";
       version = "0.1.0.2";
       sha256 = "e5da89c66f52eb28a3fd708ab0feea95a4fbab20c1c6c6f9922d380eab121f73";
       libraryHaskellDepends = [ base mtl QuickCheck ];
       jailbreak = true;
       homepage = "http://www.github.com/jfeltz/quickcheck-property-comb";
       description = "Combinators for Quickcheck Property construction and diagnostics";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "quickcheck-property-monad" = callPackage
    ({ mkDerivation, base, directory, doctest, either, filepath
     , QuickCheck, transformers
     }:
     mkDerivation {
       pname = "quickcheck-property-monad";
       version = "0.2.4";
       sha256 = "2ce59041850673d8125078e36b5d29e7daab17da54d0e97547d14027452ae76a";
       libraryHaskellDepends = [ base either QuickCheck transformers ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck
       ];
       homepage = "http://github.com/bennofs/quickcheck-property-monad/";
       description = "A monad for generating QuickCheck properties without Arbitrary instances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quickcheck-regex" = callPackage
    ({ mkDerivation, base, containers, QuickCheck, regex-genex
     , regex-tdfa
     }:
     mkDerivation {
       pname = "quickcheck-regex";
       version = "0.0.3";
       sha256 = "1645deee601e5581b5d9ddf0227be0ccac9f3c3c485ef63f20412e8507450002";
       libraryHaskellDepends = [
         base containers QuickCheck regex-genex regex-tdfa
       ];
       homepage = "http://github.com/audreyt/quickcheck-regex/";
       description = "Generate regex-constrained strings for QuickCheck";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "quickcheck-relaxng" = callPackage
    ({ mkDerivation, base, hxt, hxt-relaxng, QuickCheck
     , quickcheck-regex
     }:
     mkDerivation {
       pname = "quickcheck-relaxng";
       version = "0.0.2";
       sha256 = "89241fa3960a9b5741a7c2226e677b165d08c6527c3e01a202c124f5f76b36f3";
       libraryHaskellDepends = [
         base hxt hxt-relaxng QuickCheck quickcheck-regex
       ];
       homepage = "http://github.com/audreyt/quickcheck-relaxng/";
       description = "Generate RelaxNG-constrained XML documents for QuickCheck";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "quickcheck-rematch" = callPackage
    ({ mkDerivation, base, hspec, HUnit, QuickCheck, rematch }:
     mkDerivation {
       pname = "quickcheck-rematch";
       version = "0.1.0.0";
       sha256 = "6a158749e4d13b167fd242d8d2fe116493e8857d063f9b78beda0c1a0849bc5e";
       libraryHaskellDepends = [ base QuickCheck rematch ];
       testHaskellDepends = [ base hspec HUnit QuickCheck rematch ];
       jailbreak = true;
       homepage = "http://github.com/tcrayford/rematch";
       description = "QuickCheck support for rematch";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quickcheck-script" = callPackage
    ({ mkDerivation, base, directory, process, QuickCheck }:
     mkDerivation {
       pname = "quickcheck-script";
       version = "0.1.1.1";
       sha256 = "afe8080ee42265b33cce7b096b0719d510a95dd6b9f80aab858695e91926fb94";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory process QuickCheck ];
       homepage = "http://www.cs.chalmers.se/~rjmh/QuickCheck/";
       description = "Automated test tool for QuickCheck";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quickcheck-simple" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "quickcheck-simple";
       version = "0.1.0.0";
       sha256 = "b4a305ab0b0e5612d083b98fede31c5986465928c1a837ebcd21a28fc7f2dd6e";
       libraryHaskellDepends = [ base QuickCheck ];
       description = "Test properties and default-mains for QuickCheck";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quickcheck-text" = callPackage
    ({ mkDerivation, base, binary, bytestring, QuickCheck, text }:
     mkDerivation {
       pname = "quickcheck-text";
       version = "0.1.0.1";
       sha256 = "bf33117023b1b2980e516ec74e15b214bc14211fa3ef4daa5a7c7d9a651b553c";
       libraryHaskellDepends = [ base binary bytestring QuickCheck text ];
       testHaskellDepends = [ base bytestring QuickCheck text ];
       homepage = "https://github.com/olorin/quickcheck-text";
       description = "Alternative arbitrary instance for Text";
       license = stdenv.lib.licenses.mit;
     }) {};

  "quickcheck-unicode_1_0_0_0" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "quickcheck-unicode";
       version = "1.0.0.0";
       sha256 = "b833debbe9263a11f00c6262127d6032c63876215513279b16fcc6cda168e77a";
       libraryHaskellDepends = [ base QuickCheck ];
       homepage = "https://github.com/bos/quickcheck-unicode";
       description = "Generator and shrink functions for testing Unicode-related software";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quickcheck-unicode" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "quickcheck-unicode";
       version = "1.0.0.1";
       sha256 = "24c29caddc515d477878ef97581a0cebf760055ca0f260ba1762257abaa116a9";
       libraryHaskellDepends = [ base QuickCheck ];
       homepage = "https://github.com/bos/quickcheck-unicode";
       description = "Generator and shrink functions for testing Unicode-related software";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quickcheck-webdriver" = callPackage
    ({ mkDerivation, base, QuickCheck, transformers, webdriver }:
     mkDerivation {
       pname = "quickcheck-webdriver";
       version = "0.1.0.7";
       sha256 = "10447118796aefc05405e9e3b58676c888ce9f93a85d544c8f1538e22592538a";
       libraryHaskellDepends = [ base QuickCheck transformers webdriver ];
       jailbreak = true;
       description = "Utilities for using WebDriver with QuickCheck";
       license = stdenv.lib.licenses.mit;
     }) {};

  "quicklz" = callPackage
    ({ mkDerivation, base, bytestring, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "quicklz";
       version = "1.5.0.11";
       sha256 = "0d0b23370a848efa86da80f835d036f468cdb1b201809351116945729b5b699f";
       libraryHaskellDepends = [ base bytestring ];
       testHaskellDepends = [
         base bytestring QuickCheck test-framework
         test-framework-quickcheck2
       ];
       homepage = "http://github.com/thoughtpolice/hs-quicklz";
       description = "QuickLZ compression for ByteStrings";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "quickpull_0_4_0_0" = callPackage
    ({ mkDerivation, barecheck, base, directory, filepath, QuickCheck
     }:
     mkDerivation {
       pname = "quickpull";
       version = "0.4.0.0";
       sha256 = "f6939203e0bf30a04a7366c30b11d5717cb7fa903c96d6b5e38e8873f6a1df61";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory filepath QuickCheck ];
       executableHaskellDepends = [
         barecheck base directory filepath QuickCheck
       ];
       testHaskellDepends = [ base directory filepath QuickCheck ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/quickpull";
       description = "Generate Main module with QuickCheck tests";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quickpull" = callPackage
    ({ mkDerivation, barecheck, base, directory, filepath, QuickCheck
     }:
     mkDerivation {
       pname = "quickpull";
       version = "0.4.2.2";
       sha256 = "a49d5521ce35de82a76ae32dd083c2fbe21f31fc80e19e91917c1ea3f0d0c56f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory filepath QuickCheck ];
       executableHaskellDepends = [
         barecheck base directory filepath QuickCheck
       ];
       testHaskellDepends = [ base directory filepath QuickCheck ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/quickpull";
       description = "Generate Main module with QuickCheck tests";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quickset" = callPackage
    ({ mkDerivation, base, vector, vector-algorithms }:
     mkDerivation {
       pname = "quickset";
       version = "0.1.0";
       sha256 = "befdb3d11178c4bd0eb14dc9247c642d653d38731b4072ab3da6fc14f9293c76";
       libraryHaskellDepends = [ base vector vector-algorithms ];
       description = "Very fast and memory-compact query-only set and map structures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quickspec" = callPackage
    ({ mkDerivation, array, base, containers, ghc-prim, QuickCheck
     , random, spoon, transformers
     }:
     mkDerivation {
       pname = "quickspec";
       version = "0.9.6";
       sha256 = "417825d423849288fd14a70db68351f978d29210aad65c0ef519bb9d75ff3c5f";
       libraryHaskellDepends = [
         array base containers ghc-prim QuickCheck random spoon transformers
       ];
       homepage = "https://github.com/nick8325/quickspec";
       description = "Equational laws for free!";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quicktest" = callPackage
    ({ mkDerivation, base, directory, haskell98, mtl, process }:
     mkDerivation {
       pname = "quicktest";
       version = "0.1.3";
       sha256 = "2531b95fe8aa37776abe15b6b90342a07c041ac2e5eb35e797b997129a34705b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory haskell98 mtl process
       ];
       homepage = "https://github.com/davidsiegel/quicktest";
       description = "A reflective batch tester for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "quickwebapp" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, either, lucid
     , servant, servant-lucid, servant-server, text, warp
     }:
     mkDerivation {
       pname = "quickwebapp";
       version = "3.0.0.2";
       sha256 = "1b84a728f36fe68c92b269174e9c3655112408f78c2990d0c6568f9fb80f282d";
       revision = "1";
       editedCabalFile = "9d34bc5555232a31a1c17ced7fbbae606278fdc19e54d6a058f331c2cabace65";
       libraryHaskellDepends = [
         aeson base bytestring containers either lucid servant servant-lucid
         servant-server text warp
       ];
       homepage = "https://github.com/jtanguy/quickwebapp";
       description = "A quick webapp generator for any file processing tool";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "quiver" = callPackage
    ({ mkDerivation, base, mmorph, transformers }:
     mkDerivation {
       pname = "quiver";
       version = "1.1.3";
       sha256 = "fdf0a4aabc5787e4e9f512485bea9771885dcab0482ef811e68189962d15e0bd";
       libraryHaskellDepends = [ base mmorph transformers ];
       homepage = "https://github.com/zadarnowski/quiver";
       description = "Quiver finite stream processing library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quiver-bytestring" = callPackage
    ({ mkDerivation, base, bytestring, quiver }:
     mkDerivation {
       pname = "quiver-bytestring";
       version = "1.0.0";
       sha256 = "bfb24db01b676e1f2ed374e58b4192037facf74b52d0205a55390a6bce3797c7";
       libraryHaskellDepends = [ base bytestring quiver ];
       homepage = "https://github.com/zadarnowski/quiver-bytestring";
       description = "Quiver combinators for bytestring streaming";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quiver-cell" = callPackage
    ({ mkDerivation, base, data-cell, quiver }:
     mkDerivation {
       pname = "quiver-cell";
       version = "1.0.0";
       sha256 = "e806d29ffb46b80ddd21cca89de3c9d4606dbc30aad523fa9691ca05e12e0c51";
       libraryHaskellDepends = [ base data-cell quiver ];
       homepage = "https://github.com/zadarnowski/quiver-cell";
       description = "Quiver combinators for cellular data processing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quiver-csv" = callPackage
    ({ mkDerivation, base, bytestring, data-cell, quiver
     , quiver-bytestring
     }:
     mkDerivation {
       pname = "quiver-csv";
       version = "0.0.0.3";
       sha256 = "92699f62236b6106becd5baed0a5f717b65f1b13cfa885053f9983bda8098ba7";
       libraryHaskellDepends = [
         base bytestring data-cell quiver quiver-bytestring
       ];
       homepage = "https://github.com/zadarnowski/quiver-csv";
       description = "Quiver combinators for cellular CSV data processing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quiver-enumerator" = callPackage
    ({ mkDerivation, base, enumerator, quiver }:
     mkDerivation {
       pname = "quiver-enumerator";
       version = "0.0.0.1";
       sha256 = "b71266c7a11adfee73a292e117547da18fa6d6a8900c64c8326b76fabd10084c";
       libraryHaskellDepends = [ base enumerator quiver ];
       homepage = "https://github.com/zadarnowski/quiver-enumerator";
       description = "Bridge between Quiver and Iteratee paradigms";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quiver-http" = callPackage
    ({ mkDerivation, base, bytestring, http-client, http-client-tls
     , quiver
     }:
     mkDerivation {
       pname = "quiver-http";
       version = "0.0.0.2";
       sha256 = "e221dbbe65a0b4509e7efbd1e70383575175932e16b28d0cbeaa2165b7a5dfe0";
       revision = "2";
       editedCabalFile = "25c3ec8b9fe27ef80eb8b2c2918676437a7c79b4504e419c319593262c61b3e1";
       libraryHaskellDepends = [
         base bytestring http-client http-client-tls quiver
       ];
       homepage = "https://github.com/christian-marie/quiver-http/";
       description = "Adapter to stream over HTTP(s) with quiver";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "quoridor-hs" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
     , directory, dlist, exceptions, filepath, hex, HUnit, mtl, network
     , network-simple, parsec, process, snap-core, snap-server, stm
     , websockets, websockets-snap
     }:
     mkDerivation {
       pname = "quoridor-hs";
       version = "0.1.1.2";
       sha256 = "9b0acf3fc902d39ad473e0ecd70da99eb420cca3ad847b18ca4a607875160afa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal async base bytestring containers directory dlist
         exceptions filepath hex mtl network network-simple parsec process
         snap-core snap-server stm websockets websockets-snap
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base HUnit mtl ];
       jailbreak = true;
       homepage = "https://github.com/talw/quoridor-hs";
       description = "A Quoridor implementation in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "qux" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , language-qux, llvm-general, mtl, optparse-applicative, pretty
     }:
     mkDerivation {
       pname = "qux";
       version = "0.2.0.0";
       sha256 = "9f3a033e164b906384b4dd8312306a75ab2afefb3aa5533fc512ab38e33f341f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory filepath language-qux
         llvm-general mtl optparse-applicative pretty
       ];
       jailbreak = true;
       homepage = "https://github.com/qux-lang/qux";
       description = "Command line binary for working with the Qux language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rabocsv2qif" = callPackage
    ({ mkDerivation, base, old-locale, split, time }:
     mkDerivation {
       pname = "rabocsv2qif";
       version = "1.1.5";
       sha256 = "6f8c2b10adb695147979f027f0a5f88f4e13cb77ff4aa172e8cbc359adc869ed";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base old-locale split time ];
       executableHaskellDepends = [ base ];
       description = "A library and program to create QIF files from Rabobank CSV exports";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rad" = callPackage
    ({ mkDerivation, array, base, containers, data-reify }:
     mkDerivation {
       pname = "rad";
       version = "0.1.6.3";
       sha256 = "4d04262c569592c6189a3300cb9e1a6d25ea6665200dd71b6357d9ba07a3e2a5";
       libraryHaskellDepends = [ array base containers data-reify ];
       jailbreak = true;
       homepage = "http://comonad.com/reader/";
       description = "Reverse Automatic Differentiation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "radian" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, lens
     , profunctors, QuickCheck, template-haskell
     }:
     mkDerivation {
       pname = "radian";
       version = "0.0.6";
       sha256 = "f7dbf6d15669d9bda2f7c54969bcb8cf39a7dfd28e27355955f553bb1157cc5c";
       libraryHaskellDepends = [ base profunctors ];
       testHaskellDepends = [
         base directory doctest filepath lens QuickCheck template-haskell
       ];
       homepage = "https://github.com/NICTA/radian";
       description = "Isomorphisms for measurements that use radians";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "radium" = callPackage
    ({ mkDerivation, base, Cabal, containers, hspec, parsec, QuickCheck
     }:
     mkDerivation {
       pname = "radium";
       version = "0.5";
       sha256 = "17572031f5bf539dc9c73670f06375c797262e233a553ca0c008d12c8fef0aee";
       libraryHaskellDepends = [ base containers parsec ];
       testHaskellDepends = [
         base Cabal containers hspec parsec QuickCheck
       ];
       homepage = "https://github.com/klangner/radium";
       description = "Chemistry";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "radium-formula-parser" = callPackage
    ({ mkDerivation, base, Cabal, containers, hspec, parsec, QuickCheck
     }:
     mkDerivation {
       pname = "radium-formula-parser";
       version = "0.2";
       sha256 = "6e91828c5353bb3c6eba1b1bd67cf87240290548001e2897552ec97604ab4fac";
       libraryHaskellDepends = [ base containers parsec ];
       testHaskellDepends = [
         base Cabal containers hspec parsec QuickCheck
       ];
       jailbreak = true;
       homepage = "https://github.com/klangner/radium-formula-parser";
       description = "Chemistry";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "radix" = callPackage
    ({ mkDerivation, base, filepath }:
     mkDerivation {
       pname = "radix";
       version = "1.0.0.0";
       sha256 = "3a511d2cf646be113ef2a131aa2095b3a49088f807b7d42d374f1c1e9a037fc2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base filepath ];
       jailbreak = true;
       homepage = "https://github.com/thomaseding/radix";
       description = "Command-line tool for emitting numbers in various bases";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rados-haskell" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, hspec, HUnit
     , mtl, rados, uuid
     }:
     mkDerivation {
       pname = "rados-haskell";
       version = "3.1.0";
       sha256 = "533893bf14b7a5fcbd9caa94c089f920a6a1bd3fb029e3b42044eb56927bce75";
       libraryHaskellDepends = [
         async base bytestring containers mtl uuid
       ];
       librarySystemDepends = [ rados ];
       testHaskellDepends = [
         async base bytestring hspec HUnit mtl uuid
       ];
       testSystemDepends = [ rados ];
       homepage = "github";
       description = "librados haskell bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {rados = null;};

  "rail-compiler-editor" = callPackage
    ({ mkDerivation, base, cairo, containers, gtk, HUnit, llvm-general
     , llvm-general-pure, mtl, process, transformers
     }:
     mkDerivation {
       pname = "rail-compiler-editor";
       version = "0.3.0.0";
       sha256 = "8b53a6c96d4f3a2ba1f7c70a0065ad9959c1bcef6ce33497f690b8a382505a4a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers llvm-general llvm-general-pure mtl
       ];
       executableHaskellDepends = [
         base cairo containers gtk mtl process transformers
       ];
       testHaskellDepends = [ base containers HUnit process ];
       jailbreak = true;
       homepage = "https://github.com/SWP-Ubau-SoSe2014-Haskell/SWPSoSe14";
       description = "Compiler and editor for the esolang rail";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rainbow_0_20_0_4" = callPackage
    ({ mkDerivation, base, terminfo, text }:
     mkDerivation {
       pname = "rainbow";
       version = "0.20.0.4";
       sha256 = "75e671c1d400a8739eba32bd81a895900b63426c30451b6038d1bb4bc6bed157";
       libraryHaskellDepends = [ base terminfo text ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/rainbow";
       description = "Print text to terminal with colors and effects";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rainbow_0_22_0_2" = callPackage
    ({ mkDerivation, base, bytestring, process, QuickCheck, text }:
     mkDerivation {
       pname = "rainbow";
       version = "0.22.0.2";
       sha256 = "49e7a5265eb594f89b5d44f2e9f3390f22010f0df126b15cddbf4d06e481f22f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring process text ];
       testHaskellDepends = [ base bytestring process QuickCheck text ];
       homepage = "https://www.github.com/massysett/rainbow";
       description = "Print text to terminal with colors and effects";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rainbow" = callPackage
    ({ mkDerivation, base, bytestring, lens, process, QuickCheck, text
     }:
     mkDerivation {
       pname = "rainbow";
       version = "0.26.0.6";
       sha256 = "ec0fbfeec8478eea571e0bfbddcea5fa0aeb9170f4f1355d01225c764c521fec";
       libraryHaskellDepends = [ base bytestring lens process text ];
       testHaskellDepends = [
         base bytestring lens process QuickCheck text
       ];
       homepage = "https://www.github.com/massysett/rainbow";
       description = "Print text to terminal with colors and effects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rainbow-tests" = callPackage
    ({ mkDerivation, barecheck, base, QuickCheck, rainbow, terminfo
     , text
     }:
     mkDerivation {
       pname = "rainbow-tests";
       version = "0.20.0.4";
       sha256 = "8fc20ff86fcb68d689768860ab73787612e637c6be18fe8e1392ccfb45155832";
       libraryHaskellDepends = [
         barecheck base QuickCheck rainbow terminfo text
       ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/rainbow";
       description = "Tests and QuickCheck generators to accompany rainbow";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rainbox_0_18_0_2" = callPackage
    ({ mkDerivation, base, bytestring, containers, lens, QuickCheck
     , rainbow, tasty, tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "rainbox";
       version = "0.18.0.2";
       sha256 = "9bbca03b4357f87a8924f68f66aa15ee8b2d0375c03b2646b8fb7be4895e9fb5";
       libraryHaskellDepends = [
         base bytestring containers lens rainbow text
       ];
       testHaskellDepends = [
         base bytestring containers lens QuickCheck rainbow tasty
         tasty-quickcheck text
       ];
       homepage = "http://www.github.com/massysett/rainbox";
       description = "Two-dimensional box pretty printing, with colors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rainbox_0_18_0_4" = callPackage
    ({ mkDerivation, base, bytestring, containers, lens, QuickCheck
     , rainbow, tasty, tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "rainbox";
       version = "0.18.0.4";
       sha256 = "f8efeb3f81ee5b7d9765f427d9c592e15cb732334ac8330464fe545d301525a1";
       libraryHaskellDepends = [
         base bytestring containers lens rainbow text
       ];
       testHaskellDepends = [
         base bytestring containers lens QuickCheck rainbow tasty
         tasty-quickcheck text
       ];
       homepage = "http://www.github.com/massysett/rainbox";
       description = "Two-dimensional box pretty printing, with colors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rainbox" = callPackage
    ({ mkDerivation, base, bytestring, containers, lens, QuickCheck
     , rainbow, tasty, tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "rainbox";
       version = "0.18.0.6";
       sha256 = "8197c0b75410c760777a7e9e46632de792b5539d2ac1e4fdd9259dbb7cb3ac9b";
       libraryHaskellDepends = [
         base bytestring containers lens rainbow text
       ];
       testHaskellDepends = [
         base bytestring containers lens QuickCheck rainbow tasty
         tasty-quickcheck text
       ];
       homepage = "http://www.github.com/massysett/rainbox";
       description = "Two-dimensional box pretty printing, with colors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rake" = callPackage
    ({ mkDerivation, base, containers, text }:
     mkDerivation {
       pname = "rake";
       version = "0.0.1";
       sha256 = "f63aa533db66953d1fb3d7519807e9983c857106f1b88b7e300ea07c5e17c232";
       libraryHaskellDepends = [ base containers text ];
       homepage = "http://github.com/toschoo/Haskell-Libs";
       description = "Rapid Automatic Keyword Extraction (RAKE)";
       license = "LGPL";
     }) {};

  "rakhana" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, lens
     , mtl, pipes, scientific, transformers, vector, zlib
     }:
     mkDerivation {
       pname = "rakhana";
       version = "0.2.0.2";
       sha256 = "d3704a2216ec32864f38d626a2cc27f1b79152d5582312e60fbe24822617f381";
       libraryHaskellDepends = [
         attoparsec base bytestring containers lens mtl pipes scientific
         transformers vector zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/YoEight/rakhana";
       description = "Stream based PDF library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ralist" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ralist";
       version = "0.1.0.0";
       sha256 = "b1fc92a18b3890ae9899d6d29b3de298e5e49d0f9f6174e6f34c7e2e5a784c6c";
       libraryHaskellDepends = [ base ];
       description = "Random access list with a list compatible interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rallod" = callPackage
    ({ mkDerivation, base, haskell98 }:
     mkDerivation {
       pname = "rallod";
       version = "0.0.1";
       sha256 = "094383eb36a0950a2fb7b996a61dd977460297fd3365306005150b70b098d691";
       libraryHaskellDepends = [ base haskell98 ];
       homepage = "http://github.com/moonmaster9000/rallod";
       description = "'$' in reverse";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "raml" = callPackage
    ({ mkDerivation, aeson, base, bytestring, text
     , unordered-containers, yaml
     }:
     mkDerivation {
       pname = "raml";
       version = "0.1.0";
       sha256 = "29df228af2ff703aaf8beb049e0de9cdf11fee2b3f89c85574dc7d75e2cc8109";
       libraryHaskellDepends = [
         aeson base bytestring text unordered-containers yaml
       ];
       homepage = "https://github.com/fnoble/raml";
       description = "RESTful API Modeling Language (RAML) library for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "rand-vars" = callPackage
    ({ mkDerivation, array, base, IntervalMap, mtl, random }:
     mkDerivation {
       pname = "rand-vars";
       version = "0.1";
       sha256 = "7d78456a234b1e25f99c51469e63606f9ea3a6db1118feceedb7fe9d4adfb298";
       libraryHaskellDepends = [ array base IntervalMap mtl random ];
       description = "Random variable library, with Functor, Applicative and Monad instances";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "randfile" = callPackage
    ({ mkDerivation, base, crypto-api, directory, filepath
     , monadcryptorandom, transformers, unix
     }:
     mkDerivation {
       pname = "randfile";
       version = "0.1.0.0";
       sha256 = "df3faa36c16fe0727f33d3449403123edff861095f6d09630b8412e5dd14c785";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base crypto-api directory filepath monadcryptorandom transformers
         unix
       ];
       description = "Program for picking a random file";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "random_1_0_1_1" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "random";
       version = "1.0.1.1";
       sha256 = "df7c3b405de0ac27a2ee8fdc8dad87cb42e8eac01fef53861e43bc47c8111559";
       libraryHaskellDepends = [ base time ];
       description = "random number library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "random" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "random";
       version = "1.1";
       sha256 = "b718a41057e25a3a71df693ab0fe2263d492e759679b3c2fea6ea33b171d3a5a";
       libraryHaskellDepends = [ base time ];
       testHaskellDepends = [ base ];
       description = "random number library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "random-access-list" = callPackage
    ({ mkDerivation, array, base, containers }:
     mkDerivation {
       pname = "random-access-list";
       version = "0.2";
       sha256 = "19d18e04c76f37405daaf90dfb15242a2c2f46bcc96b782d80cc5034dcd0abfa";
       libraryHaskellDepends = [ array base containers ];
       description = "Random-access lists in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "random-derive" = callPackage
    ({ mkDerivation, base, random, template-haskell }:
     mkDerivation {
       pname = "random-derive";
       version = "0.1.0.0";
       sha256 = "17495d57a9ceace879853d7fef5bb62af3f6c678b0dc9f00902f3e869eff3922";
       libraryHaskellDepends = [ base random template-haskell ];
       homepage = "https://github.com/frerich/random-derive";
       description = "A Template Haskell helper for deriving Random instances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "random-eff" = callPackage
    ({ mkDerivation, base, extensible-effects, random }:
     mkDerivation {
       pname = "random-eff";
       version = "0.1.0.1";
       sha256 = "ce77a52b645306f38b2272a6d10e0dd9f55506fcf922d0820d7729f7c1b548d4";
       libraryHaskellDepends = [ base extensible-effects random ];
       jailbreak = true;
       description = "A simple random generator library for extensible-effects";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "random-effin" = callPackage
    ({ mkDerivation, base, effin, random }:
     mkDerivation {
       pname = "random-effin";
       version = "0.1.1.0";
       sha256 = "105c2091eba9bbfa5041a9dc90a2e4a095391265fd34486bc2005cdd5c2b365c";
       libraryHaskellDepends = [ base effin random ];
       jailbreak = true;
       description = "A simple random generator library for effin";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "random-extras" = callPackage
    ({ mkDerivation, array, base, containers, random-fu, random-source
     }:
     mkDerivation {
       pname = "random-extras";
       version = "0.19";
       sha256 = "c0beeda8d2734673ee45debaf8594b7b6e9c39b8e30243ae0573e24cc2d085ac";
       libraryHaskellDepends = [
         array base containers random-fu random-source
       ];
       homepage = "http://github.com/aristidb/random-extras";
       description = "Additional functions for random values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "random-fu_0_2_6_1" = callPackage
    ({ mkDerivation, base, erf, logfloat, math-functions, monad-loops
     , mtl, random-shuffle, random-source, rvar, syb, template-haskell
     , transformers, vector
     }:
     mkDerivation {
       pname = "random-fu";
       version = "0.2.6.1";
       sha256 = "2f5def57bf836f2e828d102affe13111c7bb01f85eb9fe9c03cfcbfbb548d111";
       libraryHaskellDepends = [
         base erf logfloat math-functions monad-loops mtl random-shuffle
         random-source rvar syb template-haskell transformers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/mokus0/random-fu";
       description = "Random number generation";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "random-fu" = callPackage
    ({ mkDerivation, base, erf, log-domain, math-functions, monad-loops
     , mtl, random-shuffle, random-source, rvar, syb, template-haskell
     , transformers, vector
     }:
     mkDerivation {
       pname = "random-fu";
       version = "0.2.6.2";
       sha256 = "cf02b03dc869305c98387ad8efb7f09410dd531852a79620e5720383e0c9ffc8";
       libraryHaskellDepends = [
         base erf log-domain math-functions monad-loops mtl random-shuffle
         random-source rvar syb template-haskell transformers vector
       ];
       homepage = "https://github.com/mokus0/random-fu";
       description = "Random number generation";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "random-hypergeometric" = callPackage
    ({ mkDerivation, base, Cabal, cabal-test-quickcheck, math-functions
     , mwc-random, QuickCheck, random-fu, vector
     }:
     mkDerivation {
       pname = "random-hypergeometric";
       version = "0.1.0.0";
       sha256 = "f051bc611d5aa1801c922f110d5c6d01210b71acc917fa138b65c9c8ad90e449";
       libraryHaskellDepends = [ base math-functions random-fu ];
       testHaskellDepends = [
         base Cabal cabal-test-quickcheck math-functions mwc-random
         QuickCheck random-fu vector
       ];
       jailbreak = true;
       homepage = "https://github.com/srijs/random-hypergeometric";
       description = "Random variate generation from hypergeometric distributions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "random-shuffle" = callPackage
    ({ mkDerivation, base, MonadRandom, random }:
     mkDerivation {
       pname = "random-shuffle";
       version = "0.0.4";
       sha256 = "52704411f040fd0bf2361dad162e35dc13caa6535b2e4908d3513c00a95d0615";
       libraryHaskellDepends = [ base MonadRandom random ];
       description = "Random shuffle implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "random-source" = callPackage
    ({ mkDerivation, base, flexible-defaults, mersenne-random-pure64
     , mtl, mwc-random, random, stateref, syb, template-haskell
     , th-extras
     }:
     mkDerivation {
       pname = "random-source";
       version = "0.3.0.6";
       sha256 = "f3dfec3aef0614ff856abbba018f3bc3446295157895ea09a015737d67205b73";
       libraryHaskellDepends = [
         base flexible-defaults mersenne-random-pure64 mtl mwc-random random
         stateref syb template-haskell th-extras
       ];
       homepage = "https://github.com/mokus0/random-fu";
       description = "Generic basis for random number generators";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "random-stream" = callPackage
    ({ mkDerivation, base, binary, bytestring, random }:
     mkDerivation {
       pname = "random-stream";
       version = "0.1.1";
       sha256 = "c6f48de53efd13c331afa13834d68b07e8c85e51d20e12f4cb5f5638fe0c2960";
       libraryHaskellDepends = [ base binary bytestring random ];
       description = "An infinite stream of random data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "random-tree" = callPackage
    ({ mkDerivation, base, containers, lens, MonadRandom, mtl, random
     , random-shuffle, transformers, tree-fun
     }:
     mkDerivation {
       pname = "random-tree";
       version = "0.6.0.5";
       sha256 = "2b604e7ce184e2c877fac63dbac1df3060cdc023427b8eb5844106a826591cc2";
       libraryHaskellDepends = [
         base containers lens MonadRandom mtl random random-shuffle
         transformers tree-fun
       ];
       description = "Create random trees";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "random-variates" = callPackage
    ({ mkDerivation, base, containers, directory, erf, HUnit, lens, mtl
     , random, reinterpret-cast
     }:
     mkDerivation {
       pname = "random-variates";
       version = "0.1.1.0";
       sha256 = "9f2107e834a7c66e1e2fe37097d0a8e839221a86b03d2eab355a6b7bfeb3573b";
       libraryHaskellDepends = [
         base containers erf lens mtl random reinterpret-cast
       ];
       testHaskellDepends = [ base directory HUnit ];
       jailbreak = true;
       homepage = "https://bitbucket.org/kpratt/random-variate";
       description = "\"Uniform RNG => Non-Uniform RNGs\"";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "randomgen" = callPackage
    ({ mkDerivation, base, binary, bytestring, mersenne-random-pure64
     , openssl
     }:
     mkDerivation {
       pname = "randomgen";
       version = "0.1";
       sha256 = "d153deda99abce22bdd8ccf0f3ea0d48e02cb7322377a6a13a8201c894defe78";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring mersenne-random-pure64
       ];
       executableSystemDepends = [ openssl ];
       homepage = "http://galois.com";
       description = "A fast, SMP parallel random data generator";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) openssl;};

  "randproc" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "randproc";
       version = "0.4";
       sha256 = "a779a5ae0b31cc6029c0312834cc5affc5d0279903e4b6f2b0c16eeed2106039";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.haskell.org/haskellwiki/Random_Processes";
       description = "Data structures and support functions for working with random processes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "randsolid" = callPackage
    ({ mkDerivation, base, random, X11 }:
     mkDerivation {
       pname = "randsolid";
       version = "0.3";
       sha256 = "93eb2520c6ac1d568ca1f42070e8f60fc73c2fdb600c606140429aa03136f26c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base random X11 ];
       description = "Set the background of your root window to a random colour";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "range" = callPackage
    ({ mkDerivation, base, Cabal, free, parsec, QuickCheck, random
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "range";
       version = "0.1.2.0";
       sha256 = "4b997ffc63dfc93716938b086ceefffd9df14684c511e0fef4656e82d58b0b09";
       libraryHaskellDepends = [ base free parsec ];
       testHaskellDepends = [
         base Cabal free QuickCheck random test-framework
         test-framework-quickcheck2
       ];
       homepage = "https://bitbucket.org/robertmassaioli/range";
       description = "This has a bunch of code for specifying and managing ranges in your code";
       license = stdenv.lib.licenses.mit;
     }) {};

  "range-set-list" = callPackage
    ({ mkDerivation, base, containers, deepseq, hashable, semigroups
     , tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "range-set-list";
       version = "0.1.2.0";
       sha256 = "3b749cf447dcf1f81f263c9c43dd61ee533b4fb25e6e4ca3bdbe2321702bab67";
       libraryHaskellDepends = [
         base containers deepseq hashable semigroups
       ];
       testHaskellDepends = [
         base containers deepseq hashable semigroups tasty tasty-quickcheck
       ];
       homepage = "https://github.com/phadej/range-set-list#readme";
       description = "Memory efficient sets with ranges of elements";
       license = stdenv.lib.licenses.mit;
     }) {};

  "range-space" = callPackage
    ({ mkDerivation, base, QuickCheck, semigroups, test-framework
     , test-framework-quickcheck2, time, vector-space
     , vector-space-points
     }:
     mkDerivation {
       pname = "range-space";
       version = "0.1.2.0";
       sha256 = "388d6cea0511019d7e0b43989722e94202d505772271a5f84ec66d99856b38c3";
       libraryHaskellDepends = [
         base semigroups vector-space vector-space-points
       ];
       testHaskellDepends = [
         base QuickCheck semigroups test-framework
         test-framework-quickcheck2 time vector-space vector-space-points
       ];
       jailbreak = true;
       homepage = "https://github.com/JohnLato/range-space";
       description = "A Range type with vector-space instances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rangemin" = callPackage
    ({ mkDerivation, base, containers, primitive, vector }:
     mkDerivation {
       pname = "rangemin";
       version = "2.2.2";
       sha256 = "8c5ba8b910d12f5ccaef7f216cebd5f34b17ca9126bc4ac0939790b8e2a8c106";
       libraryHaskellDepends = [ base containers primitive vector ];
       description = "Linear range-min algorithms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ranges" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "ranges";
       version = "0.2.4";
       sha256 = "dbbba083fccdd7f27454db3f29d0f9f13e927cb1e985641e5dbdcdbfddaebbfa";
       libraryHaskellDepends = [ base containers ];
       description = "Ranges and various functions on them";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rank1dynamic_0_2_0_1" = callPackage
    ({ mkDerivation, base, binary, constraints, ghc-prim, HUnit
     , test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "rank1dynamic";
       version = "0.2.0.1";
       sha256 = "1432f6e953cd1b29c56b9b76e04d6385110d9d916552ed3565c0367e2e7ce3da";
       libraryHaskellDepends = [ base binary ghc-prim ];
       testHaskellDepends = [
         base constraints HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://haskell-distributed.github.com";
       description = "Like Data.Dynamic/Data.Typeable but with support for rank-1 polymorphic types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rank1dynamic_0_3_1_0" = callPackage
    ({ mkDerivation, base, binary, ghc-prim, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "rank1dynamic";
       version = "0.3.1.0";
       sha256 = "a56939274a05c61bb03c3b96d3dea5438b064695cfadbcc215e85cade9e38e4e";
       libraryHaskellDepends = [ base binary ghc-prim ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://haskell-distributed.github.com";
       description = "Like Data.Dynamic/Data.Typeable but with support for rank-1 polymorphic types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rank1dynamic_0_3_1_1" = callPackage
    ({ mkDerivation, base, binary, ghc-prim, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "rank1dynamic";
       version = "0.3.1.1";
       sha256 = "2ef57df7694e3aebc066d7cce59231a9d581c6b447d48aac4fcaeda2406e4dd7";
       libraryHaskellDepends = [ base binary ghc-prim ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       doCheck = false;
       homepage = "http://haskell-distributed.github.com";
       description = "Like Data.Dynamic/Data.Typeable but with support for rank-1 polymorphic types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rank1dynamic" = callPackage
    ({ mkDerivation, base, binary, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "rank1dynamic";
       version = "0.3.2.0";
       sha256 = "e2ddd96d1908a61bd244e13884a041b64837ac25370198934b0dbd4a449e1deb";
       libraryHaskellDepends = [ base binary ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       homepage = "http://haskell-distributed.github.com";
       description = "Like Data.Dynamic/Data.Typeable but with support for rank-1 polymorphic types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rascal" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, base, containers, curl
     , curl-aeson, directory, filepath, HUnit, mtl, process, QuickCheck
     , tasty, tasty-hunit, tasty-quickcheck, vector
     }:
     mkDerivation {
       pname = "rascal";
       version = "1.1.6";
       sha256 = "3a1b648aed56c9e1d98bdcb41df832cffc76a5d3ff6b37c20d4d963aef75ea60";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal base containers curl curl-aeson directory
         filepath mtl process vector
       ];
       executableHaskellDepends = [
         aeson ansi-terminal base containers curl curl-aeson directory
         filepath mtl process vector
       ];
       testHaskellDepends = [
         aeson ansi-terminal base containers curl curl-aeson directory
         filepath HUnit mtl process QuickCheck tasty tasty-hunit
         tasty-quickcheck vector
       ];
       jailbreak = true;
       homepage = "http://soli.github.io/rascal/";
       description = "A command-line client for Reddit";
       license = stdenv.lib.licenses.mit;
     }) {};

  "rasterific-svg_0_1_0_3" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , filepath, FontyFruity, JuicyPixels, lens, linear, mtl
     , optparse-applicative, Rasterific, scientific, svg-tree, text
     , transformers, vector
     }:
     mkDerivation {
       pname = "rasterific-svg";
       version = "0.1.0.3";
       sha256 = "c4c82cad85884611adf9c8f0b2c00e614447c53f452b6a676cfc24f9e6c2fbe3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers directory filepath FontyFruity
         JuicyPixels lens linear mtl Rasterific scientific svg-tree text
         transformers vector
       ];
       executableHaskellDepends = [
         base filepath FontyFruity JuicyPixels optparse-applicative
         Rasterific svg-tree
       ];
       jailbreak = true;
       description = "SVG renderer based on Rasterific";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rasterific-svg_0_2_3_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , filepath, FontyFruity, JuicyPixels, lens, linear, mtl
     , optparse-applicative, Rasterific, scientific, svg-tree, text
     , transformers, vector
     }:
     mkDerivation {
       pname = "rasterific-svg";
       version = "0.2.3.1";
       sha256 = "731e8fe9889961fbabba03be1d532fb2ec9416372cd9154d95891ef919a2e302";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers directory filepath FontyFruity
         JuicyPixels lens linear mtl Rasterific scientific svg-tree text
         transformers vector
       ];
       executableHaskellDepends = [
         base directory filepath FontyFruity JuicyPixels
         optparse-applicative Rasterific svg-tree
       ];
       jailbreak = true;
       description = "SVG renderer based on Rasterific";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rasterific-svg_0_2_3_2" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , filepath, FontyFruity, JuicyPixels, lens, linear, mtl
     , optparse-applicative, Rasterific, scientific, svg-tree, text
     , transformers, vector
     }:
     mkDerivation {
       pname = "rasterific-svg";
       version = "0.2.3.2";
       sha256 = "d8b744ba09d5303bd84c6820d407d3fe13d58271f8794eb1088bb6b6c0d51805";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers directory filepath FontyFruity
         JuicyPixels lens linear mtl Rasterific scientific svg-tree text
         transformers vector
       ];
       executableHaskellDepends = [
         base directory filepath FontyFruity JuicyPixels
         optparse-applicative Rasterific svg-tree
       ];
       jailbreak = true;
       description = "SVG renderer based on Rasterific";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rasterific-svg" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , filepath, FontyFruity, JuicyPixels, lens, linear, mtl
     , optparse-applicative, Rasterific, scientific, svg-tree, text
     , transformers, vector
     }:
     mkDerivation {
       pname = "rasterific-svg";
       version = "0.3";
       sha256 = "909c07e2db1ecd9f67aaa4728386d7b17932e53f3c68c7afef45726142eb9425";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers directory filepath FontyFruity
         JuicyPixels lens linear mtl Rasterific scientific svg-tree text
         transformers vector
       ];
       executableHaskellDepends = [
         base directory filepath FontyFruity JuicyPixels
         optparse-applicative Rasterific svg-tree
       ];
       description = "SVG renderer based on Rasterific";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rate-limit" = callPackage
    ({ mkDerivation, base, time-units }:
     mkDerivation {
       pname = "rate-limit";
       version = "1.1.1";
       sha256 = "3f664149c578a095c55dca9d5e99a99fa06a392a4a10ef98c812c55d80742db4";
       libraryHaskellDepends = [ base time-units ];
       homepage = "http://github.com/acw/rate-limit";
       description = "A basic library for rate-limiting IO actions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ratio-int" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ratio-int";
       version = "0.1.2";
       sha256 = "efe86052c5979261d9aa6861c6297205ee0b60e1b36de191d20485e823c9781a";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/RaphaelJ/ratio-int";
       description = "Fast specialisation of Data.Ratio for Int.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "raven-haskell" = callPackage
    ({ mkDerivation, aeson, base, bytestring, hspec, http-conduit
     , network, random, text, time, unordered-containers, uuid
     }:
     mkDerivation {
       pname = "raven-haskell";
       version = "0.1.0.1";
       sha256 = "ef1eeb5734d94b9ace31ce41e6afc79cb1a9a60d5944c6abfee54c4d064ac77b";
       libraryHaskellDepends = [
         aeson base bytestring http-conduit network random text time
         unordered-containers uuid
       ];
       testHaskellDepends = [
         aeson base bytestring hspec unordered-containers
       ];
       homepage = "https://bitbucket.org/dpwiz/raven-haskell";
       description = "Haskell client for Sentry logging service";
       license = stdenv.lib.licenses.mit;
     }) {};

  "raven-haskell-scotty" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, mtl
     , raven-haskell, scotty, text, wai
     }:
     mkDerivation {
       pname = "raven-haskell-scotty";
       version = "0.1.0.3";
       sha256 = "d338b67370dc71dd81ad8aa3bef366abcf7691a5b78ee750467e6662b572946e";
       libraryHaskellDepends = [
         base bytestring case-insensitive mtl raven-haskell scotty text wai
       ];
       homepage = "http://bitbucket.org/dpwiz/raven-haskell";
       description = "Sentry http interface for Scotty web server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "raw-strings-qq_1_0_2" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "raw-strings-qq";
       version = "1.0.2";
       sha256 = "e9c953347783edf77b0e568f37b1802470e4ece02dd21ef14a5a54759272d172";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "https://github.com/23Skidoo/raw-strings-qq";
       description = "Raw string literals for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "raw-strings-qq" = callPackage
    ({ mkDerivation, base, HUnit, template-haskell }:
     mkDerivation {
       pname = "raw-strings-qq";
       version = "1.1";
       sha256 = "2e011ec26aeaa53ab43c30b7d9b5b0f661f24b4ebef8884c12c571353c0fbed3";
       libraryHaskellDepends = [ base template-haskell ];
       testHaskellDepends = [ base HUnit ];
       homepage = "https://github.com/23Skidoo/raw-strings-qq";
       description = "Raw string literals for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rawstring-qm" = callPackage
    ({ mkDerivation, base, bytestring, template-haskell, text }:
     mkDerivation {
       pname = "rawstring-qm";
       version = "0.2.2.2";
       sha256 = "e62f4f9bbb7e67b2cf1bf39e1765cce6ede6b9669ed17447e7531364b5307a40";
       libraryHaskellDepends = [ base bytestring template-haskell text ];
       homepage = "https://github.com/tolysz/rawstring-qm";
       description = "Simple raw string quotation and dictionary interpolation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "razom-text-util" = callPackage
    ({ mkDerivation, base, QuickCheck, regex-applicative, smaoin, text
     , text-position
     }:
     mkDerivation {
       pname = "razom-text-util";
       version = "0.1.2.0";
       sha256 = "ef1e986636f7f788e19979a026df4641e17a8d6b6b7398576d9ade2b8460d869";
       revision = "1";
       editedCabalFile = "96699ade66f11b3559e640f040ee602eaa8bfcdbe414c11a0025f679bd139651";
       libraryHaskellDepends = [
         base regex-applicative smaoin text text-position
       ];
       testHaskellDepends = [ base QuickCheck regex-applicative smaoin ];
       homepage = "http://rel4tion.org/projects/razom-text-util/";
       description = "Common text/parsing tools for Razom language packages";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "rbr" = callPackage
    ({ mkDerivation, base, bio, bytestring, containers }:
     mkDerivation {
       pname = "rbr";
       version = "0.8.6";
       sha256 = "8729cf9f06989cb89ffa6bc37a9ebf7ed7bfd31c48846a219752c631414aeb60";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bio bytestring containers ];
       homepage = "http://malde.org/~ketil/";
       description = "Mask nucleotide (EST) sequences in Fasta format";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rclient" = callPackage
    ({ mkDerivation, base, binary, bytestring, data-binary-ieee754
     , network, QuickCheck, split
     }:
     mkDerivation {
       pname = "rclient";
       version = "0.1.0.0";
       sha256 = "16fe2278c485b0637a5c788062b82eccfee4dceb8e40dddd0f8aa0b0a65dacc1";
       libraryHaskellDepends = [
         base binary bytestring data-binary-ieee754 network QuickCheck split
       ];
       description = "Haskell client for Rserve";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rcu" = callPackage
    ({ mkDerivation, atomic-primops, base, directory, doctest, filepath
     , hlint, parallel, primitive, stm, transformers
     }:
     mkDerivation {
       pname = "rcu";
       version = "0.1";
       sha256 = "06d31a3da492590af81479119ba0f6c5d4ddbf15e8cd78af1cc80a56d34895ed";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         atomic-primops base parallel primitive transformers
       ];
       executableHaskellDepends = [ base stm transformers ];
       testHaskellDepends = [
         base directory doctest filepath hlint parallel
       ];
       homepage = "http://github.com/ekmett/rcu/";
       description = "Read-Copy-Update for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rdf4h" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , directory, fgl, hashable, HTTP, HUnit, hxt, knob, network
     , network-uri, parsec, QuickCheck, safe, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     , text-binary, unordered-containers
     }:
     mkDerivation {
       pname = "rdf4h";
       version = "1.3.6";
       sha256 = "59b3f7a1893b1ec2c4ce967dd98d1dd1541e57ce1a697810d3b8fec27d21b1da";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers deepseq directory fgl hashable
         HTTP hxt network network-uri parsec text text-binary
         unordered-containers
       ];
       executableHaskellDepends = [
         base bytestring containers network network-uri text
       ];
       testHaskellDepends = [
         base bytestring containers directory HUnit knob network network-uri
         QuickCheck safe test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       homepage = "https://github.com/robstewart57/rdf4h";
       description = "A library for RDF processing in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rdioh" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, hoauth, hspec
     , json, MissingH, mtl, transformers, urlencoded
     }:
     mkDerivation {
       pname = "rdioh";
       version = "0.2.1";
       sha256 = "40361c10907d0bf5c99271ccb192ed9e6530873d7215d40f2692f9a520950dcc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers hoauth json MissingH mtl
         transformers urlencoded
       ];
       executableHaskellDepends = [
         aeson base bytestring containers hoauth hspec json MissingH mtl
         transformers urlencoded
       ];
       description = "A Haskell wrapper for Rdio's API";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rdtsc" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "rdtsc";
       version = "1.3.0.1";
       sha256 = "54c9a925f68d6c60b405e92f9d3bd9ebfc25cce0c72d2313a6c7e1b7cc2ed950";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/mgrabmueller/rdtsc";
       description = "Binding for the rdtsc machine instruction";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rdtsc-enolan" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "rdtsc-enolan";
       version = "0.1";
       sha256 = "b89cc31ba31827af3d47e2bf98328d5e569a9558b07504f923b8f447d43b7d6c";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.haskell.org/rdtsc";
       description = "Binding to sources of high-efficiency, high-precision, monotonically increasing relative time";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "re2" = callPackage
    ({ mkDerivation, base, bytestring, chell, vector }:
     mkDerivation {
       pname = "re2";
       version = "0.1";
       sha256 = "c5110554a41b2af45fbfde30f1d21e7cdc1aedf914c06d9629cbde96645fb522";
       libraryHaskellDepends = [ base bytestring vector ];
       testHaskellDepends = [ base bytestring chell vector ];
       homepage = "https://john-millikin.com/software/haskell-re2/";
       description = "Bindings to the re2 regular expression library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "react-flux" = callPackage
    ({ mkDerivation, aeson, base, bytestring, deepseq, mtl
     , template-haskell, text, time, unordered-containers
     }:
     mkDerivation {
       pname = "react-flux";
       version = "1.0.3";
       sha256 = "b30f88e08577f8fd9375fe71d0e3a8dcd4452b5c8e0019d93b6a5146715d3710";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring deepseq mtl template-haskell text time
         unordered-containers
       ];
       executableHaskellDepends = [ aeson base deepseq text time ];
       homepage = "https://bitbucket.org/wuzzeb/react-flux";
       description = "A binding to React based on the Flux application architecture for GHCJS";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "react-haskell" = callPackage
    ({ mkDerivation, aeson, base, deepseq, lens-family, monads-tf, text
     , transformers, unordered-containers, void
     }:
     mkDerivation {
       pname = "react-haskell";
       version = "2.0.1";
       sha256 = "12c92fe0aa26c4845584967320761cb74c97753e4b20ff40f191c6bc338b4b4e";
       libraryHaskellDepends = [
         aeson base deepseq lens-family monads-tf text transformers
         unordered-containers void
       ];
       jailbreak = true;
       homepage = "https://github.com/joelburget/react-haskell";
       description = "Haskell React bindings";
       license = stdenv.lib.licenses.mit;
     }) {};

  "reaction-logic" = callPackage
    ({ mkDerivation, base, mtl, QuickCheck }:
     mkDerivation {
       pname = "reaction-logic";
       version = "2010.11.17";
       sha256 = "209f824b2298a7710815a1617b18b3c3c8377aa70913d36a6be1744d415e343c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl QuickCheck ];
       executableHaskellDepends = [ base mtl QuickCheck ];
       homepage = "http://wiki.github.com/paolino/realogic";
       description = "pluggable pure logic serializable reactor";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reactive" = callPackage
    ({ mkDerivation, base, category-extras, checkers, old-time
     , QuickCheck, random, Stream, TypeCompose, unamb, vector-space
     }:
     mkDerivation {
       pname = "reactive";
       version = "0.11.5";
       sha256 = "321ca74b1182a4412611628a3818d343b04ee4b4eb047477931ebd40df7bb0ab";
       libraryHaskellDepends = [
         base category-extras checkers old-time QuickCheck random Stream
         TypeCompose unamb vector-space
       ];
       homepage = "http://haskell.org/haskellwiki/reactive";
       description = "Push-pull functional reactive programming";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reactive-bacon" = callPackage
    ({ mkDerivation, base, containers, HUnit, old-time, stm }:
     mkDerivation {
       pname = "reactive-bacon";
       version = "0.4.1";
       sha256 = "75482d6fe3e550fda4d33baa43bbf517b0138f76c0a39fefa2eaf1197d002c32";
       libraryHaskellDepends = [ base old-time stm ];
       testHaskellDepends = [ base containers HUnit old-time stm ];
       homepage = "http://github.com/raimohanska/reactive-bacon";
       description = "FRP (functional reactive programming) framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reactive-balsa" = callPackage
    ({ mkDerivation, alsa-core, alsa-seq, base, containers
     , data-accessor, data-accessor-transformers, event-list
     , extensible-exceptions, midi, midi-alsa, non-negative, random
     , reactive-banana, transformers, utility-ht
     }:
     mkDerivation {
       pname = "reactive-balsa";
       version = "0.1.1";
       sha256 = "7664870dd5ba4c3345e79dc06dcec64b512a13fa0c8fa2f4258b77bf652e6692";
       libraryHaskellDepends = [
         alsa-core alsa-seq base containers data-accessor
         data-accessor-transformers event-list extensible-exceptions midi
         midi-alsa non-negative random reactive-banana transformers
         utility-ht
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Reactive-balsa";
       description = "Programmatically edit MIDI events via ALSA and reactive-banana";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reactive-banana" = callPackage
    ({ mkDerivation, base, containers, hashable, HUnit, pqueue
     , psqueues, test-framework, test-framework-hunit, transformers
     , unordered-containers, vault
     }:
     mkDerivation {
       pname = "reactive-banana";
       version = "1.1.0.0";
       sha256 = "8557c1140f2e27064a59502215b64dd0c005b97b5b1c8ecf999a3dd59881fde2";
       libraryHaskellDepends = [
         base containers hashable pqueue transformers unordered-containers
         vault
       ];
       testHaskellDepends = [
         base containers hashable HUnit pqueue psqueues test-framework
         test-framework-hunit transformers unordered-containers vault
       ];
       homepage = "http://wiki.haskell.org/Reactive-banana";
       description = "Library for functional reactive programming (FRP)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "reactive-banana-sdl" = callPackage
    ({ mkDerivation, base, data-lens, data-lens-template
     , reactive-banana, SDL, SDL-image, SDL-ttf
     }:
     mkDerivation {
       pname = "reactive-banana-sdl";
       version = "0.2.0";
       sha256 = "d55015543991f1892283502dee95c91b4541c17631df439c098452d8cf46ef18";
       libraryHaskellDepends = [
         base data-lens data-lens-template reactive-banana SDL SDL-image
         SDL-ttf
       ];
       jailbreak = true;
       homepage = "https://github.com/JPMoresmau/reactive-banana-sdl";
       description = "Reactive Banana bindings for SDL";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reactive-banana-sdl2" = callPackage
    ({ mkDerivation, base, reactive-banana, sdl2 }:
     mkDerivation {
       pname = "reactive-banana-sdl2";
       version = "0.1.1.0";
       sha256 = "87981c16e9ec48e898b62a121b7e60fa4ed1b977391770d21a2ad506b68e1e95";
       libraryHaskellDepends = [ base reactive-banana sdl2 ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/cies/reactive-banana-sdl2#readme";
       description = "Reactive Banana integration with SDL2";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "reactive-banana-threepenny" = callPackage
    ({ mkDerivation, base, reactive-banana, threepenny-gui }:
     mkDerivation {
       pname = "reactive-banana-threepenny";
       version = "0.7.1.3";
       sha256 = "2a51bbecf637916ac67cd8803fd08072927bb38024c10e857a5677960f5e60b9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base reactive-banana threepenny-gui ];
       jailbreak = true;
       homepage = "http://haskell.org/haskellwiki/Reactive-banana";
       description = "Examples for the reactive-banana library, using threepenny-gui";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reactive-banana-wx" = callPackage
    ({ mkDerivation, base, cabal-macosx, reactive-banana, wx, wxcore }:
     mkDerivation {
       pname = "reactive-banana-wx";
       version = "1.1.0.0";
       sha256 = "1938d3f12768ec8a1bcff22330918b619739efbd4219ab2886451026421be89f";
       configureFlags = [ "-f-buildexamples" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cabal-macosx reactive-banana wx wxcore
       ];
       homepage = "http://wiki.haskell.org/Reactive-banana";
       description = "Examples for the reactive-banana library, using wxHaskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "reactive-fieldtrip" = callPackage
    ({ mkDerivation, base, FieldTrip, InfixApplicative, reactive
     , reactive-glut, unamb, vector-space
     }:
     mkDerivation {
       pname = "reactive-fieldtrip";
       version = "0.0.9";
       sha256 = "af33ede9752f2b6437af1355c9cb65f698690a2301308964a4d8b305adec4b24";
       libraryHaskellDepends = [
         base FieldTrip InfixApplicative reactive reactive-glut unamb
         vector-space
       ];
       homepage = "http://haskell.org/haskellwiki/reactive-fieldtrip";
       description = "Connect Reactive and FieldTrip";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reactive-glut" = callPackage
    ({ mkDerivation, base, GLUT, old-time, OpenGL, reactive
     , vector-space
     }:
     mkDerivation {
       pname = "reactive-glut";
       version = "0.1.10";
       sha256 = "d0e9b5f444a771a43783507dafa604141f52d3b3fa2919f2e91b6f9bdfdf9198";
       libraryHaskellDepends = [
         base GLUT old-time OpenGL reactive vector-space
       ];
       homepage = "http://haskell.org/haskellwiki/reactive-glut";
       description = "Connects Reactive and GLUT";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reactive-haskell" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "reactive-haskell";
       version = "0.0.1";
       sha256 = "05319c754954b7e9e0943bc38be4148a1823414058e2c6e9a92d7456bd92bf84";
       libraryHaskellDepends = [ base ];
       description = "minimal fork of io-reactive";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "reactive-io" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "reactive-io";
       version = "0.1";
       sha256 = "c3e47cf170f27b1201f67868f9cdb85644a66cb1a14f8f772f52acef5812ea68";
       libraryHaskellDepends = [ base transformers ];
       description = "IO-oriented FRP library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "reactive-thread" = callPackage
    ({ mkDerivation, base, monad-parallel, SDL, stm, transformers }:
     mkDerivation {
       pname = "reactive-thread";
       version = "0.3.2.1";
       sha256 = "a0e81fd87b883e24871ee47c25f4668d07ccb4679c9dedfea99d3071c7e2cdd7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base monad-parallel stm transformers ];
       executableHaskellDepends = [
         base monad-parallel SDL stm transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/strager/reactive-thread";
       description = "Reactive programming via imperative threads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reactor" = callPackage
    ({ mkDerivation, array, base, bits-atomic, comonad, contravariant
     , mtl, semigroupoids, transformers
     }:
     mkDerivation {
       pname = "reactor";
       version = "0.1.3";
       sha256 = "4e106392271aa2bcb9d4e8fb0c23db818ebb9699b2dc8186f12f3e86f0dca73c";
       libraryHaskellDepends = [
         array base bits-atomic comonad contravariant mtl semigroupoids
         transformers
       ];
       jailbreak = true;
       homepage = "http://comonad.com/reader/";
       description = "Reactor - task parallel reactive programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "read-bounded" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "read-bounded";
       version = "0.1.1.0";
       sha256 = "f310debaed6ede28440f1b177be6c5c6f281b7b3c0af9936bcb615d577d9d6a7";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/thomaseding/read-bounded";
       description = "Class for reading bounded values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "read-editor_0_1_0_1" = callPackage
    ({ mkDerivation, base, directory, hspec, process }:
     mkDerivation {
       pname = "read-editor";
       version = "0.1.0.1";
       sha256 = "97d00279dacff63044e4cf6f0e66a05f284eb55cb3d4a379d77f2ec2aa664574";
       libraryHaskellDepends = [ base directory process ];
       testHaskellDepends = [ base directory hspec process ];
       homepage = "https://github.com/yamadapc/haskell-read-editor";
       description = "Opens a temporary file on the system's EDITOR and returns the resulting edits";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "read-editor" = callPackage
    ({ mkDerivation, base, directory, process }:
     mkDerivation {
       pname = "read-editor";
       version = "0.1.0.2";
       sha256 = "ed8aeca86823fbaf11a0a543fd106c9c3abe65216ea974ed56050cbebf777085";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory process ];
       homepage = "https://github.com/yamadapc/haskell-read-editor";
       description = "Opens a temporary file on the system's EDITOR and returns the resulting edits";
       license = stdenv.lib.licenses.mit;
     }) {};

  "readable" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "readable";
       version = "0.3.1";
       sha256 = "703037ad2cca4d6d42ba23e2758d1911cd82e3e922c4078076c273231e4b43c9";
       libraryHaskellDepends = [ base bytestring text ];
       homepage = "https://github.com/mightybyte/readable";
       description = "Reading from Text and ByteString";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "readline" = callPackage
    ({ mkDerivation, base, ncurses, process, readline }:
     mkDerivation {
       pname = "readline";
       version = "1.0.3.0";
       sha256 = "c0b9e174910620db0edea8f9fd6fb6c1d7b066260d523e9a7208294c46a75feb";
       libraryHaskellDepends = [ base process ];
       librarySystemDepends = [ ncurses readline ];
       description = "An interface to the GNU readline library";
       license = "GPL";
     }) {inherit (pkgs) ncurses; inherit (pkgs) readline;};

  "readline-statevar" = callPackage
    ({ mkDerivation, base, readline, StateVar }:
     mkDerivation {
       pname = "readline-statevar";
       version = "1.0.1.0";
       sha256 = "88c5eec58816b2bfd487fa6220a5daa266af51a1c52a4163cf6acee6f8d0ddbd";
       libraryHaskellDepends = [ base readline StateVar ];
       jailbreak = true;
       description = "Readline with variables (setX/getY) wrapped in state vars";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "readpyc" = callPackage
    ({ mkDerivation, base, bliplib, parseargs }:
     mkDerivation {
       pname = "readpyc";
       version = "0.2.1";
       sha256 = "f7e6b0c7c1038ac4bacb99f795d8e0ca1760e9e614918e48ce9fb907073f8bc5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bliplib parseargs ];
       jailbreak = true;
       homepage = "https://github.com/bjpop/blip";
       description = "Read and pretty print Python bytecode (.pyc) files.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "really-simple-xml-parser" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "really-simple-xml-parser";
       version = "0.4.0.0";
       sha256 = "deebf19a654850fc893bfa58befe4e46596f0cc9e4699d54112ad56d7574b9e2";
       libraryHaskellDepends = [ base parsec ];
       jailbreak = true;
       homepage = "http://website-ckkashyap.rhcloud.com";
       description = "A really simple XML parser";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reasonable-lens" = callPackage
    ({ mkDerivation, base, mtl, split, template-haskell }:
     mkDerivation {
       pname = "reasonable-lens";
       version = "0.2.1.1";
       sha256 = "5575f5ee0cff708aeb37ea79cc9fae555e62e55053656f252653e33e631a8245";
       libraryHaskellDepends = [ base mtl split template-haskell ];
       homepage = "https://github.com/tokiwoousaka/reasonable-lens";
       description = "Lens implementation. It is more small but adequately.";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reasonable-operational" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "reasonable-operational";
       version = "0.1.0.1";
       sha256 = "097a4ee78679f0ff06e1137e293ab55f1af9d64ae7c3d44e687a3d7f7f4ea4a1";
       revision = "1";
       editedCabalFile = "963ed294ec0f951858022c25b9713b06e65d2a05098068a1183110e298b5c8cf";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/tokiwoousaka/reasonable-operational";
       description = "Just size Operational Monad implementation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "rebase" = callPackage
    ({ mkDerivation, base, base-prelude, bifunctors, bytestring
     , containers, contravariant, contravariant-extras, deepseq, dlist
     , either, hashable, mtl, profunctors, scientific, semigroups, text
     , time, transformers, unordered-containers, uuid, vector, void
     }:
     mkDerivation {
       pname = "rebase";
       version = "0.4.3";
       sha256 = "375e6cb300a7d93b8c64bad5edd69464b787d5d5b22ac80e3705ad2c0f07bde5";
       libraryHaskellDepends = [
         base base-prelude bifunctors bytestring containers contravariant
         contravariant-extras deepseq dlist either hashable mtl profunctors
         scientific semigroups text time transformers unordered-containers
         uuid vector void
       ];
       homepage = "https://github.com/nikita-volkov/rebase";
       description = "A more progressive alternative to the \"base\" package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "recaptcha" = callPackage
    ({ mkDerivation, base, HTTP, network, network-uri, xhtml }:
     mkDerivation {
       pname = "recaptcha";
       version = "0.1.0.3";
       sha256 = "29a898bc7a063be88c05ac3ec0446a23117ed04c501dbd99c83684683fd638a3";
       libraryHaskellDepends = [ base HTTP network network-uri xhtml ];
       homepage = "http://github.com/jgm/recaptcha/tree/master";
       description = "Functions for using the reCAPTCHA service in web applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "record" = callPackage
    ({ mkDerivation, base, base-prelude, basic-lens, template-haskell
     , transformers
     }:
     mkDerivation {
       pname = "record";
       version = "0.4.0.2";
       sha256 = "bc96ff1b80e5c5c7aba2ce4ba366099ab262be5b858c9b1ca6a0dedb8e0443a2";
       libraryHaskellDepends = [
         base base-prelude basic-lens template-haskell transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/record";
       description = "Anonymous records";
       license = stdenv.lib.licenses.mit;
     }) {};

  "record-aeson" = callPackage
    ({ mkDerivation, aeson, base, base-prelude, hspec, record
     , template-haskell
     }:
     mkDerivation {
       pname = "record-aeson";
       version = "0.1.1";
       sha256 = "ea4001311b55cc24b51863f3bc63b8ee638a73013b8c7372eac289817767c679";
       libraryHaskellDepends = [
         aeson base base-prelude record template-haskell
       ];
       testHaskellDepends = [ aeson base-prelude hspec record ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/record-aeson";
       description = "Instances of \"aeson\" classes for the \"record\" types";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "record-gl" = callPackage
    ({ mkDerivation, base, base-prelude, containers, GLUtil, HUnit
     , linear, OpenGL, record, tagged, template-haskell, test-framework
     , test-framework-hunit, vector
     }:
     mkDerivation {
       pname = "record-gl";
       version = "0.1.0.0";
       sha256 = "18b7f0861aaed310508e54bd3b286c8dd5819ffde4a517aba23c2bafbee5187c";
       revision = "1";
       editedCabalFile = "6d2017f9112690ce717a1bb7dad9d2d4272b01b4bce8ee3ae79247f97f277d85";
       libraryHaskellDepends = [
         base base-prelude containers GLUtil linear OpenGL record tagged
         template-haskell vector
       ];
       testHaskellDepends = [
         base HUnit linear OpenGL record tagged test-framework
         test-framework-hunit
       ];
       description = "Utilities for working with OpenGL's GLSL shading language and Nikita Volkov's \"Record\"s";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "record-preprocessor" = callPackage
    ({ mkDerivation, base, base-prelude, conversion, conversion-text
     , record-syntax, text
     }:
     mkDerivation {
       pname = "record-preprocessor";
       version = "0.1.0.3";
       sha256 = "7e64e05e5769c6c48e699701c45c2004af68f7187d6096fdbee95122a790d16d";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [
         base base-prelude conversion conversion-text record-syntax text
       ];
       doHaddock = false;
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/record-preprocessor";
       description = "Compiler preprocessor introducing a syntactic extension for anonymous records";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "record-syntax" = callPackage
    ({ mkDerivation, base, base-prelude, conversion, conversion-text
     , directory, doctest, filepath, haskell-src-exts, hspec, parsec
     , record, template-haskell, text, transformers
     }:
     mkDerivation {
       pname = "record-syntax";
       version = "0.1.0.2";
       sha256 = "6798aa9a4fdc0ade9dd608efa42ea4d716a2c0bdbc28491d5577fb0224f0ff9c";
       libraryHaskellDepends = [
         base base-prelude conversion conversion-text haskell-src-exts
         parsec record template-haskell text transformers
       ];
       testHaskellDepends = [
         base base-prelude directory doctest filepath hspec record
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/record-syntax";
       description = "A library for parsing and processing the Haskell syntax sprinkled with anonymous records";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "records" = callPackage
    ({ mkDerivation, base, kinds, type-functions }:
     mkDerivation {
       pname = "records";
       version = "0.1.1.6";
       sha256 = "c9ccd6d264867b3ad1a3405136e7fdeddbb269fddeaa3abd3120ebc7f1c2f8db";
       libraryHaskellDepends = [ base kinds type-functions ];
       homepage = "http://darcs.wolfgang.jeltsch.info/haskell/records";
       description = "A flexible record system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "records-th" = callPackage
    ({ mkDerivation, aeson, base, data-default, kinds, records
     , template-haskell, text, type-functions, unordered-containers
     }:
     mkDerivation {
       pname = "records-th";
       version = "0.1.1.0";
       sha256 = "8fb58a76c4756c701547a7b549d137775da77797521e00d563940558a728dbd4";
       libraryHaskellDepends = [
         aeson base data-default kinds records template-haskell text
         type-functions unordered-containers
       ];
       jailbreak = true;
       homepage = "github.com/lassoinc/records-th";
       description = "Template Haskell declarations for the records package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "recursion-schemes" = callPackage
    ({ mkDerivation, base, comonad, free, transformers }:
     mkDerivation {
       pname = "recursion-schemes";
       version = "4.1.2";
       sha256 = "36fd1357a577e23640c2948a1b00afd38e4527e4972551042bf6b88781c8c4fc";
       libraryHaskellDepends = [ base comonad free transformers ];
       homepage = "http://github.com/ekmett/recursion-schemes/";
       description = "Generalized bananas, lenses and barbed wire";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "recursive-line-count" = callPackage
    ({ mkDerivation, base, bytestring, containers, filepath, gtk, mtl
     , process
     }:
     mkDerivation {
       pname = "recursive-line-count";
       version = "0.1";
       sha256 = "d63ba514395f4fb41d5c86617a574d82c929732523b2b680a7669ff58865ca47";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers filepath gtk mtl process
       ];
       homepage = "https://github.com/joeyadams/haskell-recursive-line-count";
       description = "Count lines in files and display them hierarchically";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "redHandlers" = callPackage
    ({ mkDerivation, array, base, bytestring, cgi, containers
     , haskell98, MaybeT, mtl, network, old-time, parsec, stm, unix
     , xhtml
     }:
     mkDerivation {
       pname = "redHandlers";
       version = "0.1";
       sha256 = "8925c73868bfbef1d1bbf184b948b9ca34bc4b5e40f8aaa5d254828c55408bd2";
       libraryHaskellDepends = [
         array base bytestring cgi containers haskell98 MaybeT mtl network
         old-time parsec stm unix xhtml
       ];
       jailbreak = true;
       description = "Monadic HTTP request handlers combinators to build a standalone web apps";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reddit" = callPackage
    ({ mkDerivation, aeson, api-builder, base, bytestring, Cabal
     , data-default-class, free, hspec, http-client, http-client-tls
     , http-types, network, text, time, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "reddit";
       version = "0.2.0.0";
       sha256 = "1969dea9612d12611b73f209466e6567e46a2706b59f2f243234d47bf2749ec0";
       libraryHaskellDepends = [
         aeson api-builder base bytestring data-default-class free
         http-client http-client-tls http-types network text time
         transformers unordered-containers vector
       ];
       testHaskellDepends = [
         aeson api-builder base bytestring Cabal hspec http-client
         http-client-tls text time transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/intolerable/reddit";
       description = "Library for interfacing with Reddit's API";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "redis" = callPackage
    ({ mkDerivation, base, bytestring, concurrent-extra, containers
     , exceptions, mtl, network, old-time, utf8-string
     }:
     mkDerivation {
       pname = "redis";
       version = "0.14.1";
       sha256 = "2be1ba0dddbbdb55543a1a8272f38d6ac7d61a5a0f9bbaaacbfe258bc03c290b";
       libraryHaskellDepends = [
         base bytestring concurrent-extra containers exceptions mtl network
         old-time utf8-string
       ];
       homepage = "http://hub.darcs.net/ganesh/redis";
       description = "A driver for Redis key-value database";
       license = stdenv.lib.licenses.mit;
     }) {};

  "redis-hs" = callPackage
    ({ mkDerivation, base, bytestring, network, utf8-string }:
     mkDerivation {
       pname = "redis-hs";
       version = "0.1.2";
       sha256 = "8fa3608e62dec65419978fd5a6448d79d67be83f349e07ce4e4ccf3679f72ac7";
       libraryHaskellDepends = [ base bytestring network utf8-string ];
       homepage = "http://ohloh.net/p/redis-hs";
       description = "A simple Redis library for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "redis-io_0_5_1" = callPackage
    ({ mkDerivation, async, attoparsec, auto-update, base, bytestring
     , bytestring-conversion, containers, exceptions, iproute
     , monad-control, mtl, network, operational, redis-resp
     , resource-pool, semigroups, stm, tasty, tasty-hunit, time, tinylog
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "redis-io";
       version = "0.5.1";
       sha256 = "b568619359175ce57abf1c565beb60165c79a840c90b2010760de796501bf28f";
       libraryHaskellDepends = [
         attoparsec auto-update base bytestring containers exceptions
         iproute monad-control mtl network operational redis-resp
         resource-pool semigroups stm time tinylog transformers
         transformers-base
       ];
       testHaskellDepends = [
         async base bytestring bytestring-conversion containers redis-resp
         tasty tasty-hunit tinylog transformers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/twittner/redis-io/";
       description = "Yet another redis client";
       license = stdenv.lib.licenses.mpl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "redis-io" = callPackage
    ({ mkDerivation, async, attoparsec, auto-update, base, bytestring
     , bytestring-conversion, containers, exceptions, iproute
     , monad-control, mtl, network, operational, redis-resp
     , resource-pool, semigroups, stm, tasty, tasty-hunit, time, tinylog
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "redis-io";
       version = "0.5.2";
       sha256 = "ad33020d6aae50b1ab67630a9b63ff4fdb61b1514a84f44d98e7e764f912efdb";
       libraryHaskellDepends = [
         attoparsec auto-update base bytestring containers exceptions
         iproute monad-control mtl network operational redis-resp
         resource-pool semigroups stm time tinylog transformers
         transformers-base
       ];
       testHaskellDepends = [
         async base bytestring bytestring-conversion containers redis-resp
         tasty tasty-hunit tinylog transformers
       ];
       doCheck = false;
       homepage = "https://github.com/twittner/redis-io/";
       description = "Yet another redis client";
       license = stdenv.lib.licenses.mpl20;
     }) {};

  "redis-job-queue" = callPackage
    ({ mkDerivation, aeson, base, bytestring, hedis }:
     mkDerivation {
       pname = "redis-job-queue";
       version = "0.1.0";
       sha256 = "5ee207f8ca3031e2b8662018ad7a4a9c820741c87e3d57336f4a2848ebabd2fe";
       libraryHaskellDepends = [ aeson base bytestring hedis ];
       description = "Simple priority job queue backed by Redis";
       license = stdenv.lib.licenses.mit;
     }) {};

  "redis-resp" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring
     , bytestring-conversion, containers, dlist, double-conversion
     , operational, semigroups, split, transformers
     }:
     mkDerivation {
       pname = "redis-resp";
       version = "0.3.2";
       sha256 = "27fddbc520436cdbf34a9c0b2a686f3f133bfa9552c2f11383503941057e9b1e";
       revision = "2";
       editedCabalFile = "6375e871f3ad78efa6e4780c4e5c026fa4694f27e32f3837679fff42f488877f";
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-conversion containers dlist
         double-conversion operational semigroups split transformers
       ];
       homepage = "https://github.com/twittner/redis-resp/";
       description = "REdis Serialization Protocol (RESP) implementation";
       license = "unknown";
     }) {};

  "redis-simple" = callPackage
    ({ mkDerivation, base, binary, bytestring, redis }:
     mkDerivation {
       pname = "redis-simple";
       version = "0.1.1";
       sha256 = "83e4f6c22f70b40f7f36912b00eb8950c69f26f87482794aff0d102f182dfa4f";
       libraryHaskellDepends = [ base binary bytestring redis ];
       homepage = "http://github.com/jaspervdj/redis-simple";
       description = "Simple redis bindings for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "redo" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , process, pureMD5
     }:
     mkDerivation {
       pname = "redo";
       version = "0.2.0";
       sha256 = "8d782683ff20389aafb0f5c318bae0fdb2ffc4431ea2f695423d7214b30e25a1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory filepath process pureMD5
       ];
       homepage = "https://github.com/jekor/redo";
       description = "software build system, make replacement, implementation of djb's redo";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "reducers_3_10_3" = callPackage
    ({ mkDerivation, array, base, bytestring, comonad, containers
     , fingertree, hashable, keys, pointed, semigroupoids, semigroups
     , text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "reducers";
       version = "3.10.3";
       sha256 = "265f249ae51c30a4cdf9a4dfa94138af1bda9ee9c74eef3af06838c15e3d2742";
       revision = "2";
       editedCabalFile = "11e598e03d86e298dae5ef844bdfdfc8b73073d0e59b22fa5d549c36dd93b49d";
       libraryHaskellDepends = [
         array base bytestring comonad containers fingertree hashable keys
         pointed semigroupoids semigroups text transformers
         unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/reducers/";
       description = "Semigroups, specialized containers and a general map/reduce framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reducers_3_10_3_1" = callPackage
    ({ mkDerivation, array, base, bytestring, comonad, containers
     , fingertree, hashable, keys, pointed, semigroupoids, semigroups
     , text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "reducers";
       version = "3.10.3.1";
       sha256 = "28e6132158ac7feea36a4096bfa82d1d67aba41719261713f31203d8e448ad62";
       revision = "1";
       editedCabalFile = "39769f43035d9bfb9b40bed69d9ac1982570869d6b0d910978e7f75a9b68cf98";
       libraryHaskellDepends = [
         array base bytestring comonad containers fingertree hashable keys
         pointed semigroupoids semigroups text transformers
         unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/reducers/";
       description = "Semigroups, specialized containers and a general map/reduce framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reducers_3_10_3_2" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, fingertree
     , hashable, semigroupoids, semigroups, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "reducers";
       version = "3.10.3.2";
       sha256 = "822c487d308a470c33915ba2323efeed2d3cff774336d388864aaaf26bf6d9fd";
       revision = "1";
       editedCabalFile = "b67a4d7200de890c9d78cfa99688dd8e568f5f7ada358a60ade64eb469f6bd32";
       libraryHaskellDepends = [
         array base bytestring containers fingertree hashable semigroupoids
         semigroups text transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/reducers/";
       description = "Semigroups, specialized containers and a general map/reduce framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reducers" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, fingertree
     , hashable, semigroupoids, semigroups, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "reducers";
       version = "3.12.1";
       sha256 = "e43bb7678272691a358c049daecbac715c4b0fcece021c6b2ac7b2a1c16b6d5e";
       libraryHaskellDepends = [
         array base bytestring containers fingertree hashable semigroupoids
         semigroups text transformers unordered-containers
       ];
       homepage = "http://github.com/ekmett/reducers/";
       description = "Semigroups, specialized containers and a general map/reduce framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "reedsolomon" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-mmap, clock
     , criterion, deepseq, exceptions, filepath, gitrev, loop, mtl
     , optparse-applicative, primitive, profunctors, QuickCheck, random
     , statistics, tasty, tasty-ant-xml, tasty-hunit, tasty-quickcheck
     , vector
     }:
     mkDerivation {
       pname = "reedsolomon";
       version = "0.0.3.0";
       sha256 = "553b52e35c3d8890673ec7053dde4d2187b121ac6191019a47477a38b72b902e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring exceptions gitrev loop mtl primitive profunctors
         vector
       ];
       executableHaskellDepends = [
         base bytestring bytestring-mmap clock criterion deepseq filepath
         optparse-applicative random statistics vector
       ];
       testHaskellDepends = [
         base bytestring exceptions loop mtl primitive profunctors
         QuickCheck random tasty tasty-ant-xml tasty-hunit tasty-quickcheck
         vector
       ];
       jailbreak = true;
       homepage = "http://github.com/NicolasT/reedsolomon";
       description = "Reed-Solomon Erasure Coding in Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reenact" = callPackage
    ({ mkDerivation, base, hamid, HCodecs, stm, time, vector-space }:
     mkDerivation {
       pname = "reenact";
       version = "0.9";
       sha256 = "bc0b4961a2898f27d415e88e3187bd1d1fb6ff2ea6937f3b2f1029590207bca7";
       libraryHaskellDepends = [
         base hamid HCodecs stm time vector-space
       ];
       description = "A reimplementation of the Reactive library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "reexport-crypto-random" = callPackage
    ({ mkDerivation, base, crypto-api }:
     mkDerivation {
       pname = "reexport-crypto-random";
       version = "0.1.0.0";
       sha256 = "a99b72a930c6b866db6b2bfc87de78ec92b8436025915f8c64a08314e8f42a53";
       libraryHaskellDepends = [ base crypto-api ];
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "ref" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "ref";
       version = "0.1.1.2";
       sha256 = "19c607d20eb96e758cbef709d5b387724bd7fde684bdadb051e491bf1ea53181";
       libraryHaskellDepends = [ base ghc-prim ];
       jailbreak = true;
       homepage = "https://bitbucket.org/carter/ref";
       description = "Generic Mutable Ref Abstraction Layer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ref-fd" = callPackage
    ({ mkDerivation, base, stm, transformers }:
     mkDerivation {
       pname = "ref-fd";
       version = "0.4";
       sha256 = "26c9d963f1ff3bb28840465d16a390ba13f0a3ded8f473d7c890a174b6910ce5";
       libraryHaskellDepends = [ base stm transformers ];
       doHaddock = false;
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "A type class for monads with references using functional dependencies";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ref-mtl" = callPackage
    ({ mkDerivation, base, mtl, stm, transformers }:
     mkDerivation {
       pname = "ref-mtl";
       version = "0.3";
       sha256 = "0001829cd8e7e63e884a157528d2f92ccbf2135ad07306bec4e67a3c9c9a3272";
       libraryHaskellDepends = [ base mtl stm transformers ];
       jailbreak = true;
       homepage = "http://www.eecs.harvard.edu/~mainland/";
       description = "A type class for monads with references compatible with the mtl2 library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ref-tf" = callPackage
    ({ mkDerivation, base, stm, transformers }:
     mkDerivation {
       pname = "ref-tf";
       version = "0.4";
       sha256 = "45301b1779ff25f39d04f875ddb6895dbb27cf6f7846a2e1c9c35f126cbb3d11";
       libraryHaskellDepends = [ base stm transformers ];
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "A type class for monads with references using type families";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "refact_0_3_0_1" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "refact";
       version = "0.3.0.1";
       sha256 = "21f0629cf251efe05ab1a1cd6d085944b612df52755a6c5c2c6b8e574687b45a";
       libraryHaskellDepends = [ base ];
       description = "Specify refactorings to perform with apply-refact";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "refact" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "refact";
       version = "0.3.0.2";
       sha256 = "0ad029727797c8ca5d179c7abf1bfc135d86a7d72cf93785ee12ad243aeb1f6c";
       libraryHaskellDepends = [ base ];
       description = "Specify refactorings to perform with apply-refact";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "refcount" = callPackage
    ({ mkDerivation, base, Cabal, hashable, HUnit, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , test-framework-th, unordered-containers
     }:
     mkDerivation {
       pname = "refcount";
       version = "0.1.2";
       sha256 = "26bc984219537a267d661d30bc904f70dd333b14318bc887bb041d4658be2fc0";
       libraryHaskellDepends = [
         base hashable QuickCheck unordered-containers
       ];
       testHaskellDepends = [
         base Cabal hashable HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 test-framework-th
         unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/RobotGymnast/refcount";
       description = "Container with element counts";
       license = stdenv.lib.licenses.mit;
     }) {};

  "reference" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "reference";
       version = "0.1";
       sha256 = "013763f0f4735e47cc12bc321b6bfcf8aa9bb3e7578d3ace0b98970e795c0bbf";
       libraryHaskellDepends = [ base stm ];
       description = "A class for references in Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "references" = callPackage
    ({ mkDerivation, array, base, containers, directory, either
     , filepath, instance-control, mtl, template-haskell, text
     , transformers
     }:
     mkDerivation {
       pname = "references";
       version = "0.3.0.0";
       sha256 = "53d69562abb903586376434b4b8dcc8e3199144bf6e0fe05bfc3a5f175ca8367";
       libraryHaskellDepends = [
         array base containers directory either filepath instance-control
         mtl template-haskell text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/lazac/references";
       description = "Generalization of lenses, folds and traversals to handle monads and addition";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {instance-control = null;};

  "refh" = callPackage
    ({ mkDerivation, base, clippard, cmdargs, directory, filepath
     , haskheap, network
     }:
     mkDerivation {
       pname = "refh";
       version = "0.1.1";
       sha256 = "357dfc6c7a6b70bff1025dd17d09630590c53bc18d5521488422612719b11bba";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base clippard cmdargs directory filepath haskheap network
       ];
       jailbreak = true;
       homepage = "https://github.com/Raynes/refh";
       description = "A command-line tool for pasting to https://www.refheap.com";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "refined" = callPackage
    ({ mkDerivation, base, base-prelude, template-haskell }:
     mkDerivation {
       pname = "refined";
       version = "0.1.2";
       sha256 = "3e43f8a0e4f141eef379920c37a04e351d6bcf8ed57f8143c48f2cc91e5c18f8";
       libraryHaskellDepends = [ base base-prelude template-haskell ];
       homepage = "https://github.com/nikita-volkov/refined";
       description = "Refinement types with static and runtime checking";
       license = stdenv.lib.licenses.mit;
     }) {};

  "reflection_1_5_1" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "reflection";
       version = "1.5.1";
       sha256 = "9d4ad85c11a4986c904629c226c2be56f129f7691ddefe9373b2e87ca4a151a1";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/ekmett/reflection";
       description = "Reifies arbitrary terms into types that can be reflected back into terms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reflection_1_5_1_1" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "reflection";
       version = "1.5.1.1";
       sha256 = "5b7f61357d0ffe5f51bbeb372fded80c3fc14e897c263bf86d4ece165193a61c";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/ekmett/reflection";
       description = "Reifies arbitrary terms into types that can be reflected back into terms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reflection_1_5_1_2" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "reflection";
       version = "1.5.1.2";
       sha256 = "a4a9f4c25eda5a76bf7e7068c3bb0eab7c3d0c4da13e32cf53ee35589f20da25";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/ekmett/reflection";
       description = "Reifies arbitrary terms into types that can be reflected back into terms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reflection_1_5_2_1" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "reflection";
       version = "1.5.2.1";
       sha256 = "e5bd6734d186a072ae55f059465e6f712bf4ead8b1e7a3e5eabbe0dee0acd6df";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/ekmett/reflection";
       description = "Reifies arbitrary terms into types that can be reflected back into terms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reflection_2" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "reflection";
       version = "2";
       sha256 = "ee199e899e3810c3c8fd27dbda5cc3d1730f69e4a75f7494482863cf4d9499c2";
       revision = "1";
       editedCabalFile = "d57b4c8d539725d15a5bbfc47f99d6eca77238378d42cc82af0fc5253169e376";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/ekmett/reflection";
       description = "Reifies arbitrary terms into types that can be reflected back into terms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reflection_2_1" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "reflection";
       version = "2.1";
       sha256 = "ef07546fb5446bfd5b5f076a4996e13bf553ee6a33e6c50710559937b6a98383";
       revision = "1";
       editedCabalFile = "a89503d1b492dacbc509cc7e3fac2926dc933be2dabb59b4caa34521d15acc01";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/ekmett/reflection";
       description = "Reifies arbitrary terms into types that can be reflected back into terms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reflection_2_1_1_1" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "reflection";
       version = "2.1.1.1";
       sha256 = "e816cad511e720faa28a958210f48c0e9264ee9f6fd23eb20dcf71c6fc1c832e";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/ekmett/reflection";
       description = "Reifies arbitrary terms into types that can be reflected back into terms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reflection" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "reflection";
       version = "2.1.2";
       sha256 = "a909882c04b24016bedb85587c09f23cf06bad71a2b1f7e781e89abaa6023c39";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/ekmett/reflection";
       description = "Reifies arbitrary terms into types that can be reflected back into terms";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "reflection-extras" = callPackage
    ({ mkDerivation, aeson, base, constraints, lens, reflection, tagged
     }:
     mkDerivation {
       pname = "reflection-extras";
       version = "0.1.1.0";
       sha256 = "93c8ec7ef16191947f516043ec3436e3d6397b1b18a81673635b6e96216ad8b2";
       libraryHaskellDepends = [
         aeson base constraints lens reflection tagged
       ];
       jailbreak = true;
       homepage = "http://github.com/jfischoff/reflection-extras";
       description = "Utilities for the reflection package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reflection-without-remorse" = callPackage
    ({ mkDerivation, base, type-aligned }:
     mkDerivation {
       pname = "reflection-without-remorse";
       version = "0.9.5";
       sha256 = "197450bb605c4b6134222468cba3bbb8e0fa0f41ab89378d0ac121060599e4c7";
       libraryHaskellDepends = [ base type-aligned ];
       homepage = "https://github.com/atzeus/reflection-without-remorse";
       description = "Efficient free and operational monads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "reflex" = callPackage
    ({ mkDerivation, base, containers, dependent-map, dependent-sum
     , exception-transformers, haskell-src-exts, haskell-src-meta
     , MemoTrie, mtl, primitive, ref-tf, semigroups, syb
     , template-haskell, these, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "reflex";
       version = "0.4.0";
       sha256 = "d60c2d425c57cf2239e1088628099f44b834e3f2c661ddb6133cc397b5476b9c";
       libraryHaskellDepends = [
         base containers dependent-map dependent-sum exception-transformers
         haskell-src-exts haskell-src-meta mtl primitive ref-tf semigroups
         syb template-haskell these transformers transformers-compat
       ];
       testHaskellDepends = [
         base containers dependent-map MemoTrie mtl ref-tf
       ];
       jailbreak = true;
       homepage = "https://github.com/ryantrinkle/reflex";
       description = "Higher-order Functional Reactive Programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reflex-animation" = callPackage
    ({ mkDerivation, base, bifunctors, containers, profunctors, reflex
     , reflex-transformers, semigroups, vector-space
     }:
     mkDerivation {
       pname = "reflex-animation";
       version = "0.1.5";
       sha256 = "3ad0b2a381a4c356fd4d5a4ce7f60b875937e685f813d52c7ef1c8593776dd05";
       libraryHaskellDepends = [
         base bifunctors containers profunctors reflex reflex-transformers
         semigroups vector-space
       ];
       jailbreak = true;
       homepage = "https://github.com/saulzar/reflex-animation";
       description = "Continuous animations support for reflex";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reflex-dom" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, bytestring, containers
     , data-default, dependent-map, dependent-sum
     , dependent-sum-template, directory, exception-transformers
     , ghcjs-dom, glib, gtk3, lens, mtl, raw-strings-qq, ref-tf, reflex
     , safe, semigroups, text, these, time, transformers, unix
     , webkitgtk3, webkitgtk3-javascriptcore
     }:
     mkDerivation {
       pname = "reflex-dom";
       version = "0.3";
       sha256 = "a52bacd0ebdbb559a64fc3c7abfb34d8264c3c84243b8bc126c256e505b58d3a";
       libraryHaskellDepends = [
         aeson base bifunctors bytestring containers data-default
         dependent-map dependent-sum dependent-sum-template directory
         exception-transformers ghcjs-dom glib gtk3 lens mtl raw-strings-qq
         ref-tf reflex safe semigroups text these time transformers unix
         webkitgtk3 webkitgtk3-javascriptcore
       ];
       description = "Functional Reactive Web Apps with Reflex";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reflex-dom-contrib" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, bytestring, containers
     , data-default, ghcjs-dom, http-types, lens, mtl, random, readable
     , reflex, reflex-dom, safe, string-conv, text, time, transformers
     }:
     mkDerivation {
       pname = "reflex-dom-contrib";
       version = "0.4.1";
       sha256 = "e0c075de9b5b5c145ad7cd70fc214d1d2f8e76a0e640fde2e6202a9172573ed5";
       libraryHaskellDepends = [
         aeson base bifunctors bytestring containers data-default ghcjs-dom
         http-types lens mtl random readable reflex reflex-dom safe
         string-conv text time transformers
       ];
       homepage = "https://github.com/reflex-frp/reflex-dom-contrib";
       description = "A playground for experimenting with infrastructure and common code for reflex applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reflex-gloss" = callPackage
    ({ mkDerivation, base, dependent-sum, gloss, mtl, reflex
     , transformers
     }:
     mkDerivation {
       pname = "reflex-gloss";
       version = "0.2";
       sha256 = "e8bcebe49b351de22a6cbf6caec64465b449bc4212074de1a867876151837ab6";
       libraryHaskellDepends = [
         base dependent-sum gloss mtl reflex transformers
       ];
       homepage = "https://github.com/reflex-frp/reflex-gloss";
       description = "An reflex interface for gloss";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reflex-gloss-scene" = callPackage
    ({ mkDerivation, base, containers, dependent-sum, gloss
     , gloss-rendering, lens, linear, MonadRandom, mtl, profunctors
     , random, reflex, reflex-animation, reflex-gloss
     , reflex-transformers, semigroups, transformers, tuple
     , vector-space
     }:
     mkDerivation {
       pname = "reflex-gloss-scene";
       version = "0.1.2";
       sha256 = "36cf3a42cbda33433c50a4dadbd580a22f9c88fc61f415777a63cf234da424d5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers dependent-sum gloss gloss-rendering lens
         MonadRandom mtl profunctors random reflex reflex-animation
         reflex-gloss reflex-transformers semigroups transformers tuple
         vector-space
       ];
       executableHaskellDepends = [
         base containers gloss lens linear mtl reflex reflex-animation
         reflex-transformers transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/saulzar/reflex-gloss-scene";
       description = "A simple scene-graph using reflex and gloss";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reflex-transformers" = callPackage
    ({ mkDerivation, base, containers, lens, mtl, reflex, semigroups
     , stateWriter, transformers
     }:
     mkDerivation {
       pname = "reflex-transformers";
       version = "0.2.1";
       sha256 = "df901365231fc8db36e70a579173be8d663c7eb6f3c7e351f5977322e8ccbd72";
       libraryHaskellDepends = [
         base containers lens mtl reflex semigroups stateWriter transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/saulzar/reflex-transformers";
       description = "Collections and switchable Monad transformers for Reflex";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reform" = callPackage
    ({ mkDerivation, base, containers, mtl, text }:
     mkDerivation {
       pname = "reform";
       version = "0.2.7.1";
       sha256 = "59be2189906788ee4ecf82559aea2e7159a7a0c716c129cccce97e9d89819230";
       libraryHaskellDepends = [ base containers mtl text ];
       homepage = "http://www.happstack.com/";
       description = "reform is a type-safe HTML form generation and validation library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "reform-blaze" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, reform, text }:
     mkDerivation {
       pname = "reform-blaze";
       version = "0.2.4.1";
       sha256 = "d4acf094d75cef125e9d587646b9bbb66ce927b43ed16c99738f11e80569678b";
       revision = "1";
       editedCabalFile = "abe598582e2e9627ce899e3fe47c1d495da157d0059115aca220beecee6a05f1";
       libraryHaskellDepends = [
         base blaze-html blaze-markup reform text
       ];
       homepage = "http://www.happstack.com/";
       description = "Add support for using blaze-html with Reform";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "reform-hamlet" = callPackage
    ({ mkDerivation, base, blaze-markup, reform, shakespeare, text }:
     mkDerivation {
       pname = "reform-hamlet";
       version = "0.0.5.1";
       sha256 = "a0271fc7580463d3790f26e651836e0030178444987c9132b3c74dab249286f2";
       libraryHaskellDepends = [
         base blaze-markup reform shakespeare text
       ];
       homepage = "http://www.happstack.com/";
       description = "Add support for using Hamlet with Reform";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "reform-happstack" = callPackage
    ({ mkDerivation, base, bytestring, happstack-server, mtl, random
     , reform, text, utf8-string
     }:
     mkDerivation {
       pname = "reform-happstack";
       version = "0.2.5.1";
       sha256 = "6fa06f0cc07251bf5ec38a553de468ede9b7495c4534ba9c3f96780c1adadaaa";
       libraryHaskellDepends = [
         base bytestring happstack-server mtl random reform text utf8-string
       ];
       homepage = "http://www.happstack.com/";
       description = "Happstack support for reform";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "reform-hsp" = callPackage
    ({ mkDerivation, base, hsp, hsx2hs, reform, text }:
     mkDerivation {
       pname = "reform-hsp";
       version = "0.2.6.1";
       sha256 = "d961b22e1ef28a9cbf13ae7214335efcba3e00a4738f3f9a21fc543f61cf80a5";
       libraryHaskellDepends = [ base hsp hsx2hs reform text ];
       homepage = "http://www.happstack.com/";
       description = "Add support for using HSP with Reform";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regex-applicative_0_3_0_3" = callPackage
    ({ mkDerivation, base, containers, smallcheck, tasty, tasty-hunit
     , tasty-smallcheck, transformers
     }:
     mkDerivation {
       pname = "regex-applicative";
       version = "0.3.0.3";
       sha256 = "8c5f0e0afa70340f1142ddc59adce86567c71bdbfe55287edca5af2343373284";
       libraryHaskellDepends = [ base containers transformers ];
       testHaskellDepends = [
         base containers smallcheck tasty tasty-hunit tasty-smallcheck
         transformers
       ];
       homepage = "https://github.com/feuerbach/regex-applicative";
       description = "Regex-based parsing with applicative interface";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regex-applicative_0_3_1" = callPackage
    ({ mkDerivation, base, containers, smallcheck, tasty, tasty-hunit
     , tasty-smallcheck, transformers
     }:
     mkDerivation {
       pname = "regex-applicative";
       version = "0.3.1";
       sha256 = "1eb8d5b2fb20f2d30180e0d1a2bbe1aba9890864e2bac3907bf6ba1f408895ce";
       libraryHaskellDepends = [ base containers transformers ];
       testHaskellDepends = [
         base containers smallcheck tasty tasty-hunit tasty-smallcheck
         transformers
       ];
       homepage = "https://github.com/feuerbach/regex-applicative";
       description = "Regex-based parsing with applicative interface";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regex-applicative_0_3_2_1" = callPackage
    ({ mkDerivation, base, containers, smallcheck, tasty, tasty-hunit
     , tasty-smallcheck, transformers
     }:
     mkDerivation {
       pname = "regex-applicative";
       version = "0.3.2.1";
       sha256 = "bf4ab2dc765d8083ac08a72b2221712a942a734b90e4ce433baf4b5c8db35ca7";
       libraryHaskellDepends = [ base containers transformers ];
       testHaskellDepends = [
         base containers smallcheck tasty tasty-hunit tasty-smallcheck
         transformers
       ];
       homepage = "https://github.com/feuerbach/regex-applicative";
       description = "Regex-based parsing with applicative interface";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regex-applicative" = callPackage
    ({ mkDerivation, base, containers, smallcheck, tasty, tasty-hunit
     , tasty-smallcheck, transformers
     }:
     mkDerivation {
       pname = "regex-applicative";
       version = "0.3.3";
       sha256 = "6659a2cc1c8137d77ef57f75027723b075d473354d935233d98b1ae1b03c3be6";
       libraryHaskellDepends = [ base containers transformers ];
       testHaskellDepends = [
         base containers smallcheck tasty tasty-hunit tasty-smallcheck
         transformers
       ];
       homepage = "https://github.com/feuerbach/regex-applicative";
       description = "Regex-based parsing with applicative interface";
       license = stdenv.lib.licenses.mit;
     }) {};

  "regex-applicative-text_0_1_0_0" = callPackage
    ({ mkDerivation, base, regex-applicative, text }:
     mkDerivation {
       pname = "regex-applicative-text";
       version = "0.1.0.0";
       sha256 = "6f01deddcbba44441b12f7b4048e143f938a65e0c518f0c211e530a661a632d7";
       revision = "1";
       editedCabalFile = "4298f6496454e2fed4f26f304aaa1b1fe54ad433596f42b9f1aaba2a38e2b691";
       libraryHaskellDepends = [ base regex-applicative text ];
       homepage = "https://github.com/phadej/regex-applicative-text#readme";
       description = "regex-applicative on text";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regex-applicative-text" = callPackage
    ({ mkDerivation, base, regex-applicative, text }:
     mkDerivation {
       pname = "regex-applicative-text";
       version = "0.1.0.1";
       sha256 = "b093051f80865d257da2ded8ad1b566927b01b3d2f86d41da2ffee4a26c4e2d9";
       libraryHaskellDepends = [ base regex-applicative text ];
       homepage = "https://github.com/phadej/regex-applicative-text#readme";
       description = "regex-applicative on text";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regex-base" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, mtl }:
     mkDerivation {
       pname = "regex-base";
       version = "0.93.2";
       sha256 = "20dc5713a16f3d5e2e6d056b4beb9cfdc4368cd09fd56f47414c847705243278";
       libraryHaskellDepends = [ array base bytestring containers mtl ];
       homepage = "http://sourceforge.net/projects/lazy-regex";
       description = "Replaces/Enhances Text.Regex";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regex-compat" = callPackage
    ({ mkDerivation, array, base, regex-base, regex-posix }:
     mkDerivation {
       pname = "regex-compat";
       version = "0.95.1";
       sha256 = "d57cb1a5a4d66753b18eaa37a1621246f660472243b001894f970037548d953b";
       libraryHaskellDepends = [ array base regex-base regex-posix ];
       homepage = "http://sourceforge.net/projects/lazy-regex";
       description = "Replaces/Enhances Text.Regex";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regex-compat-tdfa" = callPackage
    ({ mkDerivation, array, base, regex-base, regex-tdfa }:
     mkDerivation {
       pname = "regex-compat-tdfa";
       version = "0.95.1.4";
       sha256 = "4fa38ed24ae390eeffe6eef04bbe632d7ecd02b9123729e976e7420f927520dd";
       libraryHaskellDepends = [ array base regex-base regex-tdfa ];
       homepage = "http://hub.darcs.net/shelarcy/regex-compat-tdfa";
       description = "Unicode Support version of Text.Regex, using regex-tdfa";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regex-deriv" = callPackage
    ({ mkDerivation, base, bitset, bytestring, containers, deepseq
     , dequeue, ghc-prim, hashable, hashtables, mtl, parallel, parsec
     , regex-base
     }:
     mkDerivation {
       pname = "regex-deriv";
       version = "0.0.5";
       sha256 = "29e89878834b019ea156f98b97e06aba60bb4fcfff7e977f866a1d1e5c558040";
       libraryHaskellDepends = [
         base bitset bytestring containers deepseq dequeue ghc-prim hashable
         hashtables mtl parallel parsec regex-base
       ];
       homepage = "http://code.google.com/p/xhaskell-regex-deriv/";
       description = "Replaces/Enhances Text.Regex. Implementing regular expression matching using Brzozowski's Deriviatives";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regex-dfa" = callPackage
    ({ mkDerivation, base, mtl, parsec, regex-base }:
     mkDerivation {
       pname = "regex-dfa";
       version = "0.91";
       sha256 = "b71d3f1d1f81f90515be040d57d249fb953ce285cc469c8482fe3c6e503304b9";
       libraryHaskellDepends = [ base mtl parsec regex-base ];
       homepage = "http://sourceforge.net/projects/lazy-regex";
       description = "Replaces/Enhances Text.Regex";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regex-easy" = callPackage
    ({ mkDerivation, array, base, bytestring, regex-pcre
     , string-conversions
     }:
     mkDerivation {
       pname = "regex-easy";
       version = "0.1.0.0";
       sha256 = "c9517a9566054700857810ff44cb2780c5922c9af3681bf399aa2fd0fe80c280";
       libraryHaskellDepends = [
         array base bytestring regex-pcre string-conversions
       ];
       homepage = "https://github.com/zerobuzz/regex-easy";
       description = "sugar for regex-pcre";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regex-genex" = callPackage
    ({ mkDerivation, base, containers, logict, mtl, regex-tdfa, sbv
     , stream-monad, text
     }:
     mkDerivation {
       pname = "regex-genex";
       version = "0.7.0";
       sha256 = "70d4028bfdafaaffc95d82d38d54949e9c0b102578ecd73a8a00a2669c55e4cc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers logict mtl regex-tdfa sbv stream-monad text
       ];
       executableHaskellDepends = [ base containers mtl regex-tdfa sbv ];
       homepage = "https://github.com/audreyt/regex-genex";
       description = "From a regex, generate all possible strings it can match";
       license = "unknown";
     }) {};

  "regex-parsec" = callPackage
    ({ mkDerivation, base, parsec, regex-base }:
     mkDerivation {
       pname = "regex-parsec";
       version = "0.90";
       sha256 = "dd76019bdbc921d1e720600e5a47ef85f5154d8f0493eb50eb9df60a4266c57d";
       libraryHaskellDepends = [ base parsec regex-base ];
       homepage = "http://sourceforge.net/projects/lazy-regex";
       description = "Replaces/Enhances Text.Regex";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regex-pcre" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, pcre
     , regex-base
     }:
     mkDerivation {
       pname = "regex-pcre";
       version = "0.94.4";
       sha256 = "8eaa7d4ac6c0a4ba35aa59fc3f6b8f8e252bb25a47e136791446a74752e226c0";
       libraryHaskellDepends = [
         array base bytestring containers regex-base
       ];
       librarySystemDepends = [ pcre ];
       homepage = "http://hackage.haskell.org/package/regex-pcre";
       description = "Replaces/Enhances Text.Regex";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) pcre;};

  "regex-pcre-builtin" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, regex-base }:
     mkDerivation {
       pname = "regex-pcre-builtin";
       version = "0.94.4.8.8.35";
       sha256 = "0bd1b695de953ba4b6e6e0de007021c346cb2a6c8e09356fbcd34f8a79d2ea78";
       libraryHaskellDepends = [
         array base bytestring containers regex-base
       ];
       homepage = "http://hackage.haskell.org/package/regex-pcre";
       description = "Replaces/Enhances Text.Regex";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regex-pderiv" = callPackage
    ({ mkDerivation, base, bitset, bytestring, containers, deepseq
     , ghc-prim, mtl, parallel, parsec, regex-base
     }:
     mkDerivation {
       pname = "regex-pderiv";
       version = "0.1.4";
       sha256 = "05de6d0794c4515c6f5dc340d9bf7b4ea8c59eb4592306c9f0342ff268a4df39";
       libraryHaskellDepends = [
         base bitset bytestring containers deepseq ghc-prim mtl parallel
         parsec regex-base
       ];
       homepage = "http://code.google.com/p/xhaskell-library/";
       description = "Replaces/Enhances Text.Regex. Implementing regular expression matching using Antimirov's partial derivatives.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regex-posix" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, regex-base }:
     mkDerivation {
       pname = "regex-posix";
       version = "0.95.2";
       sha256 = "56019921cd4a4c9682b81ec614236fea816ba8ed8785a1640cd66d8b24fc703e";
       libraryHaskellDepends = [
         array base bytestring containers regex-base
       ];
       homepage = "http://sourceforge.net/projects/lazy-regex";
       description = "Replaces/Enhances Text.Regex";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regex-posix-unittest" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, mtl
     , regex-base, regex-posix
     }:
     mkDerivation {
       pname = "regex-posix-unittest";
       version = "1.1";
       sha256 = "7d9772ee791900692c000b6a11d6480d4b9b2529f9f9796776b73e5a6cd39d4d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring containers mtl regex-base regex-posix
       ];
       description = "Unit tests for the plaform's Posix regex library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regex-tdfa_1_2_0" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, ghc-prim, mtl
     , parsec, regex-base
     }:
     mkDerivation {
       pname = "regex-tdfa";
       version = "1.2.0";
       sha256 = "fc82ac14aae378c543a55cdac3f944aae5bff9918c4a342e1da87d38ba4ef401";
       revision = "1";
       editedCabalFile = "5489b69b9f0e8e181ee5134fd500bb0e2b4f914234c5223c59186035fb50478e";
       libraryHaskellDepends = [
         array base bytestring containers ghc-prim mtl parsec regex-base
       ];
       homepage = "http://hackage.haskell.org/package/regex-tdfa";
       description = "Replaces/Enhances Text.Regex";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regex-tdfa" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, ghc-prim, mtl
     , parsec, regex-base
     }:
     mkDerivation {
       pname = "regex-tdfa";
       version = "1.2.1";
       sha256 = "a38d305eeb78be2e34542b423e6a4763fbb8ad1df757aed01993785858c871a7";
       libraryHaskellDepends = [
         array base bytestring containers ghc-prim mtl parsec regex-base
       ];
       homepage = "http://hackage.haskell.org/package/regex-tdfa";
       description = "Replaces/Enhances Text.Regex";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regex-tdfa-pipes" = callPackage
    ({ mkDerivation, array, base, lens, monads-tf, pipes, regex-base
     , regex-tdfa
     }:
     mkDerivation {
       pname = "regex-tdfa-pipes";
       version = "0.1.0.0";
       sha256 = "221369b630ea479034bf959e936a71646ec9d13db13035d817cc7c10eb1d3098";
       libraryHaskellDepends = [
         array base lens monads-tf pipes regex-base regex-tdfa
       ];
       jailbreak = true;
       homepage = "http://github.com/erisco/regex-tdfa-pipes";
       description = "Parse with regular expressions on Producers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regex-tdfa-quasiquoter" = callPackage
    ({ mkDerivation, base, regex-tdfa, template-haskell }:
     mkDerivation {
       pname = "regex-tdfa-quasiquoter";
       version = "0.2.0.0";
       sha256 = "8ae16a6297b7357ef3d9f8d2e09d006e74f67b889ec7d86296eb0ac6fb2c8361";
       libraryHaskellDepends = [ base regex-tdfa template-haskell ];
       jailbreak = true;
       homepage = "http://github.com/erisco/regex-tdfa-quasiquoter";
       description = "Quasi-quoter for TDFA (extended POSIX) regular expressions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regex-tdfa-rc" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, ghc-prim, mtl
     , parsec, regex-base
     }:
     mkDerivation {
       pname = "regex-tdfa-rc";
       version = "1.1.8.3";
       sha256 = "e35ee2a782c82c3eb313a478a8e04a464e55ca0369aa91827972ce37440c21ee";
       libraryHaskellDepends = [
         array base bytestring containers ghc-prim mtl parsec regex-base
       ];
       homepage = "http://hackage.haskell.org/package/regex-tdfa";
       description = "Replaces/Enhances Text.Regex";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regex-tdfa-text" = callPackage
    ({ mkDerivation, array, base, regex-base, regex-tdfa, text }:
     mkDerivation {
       pname = "regex-tdfa-text";
       version = "1.0.0.3";
       sha256 = "38d77a0d225c306c52c6d4eed12d11d05a4bc4194d547cb9a7a9b6f5a8792001";
       libraryHaskellDepends = [ array base regex-base regex-tdfa text ];
       description = "Text interface for regex-tdfa";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regex-tdfa-unittest" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, mtl
     , regex-base, regex-tdfa
     }:
     mkDerivation {
       pname = "regex-tdfa-unittest";
       version = "1.1";
       sha256 = "ac454b981b19cbbf443918ccb9d44508056e5e3be28fc90adb1d1b4287622cad";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring containers mtl regex-base regex-tdfa
       ];
       description = "Unit tests for the regex-tdfa";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regex-tdfa-utf8" = callPackage
    ({ mkDerivation, array, base, bytestring, regex-base, regex-tdfa
     , utf8-string
     }:
     mkDerivation {
       pname = "regex-tdfa-utf8";
       version = "1.0";
       sha256 = "93380c3d808ffcfdd2932cf4eb408d977da4162eddb58a3edc5bb7b40788ad44";
       revision = "1";
       editedCabalFile = "81e8b881e28f1943ad542e543795c1db7dcb3644311b029da4b1c110aba5997c";
       libraryHaskellDepends = [
         array base bytestring regex-base regex-tdfa utf8-string
       ];
       jailbreak = true;
       description = "This combines regex-tdfa with utf8-string to allow searching over UTF8 encoded lazy bytestrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regex-tre" = callPackage
    ({ mkDerivation, base, regex-base, tre }:
     mkDerivation {
       pname = "regex-tre";
       version = "0.91";
       sha256 = "f2ac54c70fc4b8efcaa0972e6feaf585268a1c227e1900bfbd71bb809107fdac";
       libraryHaskellDepends = [ base regex-base ];
       librarySystemDepends = [ tre ];
       homepage = "http://sourceforge.net/projects/lazy-regex";
       description = "Replaces/Enhances Text.Regex";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) tre;};

  "regex-xmlschema" = callPackage
    ({ mkDerivation, base, haskell98, parsec }:
     mkDerivation {
       pname = "regex-xmlschema";
       version = "0.1.5";
       sha256 = "446be097c8d07d9e819d1fe39b1ccc2a3dd43705f66c516d9b00496dbeddb0b6";
       libraryHaskellDepends = [ base haskell98 parsec ];
       jailbreak = true;
       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.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regexchar" = callPackage
    ({ mkDerivation, array, base, Cabal, containers, parallel, parsec
     , QuickCheck, regex-base, regex-posix, regexdot, toolshed
     }:
     mkDerivation {
       pname = "regexchar";
       version = "0.9.0.13";
       sha256 = "6ad4cfa40156d9a26b8a3c023feb757ad3be217a9f64c1ab40a984118959b79b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers parsec regex-base regexdot toolshed
       ];
       executableHaskellDepends = [
         base Cabal parallel regex-base regex-posix regexdot toolshed
       ];
       testHaskellDepends = [ base QuickCheck regexdot toolshed ];
       homepage = "http://functionalley.eu/RegExChar/regExChar.html";
       description = "A POSIX, extended regex-engine";
       license = "GPL";
     }) {};

  "regexdot" = callPackage
    ({ mkDerivation, base, deepseq, parallel, parsec, toolshed }:
     mkDerivation {
       pname = "regexdot";
       version = "0.11.1.2";
       sha256 = "c8f0ce31ae36d1f181a9c5a863967397b6431ec2436442869670468b039ebf9c";
       libraryHaskellDepends = [ base deepseq parallel parsec toolshed ];
       homepage = "http://functionalley.eu/RegExDot/regExDot.html";
       description = "A polymorphic, POSIX, extended regex-engine";
       license = "GPL";
     }) {};

  "regexp-tries" = callPackage
    ({ mkDerivation, base, containers, derive-trie, template-haskell
     , weighted-regexp
     }:
     mkDerivation {
       pname = "regexp-tries";
       version = "0.2";
       sha256 = "34ec9008abf3261f83b286c36bff2820355997a9aca076b79e74e926046e579b";
       libraryHaskellDepends = [
         base containers derive-trie template-haskell weighted-regexp
       ];
       jailbreak = true;
       homepage = "http://github.com/baldo/regexp-tries";
       description = "Regular Expressions on Tries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regexpr" = callPackage
    ({ mkDerivation, base, HUnit, mtl, mtlparse }:
     mkDerivation {
       pname = "regexpr";
       version = "0.5.4";
       sha256 = "bf7813247f26877d9fba4ba4b66eb80bfddfc2086a5cd8d635b2da0ccde56604";
       libraryHaskellDepends = [ base HUnit mtl mtlparse ];
       homepage = "http://homepage3.nifty.com/salamander/second/projects/regexpr/";
       description = "regular expression like Perl/Ruby in Haskell";
       license = "LGPL";
     }) {};

  "regexpr-symbolic" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "regexpr-symbolic";
       version = "0.5";
       sha256 = "b9693a9b9370f2cc9640cff6cfbb279b2c768bc8ccd4138ce758b15acbdafcb2";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://sulzmann.blogspot.com/2008/12/equality-containment-and-intersection.html";
       description = "Regular expressions via symbolic manipulation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regexqq" = callPackage
    ({ mkDerivation, base, bytestring, pcre-light, template-haskell }:
     mkDerivation {
       pname = "regexqq";
       version = "0.6";
       sha256 = "c301524b51049c1812c4cb2f04b3a7dbf816f64d513868c259c6ed844f247083";
       libraryHaskellDepends = [
         base bytestring pcre-light template-haskell
       ];
       homepage = "http://code.haskell.org/~morrow/code/haskell/regexqq";
       description = "A quasiquoter for PCRE regexes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regional-pointers" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, regions, transformers
     }:
     mkDerivation {
       pname = "regional-pointers";
       version = "0.7";
       sha256 = "6263cf47375da65cd9d5a0da1d94ed020d8728170698645360de201d8999e1ec";
       libraryHaskellDepends = [
         base base-unicode-symbols regions transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/regional-pointers/";
       description = "Regional memory pointers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regions" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, monad-control
     , transformers
     }:
     mkDerivation {
       pname = "regions";
       version = "0.11";
       sha256 = "f728079430f63e8b1e830b1b4d3bce91c0ad177276aea7d4060df0f837899cd0";
       libraryHaskellDepends = [
         base base-unicode-symbols monad-control transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/regions/";
       description = "Provides the region monad for safely opening and working with scarce resources";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regions-monadsfd" = callPackage
    ({ mkDerivation, base-unicode-symbols, monads-fd, regions
     , transformers
     }:
     mkDerivation {
       pname = "regions-monadsfd";
       version = "0.3.1.3";
       sha256 = "090e4f73b45b4a8ddedc62b5ae74e62c4933fee226d18ceffd4b2417f88bbe8f";
       libraryHaskellDepends = [
         base-unicode-symbols monads-fd regions transformers
       ];
       jailbreak = true;
       description = "Monads-fd instances for the RegionT monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regions-monadstf" = callPackage
    ({ mkDerivation, base-unicode-symbols, monads-tf, regions
     , transformers
     }:
     mkDerivation {
       pname = "regions-monadstf";
       version = "0.3.1.7";
       sha256 = "abbb51dccb93666250c18fa1f567711d194015814751c369c8689229eec88e64";
       libraryHaskellDepends = [
         base-unicode-symbols monads-tf regions transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/regions-monadstf/";
       description = "Monads-tf instances for the RegionT monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regions-mtl" = callPackage
    ({ mkDerivation, base-unicode-symbols, mtl, regions }:
     mkDerivation {
       pname = "regions-mtl";
       version = "0.3.1.7";
       sha256 = "80b918c8770d470abd91b6ed5073ee28af248155ec1769737dbcce3005c91ae8";
       libraryHaskellDepends = [ base-unicode-symbols mtl regions ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/regions-mtl/";
       description = "mtl instances for the RegionT monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regress" = callPackage
    ({ mkDerivation, ad, base, vector }:
     mkDerivation {
       pname = "regress";
       version = "0.1.1";
       sha256 = "d2def3d9276b75dbf685780af1af5e373b1bd2df937eb0bcba15f8c21fb16401";
       libraryHaskellDepends = [ ad base vector ];
       jailbreak = true;
       homepage = "https://github.com/alpmestan/regress";
       description = "Linear and logistic regression through automatic differentiation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regular_0_3_4_3" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "regular";
       version = "0.3.4.3";
       sha256 = "59bcc77b6ba10be8406bac213c8e10e1073bfd044e761e33888e2cfc142aec8a";
       libraryHaskellDepends = [ base template-haskell ];
       jailbreak = true;
       description = "Generic programming library for regular datatypes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regular" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "regular";
       version = "0.3.4.4";
       sha256 = "85f22409b4a5413a7180286caada7375deca4d16010f4681fe343175841c5684";
       libraryHaskellDepends = [ base template-haskell ];
       description = "Generic programming library for regular datatypes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "regular-extras" = callPackage
    ({ mkDerivation, base, binary, deepseq, QuickCheck, regular }:
     mkDerivation {
       pname = "regular-extras";
       version = "0.2.3";
       sha256 = "7d1352e17c067a996e8cd4fa39bfdb5b63eabb5c5686ee8cdb973306f45d3a74";
       libraryHaskellDepends = [ base binary deepseq QuickCheck regular ];
       jailbreak = true;
       description = "Additional functions for regular: arbitrary, coarbitrary, and binary get/put";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regular-web" = callPackage
    ({ mkDerivation, applicative-extras, base, fclabels, formlets, json
     , mtl, regular, xhtml
     }:
     mkDerivation {
       pname = "regular-web";
       version = "0.1.1";
       sha256 = "5ffbbd0e989356f396de07dd87342bbe0b078fb051ab15bf3ef724423cd59438";
       libraryHaskellDepends = [
         applicative-extras base fclabels formlets json mtl regular xhtml
       ];
       jailbreak = true;
       homepage = "http://github.com/chriseidhof/regular-web";
       description = "Generic programming for the web";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "regular-xmlpickler" = callPackage
    ({ mkDerivation, base, hxt, regular, text }:
     mkDerivation {
       pname = "regular-xmlpickler";
       version = "0.2";
       sha256 = "2e452aa77ea9bb38ca13637ca00c6789ed72d549398a3ab412f9da1675275de2";
       libraryHaskellDepends = [ base hxt regular text ];
       homepage = "http://github.com/silkapp/regular-xmlpickler";
       description = "Generic generation of HXT XmlPickler instances using Regular";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "reheat" = callPackage
    ({ mkDerivation, base, directory, QuickCheck, text, vty, vty-ui }:
     mkDerivation {
       pname = "reheat";
       version = "0.1.5";
       sha256 = "bb2df10a2ae773b08e95bcc308b6144b279a668f306beae5c4e3a5d14436da54";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory text vty vty-ui ];
       testHaskellDepends = [ base directory QuickCheck text vty vty-ui ];
       homepage = "https://github.com/mrVanDalo/reheat";
       description = "to make notes and reduce impact on idle time on writing other programms";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rehoo" = callPackage
    ({ mkDerivation, base, cmdargs, parallel-io, shelly, split
     , system-filepath, text
     }:
     mkDerivation {
       pname = "rehoo";
       version = "0.3.1";
       sha256 = "eec9480a3d23f0be2a5c30672d479bf7c2aac3260aeed52192de182470f8955f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs parallel-io shelly split system-filepath text
       ];
       homepage = "https://github.com/jwiegley/rehoo";
       description = "Rebuild default.hoo from many .hoo files in the current directory";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rei" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , directory, regex-tdfa, split
     }:
     mkDerivation {
       pname = "rei";
       version = "0.3.4.0";
       sha256 = "df67570d3078ecb170a470e23c8f267b19c339b64dfe621e8f54f33b4df725ca";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base bytestring containers directory regex-tdfa split
       ];
       jailbreak = true;
       homepage = "https://github.com/kerkomen/rei";
       description = "Process lists easily";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reified-records" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "reified-records";
       version = "0.2.2";
       sha256 = "0a1cdceeeb41a4954f06a024bfccbc950c4ffaf153d38cf85670f8e85b2ce06d";
       libraryHaskellDepends = [ base containers mtl ];
       jailbreak = true;
       homepage = "http://bitbucket.org/jozefg/reified-records";
       description = "Reify records to Maps and back again";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reify" = callPackage
    ({ mkDerivation, base, ghc }:
     mkDerivation {
       pname = "reify";
       version = "0.1.1";
       sha256 = "615e3c7bdea1e79268625cb60dafa89ed4103b5a26635a7ce084a178cef684ae";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ghc ];
       executableHaskellDepends = [ base ghc ];
       jailbreak = true;
       homepage = "http://www.cs.mu.oz.au/~bjpop/code.html";
       description = "Serialize data";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reinterpret-cast" = callPackage
    ({ mkDerivation, array, base, data-binary-ieee754, hspec, loop }:
     mkDerivation {
       pname = "reinterpret-cast";
       version = "0.1.0";
       sha256 = "5654622c904b42c62f2473c64624715dbd458ea00209ed9ab39396eabc1353e4";
       libraryHaskellDepends = [ array base ];
       testHaskellDepends = [ base data-binary-ieee754 hspec loop ];
       homepage = "https://github.com/nh2/reinterpret-cast";
       description = "Memory reinterpretation casts for Float/Double and Word32/Word64";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "relacion" = callPackage
    ({ mkDerivation, array, base, containers }:
     mkDerivation {
       pname = "relacion";
       version = "0.1";
       sha256 = "e6a4697650f8ea8053930c1cecbdfe5b8e41456e573075b243f86824538c03cb";
       libraryHaskellDepends = [ array base containers ];
       homepage = "not available";
       description = "A relation data structure";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "relation" = callPackage
    ({ mkDerivation, array, base, containers, groom }:
     mkDerivation {
       pname = "relation";
       version = "0.2.1";
       sha256 = "8cf483f92d7cbd3ade0e3bf3cbd6265bc4d17d10e1bdd6d2e3abdf3b36a2060e";
       libraryHaskellDepends = [ array base containers groom ];
       jailbreak = true;
       homepage = "https://www.github.com/d-day/relation/";
       description = "A data structure representing Relations on Sets";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "relational-postgresql8" = callPackage
    ({ mkDerivation, base, containers, HDBC, names-th
     , persistable-record, relational-query, relational-query-HDBC
     , template-haskell, time, transformers
     }:
     mkDerivation {
       pname = "relational-postgresql8";
       version = "0.2.0.0";
       sha256 = "3fff0abc19ae8e6edb2c51430fc77326f57835d329355ccb253f8001e6e237a2";
       libraryHaskellDepends = [
         base containers HDBC names-th persistable-record relational-query
         relational-query-HDBC template-haskell time transformers
       ];
       homepage = "https://github.com/yuga/haskell-relational-record-driver-postgresql8";
       description = "PostgreSQL v8.x driver for haskell-relational-record";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "relational-query" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, dlist
     , names-th, persistable-record, quickcheck-simple, sql-words
     , template-haskell, text, time, time-locale-compat, transformers
     }:
     mkDerivation {
       pname = "relational-query";
       version = "0.8.0.5";
       sha256 = "1dae8b11ade66c4be1f1755fdef7483ba569f1eb900176cd96bc48d1f904cbd7";
       libraryHaskellDepends = [
         array base bytestring containers dlist names-th persistable-record
         sql-words template-haskell text time time-locale-compat
         transformers
       ];
       testHaskellDepends = [
         base containers quickcheck-simple transformers
       ];
       homepage = "http://khibino.github.io/haskell-relational-record/";
       description = "Typeful, Modular, Relational, algebraic query engine";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "relational-query-HDBC" = callPackage
    ({ mkDerivation, base, containers, convertible, dlist, HDBC
     , HDBC-session, names-th, persistable-record, relational-query
     , relational-schemas, template-haskell, transformers
     }:
     mkDerivation {
       pname = "relational-query-HDBC";
       version = "0.6.0.0";
       sha256 = "629eb2f798603e5890ac3156fc0396276017e9eb94ce3c5a2f5f2dc1c1352541";
       libraryHaskellDepends = [
         base containers convertible dlist HDBC HDBC-session names-th
         persistable-record relational-query relational-schemas
         template-haskell transformers
       ];
       homepage = "http://khibino.github.io/haskell-relational-record/";
       description = "HDBC instance of relational-query and typed query interface for HDBC";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "relational-record" = callPackage
    ({ mkDerivation, base, relational-query, relational-query-HDBC }:
     mkDerivation {
       pname = "relational-record";
       version = "0.1.2.0";
       sha256 = "c6425751ec48c90e660f54c09330dce38b332a9c4b8eef0f9ec6c647961f8b01";
       libraryHaskellDepends = [
         base relational-query relational-query-HDBC
       ];
       homepage = "http://khibino.github.io/haskell-relational-record/";
       description = "Meta package of Relational Record";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "relational-record-examples" = callPackage
    ({ mkDerivation, base, HDBC, HDBC-session, HDBC-sqlite3, names-th
     , persistable-record, relational-query, relational-query-HDBC
     , template-haskell, time
     }:
     mkDerivation {
       pname = "relational-record-examples";
       version = "0.2.0.3";
       sha256 = "3c84a71adf6493df47e6a54cd67ed83fd9c095dea8712ed63c0905ad0729f9c1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base HDBC HDBC-session HDBC-sqlite3 names-th persistable-record
         relational-query relational-query-HDBC template-haskell time
       ];
       description = "Examples of Haskell Relationa Record";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "relational-schemas" = callPackage
    ({ mkDerivation, base, bytestring, containers, persistable-record
     , relational-query, template-haskell, time
     }:
     mkDerivation {
       pname = "relational-schemas";
       version = "0.1.2.2";
       sha256 = "aaab90384f20c5cbf3badab61b1dd7a0579acc7edcccc96af3ff07ebe9269626";
       libraryHaskellDepends = [
         base bytestring containers persistable-record relational-query
         template-haskell time
       ];
       homepage = "http://khibino.github.io/haskell-relational-record/";
       description = "RDBMSs' schema templates for relational-query";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "relative-date" = callPackage
    ({ mkDerivation, base, concatenative, datetime, mtl, parsec, time
     }:
     mkDerivation {
       pname = "relative-date";
       version = "0.0.1";
       sha256 = "c63847c963d3ad7395963bb0d28452161ea2fd88f350c6c1b9bf54ea4e985914";
       libraryHaskellDepends = [
         base concatenative datetime mtl parsec time
       ];
       jailbreak = true;
       description = "Durations and generalized time parsing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "relit" = callPackage
    ({ mkDerivation, base, regex-base, template-haskell }:
     mkDerivation {
       pname = "relit";
       version = "0.1.3";
       sha256 = "8fa58c7b159e65198598002c468fa0e106b61dd91cf4708bb9325ee781ca960d";
       libraryHaskellDepends = [ base regex-base template-haskell ];
       description = "Literal for regular expression";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rematch" = callPackage
    ({ mkDerivation, base, hspec, HUnit }:
     mkDerivation {
       pname = "rematch";
       version = "0.2.0.0";
       sha256 = "f996de29c0e7a47484a16113129166f7df12567d3ca3ea24c5c97e98a8225c51";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec HUnit ];
       doCheck = false;
       description = "A simple api for matchers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "rematch-text" = callPackage
    ({ mkDerivation, base, hspec, HUnit, rematch, text }:
     mkDerivation {
       pname = "rematch-text";
       version = "0.1.0.2";
       sha256 = "cd711fddabd475d43e9f1eb95367f35c3a08eef4c98c69b0e2c00c24c2711261";
       libraryHaskellDepends = [ base rematch text ];
       testHaskellDepends = [ base hspec HUnit rematch text ];
       description = "`rematch` matchers for Data.Text";
       license = stdenv.lib.licenses.mit;
     }) {};

  "remote" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , filepath, mtl, network, pureMD5, stm, syb, template-haskell, time
     , utf8-string
     }:
     mkDerivation {
       pname = "remote";
       version = "0.1.1";
       sha256 = "c03d049494e69fe3ff1067dfeb2cb5ba3f1fd08ae4ef517024f706c12efc5c91";
       libraryHaskellDepends = [
         base binary bytestring containers directory filepath mtl network
         pureMD5 stm syb template-haskell time utf8-string
       ];
       description = "Cloud Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "remote-debugger" = callPackage
    ({ mkDerivation, array, base, ghc, ghc-paths, json, network }:
     mkDerivation {
       pname = "remote-debugger";
       version = "0.2.2";
       sha256 = "64a6b81314fa40fee38cb2db34263caa1655bd59186e2cf099709804d280ddb0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base ghc ghc-paths json network
       ];
       homepage = "https://github.com/octomarat/HaskellDebugger";
       description = "Interface to ghci debugger";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "remote-json" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , exceptions, fail, natural-transformation, QuickCheck
     , quickcheck-instances, random, remote-monad, scientific, tasty
     , tasty-quickcheck, text, transformers, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "remote-json";
       version = "0.2";
       sha256 = "626c1a9dc5287f538d47eba6d727a2c0f4d99ec9d07e0d1679c307b028025a8a";
       libraryHaskellDepends = [
         aeson base exceptions fail natural-transformation remote-monad text
         transformers unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring containers natural-transformation
         QuickCheck quickcheck-instances random scientific tasty
         tasty-quickcheck text
       ];
       jailbreak = true;
       description = "Remote Monad implementation of the JSON RPC protocol";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "remote-json-client" = callPackage
    ({ mkDerivation, aeson, base, lens, natural-transformation
     , remote-json, wreq
     }:
     mkDerivation {
       pname = "remote-json-client";
       version = "0.2";
       sha256 = "7d8fe9df424dae251b602073d618506f22a4f8e6bde5e0a39cdb6fdb7d065953";
       revision = "1";
       editedCabalFile = "dcaba53dfe4c923ab531dbcd8ea45bb89bbe57a06f23b431477c505a7101085f";
       libraryHaskellDepends = [
         aeson base lens natural-transformation remote-json wreq
       ];
       description = "Web client wrapper for remote-json";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "remote-json-server" = callPackage
    ({ mkDerivation, aeson, base, data-default-class
     , natural-transformation, remote-json, scotty, text, transformers
     , warp
     }:
     mkDerivation {
       pname = "remote-json-server";
       version = "0.2.0.1";
       sha256 = "69d73e270668433a9526948bf24ca7cc3e2076d8e323310c830c1326232c2553";
       libraryHaskellDepends = [
         aeson base data-default-class natural-transformation remote-json
         scotty text transformers warp
       ];
       description = "Web server wrapper for remote-json";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "remote-monad" = callPackage
    ({ mkDerivation, base, containers, natural-transformation
     , QuickCheck, quickcheck-instances, tasty, tasty-quickcheck
     , transformers
     }:
     mkDerivation {
       pname = "remote-monad";
       version = "0.2";
       sha256 = "94c8fcb1c9c4088931cc960c39070778e571f195ad7ce45a12341e6f314a3f63";
       revision = "1";
       editedCabalFile = "a2439b1ff68620c1004e36420104d96bb8942395190607f98372f2afec20b31f";
       libraryHaskellDepends = [
         base natural-transformation transformers
       ];
       testHaskellDepends = [
         base containers natural-transformation QuickCheck
         quickcheck-instances tasty tasty-quickcheck
       ];
       description = "An parametrizable Remote Monad, and parametrizable Applicative Functor";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "remotion" = callPackage
    ({ mkDerivation, async, base, bytestring, concurrent-extra
     , containers, directory, errors, filelock, hashable, hashtables
     , HTF, HUnit, lifted-async, loch-th, monad-control, mtl, network
     , network-simple, old-locale, pipes, pipes-bytestring
     , pipes-cereal-plus, pipes-network, pipes-parse, placeholders
     , QuickCheck, quickcheck-instances, stm, system-fileio
     , system-filepath, text, time, transformers-base
     }:
     mkDerivation {
       pname = "remotion";
       version = "0.2.0";
       sha256 = "ca9e7df0f06d9ea224a614b756f3ad3687abe9df059a187d1a519908402cfd54";
       libraryHaskellDepends = [
         async base bytestring concurrent-extra containers directory errors
         filelock hashable hashtables lifted-async loch-th monad-control mtl
         network network-simple old-locale pipes pipes-bytestring
         pipes-cereal-plus pipes-network pipes-parse placeholders stm
         system-fileio system-filepath text time transformers-base
       ];
       testHaskellDepends = [
         async base bytestring concurrent-extra containers directory errors
         filelock hashable hashtables HTF HUnit lifted-async loch-th
         monad-control mtl network network-simple old-locale pipes
         pipes-bytestring pipes-cereal-plus pipes-network pipes-parse
         placeholders QuickCheck quickcheck-instances stm system-fileio
         system-filepath text time transformers-base
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/remotion";
       description = "A library for client-server applications based on custom protocols";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "renderable" = callPackage
    ({ mkDerivation, base, containers, hashable }:
     mkDerivation {
       pname = "renderable";
       version = "0.1.0.0";
       sha256 = "ca6b9f6b724b5e94b3d01d0848dbbbb7e8084ed5e0701a32c38ea08b02b45df5";
       libraryHaskellDepends = [ base containers hashable ];
       homepage = "http://zyghost.com";
       description = "Provides a nice API for rendering data types that change over time";
       license = stdenv.lib.licenses.mit;
     }) {};

  "reord" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "reord";
       version = "0.0.0.2";
       sha256 = "fe64082e698e22c3a23a552d6f60d047672a614bcbb2f765f3c5140ca4b39d1e";
       libraryHaskellDepends = [ base ];
       description = "Ad-hoc Ord instances";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "reorderable" = callPackage
    ({ mkDerivation, base, constraints, haskell-src-exts
     , haskell-src-meta, template-haskell
     }:
     mkDerivation {
       pname = "reorderable";
       version = "0.3.1";
       sha256 = "ce28e43d726090c64205849a37a627629bd7c479a52fd0bd6e72946255f601c5";
       libraryHaskellDepends = [
         base constraints haskell-src-exts haskell-src-meta template-haskell
       ];
       jailbreak = true;
       description = "Define compound types that do not depend on member order";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repa_3_3_1_2" = callPackage
    ({ mkDerivation, base, bytestring, ghc-prim, QuickCheck
     , template-haskell, vector
     }:
     mkDerivation {
       pname = "repa";
       version = "3.3.1.2";
       sha256 = "51911e26d9c5f770fc417e4ead486c443b561f96a4bb9f3044add7c04c834a67";
       libraryHaskellDepends = [
         base bytestring ghc-prim QuickCheck template-haskell vector
       ];
       jailbreak = true;
       homepage = "http://repa.ouroborus.net";
       description = "High performance, regular, shape polymorphic parallel arrays";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repa_3_4_0_1" = callPackage
    ({ mkDerivation, base, bytestring, ghc-prim, QuickCheck
     , template-haskell, vector
     }:
     mkDerivation {
       pname = "repa";
       version = "3.4.0.1";
       sha256 = "84a2e20b8dd3557d2f8cbf59d8d06e696cfbbec29d4d8ae2b0a04407fe59eaa4";
       libraryHaskellDepends = [
         base bytestring ghc-prim QuickCheck template-haskell vector
       ];
       jailbreak = true;
       homepage = "http://repa.ouroborus.net";
       description = "High performance, regular, shape polymorphic parallel arrays";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repa" = callPackage
    ({ mkDerivation, base, bytestring, ghc-prim, QuickCheck
     , template-haskell, vector
     }:
     mkDerivation {
       pname = "repa";
       version = "3.4.0.2";
       sha256 = "1c0b48818e415f6002794a5c0e13c63d6a738c4a5ff2bcedfea009521478e53d";
       libraryHaskellDepends = [
         base bytestring ghc-prim QuickCheck template-haskell vector
       ];
       homepage = "http://repa.ouroborus.net";
       description = "High performance, regular, shape polymorphic parallel arrays";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "repa-algorithms_3_3_1_2" = callPackage
    ({ mkDerivation, base, repa, vector }:
     mkDerivation {
       pname = "repa-algorithms";
       version = "3.3.1.2";
       sha256 = "69ce675589891600d41758150ba885bec05e9e24638e1ffbd0fc1ca4eafed189";
       libraryHaskellDepends = [ base repa vector ];
       jailbreak = true;
       homepage = "http://repa.ouroborus.net";
       description = "Algorithms using the Repa array library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repa-algorithms_3_4_0_1" = callPackage
    ({ mkDerivation, base, repa, vector }:
     mkDerivation {
       pname = "repa-algorithms";
       version = "3.4.0.1";
       sha256 = "1470245351cccf155ab587f577c2e7948214022bf0eb8ed966b13c5dc3e51261";
       libraryHaskellDepends = [ base repa vector ];
       jailbreak = true;
       homepage = "http://repa.ouroborus.net";
       description = "Algorithms using the Repa array library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repa-algorithms" = callPackage
    ({ mkDerivation, base, repa, vector }:
     mkDerivation {
       pname = "repa-algorithms";
       version = "3.4.0.2";
       sha256 = "49de64a94ebf28800c408c7e9ba418b97e7663d2c74e4499187a2d90664f8939";
       libraryHaskellDepends = [ base repa vector ];
       homepage = "http://repa.ouroborus.net";
       description = "Algorithms using the Repa array library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "repa-array" = callPackage
    ({ mkDerivation, base, bytestring, double-conversion, mtl
     , primitive, repa-convert, repa-eval, repa-stream, text, vector
     }:
     mkDerivation {
       pname = "repa-array";
       version = "4.1.0.1";
       sha256 = "d32a9ad0cce363f6347e83ac0e6ebc2a6be84a03aa1aedbf9b37e7e285147111";
       libraryHaskellDepends = [
         base bytestring double-conversion mtl primitive repa-convert
         repa-eval repa-stream text vector
       ];
       jailbreak = true;
       homepage = "http://repa.ouroborus.net";
       description = "Bulk array representations and operators";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repa-bytestring" = callPackage
    ({ mkDerivation, base, repa }:
     mkDerivation {
       pname = "repa-bytestring";
       version = "3.0.0.1";
       sha256 = "eb017a9fa85900e6a6f254e5e7ef9e31585791458344ffb2554be19846ddf3e0";
       libraryHaskellDepends = [ base repa ];
       doHaddock = false;
       jailbreak = true;
       homepage = "http://repa.ouroborus.net";
       description = "(deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "repa-convert" = callPackage
    ({ mkDerivation, base, bytestring, double-conversion, primitive
     , repa-scalar, vector
     }:
     mkDerivation {
       pname = "repa-convert";
       version = "4.2.0.1";
       sha256 = "3421d87e0d743a1454084f3e1172dcebd050895c98a675efcbe3899a1793fd78";
       libraryHaskellDepends = [
         base bytestring double-conversion primitive repa-scalar vector
       ];
       jailbreak = true;
       homepage = "http://repa.ouroborus.net";
       description = "Packing and unpacking flat tables";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "repa-devil_0_3_2_2" = callPackage
    ({ mkDerivation, base, libdevil, repa, transformers }:
     mkDerivation {
       pname = "repa-devil";
       version = "0.3.2.2";
       sha256 = "902282f88234cadb756f0db57cbd0f6375e6f924c0b38ac9f4d573f453b4865c";
       libraryHaskellDepends = [ base repa transformers ];
       librarySystemDepends = [ libdevil ];
       jailbreak = true;
       homepage = "https://github.com/RaphaelJ/repa-devil";
       description = "Support for image reading and writing of Repa arrays using in-place FFI calls";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libdevil;};

  "repa-devil" = callPackage
    ({ mkDerivation, base, libdevil, repa, transformers }:
     mkDerivation {
       pname = "repa-devil";
       version = "0.3.2.6";
       sha256 = "fec3ce06f7370378427c629587dc30ee0f37e8c777c94c8970cb514c1e57fd38";
       libraryHaskellDepends = [ base repa transformers ];
       librarySystemDepends = [ libdevil ];
       homepage = "https://github.com/RaphaelJ/repa-devil";
       description = "Support for image reading and writing of Repa arrays using in-place FFI calls";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) libdevil;};

  "repa-eval" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "repa-eval";
       version = "4.0.0.1";
       sha256 = "3e41a4fe97ad789e2743961ed797e206f4efe0c326a580cf48aabe329007cf6e";
       libraryHaskellDepends = [ base ghc-prim ];
       jailbreak = true;
       homepage = "http://repa.ouroborus.net";
       description = "Low-level parallel operators on bulk random-accessble arrays";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "repa-examples" = callPackage
    ({ mkDerivation, base, QuickCheck, random, repa, repa-algorithms
     , repa-io, template-haskell, vector
     }:
     mkDerivation {
       pname = "repa-examples";
       version = "3.4.0.1";
       sha256 = "5f3daab723795f3e40690d3ee2f5aa674ea7bafa5c6b7a2669b66ea627f96103";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base QuickCheck random repa repa-algorithms repa-io
         template-haskell vector
       ];
       jailbreak = true;
       homepage = "http://repa.ouroborus.net";
       description = "Examples using the Repa array library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "repa-fftw" = callPackage
    ({ mkDerivation, base, carray, fft, repa, storable-complex, tasty
     , tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "repa-fftw";
       version = "3.2.3.2";
       sha256 = "400c693b9771eac5a6757d0297302ab1db7ff4aa4163919bb30411a7bd840578";
       libraryHaskellDepends = [ base carray fft repa storable-complex ];
       testHaskellDepends = [
         base repa tasty tasty-hunit tasty-quickcheck
       ];
       description = "Perform fft with repa via FFTW";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "repa-flow" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , primitive, repa-array, repa-eval, repa-stream, text, vector
     }:
     mkDerivation {
       pname = "repa-flow";
       version = "4.1.0.1";
       sha256 = "e75d36f9c7a4e9a37b3aa26515b569ca4a982aaa0943216bed2b033718277234";
       libraryHaskellDepends = [
         base bytestring containers directory filepath primitive repa-array
         repa-eval repa-stream text vector
       ];
       jailbreak = true;
       homepage = "http://repa.ouroborus.net";
       description = "Data-parallel data flows";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repa-io_3_3_1_2" = callPackage
    ({ mkDerivation, base, binary, bmp, bytestring, old-time, repa
     , vector
     }:
     mkDerivation {
       pname = "repa-io";
       version = "3.3.1.2";
       sha256 = "b77cd00f7d592c4cd70d506a5b2651155337507442db2ac337fa7842a6f6a8c4";
       libraryHaskellDepends = [
         base binary bmp bytestring old-time repa vector
       ];
       jailbreak = true;
       homepage = "http://repa.ouroborus.net";
       description = "Read and write Repa arrays in various formats";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repa-io_3_4_0_1" = callPackage
    ({ mkDerivation, base, binary, bmp, bytestring, old-time, repa
     , vector
     }:
     mkDerivation {
       pname = "repa-io";
       version = "3.4.0.1";
       sha256 = "74adccf005cb2a72eac88a0f815261cedb3ed925d4de9a60a7ca4aa5fb237a1a";
       libraryHaskellDepends = [
         base binary bmp bytestring old-time repa vector
       ];
       jailbreak = true;
       homepage = "http://repa.ouroborus.net";
       description = "Read and write Repa arrays in various formats";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repa-io" = callPackage
    ({ mkDerivation, base, binary, bmp, bytestring, old-time, repa
     , vector
     }:
     mkDerivation {
       pname = "repa-io";
       version = "3.4.0.2";
       sha256 = "bfda3a8b5dc92783e6099e361a0e76b0994b26fc7a8073a22696cb3fe6cb8147";
       libraryHaskellDepends = [
         base binary bmp bytestring old-time repa vector
       ];
       homepage = "http://repa.ouroborus.net";
       description = "Read and write Repa arrays in various formats";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "repa-linear-algebra" = callPackage
    ({ mkDerivation, base, hmatrix, repa, vector }:
     mkDerivation {
       pname = "repa-linear-algebra";
       version = "0.3.0.0";
       sha256 = "643cbbbd486fa48f74ae1bbdcd05a8092325c8dba08e1950522fe27e8c45f559";
       libraryHaskellDepends = [ base hmatrix repa vector ];
       homepage = "https://github.com/marcinmrotek/repa-linear-algebra";
       description = "HMatrix operations for Repa";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "repa-plugin" = callPackage
    ({ mkDerivation, base, containers, ddc-base, ddc-core
     , ddc-core-flow, ddc-core-simpl, ghc, mtl
     }:
     mkDerivation {
       pname = "repa-plugin";
       version = "1.0.0.1";
       sha256 = "c9237d4c3e0bb0b8aaed14e22b77b9baf751822053f12c96461f6b336926c468";
       libraryHaskellDepends = [
         base containers ddc-base ddc-core ddc-core-flow ddc-core-simpl ghc
         mtl
       ];
       jailbreak = true;
       description = "Data Flow Fusion GHC Plugin";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repa-scalar" = callPackage
    ({ mkDerivation, base, bytestring, double-conversion, primitive
     , vector
     }:
     mkDerivation {
       pname = "repa-scalar";
       version = "4.2.0.1";
       sha256 = "c6190f1886a5c9ce27e2fdc5bd62f8aeeace9771d1abed23fc598a0854277ed5";
       libraryHaskellDepends = [
         base bytestring double-conversion primitive vector
       ];
       jailbreak = true;
       homepage = "http://repa.ouroborus.net";
       description = "Scalar data types and conversions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "repa-series" = callPackage
    ({ mkDerivation, base, ghc, ghc-prim, vector }:
     mkDerivation {
       pname = "repa-series";
       version = "1.0.0.1";
       sha256 = "b35cda295c1aeea79a0472a4c64a24bc02f81c5bdca3c371a41b6c461af98dce";
       libraryHaskellDepends = [ base ghc ghc-prim vector ];
       jailbreak = true;
       description = "Series Expressionss API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repa-sndfile" = callPackage
    ({ mkDerivation, base, directory, filepath, hsndfile
     , hsndfile-vector, repa, vector
     }:
     mkDerivation {
       pname = "repa-sndfile";
       version = "3.2.3.3";
       sha256 = "68bee7a0b5fb4afefc77235987b2bff74b8e60c0d0b46aa3ba8a057d226cf95d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base hsndfile repa ];
       executableHaskellDepends = [
         base hsndfile hsndfile-vector repa vector
       ];
       testHaskellDepends = [
         base directory filepath hsndfile hsndfile-vector repa vector
       ];
       description = "Reading and writing sound files with repa arrays";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "repa-stream" = callPackage
    ({ mkDerivation, base, mtl, primitive, vector }:
     mkDerivation {
       pname = "repa-stream";
       version = "4.1.0.1";
       sha256 = "b576da1cb6752c8a56be1e4bad7d991c6ba3fa26500421ad1aaaf4eb7b44c49e";
       libraryHaskellDepends = [ base mtl primitive vector ];
       jailbreak = true;
       homepage = "http://repa.ouroborus.net";
       description = "Stream functions not present in the vector library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repa-v4l2" = callPackage
    ({ mkDerivation, base, bmp, bytestring, containers, deepseq, gloss
     , mtl, repa, transformers, v4l2, vector
     }:
     mkDerivation {
       pname = "repa-v4l2";
       version = "0.2.0.0";
       sha256 = "dff6246e586d21e3f3771694aac32d2eecf0efebbf8c33ab4e8b2de9eebd1ab5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bmp bytestring containers deepseq mtl repa transformers v4l2
         vector
       ];
       executableHaskellDepends = [ base gloss repa ];
       homepage = "https://github.com/cgo/hsimage";
       description = "Provides high-level access to webcams";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repl" = callPackage
    ({ mkDerivation, base, ghc, ghc-paths, haskell-src-exts, parsec }:
     mkDerivation {
       pname = "repl";
       version = "1.1";
       sha256 = "09daa598761e3ebef3ae952ef41ff0d8439917f7d561ee90f50fd994cd992f61";
       libraryHaskellDepends = [
         base ghc ghc-paths haskell-src-exts parsec
       ];
       jailbreak = true;
       homepage = "https://github.com/mikeplus64/repl";
       description = "IRC friendly REPL library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repl-toolkit" = callPackage
    ({ mkDerivation, aeson, base, bytestring, data-default, directory
     , exceptions, filepath, functor-monadic, ListLike, listsafe
     , monad-loops, mtl, parsec, semigroupoids, text, transformers
     }:
     mkDerivation {
       pname = "repl-toolkit";
       version = "1.0.0.1";
       sha256 = "f6b6c55a73c4408381204b22edf05a8b2681eef23ec7631c2a919b28609be79a";
       libraryHaskellDepends = [
         aeson base bytestring data-default directory exceptions filepath
         functor-monadic ListLike listsafe monad-loops mtl parsec
         semigroupoids text transformers
       ];
       homepage = "https://github.com/ombocomp/repl-toolkit";
       description = "Toolkit for quickly whipping up config files and command-line interfaces";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "repline" = callPackage
    ({ mkDerivation, base, containers, haskeline, mtl, process }:
     mkDerivation {
       pname = "repline";
       version = "0.1.4.0";
       sha256 = "32ae73f4343e5b4a0530259a5b23f35ff784d00e62a6adb50dc656ff2e1d119b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers haskeline mtl ];
       executableHaskellDepends = [ base containers mtl process ];
       description = "Haskeline wrapper for GHCi-like REPL interfaces";
       license = stdenv.lib.licenses.mit;
     }) {};

  "repo-based-blog" = callPackage
    ({ mkDerivation, base, blaze-html, containers, data-default
     , directory, dyre, filepath, filestore, hspec, hspec-discover
     , ixset, lens, mtl, old-locale, pandoc, parsec, QuickCheck, stm
     , text, time, transformers, transformers-base, transformers-compat
     }:
     mkDerivation {
       pname = "repo-based-blog";
       version = "0.0.1";
       sha256 = "9a59baffe50f4989de6ecf55ad4ac2329bbf9976c8fda8c381ccdc797107aa29";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html containers data-default directory dyre filepath
         filestore ixset lens mtl old-locale pandoc parsec stm text time
         transformers transformers-base transformers-compat
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base blaze-html containers directory filepath filestore hspec
         hspec-discover ixset lens mtl old-locale parsec QuickCheck stm text
         time transformers transformers-base transformers-compat
       ];
       homepage = "https://github.com/saep/repo-based-blog";
       description = "Blogging module using blaze html for markup";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repr" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, dstring, random
     , string-combinators
     }:
     mkDerivation {
       pname = "repr";
       version = "0.4.1.3";
       sha256 = "452aec30671cc2e66786f3f75d44370ebb0c915da6ae8122cb3231e903a23ff8";
       libraryHaskellDepends = [
         base base-unicode-symbols dstring random string-combinators
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/repr";
       description = "Render overloaded expressions to their textual representation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "repr-tree-syb" = callPackage
    ({ mkDerivation, base, containers, syb, text }:
     mkDerivation {
       pname = "repr-tree-syb";
       version = "0.1.0";
       sha256 = "ba680aaa125fe2383f4cc896078e135f767cafb5df9dee80857f6c57d776fdce";
       libraryHaskellDepends = [ base containers syb text ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/repr-tree-syb";
       description = "Tree representation and pretty-printing of data structures based on SYB";
       license = stdenv.lib.licenses.mit;
     }) {};

  "representable-functors" = callPackage
    ({ mkDerivation, array, base, comonad, comonad-transformers
     , comonads-fd, containers, contravariant, distributive, free, keys
     , mtl, semigroupoids, semigroups, transformers
     }:
     mkDerivation {
       pname = "representable-functors";
       version = "3.2.0.2";
       sha256 = "8206be657d1e44332d88d1f41cccad2561f1df21c6bc7bc9be7c760c5385d994";
       libraryHaskellDepends = [
         array base comonad comonad-transformers comonads-fd containers
         contravariant distributive free keys mtl semigroupoids semigroups
         transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/representable-functors/";
       description = "Representable functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "representable-profunctors" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "representable-profunctors";
       version = "3.2";
       sha256 = "8c2794676df74874d1a9a77cfc41cdd3ef052858bcab78e8cb13801e3b499e2e";
       libraryHaskellDepends = [ base ];
       doHaddock = false;
       homepage = "http://github.com/ekmett/representable-profunctors/";
       description = "This package has been absorbed into profunctor-extras";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "representable-tries" = callPackage
    ({ mkDerivation, adjunctions, base, bifunctors, comonad
     , comonad-transformers, containers, distributive, keys, mtl
     , representable-functors, semigroupoids, semigroups, transformers
     }:
     mkDerivation {
       pname = "representable-tries";
       version = "3.0.2";
       sha256 = "55d0a8e42b475f7ee4449ea87849f95bfa62ae8495c0bbbc6f1627d709a8121f";
       libraryHaskellDepends = [
         adjunctions base bifunctors comonad comonad-transformers containers
         distributive keys mtl representable-functors semigroupoids
         semigroups transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/representable-tries/";
       description = "Tries from representations of polynomial functors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "request-monad" = callPackage
    ({ mkDerivation, base, free, mtl, transformers }:
     mkDerivation {
       pname = "request-monad";
       version = "0.3.0.1";
       sha256 = "9a27d1628f96ba9d0fcdd0bff3cfc9ae0c7abcee7b59d2ce0ca1fda152d50cab";
       libraryHaskellDepends = [ base free mtl transformers ];
       jailbreak = true;
       homepage = "http://github.com/nahiluhmot/request-monad";
       description = "A transformer for generic requests";
       license = stdenv.lib.licenses.mit;
     }) {};

  "reroute_0_2_2_1" = callPackage
    ({ mkDerivation, base, deepseq, graph-core, hashable, hspec, mtl
     , path-pieces, regex-compat, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "reroute";
       version = "0.2.2.1";
       sha256 = "f6e26fc375037ec434e7ca7790f05e98e70621edbfeb498f60e3cfa6b75c3fc3";
       libraryHaskellDepends = [
         base deepseq graph-core hashable mtl path-pieces regex-compat text
         transformers unordered-containers vector
       ];
       testHaskellDepends = [
         base hspec mtl text unordered-containers vector
       ];
       homepage = "http://github.com/agrafix/reroute";
       description = "abstract implementation of typed and untyped web routing";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reroute_0_2_3_0" = callPackage
    ({ mkDerivation, base, deepseq, graph-core, hashable, hspec, mtl
     , path-pieces, regex-compat, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "reroute";
       version = "0.2.3.0";
       sha256 = "fd063f67d91f2ca4f80c7344e2d1de68d67a6bf521899828776c404a2729d9f3";
       libraryHaskellDepends = [
         base deepseq graph-core hashable mtl path-pieces regex-compat text
         transformers unordered-containers vector
       ];
       testHaskellDepends = [
         base hspec mtl text unordered-containers vector
       ];
       homepage = "http://github.com/agrafix/reroute";
       description = "abstract implementation of typed and untyped web routing";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reroute_0_3_0_2" = callPackage
    ({ mkDerivation, base, deepseq, graph-core, hashable, hspec, hvect
     , mtl, path-pieces, regex-compat, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "reroute";
       version = "0.3.0.2";
       sha256 = "68595687d3ed7cab038a6a46c1b78349e6dcc114301164696bebbc851f9bb393";
       libraryHaskellDepends = [
         base deepseq graph-core hashable hvect mtl path-pieces regex-compat
         text transformers unordered-containers vector
       ];
       testHaskellDepends = [
         base hspec hvect mtl text unordered-containers vector
       ];
       homepage = "http://github.com/agrafix/reroute";
       description = "abstract implementation of typed and untyped web routing";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "reroute" = callPackage
    ({ mkDerivation, base, deepseq, graph-core, hashable, hspec, hvect
     , mtl, path-pieces, regex-compat, text, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "reroute";
       version = "0.3.1.0";
       sha256 = "5e31044f054305e119f80aa2625ecd4b7453e383d67dc44b8fdd9d64fa476fe9";
       libraryHaskellDepends = [
         base deepseq graph-core hashable hvect mtl path-pieces regex-compat
         text transformers unordered-containers vector
       ];
       testHaskellDepends = [
         base hspec hvect mtl text unordered-containers vector
       ];
       homepage = "http://github.com/agrafix/reroute";
       description = "abstract implementation of typed and untyped web routing";
       license = stdenv.lib.licenses.mit;
     }) {};

  "reserve" = callPackage
    ({ mkDerivation, base, base-compat, bytestring, directory, hspec
     , http-conduit, http-kit, http-types, network, process, QuickCheck
     , unix, warp
     }:
     mkDerivation {
       pname = "reserve";
       version = "0.1.1";
       sha256 = "42c2d26079369b4458e430b2db5a71773c98220c43a80212ce9ee63ef8b35794";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base base-compat bytestring directory http-kit http-types network
         process unix
       ];
       testHaskellDepends = [
         base base-compat bytestring directory hspec http-conduit http-kit
         http-types network process QuickCheck unix warp
       ];
       description = "Reserve reloads web applications";
       license = stdenv.lib.licenses.mit;
     }) {};

  "resistor-cube" = callPackage
    ({ mkDerivation, base, hmatrix, transformers, utility-ht }:
     mkDerivation {
       pname = "resistor-cube";
       version = "0.0.0.3";
       sha256 = "09f41cea22f4b0bbf2f32c80d8eab274a520d9fe611d1b83df4d14d46afb34ad";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base hmatrix transformers utility-ht
       ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/thielema/resistor-cube";
       description = "Compute total resistance of a cube of resistors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "resolve-trivial-conflicts_0_3_2_1" = callPackage
    ({ mkDerivation, ansi-terminal, base, base-compat, Diff, directory
     , filepath, mtl, optparse-applicative, process, unix
     }:
     mkDerivation {
       pname = "resolve-trivial-conflicts";
       version = "0.3.2.1";
       sha256 = "692b81bf392cadaa29c2257e272071e79a58f010b0e947db85620e3321ba0865";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base base-compat Diff directory filepath mtl
         optparse-applicative process unix
       ];
       jailbreak = true;
       homepage = "https://github.com/ElastiLotem/resolve-trivial-conflicts";
       description = "Remove trivial conflict markers in a git repository";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "resolve-trivial-conflicts" = callPackage
    ({ mkDerivation, ansi-terminal, base, base-compat, Diff, directory
     , filepath, mtl, optparse-applicative, process, unix
     }:
     mkDerivation {
       pname = "resolve-trivial-conflicts";
       version = "0.3.2.2";
       sha256 = "2d68535d32943a6640845c86de751ab5185c687a2604c3435e4d757a2a263c1b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base base-compat Diff directory filepath mtl
         optparse-applicative process unix
       ];
       homepage = "https://github.com/ElastiLotem/resolve-trivial-conflicts";
       description = "Remove trivial conflict markers in a git repository";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "resource-effect" = callPackage
    ({ mkDerivation, base, containers, extensible-effects, HUnit, mtl
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "resource-effect";
       version = "0.1.1";
       sha256 = "cb76a7d08645f40870db5454ca9384a27362c60df64dd2a9bb67e67884a2b120";
       libraryHaskellDepends = [ base containers extensible-effects ];
       testHaskellDepends = [
         base containers extensible-effects HUnit mtl QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/wowus/resource-effect/";
       description = "A port of the package 'resourcet' for extensible effects";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "resource-embed" = callPackage
    ({ mkDerivation, base, bytestring, directory }:
     mkDerivation {
       pname = "resource-embed";
       version = "0.1.0.0";
       sha256 = "db090bf91535d9023872fce13eac7b54dbe3e506811569a6f8458b93f3f863c4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bytestring directory ];
       homepage = "https://bitbucket.org/tdammers/resource-embed";
       description = "Embed data files via C and FFI";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "resource-pool_0_2_3_1" = callPackage
    ({ mkDerivation, base, hashable, monad-control, stm, time
     , transformers, transformers-base, vector
     }:
     mkDerivation {
       pname = "resource-pool";
       version = "0.2.3.1";
       sha256 = "2265fc16f409eeb8d8e85644029c19b46bc48834ebba8aba8cb0b1ef64e1d709";
       revision = "1";
       editedCabalFile = "68c8ac9105a980178fc6e2a07446b3ba87283fc662df1dec181c50953b74b96d";
       libraryHaskellDepends = [
         base hashable monad-control stm time transformers transformers-base
         vector
       ];
       jailbreak = true;
       homepage = "http://github.com/bos/pool";
       description = "A high-performance striped resource pooling implementation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "resource-pool" = callPackage
    ({ mkDerivation, base, hashable, monad-control, stm, time
     , transformers, transformers-base, vector
     }:
     mkDerivation {
       pname = "resource-pool";
       version = "0.2.3.2";
       sha256 = "8627eea2bea8824af2723646e74e2af0c73f583dd0c496c9fd242cd9d242bc12";
       libraryHaskellDepends = [
         base hashable monad-control stm time transformers transformers-base
         vector
       ];
       homepage = "http://github.com/bos/pool";
       description = "A high-performance striped resource pooling implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "resource-pool-catchio" = callPackage
    ({ mkDerivation, base, hashable, MonadCatchIO-transformers, stm
     , time, transformers, transformers-base, vector
     }:
     mkDerivation {
       pname = "resource-pool-catchio";
       version = "0.2.1.0";
       sha256 = "5c5795e7a057aa1dc51c54fd24aafa7720e814616e3a36a3b8c306602d34393d";
       libraryHaskellDepends = [
         base hashable MonadCatchIO-transformers stm time transformers
         transformers-base vector
       ];
       homepage = "http://github.com/norm2782/pool";
       description = "Fork of resource-pool, with a MonadCatchIO constraint";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "resource-pool-monad" = callPackage
    ({ mkDerivation, base, free, kan-extensions, monad-control
     , resource-pool, transformers
     }:
     mkDerivation {
       pname = "resource-pool-monad";
       version = "0.1.0.0";
       sha256 = "55b1c20a38a948defe55f39db23fc4e65f0ce452a69f2a566319ef3c896f647f";
       libraryHaskellDepends = [
         base free kan-extensions monad-control resource-pool transformers
       ];
       homepage = "https://github.com/srijs/haskell-resource-pool-monad";
       description = "A monadic interface for resource-pool";
       license = stdenv.lib.licenses.mit;
     }) {};

  "resource-simple" = callPackage
    ({ mkDerivation, base, containers, monad-control, monad-fork
     , mtl-evil-instances, transformers, transformers-base
     }:
     mkDerivation {
       pname = "resource-simple";
       version = "0.2";
       sha256 = "d132fda6954bc2c3e1ae474f4beeb4224cd0d01ebfe295aab42a39802d6cd254";
       libraryHaskellDepends = [
         base containers monad-control monad-fork mtl-evil-instances
         transformers transformers-base
       ];
       jailbreak = true;
       description = "Allocate resources which are guaranteed to be released";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "resourcet_1_1_3_1" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, monad-control, mtl, transformers, transformers-base
     }:
     mkDerivation {
       pname = "resourcet";
       version = "1.1.3.1";
       sha256 = "1d65d4fcb9a059e79868c40f91f4abe3c255663a1c48938c4538150693dce88d";
       revision = "1";
       editedCabalFile = "21218d83b388b6f7605ece81c851345f096ef2f8c2b94d214e492fa12f860906";
       libraryHaskellDepends = [
         base containers exceptions lifted-base mmorph monad-control mtl
         transformers transformers-base
       ];
       testHaskellDepends = [ base hspec lifted-base transformers ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Deterministic allocation and freeing of scarce resources";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "resourcet_1_1_3_3" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, monad-control, mtl, transformers, transformers-base
     }:
     mkDerivation {
       pname = "resourcet";
       version = "1.1.3.3";
       sha256 = "829f2a7427429dbfd343e03c5bfb3e46c3bfbe84a797e9c166d40f0b66b80546";
       revision = "1";
       editedCabalFile = "57ab06bbb0fcb0ece3504face4d3b417219678003e575c6d7a45db0cb1aaf381";
       libraryHaskellDepends = [
         base containers exceptions lifted-base mmorph monad-control mtl
         transformers transformers-base
       ];
       testHaskellDepends = [ base hspec lifted-base transformers ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Deterministic allocation and freeing of scarce resources";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "resourcet_1_1_4_1" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, monad-control, mtl, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "resourcet";
       version = "1.1.4.1";
       sha256 = "e29afb420e2f5b8d82d1a4c7a722628e1d8d2f96bc3282b20b0a3d21b25c89e3";
       revision = "1";
       editedCabalFile = "28106769e7204b32cfdfb46603990697cfef6f1a9e720d47ec76873edfb06ad7";
       libraryHaskellDepends = [
         base containers exceptions lifted-base mmorph monad-control mtl
         transformers transformers-base transformers-compat
       ];
       testHaskellDepends = [ base hspec lifted-base transformers ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Deterministic allocation and freeing of scarce resources";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "resourcet_1_1_5" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, monad-control, mtl, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "resourcet";
       version = "1.1.5";
       sha256 = "fefa591df8102f964b8d5883c5d9dbcea2d1ad22afc5d8b60fee610e5d3f7b18";
       libraryHaskellDepends = [
         base containers exceptions lifted-base mmorph monad-control mtl
         transformers transformers-base transformers-compat
       ];
       testHaskellDepends = [ base hspec lifted-base transformers ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Deterministic allocation and freeing of scarce resources";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "resourcet_1_1_6" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, monad-control, mtl, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "resourcet";
       version = "1.1.6";
       sha256 = "3e10ea62fd97334a5fd6aa3410e6cf50d46b914aa1c028b7393e234b94521a7e";
       libraryHaskellDepends = [
         base containers exceptions lifted-base mmorph monad-control mtl
         transformers transformers-base transformers-compat
       ];
       testHaskellDepends = [ base hspec lifted-base transformers ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Deterministic allocation and freeing of scarce resources";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "resourcet_1_1_7" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, monad-control, mtl, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "resourcet";
       version = "1.1.7";
       sha256 = "3b79d07199160c966c67a5300a51b7c8790dda7bed6c00e554a0062d03c9ab4d";
       libraryHaskellDepends = [
         base containers exceptions lifted-base mmorph monad-control mtl
         transformers transformers-base transformers-compat
       ];
       testHaskellDepends = [ base hspec lifted-base transformers ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Deterministic allocation and freeing of scarce resources";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "resourcet_1_1_7_1" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, monad-control, mtl, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "resourcet";
       version = "1.1.7.1";
       sha256 = "25133c9dd1ccdab047ab23b11907184ff319e561794563978768a893b27908ce";
       libraryHaskellDepends = [
         base containers exceptions lifted-base mmorph monad-control mtl
         transformers transformers-base transformers-compat
       ];
       testHaskellDepends = [ base hspec lifted-base transformers ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Deterministic allocation and freeing of scarce resources";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "resourcet" = callPackage
    ({ mkDerivation, base, containers, exceptions, hspec, lifted-base
     , mmorph, monad-control, mtl, transformers, transformers-base
     , transformers-compat
     }:
     mkDerivation {
       pname = "resourcet";
       version = "1.1.7.2";
       sha256 = "c1c71985d3f0fcc511a10dec89f8abfe31e0caa6355b8697e8d1ae3d6d14de86";
       libraryHaskellDepends = [
         base containers exceptions lifted-base mmorph monad-control mtl
         transformers transformers-base transformers-compat
       ];
       testHaskellDepends = [ base hspec lifted-base transformers ];
       homepage = "http://github.com/snoyberg/conduit";
       description = "Deterministic allocation and freeing of scarce resources";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "respond" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, bytestring, containers
     , data-default-class, exceptions, fast-logger, formatting, HList
     , http-media, http-types, lens, monad-control, monad-logger, mtl
     , path-pieces, safe, scientific, template-haskell, text, time
     , transformers, transformers-base, unordered-containers, vector
     , wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "respond";
       version = "1.1.0";
       sha256 = "79d4f4181880486e0932f0d9de86edbdda877eadba3bd0aa7357e76ca6535d48";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bifunctors bytestring containers data-default-class
         exceptions fast-logger formatting HList http-media http-types lens
         monad-control monad-logger mtl path-pieces safe scientific
         template-haskell text time transformers transformers-base
         unordered-containers vector wai wai-extra warp
       ];
       executableHaskellDepends = [
         aeson base fast-logger http-types text wai
       ];
       jailbreak = true;
       homepage = "https://github.com/raptros/respond";
       description = "process and route HTTP requests and generate responses on top of WAI";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-client_0_4_0_1" = callPackage
    ({ mkDerivation, aeson-utils, base, bytestring, case-insensitive
     , data-default, exception-transformers, http-conduit, http-types
     , hxt, hxt-pickle-utils, monad-control, mtl, primitive, resourcet
     , rest-types, tostring, transformers-base, uri-encode, utf8-string
     }:
     mkDerivation {
       pname = "rest-client";
       version = "0.4.0.1";
       sha256 = "ecda9c115cd7ce0a5c2f38a36a582bffc963391056d5392eed1c6093fd9bc2ae";
       libraryHaskellDepends = [
         aeson-utils base bytestring case-insensitive data-default
         exception-transformers http-conduit http-types hxt hxt-pickle-utils
         monad-control mtl primitive resourcet rest-types tostring
         transformers-base uri-encode utf8-string
       ];
       jailbreak = true;
       description = "Utility library for use in generated API client libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-client_0_4_0_2" = callPackage
    ({ mkDerivation, aeson-utils, base, bytestring, case-insensitive
     , data-default, exception-transformers, http-conduit, http-types
     , hxt, hxt-pickle-utils, monad-control, mtl, primitive, resourcet
     , rest-types, tostring, transformers-base, uri-encode, utf8-string
     }:
     mkDerivation {
       pname = "rest-client";
       version = "0.4.0.2";
       sha256 = "dc58480656f9c2b81d6bec921cf4b1fba87f25f774821c8e1b56a698f02f70ba";
       libraryHaskellDepends = [
         aeson-utils base bytestring case-insensitive data-default
         exception-transformers http-conduit http-types hxt hxt-pickle-utils
         monad-control mtl primitive resourcet rest-types tostring
         transformers-base uri-encode utf8-string
       ];
       jailbreak = true;
       description = "Utility library for use in generated API client libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-client_0_4_0_3" = callPackage
    ({ mkDerivation, aeson-utils, base, bytestring, case-insensitive
     , data-default, exception-transformers, http-conduit, http-types
     , hxt, hxt-pickle-utils, monad-control, mtl, primitive, resourcet
     , rest-types, tostring, transformers-base, uri-encode, utf8-string
     }:
     mkDerivation {
       pname = "rest-client";
       version = "0.4.0.3";
       sha256 = "631b65088dcb698a997455b015530cfbe5466ee4a6c09d0c1eccb0f953d82d07";
       libraryHaskellDepends = [
         aeson-utils base bytestring case-insensitive data-default
         exception-transformers http-conduit http-types hxt hxt-pickle-utils
         monad-control mtl primitive resourcet rest-types tostring
         transformers-base uri-encode utf8-string
       ];
       jailbreak = true;
       description = "Utility library for use in generated API client libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-client_0_4_0_5" = callPackage
    ({ mkDerivation, aeson-utils, base, bytestring, case-insensitive
     , data-default, exception-transformers, http-conduit, http-types
     , hxt, hxt-pickle-utils, monad-control, mtl, primitive, resourcet
     , rest-types, tostring, transformers-base, uri-encode, utf8-string
     }:
     mkDerivation {
       pname = "rest-client";
       version = "0.4.0.5";
       sha256 = "9aa0e1e364c5f318c7f3cb0b1ec07a1d7cc8626ba261a7642469b26355f23a87";
       libraryHaskellDepends = [
         aeson-utils base bytestring case-insensitive data-default
         exception-transformers http-conduit http-types hxt hxt-pickle-utils
         monad-control mtl primitive resourcet rest-types tostring
         transformers-base uri-encode utf8-string
       ];
       jailbreak = true;
       description = "Utility library for use in generated API client libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-client_0_5_0_2" = callPackage
    ({ mkDerivation, aeson-utils, base, bytestring, case-insensitive
     , data-default, exceptions, http-conduit, http-types, hxt
     , hxt-pickle-utils, monad-control, mtl, resourcet, rest-types
     , tostring, transformers, transformers-base, transformers-compat
     , uri-encode, utf8-string
     }:
     mkDerivation {
       pname = "rest-client";
       version = "0.5.0.2";
       sha256 = "e66f0f3b6c9d4e36b2ed52f2adb1d2605dd5cc8472dd79bd26e1e85ac7afd3eb";
       libraryHaskellDepends = [
         aeson-utils base bytestring case-insensitive data-default
         exceptions http-conduit http-types hxt hxt-pickle-utils
         monad-control mtl resourcet rest-types tostring transformers
         transformers-base transformers-compat uri-encode utf8-string
       ];
       jailbreak = true;
       description = "Utility library for use in generated API client libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-client_0_5_0_3" = callPackage
    ({ mkDerivation, aeson-utils, base, bytestring, case-insensitive
     , data-default, exceptions, http-conduit, http-types, hxt
     , hxt-pickle-utils, monad-control, mtl, resourcet, rest-types
     , tostring, transformers, transformers-base, transformers-compat
     , uri-encode, utf8-string
     }:
     mkDerivation {
       pname = "rest-client";
       version = "0.5.0.3";
       sha256 = "6bcef592f14ca6cd69f930f747ae27eccb62a8e7224e867800030044ac6c8f0a";
       revision = "1";
       editedCabalFile = "35626ed815619ff388861f871c987480d2856655f76f961333eff29406b8d526";
       libraryHaskellDepends = [
         aeson-utils base bytestring case-insensitive data-default
         exceptions http-conduit http-types hxt hxt-pickle-utils
         monad-control mtl resourcet rest-types tostring transformers
         transformers-base transformers-compat uri-encode utf8-string
       ];
       jailbreak = true;
       description = "Utility library for use in generated API client libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-client_0_5_0_4" = callPackage
    ({ mkDerivation, aeson-utils, base, bytestring, case-insensitive
     , data-default, exceptions, http-conduit, http-types, hxt
     , hxt-pickle-utils, monad-control, mtl, resourcet, rest-types
     , tostring, transformers, transformers-base, transformers-compat
     , uri-encode, utf8-string
     }:
     mkDerivation {
       pname = "rest-client";
       version = "0.5.0.4";
       sha256 = "52d48ea8ce25e0b854f0078f14b1a81663ec982b3a831a0c372b6b8ab09e1625";
       libraryHaskellDepends = [
         aeson-utils base bytestring case-insensitive data-default
         exceptions http-conduit http-types hxt hxt-pickle-utils
         monad-control mtl resourcet rest-types tostring transformers
         transformers-base transformers-compat uri-encode utf8-string
       ];
       jailbreak = true;
       description = "Utility library for use in generated API client libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-client" = callPackage
    ({ mkDerivation, aeson-utils, base, bytestring, case-insensitive
     , data-default, exceptions, http-conduit, http-types, hxt
     , hxt-pickle-utils, monad-control, mtl, resourcet, rest-types
     , tostring, transformers, transformers-base, transformers-compat
     , uri-encode, utf8-string
     }:
     mkDerivation {
       pname = "rest-client";
       version = "0.5.1.0";
       sha256 = "9b75fb30f0f101945440c21b38d64b22a9aad81b81bce8e6a21e4675e6c8136e";
       revision = "1";
       editedCabalFile = "792e8084ca7b8c30c3c5870c03c0f2b0e401ea75a7edea9ec598fdbe5213f676";
       libraryHaskellDepends = [
         aeson-utils base bytestring case-insensitive data-default
         exceptions http-conduit http-types hxt hxt-pickle-utils
         monad-control mtl resourcet rest-types tostring transformers
         transformers-base transformers-compat uri-encode utf8-string
       ];
       description = "Utility library for use in generated API client libraries";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rest-core_0_33_1_2" = callPackage
    ({ mkDerivation, aeson, aeson-utils, base, bytestring, either
     , errors, fclabels, HUnit, hxt, hxt-pickle-utils, json-schema, mtl
     , multipart, random, rest-stringmap, rest-types, safe, split
     , test-framework, test-framework-hunit, text, transformers
     , unordered-containers, uri-encode, utf8-string, uuid
     }:
     mkDerivation {
       pname = "rest-core";
       version = "0.33.1.2";
       sha256 = "0416558761e439934721d12401e389ee42a44620c4086a339ddf3f854433b42b";
       libraryHaskellDepends = [
         aeson aeson-utils base bytestring either errors fclabels hxt
         hxt-pickle-utils json-schema mtl multipart random rest-stringmap
         rest-types safe split text transformers unordered-containers
         uri-encode utf8-string uuid
       ];
       testHaskellDepends = [
         base bytestring HUnit mtl test-framework test-framework-hunit
         unordered-containers
       ];
       jailbreak = true;
       description = "Rest API library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-core_0_35_1" = callPackage
    ({ mkDerivation, aeson, aeson-utils, base, bytestring
     , case-insensitive, either, errors, fclabels, HUnit, hxt
     , hxt-pickle-utils, json-schema, mtl, mtl-compat, multipart, random
     , rest-stringmap, rest-types, safe, semigroups, split
     , test-framework, test-framework-hunit, text, transformers
     , transformers-compat, unordered-containers, uri-encode
     , utf8-string, uuid
     }:
     mkDerivation {
       pname = "rest-core";
       version = "0.35.1";
       sha256 = "967417821640980afd89a1a9a21e6018eb9a8d09240829979a2026b3e7dabf9a";
       libraryHaskellDepends = [
         aeson aeson-utils base bytestring case-insensitive either errors
         fclabels hxt hxt-pickle-utils json-schema mtl mtl-compat multipart
         random rest-stringmap rest-types safe semigroups split text
         transformers transformers-compat unordered-containers uri-encode
         utf8-string uuid
       ];
       testHaskellDepends = [
         base bytestring HUnit mtl test-framework test-framework-hunit
         transformers transformers-compat unordered-containers
       ];
       jailbreak = true;
       description = "Rest API library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-core_0_36_0_5" = callPackage
    ({ mkDerivation, aeson, aeson-utils, base, bytestring
     , case-insensitive, errors, fclabels, HUnit, hxt, hxt-pickle-utils
     , json-schema, mtl, mtl-compat, multipart, random, rest-stringmap
     , rest-types, safe, split, test-framework, test-framework-hunit
     , text, transformers, transformers-compat, unordered-containers
     , uri-encode, utf8-string, uuid
     }:
     mkDerivation {
       pname = "rest-core";
       version = "0.36.0.5";
       sha256 = "0e23ee4cb3a01185bc714cc5c56a0f8390dfefb00f8ca1114f63fb39808470f7";
       revision = "1";
       editedCabalFile = "7f11e39a4d8e972fc2e5773f45019351fbe039aa35d6821a673d6de1519576cf";
       libraryHaskellDepends = [
         aeson aeson-utils base bytestring case-insensitive errors fclabels
         hxt hxt-pickle-utils json-schema mtl mtl-compat multipart random
         rest-stringmap rest-types safe split text transformers
         transformers-compat unordered-containers uri-encode utf8-string
         uuid
       ];
       testHaskellDepends = [
         base bytestring HUnit mtl test-framework test-framework-hunit
         transformers transformers-compat unordered-containers
       ];
       jailbreak = true;
       description = "Rest API library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-core_0_36_0_6" = callPackage
    ({ mkDerivation, aeson, aeson-utils, base, bytestring
     , case-insensitive, errors, fclabels, HUnit, hxt, hxt-pickle-utils
     , json-schema, mtl, mtl-compat, multipart, random, rest-stringmap
     , rest-types, safe, split, test-framework, test-framework-hunit
     , text, transformers, transformers-compat, unordered-containers
     , uri-encode, utf8-string, uuid
     }:
     mkDerivation {
       pname = "rest-core";
       version = "0.36.0.6";
       sha256 = "c4863ccdd2deee9f790136d5ac53a464682f6b85276aeaff48426832d90e9215";
       revision = "1";
       editedCabalFile = "c04e636b2c6ad925592a1a19e081a11b8c7c4d0e74a34b95856af866e8975e52";
       libraryHaskellDepends = [
         aeson aeson-utils base bytestring case-insensitive errors fclabels
         hxt hxt-pickle-utils json-schema mtl mtl-compat multipart random
         rest-stringmap rest-types safe split text transformers
         transformers-compat unordered-containers uri-encode utf8-string
         uuid
       ];
       testHaskellDepends = [
         base bytestring HUnit mtl test-framework test-framework-hunit
         transformers transformers-compat unordered-containers
       ];
       jailbreak = true;
       description = "Rest API library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-core_0_37" = callPackage
    ({ mkDerivation, aeson, aeson-utils, base, bytestring
     , case-insensitive, errors, fclabels, HUnit, hxt, hxt-pickle-utils
     , json-schema, mtl, mtl-compat, multipart, random, rest-stringmap
     , rest-types, safe, split, test-framework, test-framework-hunit
     , text, transformers, transformers-compat, unordered-containers
     , uri-encode, utf8-string, uuid
     }:
     mkDerivation {
       pname = "rest-core";
       version = "0.37";
       sha256 = "6a7e13b5e1ae6aadf53cc0dcbeca99a01b68737833962b2abdd50f4e6e9d066c";
       revision = "4";
       editedCabalFile = "09d7a6cceaa574917ef0ced55b1424bc0367b240678c358c36a1e4efedc04771";
       libraryHaskellDepends = [
         aeson aeson-utils base bytestring case-insensitive errors fclabels
         hxt hxt-pickle-utils json-schema mtl mtl-compat multipart random
         rest-stringmap rest-types safe split text transformers
         transformers-compat unordered-containers uri-encode utf8-string
         uuid
       ];
       testHaskellDepends = [
         base bytestring HUnit mtl test-framework test-framework-hunit
         transformers transformers-compat unordered-containers
       ];
       description = "Rest API library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-core" = callPackage
    ({ mkDerivation, aeson, aeson-utils, base, base-compat, bytestring
     , case-insensitive, errors, fclabels, HUnit, hxt, hxt-pickle-utils
     , json-schema, mtl, mtl-compat, multipart, random, rest-stringmap
     , rest-types, safe, split, test-framework, test-framework-hunit
     , text, transformers, transformers-compat, unordered-containers
     , uri-encode, utf8-string, uuid
     }:
     mkDerivation {
       pname = "rest-core";
       version = "0.38";
       sha256 = "b491b734c2d74729f427ca02370f12b839dd92347fea44b5fb66c66a39b11cec";
       revision = "1";
       editedCabalFile = "edcbe69d770149b6e3aeb47cc7ae2a9f4e589fa3cd1c928f1538504ac24b8b2c";
       libraryHaskellDepends = [
         aeson aeson-utils base base-compat bytestring case-insensitive
         errors fclabels hxt hxt-pickle-utils json-schema mtl mtl-compat
         multipart random rest-stringmap rest-types safe split text
         transformers transformers-compat unordered-containers uri-encode
         utf8-string uuid
       ];
       testHaskellDepends = [
         base bytestring HUnit mtl test-framework test-framework-hunit
         transformers transformers-compat unordered-containers
       ];
       description = "Rest API library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rest-example" = callPackage
    ({ mkDerivation, aeson, base, containers, generic-aeson
     , generic-xmlpickler, hxt, json-schema, mtl, rest-core, rest-gen
     , safe, stm, text, time, transformers, transformers-compat
     , unordered-containers
     }:
     mkDerivation {
       pname = "rest-example";
       version = "0.2.0.3";
       sha256 = "d71368418eca3128e887198f365b857011017e2515dd30856076b54d185b1a5e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base containers generic-aeson generic-xmlpickler hxt
         json-schema mtl rest-core safe stm text time transformers
         transformers-compat unordered-containers
       ];
       executableHaskellDepends = [ base rest-gen ];
       jailbreak = true;
       homepage = "http://www.github.com/silkapp/rest";
       description = "Example project for rest";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rest-gen_0_16_1_3" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, Cabal, code-builder
     , directory, fclabels, filepath, hashable, haskell-src-exts
     , hslogger, HStringTemplate, HUnit, hxt, json-schema, pretty
     , process, rest-core, safe, scientific, semigroups, split, tagged
     , test-framework, test-framework-hunit, text, uniplate
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "rest-gen";
       version = "0.16.1.3";
       sha256 = "6a7cacbf1354f64c5927850b1c21d7fa0d99a1ea87f5bd671c619b61adcc03da";
       libraryHaskellDepends = [
         aeson base blaze-html Cabal code-builder directory fclabels
         filepath hashable haskell-src-exts hslogger HStringTemplate hxt
         json-schema pretty process rest-core safe scientific semigroups
         split tagged text uniplate unordered-containers vector
       ];
       testHaskellDepends = [
         base fclabels haskell-src-exts HUnit rest-core test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       description = "Documentation and client generation from rest definition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-gen_0_16_1_7" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, Cabal, code-builder
     , directory, fclabels, filepath, hashable, haskell-src-exts
     , hslogger, HStringTemplate, HUnit, hxt, json-schema, pretty
     , process, rest-core, safe, scientific, semigroups, split, tagged
     , test-framework, test-framework-hunit, text, uniplate
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "rest-gen";
       version = "0.16.1.7";
       sha256 = "84d7dfc846166bfc5517ac64032fae8fe0c10cf67d75866183e4d6214f37e742";
       libraryHaskellDepends = [
         aeson base blaze-html Cabal code-builder directory fclabels
         filepath hashable haskell-src-exts hslogger HStringTemplate hxt
         json-schema pretty process rest-core safe scientific semigroups
         split tagged text uniplate unordered-containers vector
       ];
       testHaskellDepends = [
         base fclabels haskell-src-exts HUnit rest-core test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       description = "Documentation and client generation from rest definition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-gen_0_16_1_8" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, Cabal, code-builder
     , directory, fclabels, filepath, hashable, haskell-src-exts
     , HStringTemplate, HUnit, hxt, json-schema, pretty, process
     , rest-core, safe, scientific, semigroups, split, tagged
     , test-framework, test-framework-hunit, text, uniplate
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "rest-gen";
       version = "0.16.1.8";
       sha256 = "5bc4c8d4efa5fc8ac924b826423a465e0ab56ecb175eb6709067115d54e99d73";
       libraryHaskellDepends = [
         aeson base blaze-html Cabal code-builder directory fclabels
         filepath hashable haskell-src-exts HStringTemplate hxt json-schema
         pretty process rest-core safe scientific semigroups split tagged
         text uniplate unordered-containers vector
       ];
       testHaskellDepends = [
         base fclabels haskell-src-exts HUnit rest-core test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       description = "Documentation and client generation from rest definition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-gen_0_17_0_2" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, Cabal, code-builder
     , directory, fclabels, filepath, hashable, haskell-src-exts
     , HStringTemplate, HUnit, hxt, json-schema, pretty, process
     , rest-core, safe, scientific, semigroups, split, tagged
     , test-framework, test-framework-hunit, text, uniplate
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "rest-gen";
       version = "0.17.0.2";
       sha256 = "5cb72c8a837a9d887d265bde5f9be8bf0a3b49ae0da72a793dbfcd3566855b26";
       libraryHaskellDepends = [
         aeson base blaze-html Cabal code-builder directory fclabels
         filepath hashable haskell-src-exts HStringTemplate hxt json-schema
         pretty process rest-core safe scientific semigroups split tagged
         text uniplate unordered-containers vector
       ];
       testHaskellDepends = [
         base fclabels haskell-src-exts HUnit rest-core test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       description = "Documentation and client generation from rest definition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-gen_0_17_0_3" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, Cabal, code-builder
     , directory, fclabels, filepath, hashable, haskell-src-exts
     , HStringTemplate, HUnit, hxt, json-schema, pretty, process
     , rest-core, safe, scientific, semigroups, split, tagged
     , test-framework, test-framework-hunit, text, uniplate
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "rest-gen";
       version = "0.17.0.3";
       sha256 = "04ccf5d052d8cff81fea8f5a82cae8e0c758fe819ff79efd14ed7d7fb38bcd43";
       libraryHaskellDepends = [
         aeson base blaze-html Cabal code-builder directory fclabels
         filepath hashable haskell-src-exts HStringTemplate hxt json-schema
         pretty process rest-core safe scientific semigroups split tagged
         text uniplate unordered-containers vector
       ];
       testHaskellDepends = [
         base fclabels haskell-src-exts HUnit rest-core test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       description = "Documentation and client generation from rest definition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-gen_0_17_0_4" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, Cabal, code-builder
     , directory, fclabels, filepath, hashable, haskell-src-exts
     , HStringTemplate, HUnit, hxt, json-schema, pretty, process
     , rest-core, safe, scientific, semigroups, split, tagged
     , test-framework, test-framework-hunit, text, uniplate
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "rest-gen";
       version = "0.17.0.4";
       sha256 = "8296d77897a5846534db59301000e7d2c4bd8e94cb6c17e4ed19b1c634be8df9";
       revision = "1";
       editedCabalFile = "b218da6eb2fd339d0d16ac67e441379824aaba7ef2b8b2cc3f9acbb88d7be778";
       libraryHaskellDepends = [
         aeson base blaze-html Cabal code-builder directory fclabels
         filepath hashable haskell-src-exts HStringTemplate hxt json-schema
         pretty process rest-core safe scientific semigroups split tagged
         text uniplate unordered-containers vector
       ];
       testHaskellDepends = [
         base fclabels haskell-src-exts HUnit rest-core test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       description = "Documentation and client generation from rest definition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-gen_0_17_0_5" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, Cabal, code-builder
     , directory, fclabels, filepath, hashable, haskell-src-exts
     , HStringTemplate, HUnit, hxt, json-schema, pretty, process
     , rest-core, safe, scientific, semigroups, split, test-framework
     , test-framework-hunit, text, uniplate, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "rest-gen";
       version = "0.17.0.5";
       sha256 = "e747b0810474ff7a767405b02c61da35946cf9918aae863c008ab366340f96df";
       libraryHaskellDepends = [
         aeson base blaze-html Cabal code-builder directory fclabels
         filepath hashable haskell-src-exts HStringTemplate hxt json-schema
         pretty process rest-core safe scientific semigroups split text
         uniplate unordered-containers vector
       ];
       testHaskellDepends = [
         base fclabels haskell-src-exts HUnit rest-core test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       description = "Documentation and client generation from rest definition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-gen_0_17_0_6" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, Cabal, code-builder
     , directory, fclabels, filepath, hashable, haskell-src-exts
     , HStringTemplate, HUnit, hxt, json-schema, pretty, process
     , rest-core, safe, scientific, semigroups, split, test-framework
     , test-framework-hunit, text, uniplate, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "rest-gen";
       version = "0.17.0.6";
       sha256 = "b87507931ed09b3123e3c14f9908e42bbb37b311026b6ae6147f35bd99bf785e";
       libraryHaskellDepends = [
         aeson base blaze-html Cabal code-builder directory fclabels
         filepath hashable haskell-src-exts HStringTemplate hxt json-schema
         pretty process rest-core safe scientific semigroups split text
         uniplate unordered-containers vector
       ];
       testHaskellDepends = [
         base fclabels haskell-src-exts HUnit rest-core test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       description = "Documentation and client generation from rest definition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-gen_0_17_1" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, Cabal, code-builder
     , directory, fclabels, filepath, hashable, haskell-src-exts
     , HStringTemplate, HUnit, hxt, json-schema, pretty, process
     , rest-core, safe, scientific, semigroups, split, test-framework
     , test-framework-hunit, text, uniplate, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "rest-gen";
       version = "0.17.1";
       sha256 = "942fc65a9ebb1a77e4f11979d9e604dc266f825c03dc565c9e984a851bb67465";
       libraryHaskellDepends = [
         aeson base blaze-html Cabal code-builder directory fclabels
         filepath hashable haskell-src-exts HStringTemplate hxt json-schema
         pretty process rest-core safe scientific semigroups split text
         uniplate unordered-containers vector
       ];
       testHaskellDepends = [
         base fclabels haskell-src-exts HUnit rest-core test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       description = "Documentation and client generation from rest definition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-gen_0_17_1_1" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, Cabal, code-builder
     , directory, fclabels, filepath, hashable, haskell-src-exts
     , HStringTemplate, HUnit, hxt, json-schema, pretty, process
     , rest-core, safe, scientific, semigroups, split, test-framework
     , test-framework-hunit, text, uniplate, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "rest-gen";
       version = "0.17.1.1";
       sha256 = "749dda834e77659663e13bc2a275e76e68985ec9f9bf77e2c0d18af5c0e6253f";
       revision = "1";
       editedCabalFile = "9d5c13bbf90373aed094821bd2005822fccd5949e0c88a2a63870d90f7c76ee4";
       libraryHaskellDepends = [
         aeson base blaze-html Cabal code-builder directory fclabels
         filepath hashable haskell-src-exts HStringTemplate hxt json-schema
         pretty process rest-core safe scientific semigroups split text
         uniplate unordered-containers vector
       ];
       testHaskellDepends = [
         base fclabels haskell-src-exts HUnit rest-core test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       description = "Documentation and client generation from rest definition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-gen_0_17_1_2" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, Cabal, code-builder
     , directory, fclabels, filepath, hashable, haskell-src-exts
     , HStringTemplate, HUnit, hxt, json-schema, pretty, process
     , rest-core, safe, scientific, semigroups, split, test-framework
     , test-framework-hunit, text, uniplate, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "rest-gen";
       version = "0.17.1.2";
       sha256 = "4aed5068ebdbac25a7c5a377904f64a6a48a83370985856258ca2c40d57a3516";
       revision = "3";
       editedCabalFile = "cae6f35e87d9cbf39e4b0ebbee24f9e1086a5b9c146a3ea2329d346ca97ddda2";
       libraryHaskellDepends = [
         aeson base blaze-html Cabal code-builder directory fclabels
         filepath hashable haskell-src-exts HStringTemplate hxt json-schema
         pretty process rest-core safe scientific semigroups split text
         uniplate unordered-containers vector
       ];
       testHaskellDepends = [
         base fclabels haskell-src-exts HUnit rest-core test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       description = "Documentation and client generation from rest definition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-gen_0_17_1_3" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, Cabal, code-builder
     , directory, fclabels, filepath, hashable, haskell-src-exts
     , HStringTemplate, HUnit, hxt, json-schema, pretty, process
     , rest-core, safe, scientific, semigroups, split, test-framework
     , test-framework-hunit, text, uniplate, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "rest-gen";
       version = "0.17.1.3";
       sha256 = "faa7c9b026b2acf45dfe5df644d05d9fd8e606cfa1ecc5631cde4cdcc47a0be6";
       libraryHaskellDepends = [
         aeson base blaze-html Cabal code-builder directory fclabels
         filepath hashable haskell-src-exts HStringTemplate hxt json-schema
         pretty process rest-core safe scientific semigroups split text
         uniplate unordered-containers vector
       ];
       testHaskellDepends = [
         base fclabels haskell-src-exts HUnit rest-core test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       description = "Documentation and client generation from rest definition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-gen_0_19_0_1" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, Cabal, code-builder
     , directory, fclabels, filepath, hashable, haskell-src-exts
     , HStringTemplate, HUnit, hxt, json-schema, pretty, process
     , rest-core, safe, scientific, semigroups, split, test-framework
     , test-framework-hunit, text, uniplate, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "rest-gen";
       version = "0.19.0.1";
       sha256 = "556762e3ce87c092d8e5982e86ab9b4319d069b157e613d5e99f67120e8357c0";
       libraryHaskellDepends = [
         aeson base blaze-html Cabal code-builder directory fclabels
         filepath hashable haskell-src-exts HStringTemplate hxt json-schema
         pretty process rest-core safe scientific semigroups split text
         uniplate unordered-containers vector
       ];
       testHaskellDepends = [
         base fclabels haskell-src-exts HUnit rest-core test-framework
         test-framework-hunit
       ];
       jailbreak = true;
       description = "Documentation and client generation from rest definition";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-gen" = callPackage
    ({ mkDerivation, aeson, base, base-compat, blaze-html, Cabal
     , code-builder, directory, fclabels, filepath, hashable
     , haskell-src-exts, HStringTemplate, HUnit, hxt, json-schema
     , pretty, process, rest-core, safe, scientific, semigroups, split
     , test-framework, test-framework-hunit, text, uniplate
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "rest-gen";
       version = "0.19.0.2";
       sha256 = "12caa70e7b29b073cb0e066cf7d5c590b13e0fb5b2f924944cd1ae5217c79330";
       revision = "1";
       editedCabalFile = "afca13957f1b186ba5922659d6275cdf5c8d49ec2bca6f2319d89c213afa5c4d";
       libraryHaskellDepends = [
         aeson base base-compat blaze-html Cabal code-builder directory
         fclabels filepath hashable haskell-src-exts HStringTemplate hxt
         json-schema pretty process rest-core safe scientific semigroups
         split text uniplate unordered-containers vector
       ];
       testHaskellDepends = [
         base fclabels haskell-src-exts HUnit rest-core test-framework
         test-framework-hunit
       ];
       description = "Documentation and client generation from rest definition";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rest-happstack_0_2_10_3" = callPackage
    ({ mkDerivation, base, containers, happstack-server, mtl, rest-core
     , rest-gen, utf8-string
     }:
     mkDerivation {
       pname = "rest-happstack";
       version = "0.2.10.3";
       sha256 = "db1b0421a8d7817d57bbc99a11bbbcbc2434d87800b40f9fe5341b89509e4a17";
       revision = "1";
       editedCabalFile = "690efa5133a2e38606a0225f713c91332416ec9097acacb98a2d6c449e2f5ad1";
       libraryHaskellDepends = [
         base containers happstack-server mtl rest-core rest-gen utf8-string
       ];
       jailbreak = true;
       description = "Rest driver for Happstack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-happstack_0_2_10_4" = callPackage
    ({ mkDerivation, base, containers, happstack-server, mtl, rest-core
     , rest-gen, utf8-string
     }:
     mkDerivation {
       pname = "rest-happstack";
       version = "0.2.10.4";
       sha256 = "d7bb959a10912e5d3aa932e98d5509ce0fe2dd2280a4c75468f5437846638d5c";
       revision = "1";
       editedCabalFile = "fe1be463d8cf69a0e97d64fad3ba17de6b520a93f71e05c7ffc56958a3f52656";
       libraryHaskellDepends = [
         base containers happstack-server mtl rest-core rest-gen utf8-string
       ];
       jailbreak = true;
       description = "Rest driver for Happstack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-happstack_0_2_10_7" = callPackage
    ({ mkDerivation, base, containers, happstack-server, mtl, rest-core
     , rest-gen, utf8-string
     }:
     mkDerivation {
       pname = "rest-happstack";
       version = "0.2.10.7";
       sha256 = "bb58af21dff4419fdb21c94cec55f9961c03850b22733bc18d54433eba72d89d";
       libraryHaskellDepends = [
         base containers happstack-server mtl rest-core rest-gen utf8-string
       ];
       jailbreak = true;
       description = "Rest driver for Happstack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-happstack_0_2_10_8" = callPackage
    ({ mkDerivation, base, containers, happstack-server, mtl, rest-core
     , rest-gen, utf8-string
     }:
     mkDerivation {
       pname = "rest-happstack";
       version = "0.2.10.8";
       sha256 = "feec31c1a8ab85941ebfe1d5081e7809592a4d622a6951691c08b79d56603958";
       revision = "1";
       editedCabalFile = "647255beca0013110e88747224f545e198aba15f47af6d894c7313997cca2bc1";
       libraryHaskellDepends = [
         base containers happstack-server mtl rest-core rest-gen utf8-string
       ];
       jailbreak = true;
       description = "Rest driver for Happstack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-happstack" = callPackage
    ({ mkDerivation, base, containers, happstack-server, mtl, rest-core
     , rest-gen, utf8-string
     }:
     mkDerivation {
       pname = "rest-happstack";
       version = "0.3.1";
       sha256 = "a2c2e1b1e1bfdc7870100eee642e488268e21117b08aad254342d14a53ce13d9";
       revision = "1";
       editedCabalFile = "bcee53122444a7394e71c1f20b614f1b3504c90f96a519ff8981f7eb05805ca1";
       libraryHaskellDepends = [
         base containers happstack-server mtl rest-core rest-gen utf8-string
       ];
       description = "Rest driver for Happstack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rest-snap_0_1_17_14" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, rest-core
     , safe, snap-core, unordered-containers, uri-encode, utf8-string
     }:
     mkDerivation {
       pname = "rest-snap";
       version = "0.1.17.14";
       sha256 = "572bd406b203d05291be5ab38313643ec3cc344fd3bd75fcc935ddff0a6aa639";
       libraryHaskellDepends = [
         base bytestring case-insensitive rest-core safe snap-core
         unordered-containers uri-encode utf8-string
       ];
       jailbreak = true;
       description = "Rest driver for Snap";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-snap_0_1_17_17" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, rest-core
     , safe, snap-core, unordered-containers, uri-encode, utf8-string
     }:
     mkDerivation {
       pname = "rest-snap";
       version = "0.1.17.17";
       sha256 = "59b914ab23e6d9e03cfdc02d42edf9dc235a022d0919537025db19f3d24d5ce0";
       libraryHaskellDepends = [
         base bytestring case-insensitive rest-core safe snap-core
         unordered-containers uri-encode utf8-string
       ];
       jailbreak = true;
       description = "Rest driver for Snap";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-snap_0_1_17_18" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, rest-core
     , safe, snap-core, unordered-containers, uri-encode, utf8-string
     }:
     mkDerivation {
       pname = "rest-snap";
       version = "0.1.17.18";
       sha256 = "c61cc1d15b00967fd43286a6f7daf5675612e9111809bb518abedbb388cd1a3d";
       libraryHaskellDepends = [
         base bytestring case-insensitive rest-core safe snap-core
         unordered-containers uri-encode utf8-string
       ];
       jailbreak = true;
       description = "Rest driver for Snap";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-snap" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, rest-core
     , safe, snap-core, unordered-containers, uri-encode, utf8-string
     }:
     mkDerivation {
       pname = "rest-snap";
       version = "0.2";
       sha256 = "38947f552b90b08cf21567dd8931891f1c328546e5e5dda7e083fb2f3711eefc";
       revision = "1";
       editedCabalFile = "86fefb10994951f66e3e125ad5bf4060fa21cc636b41d1c605ddad81744ee2af";
       libraryHaskellDepends = [
         base bytestring case-insensitive rest-core safe snap-core
         unordered-containers uri-encode utf8-string
       ];
       description = "Rest driver for Snap";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rest-stringmap_0_2_0_2" = callPackage
    ({ mkDerivation, aeson, base, containers, hashable, hxt
     , json-schema, tagged, text, tostring, unordered-containers
     }:
     mkDerivation {
       pname = "rest-stringmap";
       version = "0.2.0.2";
       sha256 = "bf0aaa267ee168f6f64f1964dd175cf84a37c5dc2ac0aac6af82a5631260f35b";
       revision = "3";
       editedCabalFile = "6bd88422dfcf66c00cb2aa8079ffae04b6540f9054963b26a82dd86b1ce93b13";
       libraryHaskellDepends = [
         aeson base containers hashable hxt json-schema tagged text tostring
         unordered-containers
       ];
       jailbreak = true;
       description = "Maps with stringy keys that can be transcoded to JSON and XML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-stringmap_0_2_0_3" = callPackage
    ({ mkDerivation, aeson, base, containers, hashable, hxt
     , json-schema, tagged, text, tostring, unordered-containers
     }:
     mkDerivation {
       pname = "rest-stringmap";
       version = "0.2.0.3";
       sha256 = "d54ca81e5769fb8e4475ebfe17f4df34dbcaf143b3b7c8d64467fa5cb0b5c3f7";
       libraryHaskellDepends = [
         aeson base containers hashable hxt json-schema tagged text tostring
         unordered-containers
       ];
       jailbreak = true;
       description = "Maps with stringy keys that can be transcoded to JSON and XML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-stringmap_0_2_0_4" = callPackage
    ({ mkDerivation, aeson, base, containers, hashable, hxt
     , json-schema, tagged, text, tostring, unordered-containers
     }:
     mkDerivation {
       pname = "rest-stringmap";
       version = "0.2.0.4";
       sha256 = "61b994eb689384ec2a44d12550a1be34797b48e114030006e2567b5f8baf3c65";
       libraryHaskellDepends = [
         aeson base containers hashable hxt json-schema tagged text tostring
         unordered-containers
       ];
       jailbreak = true;
       description = "Maps with stringy keys that can be transcoded to JSON and XML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-stringmap" = callPackage
    ({ mkDerivation, aeson, base, containers, hashable, hxt
     , json-schema, tostring, unordered-containers
     }:
     mkDerivation {
       pname = "rest-stringmap";
       version = "0.2.0.6";
       sha256 = "66e5a32f04cfcf9826296b3c053c22caa745fd890ccc6ea9199c34529507524a";
       revision = "2";
       editedCabalFile = "286ce136699cc8dffad47ead93fdaf0538e465edafde510ff7697f96e470ea1d";
       libraryHaskellDepends = [
         aeson base containers hashable hxt json-schema tostring
         unordered-containers
       ];
       description = "Maps with stringy keys that can be transcoded to JSON and XML";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rest-types_1_11_1_1" = callPackage
    ({ mkDerivation, aeson, base, generic-aeson, hxt, json-schema, mtl
     , regular, regular-xmlpickler, rest-stringmap, text, uuid
     }:
     mkDerivation {
       pname = "rest-types";
       version = "1.11.1.1";
       sha256 = "aa08a5ec5ab4f33bc410dce687975e9e9664b90494c64e9e8f75f01d57802977";
       libraryHaskellDepends = [
         aeson base generic-aeson hxt json-schema mtl regular
         regular-xmlpickler rest-stringmap text uuid
       ];
       jailbreak = true;
       description = "Silk Rest Framework Types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-types_1_13_1" = callPackage
    ({ mkDerivation, aeson, base, case-insensitive, generic-aeson, hxt
     , json-schema, mtl, regular, regular-xmlpickler, rest-stringmap
     , text, transformers, transformers-compat, uuid
     }:
     mkDerivation {
       pname = "rest-types";
       version = "1.13.1";
       sha256 = "91eacdaad428f6c94a66ff0c379a464a5c1d21b57cf8c9760cb7064e14e89e26";
       libraryHaskellDepends = [
         aeson base case-insensitive generic-aeson hxt json-schema mtl
         regular regular-xmlpickler rest-stringmap text transformers
         transformers-compat uuid
       ];
       jailbreak = true;
       description = "Silk Rest Framework Types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-types" = callPackage
    ({ mkDerivation, aeson, base, case-insensitive, generic-aeson
     , generic-xmlpickler, hxt, json-schema, rest-stringmap, text, uuid
     }:
     mkDerivation {
       pname = "rest-types";
       version = "1.14.0.1";
       sha256 = "645516a501f3f6d928c04b6022b111bd5411f301572f4de6b96ef7b15e480b32";
       revision = "2";
       editedCabalFile = "ff6c3027d4c2f87d78868a23bfbda807237c2d31b6caae9399f1de159a6e0ac1";
       libraryHaskellDepends = [
         aeson base case-insensitive generic-aeson generic-xmlpickler hxt
         json-schema rest-stringmap text uuid
       ];
       description = "Silk Rest Framework Types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rest-wai_0_1_0_4" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, containers
     , http-types, mime-types, mtl, rest-core, text
     , unordered-containers, utf8-string, wai
     }:
     mkDerivation {
       pname = "rest-wai";
       version = "0.1.0.4";
       sha256 = "6fb1c7dfad7ddfb2f12ecdfcfa8f22a783a80d5dbdd01f50e63e3a5d1d70b2df";
       libraryHaskellDepends = [
         base bytestring case-insensitive containers http-types mime-types
         mtl rest-core text unordered-containers utf8-string wai
       ];
       jailbreak = true;
       description = "Rest driver for WAI applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-wai_0_1_0_7" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, containers
     , http-types, mime-types, mtl, rest-core, text
     , unordered-containers, wai
     }:
     mkDerivation {
       pname = "rest-wai";
       version = "0.1.0.7";
       sha256 = "bb9cc1f978048e3e9a3e3b8790a5d501d88685bca74b6334fd8f19d18dd0fb29";
       revision = "1";
       editedCabalFile = "1b15b246eb06e388c3ac37b6a7eb5697109f04f085a46ced92d9e4e809841981";
       libraryHaskellDepends = [
         base bytestring case-insensitive containers http-types mime-types
         mtl rest-core text unordered-containers wai
       ];
       jailbreak = true;
       description = "Rest driver for WAI applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-wai_0_1_0_8" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, containers
     , http-types, mime-types, mtl, rest-core, text
     , unordered-containers, wai
     }:
     mkDerivation {
       pname = "rest-wai";
       version = "0.1.0.8";
       sha256 = "add022b1dea9da0c7206e641bff001828d05f8f10d6286a9ed4a4040b3f02164";
       libraryHaskellDepends = [
         base bytestring case-insensitive containers http-types mime-types
         mtl rest-core text unordered-containers wai
       ];
       jailbreak = true;
       description = "Rest driver for WAI applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rest-wai" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, containers
     , http-types, mime-types, mtl, rest-core, text
     , unordered-containers, wai
     }:
     mkDerivation {
       pname = "rest-wai";
       version = "0.2";
       sha256 = "92d7455c537d24c6d2ccadd9272cac385659ed2a828fbe20bca9249016897413";
       revision = "2";
       editedCabalFile = "ac37af20f1f44b9ada05e25dea369b8149359ba6a020a92d5b3e841846f731c7";
       libraryHaskellDepends = [
         base bytestring case-insensitive containers http-types mime-types
         mtl rest-core text unordered-containers wai
       ];
       description = "Rest driver for WAI applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "restful-snap" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers
     , data-default, digestive-functors, errors, heist, lens, mtl
     , old-locale, readable, snap, snap-core, snap-extras
     , template-haskell, text, time, xmlhtml
     }:
     mkDerivation {
       pname = "restful-snap";
       version = "0.2";
       sha256 = "ec9955ecc7551d6263be3974bef1695bdc03092ad08381e18e4109cad35cf899";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers data-default
         digestive-functors errors heist lens mtl old-locale readable snap
         snap-core snap-extras template-haskell text time xmlhtml
       ];
       jailbreak = true;
       homepage = "https://github.com/ozataman/restful-snap";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "restricted-workers" = callPackage
    ({ mkDerivation, async, base, bytestring, cereal, data-default
     , directory, either, filepath, monad-control, mtl, network, selinux
     , stm, text, transformers, transformers-base, unix
     }:
     mkDerivation {
       pname = "restricted-workers";
       version = "0.1.1";
       sha256 = "34bd9f45d29e692c0800133d7d2890d05547bbcb689155e101fc698b2ebeb153";
       libraryHaskellDepends = [
         async base bytestring cereal data-default directory either filepath
         monad-control mtl network selinux stm text transformers
         transformers-base unix
       ];
       jailbreak = true;
       homepage = "https://github.com/co-dan/interactive-diagrams/wiki/Restricted-Workers";
       description = "Running worker processes under system resource restrictions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "restyle" = callPackage
    ({ mkDerivation, base, directory, filepath, utf8-string }:
     mkDerivation {
       pname = "restyle";
       version = "0.1.0";
       sha256 = "fd74359fbd4fdf9c4351e495b67ff8ef84fd735f72656b3ffe26c1e2c86bf343";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base directory filepath utf8-string ];
       jailbreak = true;
       description = "Convert between camel case and separated words style";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "resumable-exceptions" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "resumable-exceptions";
       version = "0.0.0.20100920";
       sha256 = "fa8d9776668e5356055ec8327efff7197243c211960cd24fd1b32fd690939f1a";
       libraryHaskellDepends = [ base mtl ];
       jailbreak = true;
       description = "A monad transformer for resumable exceptions";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rethinkdb_2_2_0_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring, binary
     , bytestring, containers, data-default, doctest, mtl, network
     , scientific, text, time, unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "rethinkdb";
       version = "2.2.0.2";
       sha256 = "91c1ea290efa7f9336ef824832545cce401466cc773cde38ea2a8e0a763d0eb5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base64-bytestring binary bytestring containers
         data-default mtl network scientific text time unordered-containers
         utf8-string vector
       ];
       executableHaskellDepends = [ attoparsec base text ];
       testHaskellDepends = [ base doctest ];
       doCheck = false;
       homepage = "http://github.com/atnnn/haskell-rethinkdb";
       description = "A driver for RethinkDB 2.1";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rethinkdb" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring, binary
     , bytestring, containers, data-default, doctest, mtl, network
     , scientific, text, time, unordered-containers, utf8-string, vector
     }:
     mkDerivation {
       pname = "rethinkdb";
       version = "2.2.0.3";
       sha256 = "c5499076552d6fa07972e7597b6c8c04c0f2a0dcdb9b9e630c2fb48cc06f1183";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base64-bytestring binary bytestring containers
         data-default mtl network scientific text time unordered-containers
         utf8-string vector
       ];
       executableHaskellDepends = [ attoparsec base text ];
       testHaskellDepends = [ base doctest ];
       doCheck = false;
       homepage = "http://github.com/atnnn/haskell-rethinkdb";
       description = "A driver for RethinkDB 2.2";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "rethinkdb-client-driver_0_0_13" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, hashable, hspec
     , hspec-smallcheck, mtl, network, old-locale, scientific
     , smallcheck, template-haskell, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "rethinkdb-client-driver";
       version = "0.0.13";
       sha256 = "7a9457b06bc4ba3613b2e6c49f6fe052ab76cd1c345dceb3f0596d057eab2b3b";
       libraryHaskellDepends = [
         aeson base binary bytestring hashable mtl network old-locale
         scientific template-haskell text time unordered-containers vector
       ];
       testHaskellDepends = [
         base hspec hspec-smallcheck smallcheck text time
         unordered-containers vector
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/wereHamster/rethinkdb-client-driver";
       description = "Client driver for RethinkDB";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rethinkdb-client-driver_0_0_16" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, hashable, hspec
     , hspec-smallcheck, mtl, network, old-locale, scientific
     , smallcheck, template-haskell, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "rethinkdb-client-driver";
       version = "0.0.16";
       sha256 = "c1293c7246c81b884b545f82590624e161b74fcb53ed6a3100895c5989e193f4";
       libraryHaskellDepends = [
         aeson base binary bytestring hashable mtl network old-locale
         scientific template-haskell text time unordered-containers vector
       ];
       testHaskellDepends = [
         base hspec hspec-smallcheck smallcheck text time
         unordered-containers vector
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/wereHamster/rethinkdb-client-driver";
       description = "Client driver for RethinkDB";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rethinkdb-client-driver_0_0_18" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, hashable, hspec
     , hspec-smallcheck, mtl, network, old-locale, scientific
     , smallcheck, template-haskell, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "rethinkdb-client-driver";
       version = "0.0.18";
       sha256 = "9fd0a6dcb57340e6627454494da54559b066a2d8df0c89aa31f1869d265849fe";
       libraryHaskellDepends = [
         aeson base binary bytestring hashable mtl network old-locale
         scientific template-haskell text time unordered-containers vector
       ];
       testHaskellDepends = [
         base hspec hspec-smallcheck smallcheck text time
         unordered-containers vector
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/wereHamster/rethinkdb-client-driver";
       description = "Client driver for RethinkDB";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rethinkdb-client-driver_0_0_19" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, hashable, hspec
     , hspec-smallcheck, mtl, network, old-locale, scientific
     , smallcheck, template-haskell, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "rethinkdb-client-driver";
       version = "0.0.19";
       sha256 = "d1db41828f7290919cb25be67b86c8f5834266ab52485ffc6f638447ddf5f57b";
       libraryHaskellDepends = [
         aeson base binary bytestring hashable mtl network old-locale
         scientific template-haskell text time unordered-containers vector
       ];
       testHaskellDepends = [
         base hspec hspec-smallcheck smallcheck text time
         unordered-containers vector
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/wereHamster/rethinkdb-client-driver";
       description = "Client driver for RethinkDB";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rethinkdb-client-driver_0_0_20" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, hashable, hspec
     , hspec-smallcheck, mtl, network, old-locale, scientific
     , smallcheck, template-haskell, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "rethinkdb-client-driver";
       version = "0.0.20";
       sha256 = "9cd46fed35bfb1b09283e9109e6da5d848b6e50794e4debe4819f3654d4b8381";
       libraryHaskellDepends = [
         aeson base binary bytestring hashable mtl network old-locale
         scientific template-haskell text time unordered-containers vector
       ];
       testHaskellDepends = [
         base hspec hspec-smallcheck smallcheck text time
         unordered-containers vector
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/wereHamster/rethinkdb-client-driver";
       description = "Client driver for RethinkDB";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rethinkdb-client-driver" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, containers
     , hashable, hspec, hspec-smallcheck, mtl, network, old-locale
     , scientific, smallcheck, stm, template-haskell, text, time
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "rethinkdb-client-driver";
       version = "0.0.22";
       sha256 = "4a192e989e1f1b60398123ad2c74701203b66a33a220f1b5c47ad495e98575bb";
       libraryHaskellDepends = [
         aeson base binary bytestring containers hashable mtl network
         old-locale scientific stm template-haskell text time
         unordered-containers vector
       ];
       testHaskellDepends = [
         base hspec hspec-smallcheck smallcheck text time
         unordered-containers vector
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/wereHamster/rethinkdb-client-driver";
       description = "Client driver for RethinkDB";
       license = stdenv.lib.licenses.mit;
     }) {};

  "rethinkdb-model" = callPackage
    ({ mkDerivation, aeson, base, mtl, rethinkdb, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "rethinkdb-model";
       version = "0.1.0.2";
       sha256 = "58f07f3f54ab61a5c23647e0194cbfe7b4cb249316476758027bf025421a2995";
       libraryHaskellDepends = [
         aeson base mtl rethinkdb text transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/seanhess/rethinkdb-model";
       description = "Useful tools for modeling data with rethinkdb";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rethinkdb-wereHamster" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , data-default, ghc-prim, mtl, network, protocol-buffers
     , protocol-buffers-descriptor, text, time, unordered-containers
     , utf8-string, vector
     }:
     mkDerivation {
       pname = "rethinkdb-wereHamster";
       version = "1.8.0.5";
       sha256 = "781a086c60e61100f008ad21c0c93be7cb8b835135729505b539f91e63707d72";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers data-default ghc-prim
         mtl network protocol-buffers protocol-buffers-descriptor text time
         unordered-containers utf8-string vector
       ];
       homepage = "http://github.com/atnnn/haskell-rethinkdb";
       description = "RethinkDB driver for Haskell";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "retry_0_6" = callPackage
    ({ mkDerivation, base, data-default-class, exceptions, hspec, HUnit
     , QuickCheck, time, transformers
     }:
     mkDerivation {
       pname = "retry";
       version = "0.6";
       sha256 = "f269db0c9f4943249cd8a0a2a0a05183da41afe4ca34bb627935985134fec2e7";
       revision = "1";
       editedCabalFile = "08f3ff261b1f52787e49e0a6bb585db0b0820393715eb510ab8a937173076b42";
       libraryHaskellDepends = [
         base data-default-class exceptions transformers
       ];
       testHaskellDepends = [
         base data-default-class exceptions hspec HUnit QuickCheck time
         transformers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/Soostone/retry";
       description = "Retry combinators for monadic actions that may fail";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "retry_0_7_0_1" = callPackage
    ({ mkDerivation, base, data-default-class, exceptions, hspec, HUnit
     , QuickCheck, random, stm, time, transformers
     }:
     mkDerivation {
       pname = "retry";
       version = "0.7.0.1";
       sha256 = "7ab82a1ba52eaf2a98186ff853d26fa0f54f676939739b2d2bd8735e0406486a";
       libraryHaskellDepends = [
         base data-default-class exceptions random transformers
       ];
       testHaskellDepends = [
         base data-default-class exceptions hspec HUnit QuickCheck random
         stm time transformers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/Soostone/retry";
       description = "Retry combinators for monadic actions that may fail";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "retry" = callPackage
    ({ mkDerivation, base, data-default-class, exceptions, hspec, HUnit
     , QuickCheck, random, stm, time, transformers
     }:
     mkDerivation {
       pname = "retry";
       version = "0.7.1";
       sha256 = "55900f2b01de0acd83874fc6a986c12f34f31e362cb318e271942418dedef680";
       libraryHaskellDepends = [
         base data-default-class exceptions random transformers
       ];
       testHaskellDepends = [
         base data-default-class exceptions hspec HUnit QuickCheck random
         stm time transformers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/Soostone/retry";
       description = "Retry combinators for monadic actions that may fail";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "retryer" = callPackage
    ({ mkDerivation, base, optparse-applicative, process }:
     mkDerivation {
       pname = "retryer";
       version = "0.1.0.1";
       sha256 = "f224462d9db633895f39f71e3d48ca398b40285acf86f3e5dedb794d7fa56be7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base optparse-applicative process ];
       jailbreak = true;
       homepage = "https://github.com/dgonyeo/retryer";
       description = "Retry failed commands";
       license = stdenv.lib.licenses.mpl20;
     }) {};

  "rev-state_0_1" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "rev-state";
       version = "0.1";
       sha256 = "8e91583233e46a4277a96d2ffe4736506a85848536db2c2acf06ed22c43a58d3";
       libraryHaskellDepends = [ base mtl ];
       homepage = "https://github.com/DanBurton/rev-state#readme";
       description = "Reverse State monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rev-state_0_1_1" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "rev-state";
       version = "0.1.1";
       sha256 = "844626648793fd5a939e85aa58a52bc3a9511398755b2012bb3e56164cfb9934";
       libraryHaskellDepends = [ base mtl ];
       testHaskellDepends = [ base ];
       homepage = "https://github.com/DanBurton/rev-state#readme";
       description = "Reverse State monad transformer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rev-state" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "rev-state";
       version = "0.1.2";
       sha256 = "ee070e39d7f7d673593e2f356ab317bc2fdd0d8a283f8316c0e5b5adbdf0f919";
       revision = "2";
       editedCabalFile = "de8db922a675a68ac8ac03f80fabaed250fe332a20f7b3bd8272238088e3d135";
       libraryHaskellDepends = [ base mtl ];
       testHaskellDepends = [ base ];
       homepage = "https://github.com/DanBurton/rev-state#readme";
       description = "Reverse State monad transformer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "revdectime" = callPackage
    ({ mkDerivation, base, old-time }:
     mkDerivation {
       pname = "revdectime";
       version = "0.1.1";
       sha256 = "55ab818d99ce2dd2bac76511163771fc9453551cd84b7e96297e3746593b6e51";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base old-time ];
       description = "A French revolutionary decimal time (metric) clock";
       license = "GPL";
     }) {};

  "reverse-apply" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "reverse-apply";
       version = "2.0.1";
       sha256 = "cb1e3382bfa3f0426c0e43420bf28fe26c3a2676e731be824ac2b792bb908147";
       libraryHaskellDepends = [ base ];
       description = "Standard version of the reverse apply operator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "reverse-geocoding" = callPackage
    ({ mkDerivation, aeson, base, iso3166-country-codes, lens
     , lens-aeson, text, wreq
     }:
     mkDerivation {
       pname = "reverse-geocoding";
       version = "0.2.2.2";
       sha256 = "3e1b2f6f44272a1173483b8d2aa9c4bfa4eb1bc15e99468e7fa3aae156e75f59";
       revision = "1";
       editedCabalFile = "9d91cf76a4c2958487e3ec7ad6e38963cbae63cf8586ca041c71addb84dd009c";
       libraryHaskellDepends = [
         aeson base iso3166-country-codes lens lens-aeson text wreq
       ];
       homepage = "https://github.com/jcristovao/reverse-geocoding";
       description = "Simple reverse geocoding using OpenStreeMap";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "reversi" = callPackage
    ({ mkDerivation, array, base, process }:
     mkDerivation {
       pname = "reversi";
       version = "0.1.1";
       sha256 = "dfd2bd2b4792941642a735e11b47361939904346f1095bdea18695721ba5adb5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base process ];
       jailbreak = true;
       description = "Text-only reversi (aka othelo) game";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "rewrite" = callPackage
    ({ mkDerivation, base, bytestring, directory, multiarg, process }:
     mkDerivation {
       pname = "rewrite";
       version = "0.10";
       sha256 = "4f72df3baeb7de125463333920a8b44e1d1f213a60dd482224db1246a3d48b81";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory multiarg process
       ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/rewrite";
       description = "open file and rewrite it with new contents";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rewriting" = callPackage
    ({ mkDerivation, base, containers, regular }:
     mkDerivation {
       pname = "rewriting";
       version = "0.2.2";
       sha256 = "7a19e8ec948bd74f87f9326e5d248d5b1e7efef08dfa246a01a95a89b942cd3e";
       libraryHaskellDepends = [ base containers regular ];
       description = "Generic rewriting library for regular datatypes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rex" = callPackage
    ({ mkDerivation, base, bytestring, containers, haskell-src-exts
     , haskell-src-meta, pcre-light, template-haskell
     }:
     mkDerivation {
       pname = "rex";
       version = "0.5.1";
       sha256 = "864a3393d50a3535d5788242a43eec030290fc96cc6e71b628404278de4de0a1";
       libraryHaskellDepends = [
         base bytestring containers haskell-src-exts haskell-src-meta
         pcre-light template-haskell
       ];
       homepage = "http://github.com/mgsloan/rex";
       description = "A quasi-quoter for typeful results of regex captures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rezoom" = callPackage
    ({ mkDerivation, base, bytestring, containers, datetime, HTTP, json
     , mtl, nano-md5, xhtml
     }:
     mkDerivation {
       pname = "rezoom";
       version = "0.0.4";
       sha256 = "eacb40bc6511b7c6e503d8a96b92e74ad09c2923f30071fa98b87fc88d625088";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers datetime HTTP json mtl nano-md5 xhtml
       ];
       jailbreak = true;
       description = "Github resume generator";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rfc3339" = callPackage
    ({ mkDerivation, base, timerep }:
     mkDerivation {
       pname = "rfc3339";
       version = "1.0.5";
       sha256 = "60ab3db1cec904ec4909e0f4afbba900414140211f1fa76a6179465d195476dc";
       libraryHaskellDepends = [ base timerep ];
       doHaddock = false;
       description = "Parse and display time according to RFC3339 (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rfc5051" = callPackage
    ({ mkDerivation, base, bytestring, containers }:
     mkDerivation {
       pname = "rfc5051";
       version = "0.1.0.3";
       sha256 = "e38dab28a5625774be60545c8c99e647b79bbc0ac0bc9c65fe6b2ebef160642b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring containers ];
       executableHaskellDepends = [ base bytestring containers ];
       description = "Simple unicode collation as per RFC5051";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rhythm-game-tutorial" = callPackage
    ({ mkDerivation, base, call, containers, lens, mtl, objective
     , split
     }:
     mkDerivation {
       pname = "rhythm-game-tutorial";
       version = "0.1.1";
       sha256 = "faf4c390813a7cd49cb87244a808537b6adf5fe35bee57c5970d9fd86fa8ad21";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base call containers lens mtl objective split
       ];
       homepage = "https://github.com/fumieval/rhythm-game-tutorial";
       description = "Haskell rhythm game tutorial";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "riak" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, binary, blaze-builder
     , bytestring, containers, enclosed-exceptions, exceptions, HUnit
     , mersenne-random-pure64, monad-control, network, protocol-buffers
     , pureMD5, QuickCheck, random, random-shuffle, resource-pool
     , riak-protobuf, tasty, tasty-hunit, tasty-quickcheck, text, time
     , transformers, vector
     }:
     mkDerivation {
       pname = "riak";
       version = "0.9.1.1";
       sha256 = "900597ea476350d76bb0b9c429ac0d438865fdaf885267e94695d1cd1c81e43f";
       libraryHaskellDepends = [
         aeson attoparsec base binary blaze-builder bytestring containers
         enclosed-exceptions exceptions mersenne-random-pure64 monad-control
         network protocol-buffers pureMD5 random random-shuffle
         resource-pool riak-protobuf text time transformers vector
       ];
       testHaskellDepends = [
         base bytestring containers HUnit QuickCheck tasty tasty-hunit
         tasty-quickcheck text
       ];
       doCheck = false;
       homepage = "http://github.com/markhibberd/riak-haskell-client";
       description = "A Haskell client for the Riak decentralized data store";
       license = "unknown";
     }) {};

  "riak-protobuf" = callPackage
    ({ mkDerivation, array, base, parsec, protocol-buffers
     , protocol-buffers-descriptor
     }:
     mkDerivation {
       pname = "riak-protobuf";
       version = "0.20.0.0";
       sha256 = "542a99d75a67863d7be5d4c74178945ffbd5e0269ac69d6b81a76dd51b7176ae";
       libraryHaskellDepends = [
         array base parsec protocol-buffers protocol-buffers-descriptor
       ];
       homepage = "http://github.com/markhibberd/riak-haskell-client";
       description = "Haskell types for the Riak protocol buffer API";
       license = "unknown";
     }) {};

  "richreports" = callPackage
    ({ mkDerivation, ascetic, base, MissingH }:
     mkDerivation {
       pname = "richreports";
       version = "0.0.3.0";
       sha256 = "73161ff473ea9f844a1fd3a31a3e1ed08a74656d7df213ca3795c76f4d053356";
       libraryHaskellDepends = [ ascetic base MissingH ];
       description = "Integrated pretty-printing and error/static analysis reporting";
       license = stdenv.lib.licenses.mit;
     }) {};

  "riemann" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, data-default
     , directory, doctest, errors, filepath, http-client, HUnit, lens
     , mtl, network, protobuf, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , transformers, wreq
     }:
     mkDerivation {
       pname = "riemann";
       version = "0.1.1.0";
       sha256 = "8905d4997974028b71cf57f15cd6c4939d871f90fbd5130b0c09705f3e6d10c0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal containers data-default errors lens mtl
         network protobuf text time transformers
       ];
       executableHaskellDepends = [
         base bytestring cereal containers data-default errors http-client
         lens mtl network protobuf text time transformers wreq
       ];
       testHaskellDepends = [
         base directory doctest filepath HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/tel/riemann-hs";
       description = "A Riemann client for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "riff" = callPackage
    ({ mkDerivation, base, binary, bytestring, either, filepath
     , transformers
     }:
     mkDerivation {
       pname = "riff";
       version = "0.3.0.1";
       sha256 = "abc1726fbcae31061a31df4d4d569b3c4090d5bfaa22e9f5af863d1b9e5ee0a4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring either transformers
       ];
       executableHaskellDepends = [ base bytestring filepath ];
       jailbreak = true;
       homepage = "https://bitbucket.org/robertmassaioli/riff/overview";
       description = "RIFF parser for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ring-buffer" = callPackage
    ({ mkDerivation, base, mtl, primitive, vector }:
     mkDerivation {
       pname = "ring-buffer";
       version = "0.1.2";
       sha256 = "8fc8bd6234d0a3a5c427f4c263873f4bfe7ad5496563d318d31ed466524e766b";
       libraryHaskellDepends = [ base mtl primitive vector ];
       homepage = "http://github.com/bgamari/ring-buffer";
       description = "A concurrent, mutable ring-buffer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "riot" = callPackage
    ({ mkDerivation, base, containers, directory, haskell98, mtl
     , ncurses, old-locale, packedstring, process, unix
     }:
     mkDerivation {
       pname = "riot";
       version = "1.20080618";
       sha256 = "ba02d7194335c77b0787bcf062c5c1146f219c031d6ae2d0c9834ad052e6edb5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory haskell98 mtl old-locale packedstring
         process unix
       ];
       executableSystemDepends = [ ncurses ];
       homepage = "http://modeemi.fi/~tuomov/riot/";
       description = "Riot is an Information Organisation Tool";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) ncurses;};

  "ripple" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base58address, binary
     , bytestring, cereal, crypto-api, crypto-pubkey-types
     , cryptohash-cryptoapi, ecdsa, errors, largeword, text, time
     , transformers, utility-ht, websockets
     }:
     mkDerivation {
       pname = "ripple";
       version = "0.3";
       sha256 = "fcfac54c6049790224960332e8bd34dd88376cbacc60c698a4e44136cc9d29f8";
       libraryHaskellDepends = [
         aeson attoparsec base base58address binary bytestring cereal
         crypto-api crypto-pubkey-types cryptohash-cryptoapi ecdsa errors
         largeword text time transformers utility-ht websockets
       ];
       homepage = "https://github.com/singpolyma/ripple-haskell";
       description = "Ripple payment system library";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ripple-federation" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base58address
     , blaze-builder, bytestring, errors, http-streams, http-types
     , io-streams, network-uri, text, unexceptionalio
     }:
     mkDerivation {
       pname = "ripple-federation";
       version = "0.3";
       sha256 = "1ab8ea172c19f193cfa1b03884a88d766a3bf0eecfd2342d3c45f08ad1a6f554";
       libraryHaskellDepends = [
         aeson attoparsec base base58address blaze-builder bytestring errors
         http-streams http-types io-streams network-uri text unexceptionalio
       ];
       homepage = "https://github.com/singpolyma/ripple-federation-haskell";
       description = "Utilities and types to work with the Ripple federation protocol";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "risc386" = callPackage
    ({ mkDerivation, alex, array, base, containers, happy, mtl, pretty
     }:
     mkDerivation {
       pname = "risc386";
       version = "0.0.20130719";
       sha256 = "439c66188e994fb4a81d7f8a2d5b3cb376ee73942a7fc565187668bfc99b0e44";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ array base containers mtl pretty ];
       executableToolDepends = [ alex happy ];
       jailbreak = true;
       homepage = "http://www2.tcs.ifi.lmu.de/~abel/";
       description = "Reduced instruction set i386 simulator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rivers" = callPackage
    ({ mkDerivation, base, lazysmallcheck, oeis, QuickCheck }:
     mkDerivation {
       pname = "rivers";
       version = "0.1.0";
       sha256 = "c4681bf08ce5cf90d82c332980fa0fa12a42eb64ad1834dd64d8f2ce2b01f974";
       libraryHaskellDepends = [ base lazysmallcheck oeis QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/d-rive/rivers";
       description = "Rivers are like Streams, but different";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rivet" = callPackage
    ({ mkDerivation, base, rivet-core, rivet-simple-deploy }:
     mkDerivation {
       pname = "rivet";
       version = "0.1.0.0";
       sha256 = "8f0db3c306fb73fbe5666877645c7e870be2892145b05a59f28250df817d3cc2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base rivet-core rivet-simple-deploy ];
       homepage = "https://github.com/dbp/rivet";
       description = "A project management tool for Haskell applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rivet-core" = callPackage
    ({ mkDerivation, base, configurator, directory, directory-tree
     , filepath, postgresql-simple, process, shake, template-haskell
     , text, time, unordered-containers
     }:
     mkDerivation {
       pname = "rivet-core";
       version = "0.1.0.1";
       sha256 = "417451d2d95d6a676187a7d8b98ec112bdba7eaa1da68c6020833a9fc37a5f80";
       libraryHaskellDepends = [
         base configurator directory directory-tree filepath
         postgresql-simple process shake template-haskell text time
         unordered-containers
       ];
       homepage = "https://github.com/dbp/rivet";
       description = "Core library for project management tool";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rivet-migration" = callPackage
    ({ mkDerivation, base, postgresql-simple, text }:
     mkDerivation {
       pname = "rivet-migration";
       version = "0.1.0.1";
       sha256 = "6dd95a94855da826ff509814031dbe284aebb986e0002ea4c7b660a68bb6e6ed";
       libraryHaskellDepends = [ base postgresql-simple text ];
       homepage = "https://github.com/dbp/rivet";
       description = "Postgresql migration support for project management tool";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rivet-simple-deploy" = callPackage
    ({ mkDerivation, base, configurator, mtl, rivet-core, text }:
     mkDerivation {
       pname = "rivet-simple-deploy";
       version = "0.1.0.0";
       sha256 = "aedf553c435530265ec3409a9b15296a97c236434086bbdca187d95b51d50380";
       libraryHaskellDepends = [ base configurator mtl rivet-core text ];
       homepage = "https://github.com/dbp/rivet";
       description = "Basic deployment support for project management tool";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rlglue" = callPackage
    ({ mkDerivation, base, binary, bytestring, data-binary-ieee754
     , exceptions, network, network-simple, parsec, random, transformers
     }:
     mkDerivation {
       pname = "rlglue";
       version = "0.2.2.0";
       sha256 = "00c33f3df08f2a1d205fd61ee8d89c1746a81e60ceeee50476de432a3b90e218";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring data-binary-ieee754 exceptions network
         network-simple parsec transformers
       ];
       executableHaskellDepends = [
         base binary bytestring data-binary-ieee754 exceptions network
         network-simple random transformers
       ];
       jailbreak = true;
       description = "A Haskell codec for RL-Glue";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "rmonad" = callPackage
    ({ mkDerivation, base, containers, HUnit, suitable, test-framework
     , test-framework-hunit, transformers
     }:
     mkDerivation {
       pname = "rmonad";
       version = "0.8.0.2";
       sha256 = "1441035fe7b22284fa900e37c7f21d406db7f0da750f8401263e38842cba55dd";
       libraryHaskellDepends = [ base containers suitable transformers ];
       testHaskellDepends = [
         base containers HUnit test-framework test-framework-hunit
       ];
       description = "Restricted monad library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rncryptor" = callPackage
    ({ mkDerivation, base, bytestring, cipher-aes, io-streams, mtl
     , pbkdf, QuickCheck, random, tasty, tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "rncryptor";
       version = "0.0.2.3";
       sha256 = "465879f9e1209050820f939229ebea727d736071e46a19ea775aba8e0608e69f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cipher-aes io-streams mtl pbkdf QuickCheck random
       ];
       executableHaskellDepends = [
         base bytestring cipher-aes io-streams
       ];
       testHaskellDepends = [
         base bytestring QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       description = "Haskell implementation of the RNCryptor file format";
       license = stdenv.lib.licenses.mit;
     }) {};

  "rng-utils" = callPackage
    ({ mkDerivation, base, bytestring, mwc-random, vector }:
     mkDerivation {
       pname = "rng-utils";
       version = "0.2.1";
       sha256 = "cac94b9ae624b1a4cbbfd47ff901570517f6416a9eee219065c0b5d5c036de87";
       libraryHaskellDepends = [ base bytestring mwc-random vector ];
       description = "RNG within an MVar for convenient concurrent use";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "robin" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, fsnotify
     , hdaemonize, lens, lifted-base, monad-control, mtl, process
     , resourcet, text, time, unix
     }:
     mkDerivation {
       pname = "robin";
       version = "0.1.0.0";
       sha256 = "35a8626b4875eca73a7128c71d43f5b4dbcfaea156cc90f0fac1077471abea91";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal directory filepath fsnotify hdaemonize lens lifted-base
         monad-control mtl process resourcet text time unix
       ];
       homepage = "https://www.github.com/ktvoelker/robin";
       description = "A build daemon for Haskell development";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "robot" = callPackage
    ({ mkDerivation, base, containers, exceptions, transformers, xhb }:
     mkDerivation {
       pname = "robot";
       version = "1.4";
       sha256 = "ac6ce6d71150ac5c0bbd12b3736d2aa8542b7e2642f0181b4fceb739f4244ced";
       libraryHaskellDepends = [
         base containers exceptions transformers xhb
       ];
       homepage = "https://github.com/lfairy/robot";
       description = "Simulate keyboard and mouse events";
       license = "unknown";
     }) {};

  "robots-txt" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, directory, heredoc
     , hspec, old-locale, QuickCheck, time, transformers
     }:
     mkDerivation {
       pname = "robots-txt";
       version = "0.4.1.4";
       sha256 = "cc927bf848469fba0e594c5b9e46d822d410a29c978773924bb4b3268882b3a1";
       libraryHaskellDepends = [
         attoparsec base bytestring old-locale time
       ];
       testHaskellDepends = [
         attoparsec base bytestring directory heredoc hspec QuickCheck
         transformers
       ];
       homepage = "http://github.com/meanpath/robots";
       description = "Parser for robots.txt";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rocksdb-haskell" = callPackage
    ({ mkDerivation, base, bytestring, data-default, filepath
     , resourcet, rocksdb, transformers
     }:
     mkDerivation {
       pname = "rocksdb-haskell";
       version = "0.1.0";
       sha256 = "4dc561c5227a376f9907403a7fc99dd193baea233da8be453ea4b5df01ab28f2";
       libraryHaskellDepends = [
         base bytestring data-default filepath resourcet transformers
       ];
       librarySystemDepends = [ rocksdb ];
       homepage = "http://github.com/agrafix/rocksdb-haskell";
       description = "Haskell bindings to RocksDB";
       license = stdenv.lib.licenses.bsd3;
       platforms = [ "x86_64-linux" ];
     }) {inherit (pkgs) rocksdb;};

  "roguestar" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, old-time
     , process
     }:
     mkDerivation {
       pname = "roguestar";
       version = "0.6.0.1";
       sha256 = "662a3a0f231ae96ff5a8d47fd389931447366d5119cb9e1b296adf304294d776";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory filepath old-time process
       ];
       homepage = "http://roguestar.downstairspeople.org/";
       description = "Sci-fi roguelike game. Client application.";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "roguestar-engine" = callPackage
    ({ mkDerivation, array, base, bytestring, containers
     , data-memocombinators, hslogger, MaybeT, MonadRandom, mtl
     , old-time, parallel, priority-sync, PSQueue, random, stm
     }:
     mkDerivation {
       pname = "roguestar-engine";
       version = "0.6.0.1";
       sha256 = "7be21f7dea4a481d86376dd25e8ea0ea79419369a2d3c4c03436d7f61740c014";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring containers data-memocombinators hslogger
         MaybeT MonadRandom mtl old-time parallel priority-sync PSQueue
         random stm
       ];
       jailbreak = true;
       homepage = "http://roguestar.downstairspeople.org/";
       description = "Sci-fi roguelike game. Backend.";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "roguestar-gl" = callPackage
    ({ mkDerivation, arrows, base, bytestring, containers, filepath
     , GLUT, MonadRandom, mtl, OpenGL, priority-sync, random, rsagl
     , rsagl-frp, rsagl-math, stm
     }:
     mkDerivation {
       pname = "roguestar-gl";
       version = "0.6.0.1";
       sha256 = "fafbcc39e8526ca5103dd5fdab2a8cb3eb9c4de915f511574e7307af0ccb52d1";
       libraryHaskellDepends = [
         arrows base bytestring containers filepath GLUT MonadRandom mtl
         OpenGL priority-sync random rsagl rsagl-frp rsagl-math stm
       ];
       jailbreak = true;
       homepage = "http://roguestar.downstairspeople.org/";
       description = "Sci-fi roguelike game. Client library.";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "roguestar-glut" = callPackage
    ({ mkDerivation, base, GLUT, roguestar-gl, rsagl }:
     mkDerivation {
       pname = "roguestar-glut";
       version = "0.6.0.1";
       sha256 = "d0af6e869ba0150541785e2e3521b0b8c403c44c2e75f91151c103b854456f8e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base GLUT roguestar-gl rsagl ];
       jailbreak = true;
       homepage = "http://roguestar.downstairspeople.org/";
       description = "Sci-fi roguelike game. GLUT front-end.";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rollbar" = callPackage
    ({ mkDerivation, aeson, base, basic-prelude, http-conduit
     , monad-control, network, text, vector
     }:
     mkDerivation {
       pname = "rollbar";
       version = "0.3.1";
       sha256 = "613b71ffa7c5715a4b7c1df4c0655de958f89ac13612dfcdd82b30c0d0886943";
       libraryHaskellDepends = [
         aeson base basic-prelude http-conduit monad-control network text
         vector
       ];
       homepage = "https://github.com/docmunch/rollbar-haskell";
       description = "error tracking through rollbar.com";
       license = stdenv.lib.licenses.mit;
     }) {};

  "roller" = callPackage
    ({ mkDerivation, base, optparse-applicative, random
     , regex-applicative
     }:
     mkDerivation {
       pname = "roller";
       version = "0.1.6";
       sha256 = "47d5308161cf067474f8e65f73ad7292a777d4749f5132dd92daf3d7fb43bdb3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base optparse-applicative random regex-applicative
       ];
       executableHaskellDepends = [
         base optparse-applicative random regex-applicative
       ];
       homepage = "https://github.com/PiotrJustyna/roller";
       description = "Playing with applicatives and dice!";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "rolling-queue" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "rolling-queue";
       version = "0.1";
       sha256 = "833002bed0e6bc95814ab550326a9d981c3810b4f9611e115968d88b306d69d0";
       libraryHaskellDepends = [ base stm ];
       homepage = "https://github.com/joeyadams/haskell-rolling-queue";
       description = "Bounded channel for STM that discards old entries when full";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "roman-numerals" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, bytestring, text }:
     mkDerivation {
       pname = "roman-numerals";
       version = "0.5.1.5";
       sha256 = "b9c7195b69b1662a286d2c28a55fafdcb693c522ba5eb54a11b1d0a4e92eaa81";
       libraryHaskellDepends = [
         base base-unicode-symbols bytestring text
       ];
       homepage = "https://github.com/roelvandijk/roman-numerals";
       description = "Parsing and pretty printing of Roman numerals";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "romkan" = callPackage
    ({ mkDerivation, attoparsec, base, containers, HUnit
     , test-framework, test-framework-hunit, text
     }:
     mkDerivation {
       pname = "romkan";
       version = "0.1.0.0";
       sha256 = "88b59a2ba410d4c626917118e622f55ed6e7080629b919ca7ec6dfb9642a9f24";
       libraryHaskellDepends = [ attoparsec base containers text ];
       testHaskellDepends = [
         attoparsec base containers HUnit test-framework
         test-framework-hunit text
       ];
       homepage = "https://github.com/karlvoigtland/romkan-hs";
       description = "Japanese Romaji <-> Japanese Kana conversion library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "roots" = callPackage
    ({ mkDerivation, base, tagged }:
     mkDerivation {
       pname = "roots";
       version = "0.1.1.2";
       sha256 = "49027ac85d6b7349a3717243941e81d70db46747a51cb0e79cab8e1238f9fa77";
       libraryHaskellDepends = [ base tagged ];
       homepage = "/dev/null";
       description = "Root-finding algorithms (1-dimensional)";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "rope" = callPackage
    ({ mkDerivation, base, bytestring, fingertree, mtl, utf8-string }:
     mkDerivation {
       pname = "rope";
       version = "0.6.4";
       sha256 = "0bee82a9f13264b1a2cb470b45c5354b49e146156922b066151eba5ac55ee7bc";
       libraryHaskellDepends = [
         base bytestring fingertree mtl utf8-string
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/rope";
       description = "Tools for manipulating fingertrees of bytestrings with optional annotations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rosa" = callPackage
    ({ mkDerivation, aeson, argparser, base, bytestring, lens, process
     , text, unordered-containers, vector, wreq
     }:
     mkDerivation {
       pname = "rosa";
       version = "0.2.2.0";
       sha256 = "fe03cbdeda54fb80bf4e2168ceaaffdcdeb6e608e2d7911f60ab2ca5995fef31";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson argparser base bytestring lens process text
         unordered-containers vector wreq
       ];
       description = "Query the namecoin blockchain";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rose-trees" = callPackage
    ({ mkDerivation, base, containers, deepseq, mtl, QuickCheck
     , quickcheck-instances, semigroupoids, semigroups, sets, tasty
     , tasty-quickcheck, witherable
     }:
     mkDerivation {
       pname = "rose-trees";
       version = "0.0.3";
       sha256 = "f373600456dc69e3d2acf3abd949781a7b0365b412084f98a1ca367cae01ee33";
       libraryHaskellDepends = [
         base containers deepseq mtl QuickCheck quickcheck-instances
         semigroupoids semigroups sets witherable
       ];
       testHaskellDepends = [
         base containers deepseq QuickCheck quickcheck-instances
         semigroupoids semigroups sets tasty tasty-quickcheck witherable
       ];
       description = "A collection of rose tree structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rose-trie" = callPackage
    ({ mkDerivation, base, containers, deepseq, minilens, mtl
     , transformers
     }:
     mkDerivation {
       pname = "rose-trie";
       version = "1.0.0.1";
       sha256 = "669269bdf1cdbec5f3023954fa6c4aee3676253db82fe69e785128afb4ed2805";
       libraryHaskellDepends = [
         base containers deepseq minilens mtl transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/RaminHAL9001/rose-trie";
       description = "Provides \"Data.Tree.RoseTrie\": trees with polymorphic paths to nodes, combining properties of Rose Tree data structures and Trie data structures.";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "rosezipper" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "rosezipper";
       version = "0.2";
       sha256 = "6cab4f1c192cc3b8b0a9eb11a32780d235020a539a0e91125eed5ec590bad7bc";
       libraryHaskellDepends = [ base containers ];
       description = "Generic zipper implementation for Data.Tree";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "roshask" = callPackage
    ({ mkDerivation, attoparsec, base, binary, BoundedChan, bytestring
     , Cabal, containers, data-default-generics, deepseq, directory
     , filemanip, filepath, haxr, mtl, network, parsec, process, pureMD5
     , SafeSemaphore, snap-core, snap-server, stm, storable-tuple, tasty
     , tasty-hunit, template-haskell, testpack, time, transformers, unix
     , uri, utf8-string, vector, vector-space, xml
     }:
     mkDerivation {
       pname = "roshask";
       version = "0.2.1";
       sha256 = "75b8f0f9c185d6ac0c84c4418ff5f07c6ca80168708fe9d5f34f509672444a8b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary BoundedChan bytestring Cabal containers directory
         filemanip filepath haxr mtl network parsec process SafeSemaphore
         snap-core snap-server stm storable-tuple template-haskell time
         transformers unix uri utf8-string vector vector-space xml
       ];
       executableHaskellDepends = [
         attoparsec base binary bytestring containers data-default-generics
         deepseq directory filemanip filepath mtl process pureMD5 vector xml
       ];
       testHaskellDepends = [
         attoparsec base bytestring containers data-default-generics
         filepath mtl pureMD5 tasty tasty-hunit testpack transformers
       ];
       homepage = "http://github.com/acowley/roshask";
       description = "Haskell support for the ROS robotics framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rosso" = callPackage
    ({ mkDerivation, base, containers, deepseq }:
     mkDerivation {
       pname = "rosso";
       version = "1.0";
       sha256 = "3aee0c61728602ea62bf625b2d255735aba12256c68f2e7c9b1227bc2f9ee533";
       libraryHaskellDepends = [ base containers deepseq ];
       description = "General purpose utility library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rot13" = callPackage
    ({ mkDerivation, base, bytestring, hspec, QuickCheck }:
     mkDerivation {
       pname = "rot13";
       version = "0.1.0.2";
       sha256 = "0d1a579df566f2a9debb9d049bbe7fe2dd9390e003dd5676b9ae8bc4dc072c35";
       libraryHaskellDepends = [ base bytestring ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "https://github.com/kvanberendonck/codec-rot13";
       description = "Fast ROT13 cipher for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rotating-log" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, old-locale
     , time
     }:
     mkDerivation {
       pname = "rotating-log";
       version = "0.2";
       sha256 = "b320f7cbf926526476c02f61050095d36706f94c4405e3653597dbf1db770dbf";
       libraryHaskellDepends = [
         base bytestring directory filepath old-locale time
       ];
       testHaskellDepends = [
         base bytestring directory filepath old-locale time
       ];
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rounding" = callPackage
    ({ mkDerivation, array, base, numeric-extras }:
     mkDerivation {
       pname = "rounding";
       version = "0.3.0";
       sha256 = "de280304050edbce3efedad36ceb6dbbc94738a6ec4a0d33e30f29cb64545bb4";
       libraryHaskellDepends = [ array base numeric-extras ];
       jailbreak = true;
       homepage = "http://patch-tag.com/r/ekmett/rounding";
       description = "Explicit floating point rounding mode wrappers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "roundtrip" = callPackage
    ({ mkDerivation, base, containers, pretty, safe, template-haskell
     , text, xml-types
     }:
     mkDerivation {
       pname = "roundtrip";
       version = "0.2.0.3";
       sha256 = "11f24fceb9bf3a9c419ed0b8242e3ef2b743861e4ad47b88216f2647ad43f6e0";
       libraryHaskellDepends = [
         base containers pretty safe template-haskell text xml-types
       ];
       description = "Bidirectional (de-)serialization";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "roundtrip-aeson" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, lens
     , lens-aeson, roundtrip, scientific, text, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "roundtrip-aeson";
       version = "0.2.0.0";
       sha256 = "04c6b8e47c6946199d547f89eb81a272d26f6f3f07d07895221e54410f212655";
       libraryHaskellDepends = [
         aeson base bytestring containers lens lens-aeson roundtrip
         scientific text unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bytestring lens-aeson roundtrip text vector
       ];
       jailbreak = true;
       homepage = "https://github.com/anchor/roundtrip-aeson";
       description = "Un-/parse JSON with roundtrip invertible syntax definitions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "roundtrip-string" = callPackage
    ({ mkDerivation, base, mtl, parsec, roundtrip }:
     mkDerivation {
       pname = "roundtrip-string";
       version = "0.1.0.1";
       sha256 = "a721d7d219bb2aa842168e910f00934ff5f2183e6c36fa9a192e9f833c314dd1";
       libraryHaskellDepends = [ base mtl parsec roundtrip ];
       description = "Bidirectional (de-)serialization";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "roundtrip-xml" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-builder-enumerator
     , bytestring, containers, enumerator, mtl, pretty, reference
     , roundtrip, roundtrip-string, safe, text, xml-enumerator
     , xml-types
     }:
     mkDerivation {
       pname = "roundtrip-xml";
       version = "0.3.0.5";
       sha256 = "35599e1f8ed46f1583dbcfd53caab4c3956dd7ad9c18d5705c41aaa8742286be";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder blaze-builder-enumerator bytestring containers
         enumerator mtl pretty reference roundtrip roundtrip-string safe
         text xml-enumerator xml-types
       ];
       description = "Bidirectional (de-)serialization for XML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "route-generator" = callPackage
    ({ mkDerivation, attoparsec, base, network, text, yesod-routes }:
     mkDerivation {
       pname = "route-generator";
       version = "0.6.1";
       sha256 = "86c1978d9e08de70989f91ef4a65e204bf48fab879c65b28a1b9dbf4eb58d92d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base network text yesod-routes
       ];
       homepage = "http://github.com/singpolyma/route-generator";
       description = "Utility to generate routes for use with yesod-routes";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "route-planning" = callPackage
    ({ mkDerivation, base, containers, coordinate, directory, doctest
     , filepath, lens, QuickCheck, semigroupoids, semigroups, text, xsd
     }:
     mkDerivation {
       pname = "route-planning";
       version = "0.0.3";
       sha256 = "47bec5286559d900ebad38364270bc0cb93b42c460a4e71c541677d4244c7f50";
       libraryHaskellDepends = [
         base containers coordinate lens semigroupoids semigroups text xsd
       ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck
       ];
       homepage = "https://github.com/tonymorris/route";
       description = "A library and utilities for creating a route";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rowrecord" = callPackage
    ({ mkDerivation, base, containers, template-haskell }:
     mkDerivation {
       pname = "rowrecord";
       version = "0.1";
       sha256 = "14502b35a27edfd56187f7f97634e90681d523e3d99d61bd723803578e6f993d";
       libraryHaskellDepends = [ base containers template-haskell ];
       description = "Build records from lists of strings, as from CSV files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rpc" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, derive
     , network-fancy, template-haskell, th-lift
     }:
     mkDerivation {
       pname = "rpc";
       version = "0.0.1";
       sha256 = "49122d66324737a789876ef60a971fd414f4c3adf77904f85701bb69eb15892f";
       libraryHaskellDepends = [
         base bytestring cereal containers derive network-fancy
         template-haskell th-lift
       ];
       description = "type safe rpcs provided as basic IO actions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rpc-framework" = callPackage
    ({ mkDerivation, base, containers, mtl, network, template-haskell
     , transformers
     }:
     mkDerivation {
       pname = "rpc-framework";
       version = "2.0.0.2";
       sha256 = "18c37ea5c90355a528d5c95f1eed7b49026401a534accaa9d4d628fd135f722b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl network template-haskell transformers
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://github.com/mmirman/rpc-framework";
       description = "a remote procedure call framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rpf" = callPackage
    ({ mkDerivation, appar, base, blaze-builder, bytestring, c10k
     , containers, dns, domain-auth, hslogger, iproute, parsec, unix
     }:
     mkDerivation {
       pname = "rpf";
       version = "0.2.5";
       sha256 = "9340c77b356b1cf409ccae09214f9c339ea4ca79601cc9e0e7c16c3473918074";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         appar base blaze-builder bytestring c10k containers dns domain-auth
         hslogger iproute parsec unix
       ];
       homepage = "http://www.mew.org/~kazu/proj/rpf/";
       description = "Receiver Policy Framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rpm" = callPackage
    ({ mkDerivation, base, directory, filepath, HaXml, process }:
     mkDerivation {
       pname = "rpm";
       version = "0.0.1";
       sha256 = "9f2c95adfa873b55e56516ebb2a3c320914931d300b50ad1659d704669706af3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory filepath HaXml process ];
       description = "Cozy little project to question unruly rpm packages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rsagl" = callPackage
    ({ mkDerivation, array, arrows, base, containers
     , data-memocombinators, deepseq, mtl, old-time, OpenGL, OpenGLRaw
     , parallel, parsec, random, rsagl-frp, rsagl-math, stm, Vec
     , Vec-OpenGLRaw
     }:
     mkDerivation {
       pname = "rsagl";
       version = "0.6.0.1";
       sha256 = "a950f53b3ebcd659ac139111c65831775e9809d4b82d288d852ffcace7342e38";
       libraryHaskellDepends = [
         array arrows base containers data-memocombinators deepseq mtl
         old-time OpenGL OpenGLRaw parallel parsec random rsagl-frp
         rsagl-math stm Vec Vec-OpenGLRaw
       ];
       jailbreak = true;
       homepage = "http://roguestar.downstairspeople.org/";
       description = "The RogueStar Animation and Graphics Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rsagl-frp" = callPackage
    ({ mkDerivation, array, arrows, base, containers, mtl, old-time
     , random, rsagl-math, stm
     }:
     mkDerivation {
       pname = "rsagl-frp";
       version = "0.6.0.1";
       sha256 = "01d08b21e29bd3fa2714634e6caccf5d11df13227ad79908c13a7868a9263552";
       libraryHaskellDepends = [
         array arrows base containers mtl old-time random rsagl-math stm
       ];
       jailbreak = true;
       homepage = "http://roguestar.downstairspeople.org/";
       description = "The RogueStar Animation and Graphics Library: Functional Reactive Programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rsagl-math" = callPackage
    ({ mkDerivation, array, base, containers, deepseq, OpenGL
     , OpenGLRaw, parallel, parsec, random, Vec, Vec-OpenGLRaw
     }:
     mkDerivation {
       pname = "rsagl-math";
       version = "0.6.0.1";
       sha256 = "d67e304e982d19e86dc99cffea4fbf29a55aaacbd2a0dc1e41a7cab0bea12112";
       libraryHaskellDepends = [
         array base containers deepseq OpenGL OpenGLRaw parallel parsec
         random Vec Vec-OpenGLRaw
       ];
       jailbreak = true;
       homepage = "http://roguestar.downstairspeople.org/";
       description = "The RogueStar Animation and Graphics Library: Mathematics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rspp" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "rspp";
       version = "0.1.0.1";
       sha256 = "3e6771df48c5949c27d020d325295dbc322e0a1427db7f70bccf2552d73d5a8c";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://github.com/AJChapman/rspp";
       description = "A Rational Street Performer Protocol solver";
       license = stdenv.lib.licenses.mit;
     }) {};

  "rss" = callPackage
    ({ mkDerivation, base, HaXml, network, network-uri, old-locale
     , time
     }:
     mkDerivation {
       pname = "rss";
       version = "3000.2.0.5";
       sha256 = "6155b9c686b026f0cb7be13f99d2555db06c8c57cf2563d798cb30553137b979";
       libraryHaskellDepends = [
         base HaXml network network-uri old-locale time
       ];
       homepage = "https://github.com/basvandijk/rss";
       description = "A library for generating RSS 2.0 feeds.";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "rss2irc" = callPackage
    ({ mkDerivation, base, bytestring, cabal-file-th, cmdargs
     , containers, deepseq, feed, http-client, http-conduit, http-types
     , io-storage, irc, network, old-locale, parsec, regexpr, resourcet
     , safe, split, text, time, transformers, utf8-string
     }:
     mkDerivation {
       pname = "rss2irc";
       version = "1.0.6";
       sha256 = "bca14708ca66719261c36d328e6e3801b01b0a62a5525560aad70b7f5276d43d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cabal-file-th cmdargs containers deepseq feed
         http-client http-conduit http-types io-storage irc network
         old-locale parsec regexpr resourcet safe split text time
         transformers utf8-string
       ];
       jailbreak = true;
       homepage = "http://hackage.haskell.org/package/rss2irc";
       description = "watches an RSS/Atom feed and writes it to an IRC channel";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rtcm" = callPackage
    ({ mkDerivation, array, base, basic-prelude, binary, binary-bits
     , bytestring, lens, tasty, tasty-hunit, template-haskell, word24
     }:
     mkDerivation {
       pname = "rtcm";
       version = "0.1.3";
       sha256 = "8ee905a36562c93b0bd60d799eb85d59795c775497411120324fa104b13943ab";
       libraryHaskellDepends = [
         array base basic-prelude binary binary-bits bytestring lens
         template-haskell word24
       ];
       testHaskellDepends = [ base basic-prelude tasty tasty-hunit ];
       homepage = "http://github.com/swift-nav/librtcm";
       description = "RTCM Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rtld" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "rtld";
       version = "0.0.2";
       sha256 = "33baddec52dbbb148dce09e246a271e16e2dc37a85c3fbf99d84fa3d362dc5a3";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/kkardzis/rtld";
       description = "dynamic linker tools for Haskell";
       license = "unknown";
     }) {};

  "rtlsdr" = callPackage
    ({ mkDerivation, base, c2hs, rtl-sdr }:
     mkDerivation {
       pname = "rtlsdr";
       version = "0.1.0.4";
       sha256 = "ffad3e6ba6d38e6995fd5b90fbeadbebc8c4f2363346bf3cca1dbc2435461524";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ rtl-sdr ];
       libraryToolDepends = [ c2hs ];
       homepage = "https://github.com/adamwalker/hrtlsdr";
       description = "Bindings to librtlsdr";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) rtl-sdr;};

  "rtorrent-rpc" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-textual
     , bytestring, deepseq, haxr, mtl, network, split, utf8-string
     }:
     mkDerivation {
       pname = "rtorrent-rpc";
       version = "0.2.2.0";
       sha256 = "1a193b823e5400f23f983002b654f53588f24f9eac1166d6b354e90f32a9244c";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-textual bytestring deepseq haxr
         mtl network split utf8-string
       ];
       jailbreak = true;
       homepage = "https://github.com/megantti/rtorrent-rpc";
       description = "A library for communicating with RTorrent over its XML-RPC interface";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rtorrent-state" = callPackage
    ({ mkDerivation, base, bencoding, bytestring, containers, directory
     , filepath, hspec, lens, QuickCheck, temporary, utf8-string
     }:
     mkDerivation {
       pname = "rtorrent-state";
       version = "0.1.0.1";
       sha256 = "20591e2d7de88868604657c4ebb3dd823c68d1d3e26f671b509e729c2ebd0752";
       libraryHaskellDepends = [
         base bencoding bytestring containers directory filepath lens
         utf8-string
       ];
       testHaskellDepends = [
         base bencoding bytestring containers directory filepath hspec
         QuickCheck temporary utf8-string
       ];
       homepage = "http://github.com/Fuuzetsu/rtorrent-state";
       description = "Parsing and manipulation of rtorrent state file contents";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "rubberband" = callPackage
    ({ mkDerivation, base, c2hs, rubberband, vector }:
     mkDerivation {
       pname = "rubberband";
       version = "0.1.0.2";
       sha256 = "d5b94ba1bc5422ab35556b56a2546047b08e895f592661a5363df37d94004496";
       libraryHaskellDepends = [ base vector ];
       librarySystemDepends = [ rubberband ];
       libraryPkgconfigDepends = [ rubberband ];
       libraryToolDepends = [ c2hs ];
       testHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/mtolly/rubberband";
       description = "Binding to the C++ audio stretching library Rubber Band";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) rubberband;};

  "ruby-marshal" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, hspec, mtl
     , string-conv, vector
     }:
     mkDerivation {
       pname = "ruby-marshal";
       version = "0.1.1";
       sha256 = "d61ceb301b82e439b064eb4b1b84b1bb21c4ac9dc0239a0dc8d361cfe1b1800e";
       libraryHaskellDepends = [
         base bytestring cereal containers mtl string-conv vector
       ];
       testHaskellDepends = [
         base bytestring cereal containers hspec mtl string-conv vector
       ];
       jailbreak = true;
       homepage = "https://github.com/filib/ruby-marshal";
       description = "Parse a subset of Ruby objects serialised with Marshal.dump.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ruby-qq" = callPackage
    ({ mkDerivation, base, bytestring, haskell-src-exts
     , haskell-src-meta, pcre-light, process, template-haskell, trifecta
     }:
     mkDerivation {
       pname = "ruby-qq";
       version = "0.1.0.0";
       sha256 = "812936b7da627a703e4cc4595ce037be839f5f45ef3eef454317ec1867184ab4";
       libraryHaskellDepends = [
         base bytestring haskell-src-exts haskell-src-meta pcre-light
         process template-haskell trifecta
       ];
       jailbreak = true;
       homepage = "https://github.com/joelteon/ruby-qq";
       description = "rubyish quasiquoters";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ruff" = callPackage
    ({ mkDerivation, array, base, mtl, parsec, safe, strict, Vec }:
     mkDerivation {
       pname = "ruff";
       version = "0.4";
       sha256 = "d4effe4cfe26b2ebfb486e7d68f1027aaa3b11d04277d18eb64d2e566e18f225";
       libraryHaskellDepends = [ array base mtl parsec safe strict Vec ];
       homepage = "https://gitorious.org/ruff";
       description = "relatively useful fractal functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ruler" = callPackage
    ({ mkDerivation, base, containers, mtl, shuffle, uhc-util, uuagc
     , uuagc-cabal, uulib
     }:
     mkDerivation {
       pname = "ruler";
       version = "0.4.0.2";
       sha256 = "65234a5562d97306b25a06455926ecb7f0a8606d04dbec921ee6ee37a0508ccd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers mtl shuffle uhc-util uuagc uuagc-cabal uulib
       ];
       homepage = "https://github.com/UU-ComputerScience/ruler";
       description = "Ruler tool for UHC";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ruler-core" = callPackage
    ({ mkDerivation, array, base, containers, directory, fgl, filepath
     , haskell98, mtl, uuagc, uulib
     }:
     mkDerivation {
       pname = "ruler-core";
       version = "1.0";
       sha256 = "ede5dd93b8e2b8768ef853aa20bb68efb38e412b8838fa6b653bc1e9da2d8519";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory fgl filepath haskell98 mtl uuagc
         uulib
       ];
       homepage = "http://www.cs.uu.nl/wiki/HUT/WebHome";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "rungekutta" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "rungekutta";
       version = "1.0.2";
       sha256 = "d711d8efe0ef31bdd6d7413b6d2ad1797e7eb2758ad9a59db806bcb93b68b91d";
       libraryHaskellDepends = [ base ];
       description = "A collection of explicit Runge-Kutta methods of various orders";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "runghc" = callPackage
    ({ mkDerivation, base, cmdargs, directory, filepath, old-time
     , process
     }:
     mkDerivation {
       pname = "runghc";
       version = "0.1.0.3";
       sha256 = "c09ab4627b7261ed0f27a0bc385c022221baf378972da3efa0c5351d5b47c0ee";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs directory filepath old-time process
       ];
       homepage = "https://github.com/bacchanalia/runghc";
       description = "runghc replacement for fast repeated runs";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "runmemo" = callPackage
    ({ mkDerivation, base, data-memocombinators, time }:
     mkDerivation {
       pname = "runmemo";
       version = "1.0.0.1";
       sha256 = "ba5ef3177f8fe5f443808e44f62d03b23ac19bbef7f708e40532031a3505d689";
       testHaskellDepends = [ base data-memocombinators time ];
       homepage = "https://github.com/DanBurton/runmemo";
       description = "A simple memoization helper library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "rvar" = callPackage
    ({ mkDerivation, base, MonadPrompt, mtl, random-source
     , transformers
     }:
     mkDerivation {
       pname = "rvar";
       version = "0.2.0.2";
       sha256 = "a4ca344e6ba02007a24d5e845a1c1c55c2c2d232c42c749b65a7e67a047544d8";
       libraryHaskellDepends = [
         base MonadPrompt mtl random-source transformers
       ];
       homepage = "https://github.com/mokus0/random-fu";
       description = "Random Variables";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "rwlock" = callPackage
    ({ mkDerivation, base, monad-loops-stm, stm, syb }:
     mkDerivation {
       pname = "rwlock";
       version = "0.0.0.3";
       sha256 = "6ad5e97c42698e92051b701cde5cd09005877c9b3e04ea19dc0762e595185d47";
       libraryHaskellDepends = [ base monad-loops-stm stm syb ];
       homepage = "https://github.com/mokus0/rwlock";
       description = "Multiple-read / single-write locks";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "rws" = callPackage
    ({ mkDerivation, base, binary, bytestring, parsec, QuickCheck
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "rws";
       version = "0.1.1.2";
       sha256 = "c6088d196eac3ccef2742d6f28ab7cf649664031acc9696a111dc1766d5d8dc6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base binary bytestring parsec ];
       testHaskellDepends = [
         base binary bytestring parsec QuickCheck test-framework
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/karknu/rws";
       description = "Packet Generation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "s-cargot" = callPackage
    ({ mkDerivation, base, containers, parsec, text }:
     mkDerivation {
       pname = "s-cargot";
       version = "0.1.0.0";
       sha256 = "18682ea8684e704ba2abc55d699b9df0a98a2f400c3d0ace436de5b90c335a3e";
       libraryHaskellDepends = [ base containers parsec text ];
       homepage = "https://github.com/aisamanra/s-cargot";
       description = "A flexible, extensible s-expression library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "s3-signer" = callPackage
    ({ mkDerivation, base, base64-bytestring, cryptohash, http-types
     , time, utf8-string
     }:
     mkDerivation {
       pname = "s3-signer";
       version = "0.3.0.0";
       sha256 = "89e957f81211a417c425214d3d7eafb0f15f695ffe0002f4198f2e34b43bc494";
       libraryHaskellDepends = [
         base base64-bytestring cryptohash http-types time utf8-string
       ];
       homepage = "https://github.com/dmjio/s3-signer";
       description = "Pre-signed Amazon S3 URLs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "safe_0_3_8" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "safe";
       version = "0.3.8";
       sha256 = "ae49664668929213f413da234bb9dda5c48d9e18759edece7c1379f10b9ab44c";
       libraryHaskellDepends = [ base ];
       homepage = "http://community.haskell.org/~ndm/safe/";
       description = "Library of safe (exception free) functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "safe" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "safe";
       version = "0.3.9";
       sha256 = "d0319ea7b55947e70092f0256aa9f9d2496a93b0e2a0887c0f8eaa0d7fb9b6c9";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/ndmitchell/safe#readme";
       description = "Library of safe (exception free) functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "safe-access" = callPackage
    ({ mkDerivation, base, mtl, transformers }:
     mkDerivation {
       pname = "safe-access";
       version = "0.2.1.1";
       sha256 = "e803e2cd23dcee8b222b1fdece54a3c7cf3c67c7b0d26855bd1a601a9197325e";
       libraryHaskellDepends = [ base mtl transformers ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/thoferon/safe-access";
       description = "A simple environment to control access to data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "safe-failure" = callPackage
    ({ mkDerivation, base, failure }:
     mkDerivation {
       pname = "safe-failure";
       version = "0.5.0.2";
       sha256 = "87ab46ddc3340c994855aa0305962983181aaac18f2abf81ffc935d7b2924e80";
       libraryHaskellDepends = [ base failure ];
       homepage = "http://www-users.cs.york.ac.uk/~ndm/safe/";
       description = "Library for safe functions (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "safe-failure-cme" = callPackage
    ({ mkDerivation, base, control-monad-exception, safe-failure }:
     mkDerivation {
       pname = "safe-failure-cme";
       version = "0.1.0";
       sha256 = "f38d527ceb747208102feb998955622483280759ac7c275ce37ef7e40c7ee05a";
       libraryHaskellDepends = [
         base control-monad-exception safe-failure
       ];
       description = "control-monad-exception Instances for safe-failure";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "safe-freeze" = callPackage
    ({ mkDerivation, base, indexed, mtl, vector }:
     mkDerivation {
       pname = "safe-freeze";
       version = "0.2.1";
       sha256 = "636cc1fb3825830f986689a0cca43520f3454cb7de54b2920542d10ca67ab88a";
       libraryHaskellDepends = [ base indexed mtl vector ];
       jailbreak = true;
       homepage = "https://github.com/reinerp/safe-freeze";
       description = "Support for safely freezing multiple arrays in the ST monad";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "safe-globals" = callPackage
    ({ mkDerivation, base, stm, template-haskell }:
     mkDerivation {
       pname = "safe-globals";
       version = "0.1.1";
       sha256 = "6573ce84639aba76819eaf225acc1599dcfff5722374f9ca1ebc5d878487c32a";
       libraryHaskellDepends = [ base stm template-haskell ];
       description = "Safe top-level mutable variables which scope like ordinary values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "safe-lazy-io" = callPackage
    ({ mkDerivation, base, extensible-exceptions, parallel, strict-io
     }:
     mkDerivation {
       pname = "safe-lazy-io";
       version = "0.1";
       sha256 = "8ca0637127bd69b0de43d3d95cc1aebc0aa55054321de97124e96b1250241cc3";
       libraryHaskellDepends = [
         base extensible-exceptions parallel strict-io
       ];
       description = "A library providing safe lazy IO features";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "safe-length" = callPackage
    ({ mkDerivation, base, hspec, hspec-core, QuickCheck
     , should-not-typecheck
     }:
     mkDerivation {
       pname = "safe-length";
       version = "0.1.0.0";
       sha256 = "241155e4a2b91731872729ed90641a6d34fcee82d5fc4d1ff7a5247e6ec18979";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base hspec hspec-core QuickCheck should-not-typecheck
       ];
       homepage = "http://www.github.com/stepcut/safe-length";
       description = "Tired of accidentally calling length on tuples? Relief at last!";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "safe-plugins" = callPackage
    ({ mkDerivation, base, directory, filepath, haskell-src-exts
     , plugins, Unixutils
     }:
     mkDerivation {
       pname = "safe-plugins";
       version = "0.1";
       sha256 = "c574be8cbfb49ba965d31546e35339d2894010e315c5f52f4a8094172338bedb";
       libraryHaskellDepends = [
         base directory filepath haskell-src-exts plugins Unixutils
       ];
       description = "A small wrapper over hs-plugins to allow loading safe plugins";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "safe-printf" = callPackage
    ({ mkDerivation, base, doctest, haskell-src-meta, hspec, QuickCheck
     , template-haskell, th-lift
     }:
     mkDerivation {
       pname = "safe-printf";
       version = "0.1.0.0";
       sha256 = "e6a5b44ff6798abfa8b1626af847cfa61ff3a676b46331823692f6830d18dca6";
       libraryHaskellDepends = [
         base haskell-src-meta template-haskell th-lift
       ];
       testHaskellDepends = [
         base doctest haskell-src-meta hspec QuickCheck template-haskell
         th-lift
       ];
       homepage = "https://github.com/konn/safe-printf";
       description = "Well-typed, flexible and variadic printf for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "safecopy_0_8_3" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, containers, lens
     , old-time, quickcheck-instances, tasty, tasty-quickcheck
     , template-haskell, text, time, vector
     }:
     mkDerivation {
       pname = "safecopy";
       version = "0.8.3";
       sha256 = "768cc140b95e36d638008c63edb14c536bd4168912ac367ce48ea0189420ad83";
       revision = "3";
       editedCabalFile = "5a966c6cfe277c6c7044ba81748f2475752eda255d503b9c83f170a912ae3dac";
       libraryHaskellDepends = [
         array base bytestring cereal containers old-time template-haskell
         text time vector
       ];
       testHaskellDepends = [
         array base cereal containers lens quickcheck-instances tasty
         tasty-quickcheck template-haskell time vector
       ];
       jailbreak = true;
       homepage = "http://acid-state.seize.it/safecopy";
       description = "Binary serialization with version control";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "safecopy_0_8_4" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, containers, lens
     , lens-action, old-time, quickcheck-instances, tasty
     , tasty-quickcheck, template-haskell, text, time, vector
     }:
     mkDerivation {
       pname = "safecopy";
       version = "0.8.4";
       sha256 = "10a9c6d1cea5ef8721a307880bcdc192379c81d36efe867f715dfbfda25a8f7f";
       revision = "3";
       editedCabalFile = "35e255ae79778f5e875692b4bd97ef52e0d65a0efbbabfa83e7fd207b732b54b";
       libraryHaskellDepends = [
         array base bytestring cereal containers old-time template-haskell
         text time vector
       ];
       testHaskellDepends = [
         array base cereal containers lens lens-action quickcheck-instances
         tasty tasty-quickcheck template-haskell time vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://acid-state.seize.it/safecopy";
       description = "Binary serialization with version control";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "safecopy_0_8_5" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, containers, lens
     , lens-action, old-time, quickcheck-instances, tasty
     , tasty-quickcheck, template-haskell, text, time, vector
     }:
     mkDerivation {
       pname = "safecopy";
       version = "0.8.5";
       sha256 = "69566beb14d27d591a040f49b3c557aff347c610beb6ecb59fdd7a688e101be4";
       revision = "3";
       editedCabalFile = "8ea114ff634e746a7e99eb70ab3fcca2c834248f3b980e5b23c20188fae5cf8f";
       libraryHaskellDepends = [
         array base bytestring cereal containers old-time template-haskell
         text time vector
       ];
       testHaskellDepends = [
         array base cereal containers lens lens-action quickcheck-instances
         tasty tasty-quickcheck template-haskell time vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://acid-state.seize.it/safecopy";
       description = "Binary serialization with version control";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "safecopy_0_8_6" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, containers, lens
     , lens-action, old-time, quickcheck-instances, tasty
     , tasty-quickcheck, template-haskell, text, time, vector
     }:
     mkDerivation {
       pname = "safecopy";
       version = "0.8.6";
       sha256 = "e2b435151fe7e15cd1cbb276646b0a9aee7ad69dbf984dfc68996289d45dd1d6";
       revision = "2";
       editedCabalFile = "5ea34be4625333c54135b8aaac9e2f13b5f2dbbd3a9a3348e7fd2c4cedc3faf0";
       libraryHaskellDepends = [
         array base bytestring cereal containers old-time template-haskell
         text time vector
       ];
       testHaskellDepends = [
         array base cereal containers lens lens-action quickcheck-instances
         tasty tasty-quickcheck template-haskell time vector
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://acid-state.seize.it/safecopy";
       description = "Binary serialization with version control";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "safecopy" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, containers, lens
     , lens-action, old-time, quickcheck-instances, tasty
     , tasty-quickcheck, template-haskell, text, time, vector
     }:
     mkDerivation {
       pname = "safecopy";
       version = "0.9.0.1";
       sha256 = "3fd178f6066cb5d0eedb7981bd39ffae34908d636c63d32d78aefe67dfe65031";
       libraryHaskellDepends = [
         array base bytestring cereal containers old-time template-haskell
         text time vector
       ];
       testHaskellDepends = [
         array base cereal containers lens lens-action quickcheck-instances
         tasty tasty-quickcheck template-haskell time vector
       ];
       doCheck = false;
       homepage = "http://acid-state.seize.it/safecopy";
       description = "Binary serialization with version control";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "safeint" = callPackage
    ({ mkDerivation, base, ghc-prim, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "safeint";
       version = "0.6";
       sha256 = "d4d9851547c1e0951730e5d4cf9897c2666f27048ef80be0bb9dc94ac72f2794";
       libraryHaskellDepends = [ base ghc-prim ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       description = "overflow-checked Int type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "safer-file-handles" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, explicit-iomodes
     , pathtype, regional-pointers, regions, transformers
     }:
     mkDerivation {
       pname = "safer-file-handles";
       version = "0.11";
       sha256 = "69986b30dc3d4ff3d4f44dbfaa2ff2b705c948c32e3945b77c66c89fdb081ccb";
       libraryHaskellDepends = [
         base base-unicode-symbols explicit-iomodes pathtype
         regional-pointers regions transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/safer-file-handles/";
       description = "Type-safe file handling";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "safer-file-handles-bytestring" = callPackage
    ({ mkDerivation, base, bytestring, explicit-iomodes-bytestring
     , regions, safer-file-handles, transformers
     }:
     mkDerivation {
       pname = "safer-file-handles-bytestring";
       version = "0.3.0.1";
       sha256 = "6989e047b296d7bc09377e3df76fb1000d59f01edcfc6d4ae177255c619970b9";
       libraryHaskellDepends = [
         base bytestring explicit-iomodes-bytestring regions
         safer-file-handles transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/safer-file-handles-bytestring/";
       description = "Extends safer-file-handles with ByteString operations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "safer-file-handles-text" = callPackage
    ({ mkDerivation, explicit-iomodes-text, regions, safer-file-handles
     , text, transformers
     }:
     mkDerivation {
       pname = "safer-file-handles-text";
       version = "0.2.0.2";
       sha256 = "d52ab6109305393899dc2c3e89196685808c79e3f59175a09e59da965e9ca093";
       libraryHaskellDepends = [
         explicit-iomodes-text regions safer-file-handles text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/safer-file-handles-text/";
       description = "Extends safer-file-handles with Text operations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "saferoute" = callPackage
    ({ mkDerivation, base, blaze-html, containers, text }:
     mkDerivation {
       pname = "saferoute";
       version = "0.2.0.0";
       sha256 = "d02c3b48cefb6cc5088d5dd06b0209617f00200c378c53077bf0a94b88afd303";
       libraryHaskellDepends = [ base blaze-html containers text ];
       jailbreak = true;
       description = "A simple type-safe routing library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sai-shape-syb" = callPackage
    ({ mkDerivation, base, containers, ghc, ghc-syb-utils, HUnit, syb
     }:
     mkDerivation {
       pname = "sai-shape-syb";
       version = "0.3.4";
       sha256 = "4385f485ffc78688b5dd6a41b239afa96b94f1e904e6e9bb85656f75dcc5e71d";
       libraryHaskellDepends = [ base containers ghc ghc-syb-utils syb ];
       testHaskellDepends = [
         base containers ghc ghc-syb-utils HUnit syb
       ];
       jailbreak = true;
       homepage = "http://fremissant.net/shape-syb";
       description = "Obtain homogeneous values from arbitrary values, transforming or culling data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "saltine" = callPackage
    ({ mkDerivation, base, bytestring, libsodium, profunctors
     , QuickCheck, test-framework, test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "saltine";
       version = "0.0.0.4";
       sha256 = "07a1ea393e9d85b921e82659e695961e0cf0ca5419196d9f91d483e5d1c4e4d8";
       libraryHaskellDepends = [ base bytestring profunctors ];
       librarySystemDepends = [ libsodium ];
       testHaskellDepends = [
         base bytestring QuickCheck test-framework
         test-framework-quickcheck2 vector
       ];
       description = "Cryptography that's easy to digest (NaCl/libsodium bindings)";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) libsodium;};

  "saltine-quickcheck" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-arbitrary, hex
     , libsodium, QuickCheck, saltine, tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "saltine-quickcheck";
       version = "0.1.0.1";
       sha256 = "d2761d1c435b5205710619132d01adf5639c9843a3adb5303e667fafb3412210";
       libraryHaskellDepends = [
         base bytestring bytestring-arbitrary hex QuickCheck saltine
       ];
       librarySystemDepends = [ libsodium ];
       testHaskellDepends = [
         base bytestring-arbitrary QuickCheck saltine tasty tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "https://github.com/tsuraan/saltine-quickcheck";
       description = "Quickcheck implementations for some NaCl data";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libsodium;};

  "salvia" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, fclabels
     , MaybeT-transformers, monads-fd, network, old-locale, process
     , pureMD5, random, safe, salvia-protocol, split, stm, text
     , threadmanager, time, transformers, unix, utf8-string
     }:
     mkDerivation {
       pname = "salvia";
       version = "1.0.0";
       sha256 = "d1be63e3eb7cb071e8e339d730692b3ce52576e513f718b89a194b17878496e1";
       libraryHaskellDepends = [
         base bytestring containers directory fclabels MaybeT-transformers
         monads-fd network old-locale process pureMD5 random safe
         salvia-protocol split stm text threadmanager time transformers unix
         utf8-string
       ];
       jailbreak = true;
       description = "Modular web application framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "salvia-demo" = callPackage
    ({ mkDerivation, base, c10k, fclabels, filestore, monads-fd
     , network, salvia, salvia-extras, salvia-protocol, salvia-sessions
     , salvia-websocket, stm, threadmanager, transformers
     }:
     mkDerivation {
       pname = "salvia-demo";
       version = "1.0.0";
       sha256 = "30b82129626bdf907158cc5d529f8364a8f1d1013a50a3df294f7c20e1e9db69";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base c10k fclabels filestore monads-fd network salvia salvia-extras
         salvia-protocol salvia-sessions salvia-websocket stm threadmanager
         transformers
       ];
       doHaddock = false;
       jailbreak = true;
       description = "Demo Salvia servers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "salvia-extras" = callPackage
    ({ mkDerivation, base, bytestring, c10k, clevercss, fclabels
     , filestore, hscolour, HStringTemplate, monads-fd, network
     , old-locale, pureMD5, salvia, salvia-protocol, sendfile, split
     , stm, text, threadmanager, time, transformers, utf8-string
     }:
     mkDerivation {
       pname = "salvia-extras";
       version = "1.0.0";
       sha256 = "a12870b0c125fbbac0c45916f1576ec7f2db647051e9d9da11b52f65c954d1d9";
       libraryHaskellDepends = [
         base bytestring c10k clevercss fclabels filestore hscolour
         HStringTemplate monads-fd network old-locale pureMD5 salvia
         salvia-protocol sendfile split stm text threadmanager time
         transformers utf8-string
       ];
       jailbreak = true;
       description = "Collection of non-fundamental handlers for the Salvia web server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "salvia-protocol" = callPackage
    ({ mkDerivation, base, bimap, bytestring, containers, fclabels
     , parsec, safe, split, utf8-string
     }:
     mkDerivation {
       pname = "salvia-protocol";
       version = "1.0.1";
       sha256 = "6b2312e52efaa81feec7461b1a3db77e1f2a8dfd829ae878b614c206a5e48928";
       libraryHaskellDepends = [
         base bimap bytestring containers fclabels parsec safe split
         utf8-string
       ];
       jailbreak = true;
       description = "Salvia webserver protocol suite supporting URI, HTTP, Cookie and MIME";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "salvia-sessions" = callPackage
    ({ mkDerivation, base, containers, fclabels, MaybeT-transformers
     , monads-fd, pureMD5, random, safe, salvia, salvia-protocol, stm
     , time, utf8-string
     }:
     mkDerivation {
       pname = "salvia-sessions";
       version = "1.0.0";
       sha256 = "10acd7f9c763629829ab4fad84c7f2220cabbdbcdd7114e87c263cae604fd431";
       libraryHaskellDepends = [
         base containers fclabels MaybeT-transformers monads-fd pureMD5
         random safe salvia salvia-protocol stm time utf8-string
       ];
       jailbreak = true;
       description = "Session support for the Salvia webserver";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "salvia-websocket" = callPackage
    ({ mkDerivation, base, bytestring, fclabels, monads-fd, salvia
     , salvia-protocol, stm, utf8-string
     }:
     mkDerivation {
       pname = "salvia-websocket";
       version = "1.0.0";
       sha256 = "f4d927d44868d5eedc45ea50ff898630fbc81e333febf0517053f6f4cb2f5993";
       libraryHaskellDepends = [
         base bytestring fclabels monads-fd salvia salvia-protocol stm
         utf8-string
       ];
       jailbreak = true;
       description = "Websocket implementation for the Salvia Webserver";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sample-frame" = callPackage
    ({ mkDerivation, base, QuickCheck, storable-record }:
     mkDerivation {
       pname = "sample-frame";
       version = "0.0.3";
       sha256 = "5baf301a4f7b2d52e6b9b9c06b10afd3938de0be6d09736d0188616cd9027247";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base QuickCheck storable-record ];
       homepage = "http://www.haskell.org/haskellwiki/Synthesizer";
       description = "Handling of samples in an (audio) signal";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sample-frame-np" = callPackage
    ({ mkDerivation, base, numeric-prelude, sample-frame }:
     mkDerivation {
       pname = "sample-frame-np";
       version = "0.0.4";
       sha256 = "cdec6e95f9b3739ca5031dfa914465d5e82b9b6bb09c95529728c92efb21e4d0";
       libraryHaskellDepends = [ base numeric-prelude sample-frame ];
       homepage = "http://www.haskell.org/haskellwiki/Synthesizer";
       description = "Orphan instances for types from sample-frame and numericprelude";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sampling" = callPackage
    ({ mkDerivation, base, foldl, mwc-random, primitive, vector }:
     mkDerivation {
       pname = "sampling";
       version = "0.1.1";
       sha256 = "a1282010e483959c81cf9c018aac5560f2429cc9826e0e79452bc19ea484f19d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base foldl mwc-random primitive vector ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/jtobin/sampling";
       description = "Sample values from collections";
       license = stdenv.lib.licenses.mit;
     }) {};

  "samtools" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, filepath, process, seqloc
     , vector, zlib
     }:
     mkDerivation {
       pname = "samtools";
       version = "0.2.4.1";
       sha256 = "2da6f94a7a673224522f82abe64843f3d480f7ef789f9dac041b6bf3b9081502";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring seqloc vector ];
       librarySystemDepends = [ zlib ];
       libraryToolDepends = [ c2hs ];
       executableHaskellDepends = [
         base bytestring filepath process seqloc vector
       ];
       executableSystemDepends = [ zlib ];
       executableToolDepends = [ c2hs ];
       homepage = "http://www.ingolia-lab.org/samtools-tutorial.html";
       description = "Binding to the C samtools library";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) zlib;};

  "samtools-conduit" = callPackage
    ({ mkDerivation, base, bytestring, conduit, filepath, resourcet
     , samtools, transformers
     }:
     mkDerivation {
       pname = "samtools-conduit";
       version = "0.1.1.0";
       sha256 = "bce2d5f74f3b06741c661bab51d4ab0bed629016d03a263047123ea4936ea968";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring conduit filepath resourcet samtools transformers
       ];
       executableHaskellDepends = [
         base bytestring conduit filepath resourcet samtools transformers
       ];
       jailbreak = true;
       homepage = "http://www.ingolia-lab.org/samtools-tutorial.html";
       description = "Conduit interface to SAM/BAM format files through samtools";
       license = stdenv.lib.licenses.mit;
     }) {};

  "samtools-enumerator" = callPackage
    ({ mkDerivation, base, bytestring, enumerator, samtools
     , transformers
     }:
     mkDerivation {
       pname = "samtools-enumerator";
       version = "0.1.2.1";
       sha256 = "b5e4312ee21583d4768676bbcf320c137fc416a5c4d724fafea5b9b495a86272";
       libraryHaskellDepends = [
         base bytestring enumerator samtools transformers
       ];
       description = "Enumerator interface to SamTools library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "samtools-iteratee" = callPackage
    ({ mkDerivation, base, bytestring, iteratee, monads-tf, samtools
     , transformers
     }:
     mkDerivation {
       pname = "samtools-iteratee";
       version = "0.2.2.1";
       sha256 = "d4807605be6092c876ca779b2e74beb1ea4c8f8d0338fdcc28ba804a07b82c8d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring iteratee samtools transformers
       ];
       executableHaskellDepends = [
         base bytestring iteratee monads-tf samtools transformers
       ];
       description = "Iteratee interface to SamTools library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sandi_0_3_5" = callPackage
    ({ mkDerivation, base, bytestring, conduit, exceptions, HUnit
     , tasty, tasty-hunit, tasty-quickcheck, tasty-th
     }:
     mkDerivation {
       pname = "sandi";
       version = "0.3.5";
       sha256 = "856ed995bad4183a69f65c70a78c4be37cf614c906097ea126bae75ce08daea5";
       libraryHaskellDepends = [ base bytestring conduit exceptions ];
       testHaskellDepends = [
         base bytestring HUnit tasty tasty-hunit tasty-quickcheck tasty-th
       ];
       homepage = "http://hackage.haskell.org/package/sandi";
       description = "Data encoding library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sandi" = callPackage
    ({ mkDerivation, base, bytestring, conduit, exceptions, HUnit
     , tasty, tasty-hunit, tasty-quickcheck, tasty-th
     }:
     mkDerivation {
       pname = "sandi";
       version = "0.3.6";
       sha256 = "fafcb3501b8a17238de44239ef62c3051f9a33010424ef91dd76057257bf2284";
       libraryHaskellDepends = [ base bytestring conduit exceptions ];
       testHaskellDepends = [
         base bytestring HUnit tasty tasty-hunit tasty-quickcheck tasty-th
       ];
       homepage = "http://hackage.haskell.org/package/sandi";
       description = "Data encoding library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sandlib" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "sandlib";
       version = "0.0.2";
       sha256 = "7d5e80bf57f477f3a9fff60a28b507e2e5a1ace3756169fbdec6dd4cd436901f";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://github.com/regularlambda/sandlib";
       description = "SAND data serialization and manipulation library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sandman" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, filepath
     , optparse-applicative, process, text, unix-compat
     }:
     mkDerivation {
       pname = "sandman";
       version = "0.2.0.0";
       sha256 = "25935a86ce5ec33c04b4203d1aa91bb7fd7cce4af37ccea8f1d4a85660cc7d46";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers directory filepath optparse-applicative
         process text unix-compat
       ];
       homepage = "https://github.com/abhinav/sandman";
       description = "Manages Cabal sandboxes to avoid rebuilding packages";
       license = stdenv.lib.licenses.mit;
     }) {};

  "sarasvati" = callPackage
    ({ mkDerivation, base, deepseq, portaudio }:
     mkDerivation {
       pname = "sarasvati";
       version = "0.3.0.0";
       sha256 = "68102bb2f1db289783a8e406b17aaa5e89854ab667fe7d60a21c365f852d0d75";
       libraryHaskellDepends = [ base deepseq portaudio ];
       jailbreak = true;
       homepage = "https://github.com/tokiwoousaka/Sarasvati";
       description = "audio library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "sasl" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, cryptohash
     , monads-tf, papillon, simple-pipe
     }:
     mkDerivation {
       pname = "sasl";
       version = "0.0.0.1";
       sha256 = "f43b3e48169e1e579f4fb2e3ab84410321233ef798a63b6df847df82de9f4b29";
       libraryHaskellDepends = [
         base base64-bytestring bytestring cryptohash monads-tf papillon
         simple-pipe
       ];
       homepage = "https://github.com/YoshikuniJujo/sasl/wiki";
       description = "SASL implementation using simple-pipe";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sat" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "sat";
       version = "1.1.1";
       sha256 = "d74427a71ce32a774297984fe4dd021da10180f708114b74cafefe6eb15642c5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       homepage = "http://tcana.info/sat.html";
       description = "CNF SATisfier";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sat-micro-hs" = callPackage
    ({ mkDerivation, base, containers, haskell98, mtl, parse-dimacs
     , pretty
     }:
     mkDerivation {
       pname = "sat-micro-hs";
       version = "0.1.1";
       sha256 = "842d181af744d36785481fd63e0f63c07ad77cbab2e7f10a0d17e6e4276309f0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers haskell98 mtl parse-dimacs pretty
       ];
       description = "A minimal SAT solver";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "satchmo" = callPackage
    ({ mkDerivation, array, async, base, bytestring, containers
     , deepseq, directory, hashable, lens, memoize, minisat, mtl
     , process, transformers
     }:
     mkDerivation {
       pname = "satchmo";
       version = "2.9.9.1";
       sha256 = "3414dcc5184cd34bce55eb041ff84f8985672964c64786d146b9520237ee13e2";
       libraryHaskellDepends = [
         array async base bytestring containers deepseq directory hashable
         lens memoize minisat mtl process transformers
       ];
       testHaskellDepends = [ array base ];
       homepage = "https://github.com/jwaldmann/satchmo";
       description = "SAT encoding monad";
       license = "GPL";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "satchmo-backends" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, process
     , satchmo, timeit
     }:
     mkDerivation {
       pname = "satchmo-backends";
       version = "1.9.1";
       sha256 = "aeb9155253a5eec6dc13df22fa641ebc938c0795092e8921309338e061e5dfc3";
       libraryHaskellDepends = [
         array base bytestring containers process satchmo timeit
       ];
       homepage = "http://dfa.imn.htwk-leipzig.de/satchmo/";
       description = "driver for external satchmo backends";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "satchmo-examples" = callPackage
    ({ mkDerivation, array, base, containers, process, satchmo
     , satchmo-backends
     }:
     mkDerivation {
       pname = "satchmo-examples";
       version = "1.8.1";
       sha256 = "8313c4be7ecd32efa77cfdca6be4b2ba43da8ef76ef1740365dff95170556ff7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers process satchmo satchmo-backends
       ];
       homepage = "http://dfa.imn.htwk-leipzig.de/satchmo/";
       description = "examples that show how to use satchmo";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "satchmo-funsat" = callPackage
    ({ mkDerivation, array, base, containers, funsat, parse-dimacs
     , satchmo
     }:
     mkDerivation {
       pname = "satchmo-funsat";
       version = "1.4";
       sha256 = "64ec9531d40ed196831021904576697929d43f8f752a044c6bb031ce17eda05b";
       libraryHaskellDepends = [
         array base containers funsat parse-dimacs satchmo
       ];
       homepage = "http://dfa.imn.htwk-leipzig.de/satchmo/";
       description = "funsat driver as backend for satchmo";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "satchmo-minisat" = callPackage
    ({ mkDerivation, base, containers, process, satchmo }:
     mkDerivation {
       pname = "satchmo-minisat";
       version = "1.3";
       sha256 = "a6b0c9cdd6466fa60d605da3a14c9c3c52e64b32f94e915c75587e414d908fb7";
       libraryHaskellDepends = [ base containers process satchmo ];
       homepage = "http://dfa.imn.htwk-leipzig.de/satchmo/";
       description = "minisat driver as backend for satchmo";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "satchmo-toysat" = callPackage
    ({ mkDerivation, array, base, containers, satchmo, toysolver }:
     mkDerivation {
       pname = "satchmo-toysat";
       version = "0.2.1.0";
       sha256 = "c1c0ee4e46975dfc874b43c3145110956bb1a920b123910e9afcb318dbfbd0bc";
       revision = "1";
       editedCabalFile = "c7d42104f5373844f95b97b8e4ed7482712f1ca054ca669a17ccfffaee8acab3";
       libraryHaskellDepends = [
         array base containers satchmo toysolver
       ];
       jailbreak = true;
       homepage = "https://github.com/msakai/satchmo-toysat";
       description = "toysat driver as backend for satchmo";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "sbp" = callPackage
    ({ mkDerivation, aeson, array, base, base64-bytestring
     , basic-prelude, binary, binary-conduit, bytestring, conduit
     , conduit-combinators, conduit-extra, data-binary-ieee754, lens
     , monad-loops, QuickCheck, resourcet, tasty, tasty-hunit
     , tasty-quickcheck, template-haskell, text, unordered-containers
     , yaml, yaml-light
     }:
     mkDerivation {
       pname = "sbp";
       version = "0.52.1";
       sha256 = "72e53ab77cf026fc5bde9899a5a49a35bbe6a2e3853022b9d62e238eee8450f6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson array base base64-bytestring basic-prelude binary bytestring
         data-binary-ieee754 lens monad-loops template-haskell text
         unordered-containers
       ];
       executableHaskellDepends = [
         aeson base basic-prelude binary-conduit bytestring conduit
         conduit-combinators conduit-extra resourcet yaml
       ];
       testHaskellDepends = [
         aeson base base64-bytestring basic-prelude bytestring QuickCheck
         tasty tasty-hunit tasty-quickcheck yaml-light
       ];
       homepage = "https://github.com/swift-nav/libsbp";
       description = "SwiftNav's SBP Library";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sbv_4_2" = callPackage
    ({ mkDerivation, array, async, base, containers, deepseq, directory
     , filepath, HUnit, mtl, old-time, pretty, process, QuickCheck
     , random, syb
     }:
     mkDerivation {
       pname = "sbv";
       version = "4.2";
       sha256 = "1879a4ee5835553f64197ab58904c045efa84dc6fde291fa9a5da3c88572c2e0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array async base containers deepseq directory filepath mtl old-time
         pretty process QuickCheck random syb
       ];
       executableHaskellDepends = [
         base directory filepath HUnit process syb
       ];
       testHaskellDepends = [ base directory filepath HUnit syb ];
       homepage = "http://leventerkok.github.com/sbv/";
       description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sbv_4_4" = callPackage
    ({ mkDerivation, array, async, base, containers, crackNum
     , data-binary-ieee754, deepseq, directory, filepath, HUnit, mtl
     , old-time, pretty, process, QuickCheck, random, syb
     }:
     mkDerivation {
       pname = "sbv";
       version = "4.4";
       sha256 = "9a1aed296ffbd3b848d3b714310cdd1f5cf02742ad99f2c353a3f9ee4b3224a4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array async base containers crackNum data-binary-ieee754 deepseq
         directory filepath mtl old-time pretty process QuickCheck random
         syb
       ];
       executableHaskellDepends = [
         base directory filepath HUnit process syb
       ];
       testHaskellDepends = [ base directory filepath HUnit syb ];
       homepage = "http://leventerkok.github.com/sbv/";
       description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sbv_5_9" = callPackage
    ({ mkDerivation, array, async, base, base-compat, containers
     , crackNum, data-binary-ieee754, deepseq, directory, filepath
     , HUnit, mtl, old-time, pretty, process, QuickCheck, random, syb
     }:
     mkDerivation {
       pname = "sbv";
       version = "5.9";
       sha256 = "d515d54203862c936f0395aec042e7bdc8779bc4342ce921622694d6ff92f3b9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array async base base-compat containers crackNum
         data-binary-ieee754 deepseq directory filepath mtl old-time pretty
         process QuickCheck random syb
       ];
       executableHaskellDepends = [
         base data-binary-ieee754 directory filepath HUnit process syb
       ];
       testHaskellDepends = [
         base data-binary-ieee754 directory filepath HUnit syb
       ];
       homepage = "http://leventerkok.github.com/sbv/";
       description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sbv" = callPackage
    ({ mkDerivation, array, async, base, base-compat, containers
     , crackNum, data-binary-ieee754, deepseq, directory, filepath
     , HUnit, mtl, old-time, pretty, process, QuickCheck, random, syb
     }:
     mkDerivation {
       pname = "sbv";
       version = "5.11";
       sha256 = "9ede93f41cdbdfb73638f25eec9c201190d049163ad503202ebefa2d18cfc90d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array async base base-compat containers crackNum
         data-binary-ieee754 deepseq directory filepath mtl old-time pretty
         process QuickCheck random syb
       ];
       executableHaskellDepends = [
         base data-binary-ieee754 directory filepath HUnit process syb
       ];
       testHaskellDepends = [
         base data-binary-ieee754 directory filepath HUnit syb
       ];
       homepage = "http://leventerkok.github.com/sbv/";
       description = "SMT Based Verification: Symbolic Haskell theorem prover using SMT solving";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sbvPlugin" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, ghc
     , ghc-prim, mtl, process, sbv, tasty, tasty-golden
     , template-haskell
     }:
     mkDerivation {
       pname = "sbvPlugin";
       version = "0.6";
       sha256 = "36355a645df160dd15399a6704759032822f5d5cf9670db4e7c8e249ac1d8f75";
       libraryHaskellDepends = [
         base containers ghc ghc-prim mtl sbv template-haskell
       ];
       testHaskellDepends = [
         base directory filepath process tasty tasty-golden
       ];
       homepage = "http://github.com/LeventErkok/sbvPlugin";
       description = "Formally prove properties of Haskell programs using SBV/SMT";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sc3-rdu" = callPackage
    ({ mkDerivation, base, hsc3, hsc3-db }:
     mkDerivation {
       pname = "sc3-rdu";
       version = "0.15";
       sha256 = "60cc87b6977770f6de62a1a331a0252e356922792ed76a6f13ab8ca2074f2d7f";
       libraryHaskellDepends = [ base hsc3 hsc3-db ];
       homepage = "http://rd.slavepianos.org/t/sc3-rdu";
       description = "Haskell bindings to sc3-rdu (sc3 rd ugens)";
       license = "GPL";
     }) {};

  "scalable-server" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , blaze-builder, BoundedChan, bytestring, enumerator, mtl, network
     , network-enumerator
     }:
     mkDerivation {
       pname = "scalable-server";
       version = "0.2.2";
       sha256 = "a6d77658a45b072a2c9e0d8c3fce4505730fc5243521699a91a1c56ffe66d618";
       libraryHaskellDepends = [
         attoparsec attoparsec-enumerator base blaze-builder BoundedChan
         bytestring enumerator mtl network network-enumerator
       ];
       jailbreak = true;
       homepage = "https://github.com/jamwt/haskell-scalable-server/";
       description = "Library for writing fast/scalable TCP-based services";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "scaleimage" = callPackage
    ({ mkDerivation, base, filepath, gd }:
     mkDerivation {
       pname = "scaleimage";
       version = "0.1";
       sha256 = "d60e385a335ddf93b352bd6540e5b7a4596130c2dfdbcb05492759913f88902a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base filepath gd ];
       homepage = "http://code.haskell.org/~dons/code/scaleimage";
       description = "Scale an image to a new geometry";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scalp-webhooks" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, hastache, hspec
     , lens, lens-aeson, rainbow, random, regex-compat, shelly, Spock
     , stm, text, transformers, wreq
     }:
     mkDerivation {
       pname = "scalp-webhooks";
       version = "0.1.2.0";
       sha256 = "a4ea035465a3868fe3ffd70b8db58ee08110462e2fa735766083d815ee7061c8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bytestring hastache lens lens-aeson rainbow random
         shelly Spock stm text transformers wreq
       ];
       executableHaskellDepends = [
         aeson async base bytestring hastache lens lens-aeson rainbow random
         shelly Spock stm text transformers wreq
       ];
       testHaskellDepends = [
         aeson base hspec lens regex-compat stm text transformers wreq
       ];
       description = "Test webhooks locally";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scalpel_0_2_1" = callPackage
    ({ mkDerivation, base, bytestring, curl, HUnit, regex-base
     , regex-tdfa, tagsoup, text
     }:
     mkDerivation {
       pname = "scalpel";
       version = "0.2.1";
       sha256 = "e061abe1b6015818461fbdcacc91509575af8865bea5d024eb4b4f74e23d6a53";
       libraryHaskellDepends = [
         base bytestring curl regex-base regex-tdfa tagsoup text
       ];
       testHaskellDepends = [ base HUnit regex-base regex-tdfa tagsoup ];
       homepage = "https://github.com/fimad/scalpel";
       description = "A high level web scraping library for Haskell";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scalpel_0_2_1_1" = callPackage
    ({ mkDerivation, base, bytestring, curl, HUnit, regex-base
     , regex-tdfa, tagsoup, text
     }:
     mkDerivation {
       pname = "scalpel";
       version = "0.2.1.1";
       sha256 = "fdcad5f9b1b98e0a8720317fe20b8a696efcdda88f7384dc8e579dd026a17ad6";
       libraryHaskellDepends = [
         base bytestring curl regex-base regex-tdfa tagsoup text
       ];
       testHaskellDepends = [ base HUnit regex-base regex-tdfa tagsoup ];
       homepage = "https://github.com/fimad/scalpel";
       description = "A high level web scraping library for Haskell";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scalpel" = callPackage
    ({ mkDerivation, base, bytestring, containers, curl, data-default
     , HUnit, regex-base, regex-tdfa, tagsoup, text
     }:
     mkDerivation {
       pname = "scalpel";
       version = "0.3.0.1";
       sha256 = "ab1c9462b2bc7ef7d6ae028172eda278c3bf06adb3c877d6c5356491ab836471";
       libraryHaskellDepends = [
         base bytestring containers curl data-default regex-base regex-tdfa
         tagsoup text
       ];
       testHaskellDepends = [ base HUnit regex-base regex-tdfa tagsoup ];
       homepage = "https://github.com/fimad/scalpel";
       description = "A high level web scraping library for Haskell";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "scan" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "scan";
       version = "0.1.0.9";
       sha256 = "fbc9624885ce463cc7aa7748a9c68944e0d23145d1c79ed7bf8234f0ea47ac46";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base parsec ];
       homepage = "http://projects.haskell.org/style-scanner";
       description = "lexical style suggestions for source code";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "scan-vector-machine" = callPackage
    ({ mkDerivation, accelerate, array, base, dph-base, HUnit }:
     mkDerivation {
       pname = "scan-vector-machine";
       version = "0.2.7";
       sha256 = "6c6f7196f52037274f9a589368b0778501d8eee1762e1e6565f21620d85f5184";
       libraryHaskellDepends = [ accelerate array base dph-base HUnit ];
       testHaskellDepends = [ array base HUnit ];
       description = "An implementation of the Scan Vector Machine instruction set in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scat" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, mtl
     , optparse-applicative, scrypt, vector
     }:
     mkDerivation {
       pname = "scat";
       version = "1.1.0.2";
       sha256 = "9686d2ceb1b086ff3ab536f90a842099ef1ee3d8f63b25d270168b3ed11e0236";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base bytestring mtl optparse-applicative scrypt
         vector
       ];
       testHaskellDepends = [
         ansi-terminal base bytestring mtl optparse-applicative scrypt
         vector
       ];
       homepage = "https://github.com/redelmann/scat";
       description = "Generates unique passwords for various websites from a single password";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "scc" = callPackage
    ({ mkDerivation, base, bytestring, containers, haskeline
     , incremental-parser, monad-coroutine, monad-parallel
     , monoid-subclasses, parsec, process, QuickCheck, test-framework
     , test-framework-quickcheck2, text, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "scc";
       version = "0.8.2.2";
       sha256 = "a5294a179985d93e7bf9dfbb31c0bad6d9d2ebfdedd3431e7f5abce2014c5d67";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers incremental-parser monad-coroutine
         monad-parallel monoid-subclasses text transformers
         transformers-compat
       ];
       executableHaskellDepends = [
         base bytestring containers haskeline incremental-parser
         monad-coroutine monad-parallel monoid-subclasses parsec process
         text transformers transformers-compat
       ];
       testHaskellDepends = [
         base bytestring containers incremental-parser monad-coroutine
         monad-parallel monoid-subclasses QuickCheck test-framework
         test-framework-quickcheck2 text transformers transformers-compat
       ];
       jailbreak = true;
       homepage = "http://trac.haskell.org/SCC/";
       description = "Streaming component combinators";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scenegraph" = callPackage
    ({ mkDerivation, array, base, containers, fgl, GLUT, haskell98
     , hmatrix, mtl, old-time, OpenGL, process
     }:
     mkDerivation {
       pname = "scenegraph";
       version = "0.1.0.2";
       sha256 = "dc83d430f13122f429d59993114feb58fa46ba169b8cde28b2e2bda70d3424d1";
       libraryHaskellDepends = [
         array base containers fgl GLUT haskell98 hmatrix mtl old-time
         OpenGL process
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/SceneGraph";
       description = "Scene Graph";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scgi" = callPackage
    ({ mkDerivation, base, bytestring, cgi, extensible-exceptions
     , network
     }:
     mkDerivation {
       pname = "scgi";
       version = "0.3.3";
       sha256 = "55b40f48739aefb7f25ac971a1b3f27aaf0a9d0c32afe62dd56877be0b2fb67e";
       libraryHaskellDepends = [
         base bytestring cgi extensible-exceptions network
       ];
       description = "A Haskell library for writing SCGI programs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "schedevr" = callPackage
    ({ mkDerivation, base, directory, filepath, old-locale, time
     , xturtle
     }:
     mkDerivation {
       pname = "schedevr";
       version = "0.1.0.6";
       sha256 = "8bc9d4fbf7c5c0514323f4f0da88c961dba0c647b24763a60beab7ebfce3febd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath old-locale time xturtle
       ];
       jailbreak = true;
       description = "Marge schedules and show EVR";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "schedule-planner" = callPackage
    ({ mkDerivation, aeson, base, bytestring, composition, containers
     , HTTP, http-types, mtl, options, text, text-icu, transformers, wai
     , warp
     }:
     mkDerivation {
       pname = "schedule-planner";
       version = "1.0.1.1";
       sha256 = "68f3e4be529847d3ec8297cc8eac08fc2272e82e9c6d0a67b88d47e6529582f4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring composition containers HTTP http-types mtl
         options text text-icu transformers wai warp
       ];
       description = "Find the ideal lesson layout";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "schedyield" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "schedyield";
       version = "1.0";
       sha256 = "f75d3f6f125236e88ab43f0f08806a0d6d73b078eb25e249dfc018d51dedf053";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Exposes standard POSIX function sched_yield";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "scholdoc" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, binary, blaze-html
     , blaze-markup, bytestring, containers, data-default, Diff
     , directory, executable-path, extensible-exceptions, filepath
     , highlighting-kate, hslua, HTTP, http-client, http-client-tls
     , http-types, HUnit, JuicyPixels, mtl, network, network-uri
     , old-locale, old-time, parsec, process, QuickCheck, random
     , scholdoc-texmath, scholdoc-types, scientific, SHA, syb, tagsoup
     , temporary, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, time, unordered-containers
     , vector, xml, yaml, zip-archive, zlib
     }:
     mkDerivation {
       pname = "scholdoc";
       version = "0.1.3";
       sha256 = "c4d68f7ab5c606479cd2d14f98c6e2e262c2681a3aa469db5b9599322dc94b37";
       revision = "1";
       editedCabalFile = "bbe7070ca2ca48d86095c9a45120d2bfbf6a480b3894117d70e0f8e3ccabb435";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base64-bytestring binary blaze-html blaze-markup
         bytestring containers data-default directory extensible-exceptions
         filepath highlighting-kate hslua HTTP http-client http-client-tls
         http-types JuicyPixels mtl network network-uri old-locale old-time
         parsec process random scholdoc-texmath scholdoc-types scientific
         SHA syb tagsoup temporary text time unordered-containers vector xml
         yaml zip-archive zlib
       ];
       executableHaskellDepends = [
         aeson base bytestring containers directory extensible-exceptions
         filepath highlighting-kate network-uri scholdoc-types text yaml
       ];
       testHaskellDepends = [
         base bytestring containers Diff directory executable-path filepath
         HUnit process QuickCheck scholdoc-types syb test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://scholdoc.scholarlymarkdown.com";
       description = "Converts ScholarlyMarkdown documents to HTML5/LaTeX/Docx format";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scholdoc-citeproc" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base, bytestring
     , containers, data-default, directory, filepath, hs-bibutils, mtl
     , old-locale, parsec, process, rfc5051, scholdoc, scholdoc-types
     , split, syb, tagsoup, temporary, text, time, vector, xml-conduit
     , yaml
     }:
     mkDerivation {
       pname = "scholdoc-citeproc";
       version = "0.6";
       sha256 = "94c2695699811dfdc84a4fb4352bda5d5086134d92695cd0c2ec8f913267c873";
       revision = "1";
       editedCabalFile = "33a066de8000d8bdb0a8f04f71baca64e27f4a2bb2d2a330f6d5a7f81090b118";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers data-default directory filepath
         hs-bibutils mtl old-locale parsec rfc5051 scholdoc scholdoc-types
         split syb tagsoup text time vector xml-conduit yaml
       ];
       executableHaskellDepends = [
         aeson aeson-pretty attoparsec base bytestring containers directory
         filepath process scholdoc scholdoc-types syb temporary text vector
         yaml
       ];
       testHaskellDepends = [
         aeson base bytestring directory filepath process scholdoc
         scholdoc-types temporary text yaml
       ];
       jailbreak = true;
       homepage = "http://scholdoc.scholarlymarkdown.com";
       description = "Scholdoc fork of pandoc-citeproc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scholdoc-texmath" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, network-uri, parsec, process, scholdoc-types, split, syb
     , temporary, text, utf8-string, xml
     }:
     mkDerivation {
       pname = "scholdoc-texmath";
       version = "0.1.0.1";
       sha256 = "2939f906890eb13f488013f787f09ef1e35ee12b29cf06e729638fe15a29cb17";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl parsec scholdoc-types syb xml
       ];
       executableHaskellDepends = [ network-uri ];
       testHaskellDepends = [
         base bytestring directory filepath process split temporary text
         utf8-string xml
       ];
       homepage = "http://github.com/timtylin/scholdoc-texmath";
       description = "Scholdoc fork of texmath";
       license = "GPL";
     }) {};

  "scholdoc-types" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers
     , deepseq-generics, ghc-prim, syb
     }:
     mkDerivation {
       pname = "scholdoc-types";
       version = "0.1.3.1";
       sha256 = "59ad496dc91ddca4e0eddf2be0c146e7ac8190a84df318bfecf570a3742c6308";
       libraryHaskellDepends = [
         aeson base bytestring containers deepseq-generics ghc-prim syb
       ];
       jailbreak = true;
       homepage = "http://scholdoc.scholarlymarkdown.com";
       description = "Scholdoc fork of pandoc-types";
       license = "GPL";
     }) {};

  "schonfinkeling" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "schonfinkeling";
       version = "0.1.0.0";
       sha256 = "be732b44f963e0b8f82a989b360e4e5133c1da66fac79ff257c63c371d558bf3";
       libraryHaskellDepends = [ base ];
       description = "Transformation of n-ary functions to unary functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sci-ratio" = callPackage
    ({ mkDerivation, base, hashable }:
     mkDerivation {
       pname = "sci-ratio";
       version = "0.2.1.0";
       sha256 = "3365e46c9e46fd18236c63ddd7bdafd3fcf447061eb8d47b9cea3b317955ade1";
       libraryHaskellDepends = [ base hashable ];
       testHaskellDepends = [ base ];
       homepage = "https://github.com/Rufflewind/sci-ratio";
       description = "Rational numbers in scientific notation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "science-constants" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "science-constants";
       version = "0.2.0.0";
       sha256 = "7e274af9d0ea1dbbd2baef8f4b43f2cf206affa3de5fb1849e3389a4686ae362";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Mathematical/physical/chemical constants";
       license = "unknown";
     }) {};

  "science-constants-dimensional" = callPackage
    ({ mkDerivation, base, dimensional, numtype, science-constants }:
     mkDerivation {
       pname = "science-constants-dimensional";
       version = "0.1.0.2";
       sha256 = "75620e947186910796f98e391c48128ca57b812606b821fecccd89d2104bdf8f";
       libraryHaskellDepends = [
         base dimensional numtype science-constants
       ];
       jailbreak = true;
       description = "Mathematical/physical/chemical constants";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scientific_0_3_3_3" = callPackage
    ({ mkDerivation, array, base, bytestring, deepseq, ghc-prim
     , hashable, integer-gmp, QuickCheck, smallcheck, tasty
     , tasty-ant-xml, tasty-hunit, tasty-quickcheck, tasty-smallcheck
     , text
     }:
     mkDerivation {
       pname = "scientific";
       version = "0.3.3.3";
       sha256 = "16c31a8af69ff527b99fb395df0e62df6f213d60ad55f23541ecbd195a9dcfc2";
       libraryHaskellDepends = [
         array base bytestring deepseq ghc-prim hashable integer-gmp text
       ];
       testHaskellDepends = [
         base bytestring QuickCheck smallcheck tasty tasty-ant-xml
         tasty-hunit tasty-quickcheck tasty-smallcheck text
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/basvandijk/scientific";
       description = "Numbers represented using scientific notation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scientific_0_3_3_5" = callPackage
    ({ mkDerivation, array, base, bytestring, deepseq, ghc-prim
     , hashable, integer-gmp, QuickCheck, smallcheck, tasty
     , tasty-ant-xml, tasty-hunit, tasty-quickcheck, tasty-smallcheck
     , text
     }:
     mkDerivation {
       pname = "scientific";
       version = "0.3.3.5";
       sha256 = "3d07689a786c20285982f463b61c848d4842159c46fa38868b1a896597a2f2cc";
       libraryHaskellDepends = [
         array base bytestring deepseq ghc-prim hashable integer-gmp text
       ];
       testHaskellDepends = [
         base bytestring QuickCheck smallcheck tasty tasty-ant-xml
         tasty-hunit tasty-quickcheck tasty-smallcheck text
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/scientific";
       description = "Numbers represented using scientific notation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scientific_0_3_3_7" = callPackage
    ({ mkDerivation, array, base, bytestring, deepseq, ghc-prim
     , hashable, integer-gmp, QuickCheck, smallcheck, tasty
     , tasty-ant-xml, tasty-hunit, tasty-quickcheck, tasty-smallcheck
     , text
     }:
     mkDerivation {
       pname = "scientific";
       version = "0.3.3.7";
       sha256 = "c00b82c128d3b9fe350b2018674c5ac4483b91dc18bb6a807de42926b6322799";
       libraryHaskellDepends = [
         array base bytestring deepseq ghc-prim hashable integer-gmp text
       ];
       testHaskellDepends = [
         base bytestring QuickCheck smallcheck tasty tasty-ant-xml
         tasty-hunit tasty-quickcheck tasty-smallcheck text
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/scientific";
       description = "Numbers represented using scientific notation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scientific_0_3_3_8" = callPackage
    ({ mkDerivation, array, base, bytestring, deepseq, ghc-prim
     , hashable, integer-gmp, QuickCheck, smallcheck, tasty
     , tasty-ant-xml, tasty-hunit, tasty-quickcheck, tasty-smallcheck
     , text
     }:
     mkDerivation {
       pname = "scientific";
       version = "0.3.3.8";
       sha256 = "e30cde2a44a7beded15afd56606c562b76e457835e7de2942815f22bc74bce4c";
       libraryHaskellDepends = [
         array base bytestring deepseq ghc-prim hashable integer-gmp text
       ];
       testHaskellDepends = [
         base bytestring QuickCheck smallcheck tasty tasty-ant-xml
         tasty-hunit tasty-quickcheck tasty-smallcheck text
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/scientific";
       description = "Numbers represented using scientific notation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scientific_0_3_4_0" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , ghc-prim, hashable, integer-gmp, QuickCheck, smallcheck, tasty
     , tasty-ant-xml, tasty-hunit, tasty-quickcheck, tasty-smallcheck
     , text, vector
     }:
     mkDerivation {
       pname = "scientific";
       version = "0.3.4.0";
       sha256 = "fd681501f742f55fb092c967a42f537c8059db40f8b4a8870b07fe499944e97d";
       revision = "1";
       editedCabalFile = "04d40b9bb52883491e0c46f9f6d2942ec96a2de8a3dadb072cf0260f33cee208";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq ghc-prim hashable
         integer-gmp text vector
       ];
       testHaskellDepends = [
         base binary bytestring QuickCheck smallcheck tasty tasty-ant-xml
         tasty-hunit tasty-quickcheck tasty-smallcheck text
       ];
       homepage = "https://github.com/basvandijk/scientific";
       description = "Numbers represented using scientific notation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scientific_0_3_4_2" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , ghc-prim, hashable, integer-gmp, QuickCheck, smallcheck, tasty
     , tasty-ant-xml, tasty-hunit, tasty-quickcheck, tasty-smallcheck
     , text, vector
     }:
     mkDerivation {
       pname = "scientific";
       version = "0.3.4.2";
       sha256 = "f6d937039ee867d2ea4a5a4fc879c9e027e162da909b0c9957ff31a0f66c3556";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq ghc-prim hashable
         integer-gmp text vector
       ];
       testHaskellDepends = [
         base binary bytestring QuickCheck smallcheck tasty tasty-ant-xml
         tasty-hunit tasty-quickcheck tasty-smallcheck text
       ];
       homepage = "https://github.com/basvandijk/scientific";
       description = "Numbers represented using scientific notation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scientific" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , ghc-prim, hashable, integer-gmp, QuickCheck, smallcheck, tasty
     , tasty-ant-xml, tasty-hunit, tasty-quickcheck, tasty-smallcheck
     , text, vector
     }:
     mkDerivation {
       pname = "scientific";
       version = "0.3.4.4";
       sha256 = "f7c81e6ce6bf1161033ad4bc47b5bf164f4404d9df686dd0edadd488db25a519";
       revision = "1";
       editedCabalFile = "dd4a9ebfd75c61461e605995131104989a13780c987f3288c64b0a4ec80e08dc";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq ghc-prim hashable
         integer-gmp text vector
       ];
       testHaskellDepends = [
         base binary bytestring QuickCheck smallcheck tasty tasty-ant-xml
         tasty-hunit tasty-quickcheck tasty-smallcheck text
       ];
       homepage = "https://github.com/basvandijk/scientific";
       description = "Numbers represented using scientific notation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "scion" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, directory
     , filepath, ghc, ghc-paths, ghc-syb, hslogger, json, multiset
     , network, network-bytestring, time, uniplate, utf8-string
     }:
     mkDerivation {
       pname = "scion";
       version = "0.1.0.2";
       sha256 = "1154d5d1ae14e245b2e756eb32134c6a602d9f0d3741705302109aead12818c6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers directory filepath ghc ghc-paths ghc-syb
         hslogger json multiset time uniplate
       ];
       executableHaskellDepends = [
         base bytestring Cabal containers directory filepath ghc ghc-paths
         ghc-syb hslogger json multiset network network-bytestring time
         utf8-string
       ];
       jailbreak = true;
       homepage = "http://github.com/nominolo/scion";
       description = "Haskell IDE library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scion-browser" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal
     , conduit, containers, deepseq, derive, directory, filepath, ghc
     , ghc-paths, ghc-pkg-lib, haskeline, haskell-src-exts, HTTP
     , http-conduit, monad-logger, mtl, parallel-io, parsec, persistent
     , persistent-sqlite, persistent-template, process, resourcet, tar
     , text, transformers, unix, unordered-containers, utf8-string
     , vector, zlib
     }:
     mkDerivation {
       pname = "scion-browser";
       version = "0.5.0";
       sha256 = "cc627e43c779bb998b0f4dfc280b4aee1b2736685d02418dcab27f8dfccec4d9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring Cabal conduit containers deepseq
         derive directory filepath ghc ghc-paths ghc-pkg-lib
         haskell-src-exts http-conduit monad-logger mtl parallel-io parsec
         persistent persistent-sqlite persistent-template process resourcet
         tar text transformers unix unordered-containers utf8-string zlib
       ];
       executableHaskellDepends = [
         aeson attoparsec base bytestring Cabal conduit containers deepseq
         derive directory filepath ghc ghc-paths ghc-pkg-lib haskeline
         haskell-src-exts HTTP http-conduit monad-logger mtl parallel-io
         parsec persistent persistent-sqlite persistent-template process
         resourcet tar text transformers unix unordered-containers
         utf8-string vector zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/JPMoresmau/scion-class-browser";
       description = "Command-line interface for browsing and searching packages documentation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scons2dot" = callPackage
    ({ mkDerivation, base, bytestring, containers, process }:
     mkDerivation {
       pname = "scons2dot";
       version = "0.9";
       sha256 = "53c65fd515a54ced52cf47563e889fd3b589a1e4eb941f19b66d2abeef9e2ab1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bytestring containers process ];
       jailbreak = true;
       description = "Generates graphviz file of scons dependency information";
       license = "GPL";
     }) {};

  "scope" = callPackage
    ({ mkDerivation, base, bytestring, containers, iteratee
     , MonadCatchIO-transformers, mtl, mwc-random, time, unix
     , zoom-cache
     }:
     mkDerivation {
       pname = "scope";
       version = "0.8.0.1";
       sha256 = "f1cfecff59ed9d7f1939042be34403ec8e03e105df4f4af3c3bc83a1d43546cf";
       libraryHaskellDepends = [
         base bytestring containers iteratee MonadCatchIO-transformers mtl
         mwc-random time unix zoom-cache
       ];
       description = "An interactive renderer for plotting time-series data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scope-cairo" = callPackage
    ({ mkDerivation, base, cairo, gtk, MonadCatchIO-transformers, mtl
     , old-locale, scope, time, zoom-cache
     }:
     mkDerivation {
       pname = "scope-cairo";
       version = "0.8.0.1";
       sha256 = "e6120e9b710163817bc549a9330f65bbc899471c97c7913dcb191b3881f31736";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cairo gtk MonadCatchIO-transformers mtl old-locale scope time
         zoom-cache
       ];
       executableHaskellDepends = [
         base cairo gtk MonadCatchIO-transformers mtl old-locale scope time
         zoom-cache
       ];
       description = "An interactive renderer for plotting time-series data";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scottish" = callPackage
    ({ mkDerivation, base, data-default, enclosed-exceptions
     , http-types, lens, mtl, persistent, resource-pool, scotty, stm
     , text, transformers, wai, warp
     }:
     mkDerivation {
       pname = "scottish";
       version = "0.1.0.1";
       sha256 = "dd0a24cb4a9b2e4fed1cce3adfefbcbbac6eab07b1a80bf851fc53934b260705";
       libraryHaskellDepends = [
         base data-default enclosed-exceptions http-types lens mtl
         persistent resource-pool scotty stm text transformers wai warp
       ];
       jailbreak = true;
       homepage = "https://github.com/echaozh/scottish";
       description = "scotty with batteries included";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scotty_0_9_0" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring
     , case-insensitive, data-default, hspec-wai, hspec2, http-types
     , lifted-base, monad-control, mtl, regex-compat, text, transformers
     , transformers-base, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "scotty";
       version = "0.9.0";
       sha256 = "2dac5968204b5b4bb56e183ccc8d178108f8219ff44636e0424633c2cb04a03f";
       revision = "2";
       editedCabalFile = "fc2e7c26da42a87b42d3816225d662ec3604b16ce42fc32b93dfdc0d987f807e";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring case-insensitive data-default
         http-types monad-control mtl regex-compat text transformers
         transformers-base wai wai-extra warp
       ];
       testHaskellDepends = [
         base bytestring hspec-wai hspec2 http-types lifted-base text wai
       ];
       jailbreak = true;
       homepage = "https://github.com/scotty-web/scotty";
       description = "Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scotty_0_9_1" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring
     , case-insensitive, data-default, hspec, hspec-wai, http-types
     , lifted-base, monad-control, mtl, regex-compat, text, transformers
     , transformers-base, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "scotty";
       version = "0.9.1";
       sha256 = "15eb1c05817ea89a59d934835b91f8c3f7872ca7e45c44975b11d1d32c7c0770";
       revision = "2";
       editedCabalFile = "e37bd4bbb4da4e6d20bd8a29a5c3ca13476643e796a3463a20cbcbd2437bfde7";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring case-insensitive data-default
         http-types monad-control mtl regex-compat text transformers
         transformers-base wai wai-extra warp
       ];
       testHaskellDepends = [
         base bytestring hspec hspec-wai http-types lifted-base text wai
       ];
       jailbreak = true;
       homepage = "https://github.com/scotty-web/scotty";
       description = "Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scotty_0_10_2" = callPackage
    ({ mkDerivation, aeson, async, base, blaze-builder, bytestring
     , case-insensitive, data-default-class, directory, hspec, hspec-wai
     , http-types, lifted-base, monad-control, mtl, nats, network
     , regex-compat, text, transformers, transformers-base
     , transformers-compat, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "scotty";
       version = "0.10.2";
       sha256 = "86ce314927412b8eb38a8e999ecd1fcb66623b1eb801cdef62846d9b97409c4a";
       revision = "4";
       editedCabalFile = "61ca65b6ea23012d483c01bfcadcad72674011b81b180da6787e619a653e2a98";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring case-insensitive
         data-default-class http-types monad-control mtl nats network
         regex-compat text transformers transformers-base
         transformers-compat wai wai-extra warp
       ];
       testHaskellDepends = [
         async base data-default-class directory hspec hspec-wai http-types
         lifted-base network text wai
       ];
       jailbreak = true;
       homepage = "https://github.com/scotty-web/scotty";
       description = "Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scotty" = callPackage
    ({ mkDerivation, aeson, async, base, blaze-builder, bytestring
     , case-insensitive, data-default-class, directory, fail, hspec
     , hspec-wai, http-types, lifted-base, monad-control, mtl, nats
     , network, regex-compat, text, transformers, transformers-base
     , transformers-compat, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "scotty";
       version = "0.11.0";
       sha256 = "892203c937ccf1279f5005ddb78ebea84629b80687a1e38fc118b38011a386ed";
       revision = "1";
       editedCabalFile = "2e46f8dbc3078a329ac2d6662f80aa48a7c0517d02978812b0d1293c8bc050dc";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring case-insensitive
         data-default-class fail http-types monad-control mtl nats network
         regex-compat text transformers transformers-base
         transformers-compat wai wai-extra warp
       ];
       testHaskellDepends = [
         async base data-default-class directory hspec hspec-wai http-types
         lifted-base network text wai
       ];
       homepage = "https://github.com/scotty-web/scotty";
       description = "Haskell web framework inspired by Ruby's Sinatra, using WAI and Warp";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "scotty-binding-play" = callPackage
    ({ mkDerivation, base, bytestring, hspec, http-client, HUnit, mtl
     , scotty, template-haskell, text, transformers
     }:
     mkDerivation {
       pname = "scotty-binding-play";
       version = "1.3";
       sha256 = "e9cafd0ff913a0afb542376ecb59cfa8b7bf8055f41330aa7596ac0db9a73e4d";
       libraryHaskellDepends = [
         base bytestring mtl scotty template-haskell text
       ];
       testHaskellDepends = [
         base bytestring hspec http-client HUnit scotty text transformers
       ];
       homepage = "https://github.com/welmo/scotty-binding-play";
       description = "The Play Framework style data binding in Scotty";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "scotty-blaze" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, mtl, scotty, wai
     }:
     mkDerivation {
       pname = "scotty-blaze";
       version = "0.1.3";
       sha256 = "a7c5c7c0fc5010633ad20460b6534921f4acafa714a9055435de5045ef3a832e";
       libraryHaskellDepends = [
         base blaze-builder blaze-html mtl scotty wai
       ];
       description = "blaze-html integration for Scotty";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scotty-cookie" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers
     , cookie, scotty, text, time, transformers
     }:
     mkDerivation {
       pname = "scotty-cookie";
       version = "0.1.0.3";
       sha256 = "34f191cde735151d69f137c03f165ae179bb68a34ed676f05b8b2684c0e8db73";
       revision = "1";
       editedCabalFile = "3ff1df13a5acba8ba170a5ac22b3ac6a2c227791292536ce1ebfc41038f58fc9";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers cookie scotty text time
         transformers
       ];
       homepage = "https://github.com/mmartin/scotty-cookie";
       description = "Cookie management helper functions for Scotty framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "scotty-fay" = callPackage
    ({ mkDerivation, base, bytestring, data-default, directory, fay
     , fay-jquery, filepath, http-types, HUnit, scotty, test-framework
     , test-framework-hunit, text, transformers, wai, wai-test
     }:
     mkDerivation {
       pname = "scotty-fay";
       version = "0.1.1";
       sha256 = "02296cb92b81f08e89e6c3c4e99dc84ed5fa725ed64564461e4c3db305ef7a8e";
       libraryHaskellDepends = [
         base bytestring data-default directory fay fay-jquery filepath
         http-types scotty text transformers wai
       ];
       testHaskellDepends = [
         base bytestring data-default directory fay fay-jquery filepath
         http-types HUnit scotty test-framework test-framework-hunit text
         transformers wai wai-test
       ];
       jailbreak = true;
       description = "Fay integration for Scotty";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scotty-hastache" = callPackage
    ({ mkDerivation, base, containers, filepath, hastache, http-types
     , mtl, scotty, text, wai, warp
     }:
     mkDerivation {
       pname = "scotty-hastache";
       version = "0.2.1";
       sha256 = "b62135c5c1d08c9e491a9f38c5b287f7eeee623edaad5b5b8ce1d88023bad1fb";
       libraryHaskellDepends = [
         base containers filepath hastache http-types mtl scotty text wai
         warp
       ];
       homepage = "https://github.com/scotty-web/scotty-hastache";
       description = "Easy Mustache templating support for Scotty";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scotty-params-parser" = callPackage
    ({ mkDerivation, base-prelude, scotty, success, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "scotty-params-parser";
       version = "0.4";
       sha256 = "e334daaa407a407e4ececb0cd6d79b4037949abbc912d0d96641f007f041b631";
       libraryHaskellDepends = [
         base-prelude scotty success text transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/sannsyn/scotty-params-parser";
       description = "HTTP-request's query parameters parser abstraction for \"scotty\"";
       license = stdenv.lib.licenses.mit;
     }) {};

  "scotty-rest" = callPackage
    ({ mkDerivation, base, base-prelude, bytestring, convertible
     , data-default-class, hspec, hspec-wai, http-date, http-media
     , http-types, mtl, QuickCheck, scotty, string-conversions, text
     , time, transformers, wai, wai-extra
     }:
     mkDerivation {
       pname = "scotty-rest";
       version = "0.1.0.0";
       sha256 = "4012c5bf50c1512e7053027fd0068df817b7710f294f24bb6563a4a0b73b1dfc";
       libraryHaskellDepends = [
         base base-prelude bytestring convertible data-default-class
         http-date http-media http-types mtl scotty string-conversions text
         time transformers wai wai-extra
       ];
       testHaskellDepends = [
         base bytestring hspec hspec-wai mtl QuickCheck scotty
         string-conversions text wai
       ];
       jailbreak = true;
       homepage = "http://github.com/ehamberg/scotty-rest";
       description = "Webmachine-style REST library for scotty";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "scotty-session" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, bytestring
     , crypto-api, http-types, scotty, stm, text, time, transformers
     , unordered-containers, wai
     }:
     mkDerivation {
       pname = "scotty-session";
       version = "0.0.5";
       sha256 = "0762a3d8230ad6e8598ed672c0fe6e46e3c16e9dbeffb9759ae2ba7cadfe7dcb";
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder bytestring crypto-api
         http-types scotty stm text time transformers unordered-containers
         wai
       ];
       homepage = "https://github.com/agrafix/scotty-session";
       description = "Adding session functionality to scotty";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scotty-tls" = callPackage
    ({ mkDerivation, base, scotty, transformers, wai, warp, warp-tls }:
     mkDerivation {
       pname = "scotty-tls";
       version = "0.4.1";
       sha256 = "c897d73970cfe69a0b9763628e5157854df8aaaeb7c7afe2e38ea3a4ba7723a0";
       libraryHaskellDepends = [
         base scotty transformers wai warp warp-tls
       ];
       homepage = "https://github.com/dmjio/scotty-tls.git";
       description = "TLS for Scotty";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "scp-streams" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, cmdargs, io-streams
     , process, SHA, sha-streams, unix
     }:
     mkDerivation {
       pname = "scp-streams";
       version = "0.1.0";
       sha256 = "3e9beb8abea6f4921f976e4c613a44cd4bf6c06c432b0f1d3458b744193028f2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring io-streams process
       ];
       executableHaskellDepends = [
         base bytestring cmdargs io-streams SHA sha-streams unix
       ];
       testHaskellDepends = [ base bytestring io-streams ];
       jailbreak = true;
       homepage = "https://github.com/noteed/scp-streams";
       description = "An SCP protocol implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "scrabble-bot" = callPackage
    ({ mkDerivation, array, base, binary, containers, deepseq
     , directory, mtl, packed-dawg, parallel, split
     }:
     mkDerivation {
       pname = "scrabble-bot";
       version = "0.1.0.0";
       sha256 = "c3bab60c076653085733e2d4904b5b62a1aac1cba5d3d94093e050542ebfb20c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base binary containers deepseq directory mtl packed-dawg
         parallel split
       ];
       jailbreak = true;
       description = "Scrabble play generation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scrobble" = callPackage
    ({ mkDerivation, base, containers, curl, MissingH, network
     , network-uri, old-locale, pureMD5, time, url
     }:
     mkDerivation {
       pname = "scrobble";
       version = "0.2.1.1";
       sha256 = "4715c4fa900e4fed6f173ec9523470b552fab6c8e8bb5606acdd916857393498";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers curl MissingH network network-uri old-locale
         pureMD5 time url
       ];
       executableHaskellDepends = [
         base containers curl MissingH network network-uri old-locale time
         url
       ];
       description = "Scrobbling server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scroll" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, containers
     , data-default, IfElse, monad-loops, mtl, ncurses
     , optparse-applicative, random, text, unix, vector
     }:
     mkDerivation {
       pname = "scroll";
       version = "1.20151219";
       sha256 = "4f91c20e645ee715c9d3549fffffcc58943bee4fb3ba2e622e0189ccb70dd050";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring case-insensitive containers data-default IfElse
         monad-loops mtl ncurses optparse-applicative random text unix
         vector
       ];
       homepage = "https://joeyh.name/code/scroll/";
       description = "scroll(6), a roguelike game";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scrypt" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, entropy
     , HUnit, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "scrypt";
       version = "0.5.0";
       sha256 = "3ec0a622393e2a4dbbce4c899602c848d924f8516688491b1162331b7093d9b2";
       libraryHaskellDepends = [
         base base64-bytestring bytestring entropy
       ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "http://github.com/informatikr/scrypt";
       description = "Stronger password hashing via sequential memory-hard functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "scrz" = callPackage
    ({ mkDerivation, aeson, base, base16-bytestring, bytestring
     , conduit, containers, cryptohash, directory, filepath
     , friendly-time, hashable, http-conduit, http-types, MonadRandom
     , mtl, network, old-locale, process, random, stm, template-haskell
     , text, time, unix
     }:
     mkDerivation {
       pname = "scrz";
       version = "0.0.0.1";
       sha256 = "8fc107aa9bd1fa8568c8526773b17d2bd1d32df70613dab0c3879830f3deb5c8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base base16-bytestring bytestring conduit containers
         cryptohash directory filepath friendly-time hashable http-conduit
         http-types MonadRandom mtl network old-locale process random stm
         template-haskell text time unix
       ];
       homepage = "http://github.com/wereHamster/scrz";
       description = "Process management and supervision daemon";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "scyther-proof" = callPackage
    ({ mkDerivation, alex, array, base, cmdargs, containers, directory
     , filepath, json, mtl, parsec, pretty, process, safe, tagsoup, time
     , uniplate, utf8-string
     }:
     mkDerivation {
       pname = "scyther-proof";
       version = "0.10.0.1";
       sha256 = "d22c17024b74395aa4fff7a04389d45330cd348bb27e234e5cd3602a72938d30";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base cmdargs containers directory filepath json mtl parsec
         pretty process safe tagsoup time uniplate utf8-string
       ];
       executableToolDepends = [ alex ];
       description = "Automatic generation of Isabelle/HOL correctness proofs for security protocols";
       license = "GPL";
     }) {};

  "sde-solver" = callPackage
    ({ mkDerivation, base, cereal, cereal-vector, ghc-prim, haskell-mpi
     , mersenne-random-pure64, mtl, mwc-random, normaldistribution
     , parallel, vector
     }:
     mkDerivation {
       pname = "sde-solver";
       version = "0.1.0.0";
       sha256 = "46d58e7974519e9eebf2e226e21c593a6c6be81c8eae5828d098c0e09813e16a";
       libraryHaskellDepends = [
         base cereal cereal-vector ghc-prim haskell-mpi
         mersenne-random-pure64 mtl mwc-random normaldistribution parallel
         vector
       ];
       homepage = "https://github.com/davnils/sde-solver";
       description = "Distributed SDE solver";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sdf2p1-parser" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, HUnit, parsec
     , test-framework, test-framework-hunit, transformers
     }:
     mkDerivation {
       pname = "sdf2p1-parser";
       version = "0.1.1";
       sha256 = "1faa416d29abf4e299b3951d7182b9f29ded74aee2f96fd4ef64b5984914e4ab";
       libraryHaskellDepends = [ base bytestring parsec transformers ];
       testHaskellDepends = [
         base bytestring Cabal HUnit parsec test-framework
         test-framework-hunit transformers
       ];
       homepage = "https://github.com/kojung/sdf2p1-parser";
       description = "A parser for SDF version 2.1 using Parsec";
       license = stdenv.lib.licenses.mit;
     }) {};

  "sdl2_1_3_0" = callPackage
    ({ mkDerivation, base, SDL2, transformers }:
     mkDerivation {
       pname = "sdl2";
       version = "1.3.0";
       sha256 = "aae3cd9471c8a3c074e3b581da8d1c420722d20c8cf72b32319762119c9c293a";
       libraryHaskellDepends = [ base transformers ];
       librarySystemDepends = [ SDL2 ];
       libraryPkgconfigDepends = [ SDL2 ];
       description = "Low-level bindings to SDL2";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) SDL2;};

  "sdl2_1_3_1" = callPackage
    ({ mkDerivation, base, SDL2, transformers }:
     mkDerivation {
       pname = "sdl2";
       version = "1.3.1";
       sha256 = "db5358e2fe0c5bffb362590037703db623c5be50bc94ded7620c8af163b5a39d";
       libraryHaskellDepends = [ base transformers ];
       librarySystemDepends = [ SDL2 ];
       libraryPkgconfigDepends = [ SDL2 ];
       description = "Low-level bindings to SDL2";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) SDL2;};

  "sdl2" = callPackage
    ({ mkDerivation, base, bytestring, exceptions, linear, SDL2
     , StateVar, text, transformers, vector
     }:
     mkDerivation {
       pname = "sdl2";
       version = "2.1.1";
       sha256 = "6c38f02842fdda0be25359cc1d2579c09a66a2f80687943cebe0fe14b1d7efad";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring exceptions linear StateVar text transformers vector
       ];
       librarySystemDepends = [ SDL2 ];
       libraryPkgconfigDepends = [ SDL2 ];
       description = "Both high- and low-level bindings to the SDL library (version 2.0.3).";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) SDL2;};

  "sdl2-cairo" = callPackage
    ({ mkDerivation, base, cairo, linear, mtl, random, sdl2, time }:
     mkDerivation {
       pname = "sdl2-cairo";
       version = "0.1.0.2";
       sha256 = "e536adc0c2439267d3496cb5d33899c83d2e6d8debf2d56c69abd3c947704a86";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base cairo linear mtl random sdl2 time ];
       description = "Render with Cairo on SDL textures. Includes optional convenience drawing API.";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "sdl2-cairo-image" = callPackage
    ({ mkDerivation, base, cairo, convertible, JuicyPixels, linear
     , sdl2, sdl2-cairo, vector
     }:
     mkDerivation {
       pname = "sdl2-cairo-image";
       version = "1.0.0.2";
       sha256 = "c5a8adee53ed011132f8bbefc554505a3758577afc653ddb8b6f0f8ef61c9b76";
       libraryHaskellDepends = [
         base cairo convertible JuicyPixels linear sdl2 sdl2-cairo vector
       ];
       description = "An image loading and rendering library for sdl2 / sdl2-cairo";
       license = stdenv.lib.licenses.mit;
     }) {};

  "sdl2-compositor" = callPackage
    ({ mkDerivation, base, lens, linear, lrucache, QuickCheck, sdl2
     , sdl2-ttf, StateVar, stm, text, transformers
     }:
     mkDerivation {
       pname = "sdl2-compositor";
       version = "1.2.0.3";
       sha256 = "c2f4ee694f2ee8444b6e2b5af51f0a86f415745181e7734e83dcc129cd655d12";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base lens linear lrucache QuickCheck sdl2 sdl2-ttf StateVar stm
         text transformers
       ];
       description = "image compositing with sdl2 - declarative style";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "sdl2-image" = callPackage
    ({ mkDerivation, base, SDL2, sdl2, SDL2_image }:
     mkDerivation {
       pname = "sdl2-image";
       version = "0.1.3.2";
       sha256 = "527b2e7683aee11cf3a054359ad2c253515c612549efc60aa4f54be27d42fa3e";
       libraryHaskellDepends = [ base sdl2 ];
       librarySystemDepends = [ SDL2 ];
       libraryPkgconfigDepends = [ SDL2 SDL2_image ];
       jailbreak = true;
       description = "Haskell binding to sdl2-image";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_image;};

  "sdl2-ttf" = callPackage
    ({ mkDerivation, base, SDL2, sdl2, SDL2_ttf }:
     mkDerivation {
       pname = "sdl2-ttf";
       version = "0.2.2";
       sha256 = "cfe52e240f00e86edf723f08a6b6de1dd5e0ab390ed030458111e45ee9db1266";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base sdl2 ];
       librarySystemDepends = [ SDL2 SDL2_ttf ];
       executableHaskellDepends = [ base sdl2 ];
       description = "Binding to libSDL2-ttf";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) SDL2; inherit (pkgs) SDL2_ttf;};

  "sdnv" = callPackage
    ({ mkDerivation, base, binary, bytestring }:
     mkDerivation {
       pname = "sdnv";
       version = "0.1.0.0";
       sha256 = "ac66007c0940524fc311a304d08253cf4e9ee234e5c38c65f90d29b2134aa71d";
       libraryHaskellDepends = [ base binary bytestring ];
       description = "Self-delimiting numeric values encoding library";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "sdr" = callPackage
    ({ mkDerivation, array, base, bytestring, cairo, cereal, Chart
     , Chart-cairo, colour, containers, Decimal, dynamic-graph, either
     , fftwRaw, GLFW-b, mwc-random, OpenGL, optparse-applicative, pango
     , pipes, pipes-bytestring, pipes-concurrency, primitive
     , pulse-simple, QuickCheck, rtlsdr, storable-complex
     , test-framework, test-framework-quickcheck2, time, tuple, vector
     }:
     mkDerivation {
       pname = "sdr";
       version = "0.1.0.6";
       sha256 = "bf6344447783ec530ef27c8e2c55aff57e4581696d156d1d8781f54577b33135";
       libraryHaskellDepends = [
         array base bytestring cairo cereal Chart Chart-cairo colour
         containers Decimal dynamic-graph either fftwRaw GLFW-b mwc-random
         OpenGL optparse-applicative pango pipes pipes-bytestring
         pipes-concurrency primitive pulse-simple rtlsdr storable-complex
         time tuple vector
       ];
       testHaskellDepends = [
         base primitive QuickCheck storable-complex test-framework
         test-framework-quickcheck2 vector
       ];
       jailbreak = true;
       homepage = "https://github.com/adamwalker/sdr";
       description = "A software defined radio library";
       license = stdenv.lib.licenses.bsd3;
       platforms = [ "x86_64-darwin" "x86_64-linux" ];
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "seacat" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, bytestring
     , ConfigFile, data-default, directory, filepath, http-types
     , mime-types, MissingH, monad-control, mtl, network, persistent
     , persistent-postgresql, persistent-sqlite, persistent-template
     , text, time, transformers, wai, wai-extra, wai-middleware-static
     , warp, web-routes, web-routes-wai
     }:
     mkDerivation {
       pname = "seacat";
       version = "1.0.0.3";
       sha256 = "f59e2cf92bafca1b09afbf2ddafc50f4f62f88f918e393f124bedf0d6e3dd447";
       libraryHaskellDepends = [
         base blaze-builder blaze-html bytestring ConfigFile data-default
         directory filepath http-types mime-types MissingH monad-control mtl
         network persistent persistent-postgresql persistent-sqlite
         persistent-template text time transformers wai wai-extra
         wai-middleware-static warp web-routes web-routes-wai
       ];
       jailbreak = true;
       homepage = "https://github.com/Barrucadu/lambdadelta";
       description = "Small web framework using Warp and WAI";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "seal-module" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "seal-module";
       version = "0.1.0.1";
       sha256 = "d8b511f8bc3306e804fc2359326dd8438bc79b11cd88f944e65ab98501125574";
       libraryHaskellDepends = [ base template-haskell ];
       description = "Template Haskell support for global configuration data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "search" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, ghc-prim
     , profunctors, semigroupoids, tagged, transformers
     }:
     mkDerivation {
       pname = "search";
       version = "0.1.0.1";
       sha256 = "7ceeba242c9850b71e0be7b3fea1e65a066dfd5b54f3058e972eff31b8773771";
       libraryHaskellDepends = [
         base ghc-prim profunctors semigroupoids tagged transformers
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/search/";
       description = "Infinite search in finite time with Hilbert's epsilon";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sec" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "sec";
       version = "0.0.1";
       sha256 = "5be0f2b650c3238e045116b767687d812136dcf4c677d80d30f90c15aa05d4e7";
       libraryHaskellDepends = [ base template-haskell ];
       jailbreak = true;
       homepage = "http://github.com/urso/sec";
       description = "Semantic Editor Combinators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "secdh" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "secdh";
       version = "0.2";
       sha256 = "3a7b55a1c50f8d03d54545a52338b7710eb66aa43d8dcbe1a80242d7ce132b63";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [ base containers ];
       homepage = "http://github.com/pgavin/secdh";
       description = "SECDH Machine Simulator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "seclib" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "seclib";
       version = "1.1.0.2";
       sha256 = "dc22bdb13cf11fa9594f324be5bccbdf5ab6f2699b2e0dec60460458476b6f49";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "A simple library for static information-flow security in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "second-transfer_0_6_0_0" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, binary
     , bytestring, clock, conduit, containers, cpphs, deepseq
     , exceptions, hashable, hashtables, hslogger, http2, HUnit, lens
     , network, network-uri, openssl, pqueue, SafeSemaphore, stm, text
     , time, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "second-transfer";
       version = "0.6.0.0";
       sha256 = "fcfcf1aa3ac621abd651d9213b070d66ab638e2dfdaaf22e8bdaa0bf1c36e2f0";
       libraryHaskellDepends = [
         attoparsec base base16-bytestring binary bytestring clock conduit
         containers deepseq exceptions hashable hashtables hslogger http2
         lens network network-uri pqueue SafeSemaphore stm text time
         transformers
       ];
       librarySystemDepends = [ openssl ];
       libraryToolDepends = [ cpphs ];
       testHaskellDepends = [
         attoparsec base base16-bytestring binary bytestring clock conduit
         containers deepseq exceptions hashable hashtables hslogger http2
         HUnit lens network network-uri pqueue SafeSemaphore stm text time
         transformers unordered-containers
       ];
       testToolDepends = [ cpphs ];
       doCheck = false;
       homepage = "https://www.httptwo.com/second-transfer/";
       description = "Second Transfer HTTP/2 web server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openssl;};

  "second-transfer_0_6_1_0" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, binary
     , bytestring, clock, conduit, containers, cpphs, deepseq
     , exceptions, hashable, hashtables, hslogger, http2, HUnit, lens
     , network, network-uri, openssl, pqueue, SafeSemaphore, stm, text
     , time, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "second-transfer";
       version = "0.6.1.0";
       sha256 = "fd57241ab24d7f752326573ea74240b168b1ff6168cf20b35af9d764368c5c72";
       libraryHaskellDepends = [
         attoparsec base base16-bytestring binary bytestring clock conduit
         containers deepseq exceptions hashable hashtables hslogger http2
         lens network network-uri pqueue SafeSemaphore stm text time
         transformers
       ];
       librarySystemDepends = [ openssl ];
       libraryToolDepends = [ cpphs ];
       testHaskellDepends = [
         attoparsec base base16-bytestring binary bytestring clock conduit
         containers deepseq exceptions hashable hashtables hslogger http2
         HUnit lens network network-uri pqueue SafeSemaphore stm text time
         transformers unordered-containers
       ];
       testToolDepends = [ cpphs ];
       doCheck = false;
       homepage = "https://www.httptwo.com/second-transfer/";
       description = "Second Transfer HTTP/2 web server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openssl;};

  "second-transfer_0_7_1_0" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, binary
     , bytestring, clock, conduit, containers, cpphs, deepseq
     , exceptions, hashable, hashtables, hslogger, http2, HUnit, lens
     , network, network-uri, openssl, pqueue, SafeSemaphore, stm, text
     , time, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "second-transfer";
       version = "0.7.1.0";
       sha256 = "ece780d51ef2d3efd7360ace76cc88ca3efb36f151aa8aecffcae48e8c39515f";
       libraryHaskellDepends = [
         attoparsec base base16-bytestring binary bytestring clock conduit
         containers deepseq exceptions hashable hashtables hslogger http2
         lens network network-uri pqueue SafeSemaphore stm text time
         transformers
       ];
       librarySystemDepends = [ openssl ];
       libraryToolDepends = [ cpphs ];
       testHaskellDepends = [
         attoparsec base base16-bytestring binary bytestring clock conduit
         containers deepseq exceptions hashable hashtables hslogger http2
         HUnit lens network network-uri pqueue SafeSemaphore stm text time
         transformers unordered-containers
       ];
       testToolDepends = [ cpphs ];
       doCheck = false;
       homepage = "https://www.httptwo.com/second-transfer/";
       description = "Second Transfer HTTP/2 web server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openssl;};

  "second-transfer" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, binary
     , BoundedChan, bytestring, clock, conduit, containers, cpphs
     , deepseq, exceptions, hashable, hashtables, http2, HUnit, lens
     , mmorph, network, network-uri, pqueue, resourcet, stm, text, time
     , transformers, unordered-containers, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "second-transfer";
       version = "0.10.0.2";
       sha256 = "9a0a8851a4d12e2d7b1f84bb7af19a9118c206c24b65d06500f10ea718e88828";
       libraryHaskellDepends = [
         attoparsec base base16-bytestring binary BoundedChan bytestring
         clock conduit containers deepseq exceptions hashable hashtables
         http2 lens mmorph network network-uri pqueue resourcet stm text
         time transformers vector vector-algorithms
       ];
       libraryToolDepends = [ cpphs ];
       testHaskellDepends = [
         base binary bytestring conduit containers hashtables http2 HUnit
         lens network network-uri stm text transformers unordered-containers
       ];
       testToolDepends = [ cpphs ];
       doCheck = false;
       homepage = "https://www.httptwo.com/second-transfer/";
       description = "Second Transfer HTTP/2 web server";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "secp256k1" = callPackage
    ({ mkDerivation, base, base16-bytestring, binary, bytestring
     , cryptohash, entropy, HUnit, largeword, mtl, QuickCheck
     , string-conversions, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "secp256k1";
       version = "0.4.4";
       sha256 = "33532973312cafa00b12f5fe21ed65bd89810bd8e19be95b29c5d5aa0b9946d2";
       libraryHaskellDepends = [
         base base16-bytestring binary bytestring entropy largeword mtl
         QuickCheck string-conversions
       ];
       testHaskellDepends = [
         base base16-bytestring binary bytestring cryptohash entropy HUnit
         mtl QuickCheck string-conversions test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "http://github.com/haskoin/secp256k1#readme";
       description = "Bindings for secp256k1 library from Bitcoin Core";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "secret-santa" = callPackage
    ({ mkDerivation, base, containers, diagrams-cairo, diagrams-lib
     , haskell-qrencode, random
     }:
     mkDerivation {
       pname = "secret-santa";
       version = "0.1.0.0";
       sha256 = "a8522d582b759e9a8e6cda40936a585a6627d8452fc18419c0104228a60c2c63";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers diagrams-cairo diagrams-lib haskell-qrencode random
       ];
       jailbreak = true;
       homepage = "https://github.com/rodrigosetti/secret-santa";
       description = "Secret Santa game assigner using QR-Codes";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "secret-sharing" = callPackage
    ({ mkDerivation, base, binary, bytestring, dice-entropy-conduit
     , finite-field, polynomial, QuickCheck, test-framework
     , test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "secret-sharing";
       version = "1.0.0.3";
       sha256 = "62af2ba181d30e6d6c6cfd01f83a5082b6bc378a745c90497cff42ebea2b6160";
       libraryHaskellDepends = [
         base binary bytestring dice-entropy-conduit finite-field polynomial
         vector
       ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       homepage = "http://monoid.at/code";
       description = "Information-theoretic secure secret sharing";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "secrm" = callPackage
    ({ mkDerivation, base, haskell98 }:
     mkDerivation {
       pname = "secrm";
       version = "0.0";
       sha256 = "e975a8e1d1dc6409b88cf8ea6567a7ffd0268f6b0f2848cc3922af407b458e41";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskell98 ];
       jailbreak = true;
       description = "Example of writing \"secure\" file removal in Haskell rather than C";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "secure-sockets" = callPackage
    ({ mkDerivation, base, bytestring, directory, HsOpenSSL, network
     , process, transformers
     }:
     mkDerivation {
       pname = "secure-sockets";
       version = "1.2.9.2";
       sha256 = "9fca6c79055c3c3bcc0659ae5fafdf6e81e4ffbda379c8adaf0a7f674efc5146";
       libraryHaskellDepends = [
         base bytestring directory HsOpenSSL network process transformers
       ];
       homepage = "http://code.google.com/p/secure-hs/";
       description = "Secure point-to-point connectivity library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "securemem_0_1_4" = callPackage
    ({ mkDerivation, base, byteable, bytestring, ghc-prim }:
     mkDerivation {
       pname = "securemem";
       version = "0.1.4";
       sha256 = "88c4aefcbda018243b314ae75cf52f3059eb2af6aca6f3b7eb3167a5bc65abf1";
       libraryHaskellDepends = [ base byteable bytestring ghc-prim ];
       homepage = "http://github.com/vincenthz/hs-securemem";
       description = "abstraction to an auto scrubbing and const time eq, memory chunk";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "securemem_0_1_5" = callPackage
    ({ mkDerivation, base, byteable, bytestring, ghc-prim }:
     mkDerivation {
       pname = "securemem";
       version = "0.1.5";
       sha256 = "4e21b3ef178f2697e7fd629cc636d5c644155d182c04a8336d381d14d6327ebc";
       libraryHaskellDepends = [ base byteable bytestring ghc-prim ];
       homepage = "http://github.com/vincenthz/hs-securemem";
       description = "abstraction to an auto scrubbing and const time eq, memory chunk";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "securemem_0_1_7" = callPackage
    ({ mkDerivation, base, byteable, bytestring, ghc-prim }:
     mkDerivation {
       pname = "securemem";
       version = "0.1.7";
       sha256 = "f9144945bf7bf448f617822cd053ea79bd1ed13bcf68e3ea97c3f5e4858eb592";
       libraryHaskellDepends = [ base byteable bytestring ghc-prim ];
       homepage = "http://github.com/vincenthz/hs-securemem";
       description = "abstraction to an auto scrubbing and const time eq, memory chunk";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "securemem_0_1_8" = callPackage
    ({ mkDerivation, base, byteable, bytestring, ghc-prim, memory }:
     mkDerivation {
       pname = "securemem";
       version = "0.1.8";
       sha256 = "627558fdc87be7f530416d229a511b4fab14fd23b4154ca62049cf4d0cb90593";
       libraryHaskellDepends = [
         base byteable bytestring ghc-prim memory
       ];
       homepage = "http://github.com/vincenthz/hs-securemem";
       description = "abstraction to an auto scrubbing and const time eq, memory chunk";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "securemem" = callPackage
    ({ mkDerivation, base, byteable, bytestring, ghc-prim, memory }:
     mkDerivation {
       pname = "securemem";
       version = "0.1.9";
       sha256 = "feb60dc542ea3ce9cdb449093b85dc69e43df310aab4fd161e4cdaa3ba847036";
       libraryHaskellDepends = [
         base byteable bytestring ghc-prim memory
       ];
       homepage = "http://github.com/vincenthz/hs-securemem";
       description = "abstraction to an auto scrubbing and const time eq, memory chunk";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sednaDBXML" = callPackage
    ({ mkDerivation, base, bindings-DSL, bytestring, containers
     , iteratee, mtl, sedna, text
     }:
     mkDerivation {
       pname = "sednaDBXML";
       version = "0.1.2.5";
       sha256 = "7e7ed68edb4fe68ccccb05f6f71b9635a4f107540a1e76d4c9b32c0e3ea11e19";
       libraryHaskellDepends = [
         base bindings-DSL bytestring containers iteratee mtl text
       ];
       librarySystemDepends = [ sedna ];
       description = "Sedna C API XML Binding";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {sedna = null;};

  "select" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "select";
       version = "0.4.0.1";
       sha256 = "405255e4ba757c6e9b618c5656d2d062ee16ec6511199dc2a2e1aa056a910ca0";
       libraryHaskellDepends = [ base ];
       homepage = "http://nonempty.org/software/haskell-select";
       description = "Wrap the select(2) POSIX function";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "selectors" = callPackage
    ({ mkDerivation, alex, array, base, containers, happy
     , template-haskell, text, xml-conduit
     }:
     mkDerivation {
       pname = "selectors";
       version = "0.0.3.0";
       sha256 = "f98a41cd370c2f8ff06f59d5f434b71c40921f2810862102c8c4a32243131ab2";
       libraryHaskellDepends = [
         array base containers template-haskell text xml-conduit
       ];
       libraryToolDepends = [ alex happy ];
       homepage = "http://github.com/rcallahan/selectors";
       description = "CSS Selectors for DOM traversal";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "selenium" = callPackage
    ({ mkDerivation, base, HTTP, HUnit, mtl, network, pretty }:
     mkDerivation {
       pname = "selenium";
       version = "0.2.5";
       sha256 = "871e1847947a25672bbacdfcb5d27f48a06a0762ebe527363d24c91b126a236f";
       libraryHaskellDepends = [ base HTTP HUnit mtl network pretty ];
       description = "Test web applications through a browser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "selenium-server" = callPackage
    ({ mkDerivation, base, conduit, directory, filepath, hspec
     , http-conduit, http-conduit-downloader, network, process, random
     , regex-tdfa, text, utf8-string, webdriver
     }:
     mkDerivation {
       pname = "selenium-server";
       version = "0.1.0.0";
       sha256 = "0ea722e2fb4a67b48ae470437ee0665518f508bd51b80fc90965fca122fc788d";
       libraryHaskellDepends = [
         base conduit directory filepath http-conduit
         http-conduit-downloader network process random regex-tdfa
         utf8-string
       ];
       testHaskellDepends = [ base hspec text webdriver ];
       jailbreak = true;
       homepage = "https://github.com/joelteon/selenium-server.git";
       description = "Run the selenium standalone server for usage with webdriver";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "selfrestart" = callPackage
    ({ mkDerivation, base, directory, executable-path, unix }:
     mkDerivation {
       pname = "selfrestart";
       version = "0.1.0";
       sha256 = "76e0b9c23c17773887e063784795e598ceb4da90701ea8ddd94e76948f200a80";
       libraryHaskellDepends = [ base directory executable-path unix ];
       homepage = "https://github.com/nh2/selfrestart";
       description = "Restarts the current executable (on binary change)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "selinux" = callPackage
    ({ mkDerivation, base, selinux, unix }:
     mkDerivation {
       pname = "selinux";
       version = "0.1.1";
       sha256 = "1c2397bf95f960a9d8f7863f7d201e62364ee8e41f462b8bfa6c7831a0e214e4";
       libraryHaskellDepends = [ base unix ];
       librarySystemDepends = [ selinux ];
       homepage = "https://github.com/luite/selinux";
       description = "SELinux bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {selinux = null;};

  "semaphore-plus" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "semaphore-plus";
       version = "0.1";
       sha256 = "79b6e5761389388f20ea9203e63725f0d57a0600a2acd848f7aa87a4e5bf898c";
       libraryHaskellDepends = [ base ];
       description = "Various concurrency abstractions built on top of semaphores";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "semi-iso" = callPackage
    ({ mkDerivation, base, lens, profunctors, semigroupoids
     , transformers, tuple-morph
     }:
     mkDerivation {
       pname = "semi-iso";
       version = "1.0.0.0";
       sha256 = "afd4df10cef4202cc7bfe0c933ba26e699c37e23f31954c0b48b343fa1790c26";
       libraryHaskellDepends = [
         base lens profunctors semigroupoids transformers tuple-morph
       ];
       description = "Weakened partial isomorphisms, reversible computations";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "semigroupoid-extras_4_0" = callPackage
    ({ mkDerivation, base, semigroupoids }:
     mkDerivation {
       pname = "semigroupoid-extras";
       version = "4.0";
       sha256 = "6f54b62203043fca77b13a2105bb2f82fa5cd90d6b20ac6bba99716fc93f4a1d";
       libraryHaskellDepends = [ base semigroupoids ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://github.com/ekmett/semigroupoid-extras";
       description = "This package has been absorbed into semigroupoids 4.0";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "semigroupoid-extras" = callPackage
    ({ mkDerivation, base, profunctors, semigroupoids }:
     mkDerivation {
       pname = "semigroupoid-extras";
       version = "5";
       sha256 = "102e33b55cc3b15a1b714825a3703f3fc2bb09d8038404af442d35c0ac0c3832";
       libraryHaskellDepends = [ base profunctors semigroupoids ];
       homepage = "http://github.com/ekmett/semigroupoid-extras";
       description = "Semigroupoids that depend on PolyKinds";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "semigroupoids_4_2" = callPackage
    ({ mkDerivation, base, comonad, containers, contravariant
     , distributive, semigroups, transformers
     }:
     mkDerivation {
       pname = "semigroupoids";
       version = "4.2";
       sha256 = "88a95d383195307f4e9e20d49f194a192d816bf15fc2f12a63820a8742b9f1a3";
       revision = "2";
       editedCabalFile = "610d610c6aeddb4597f1ada0f512b9c60c11b2a570e8f8a2eb5f1a9d91adf89b";
       libraryHaskellDepends = [
         base comonad containers contravariant distributive semigroups
         transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/semigroupoids";
       description = "Semigroupoids: Category sans id";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "semigroupoids_4_3" = callPackage
    ({ mkDerivation, base, comonad, containers, contravariant
     , distributive, doctest, Glob, semigroups, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "semigroupoids";
       version = "4.3";
       sha256 = "4ea30261a070a6af8dce041041cdb8af67154dbab95f329c9953ffc09ccbc0e2";
       revision = "2";
       editedCabalFile = "235598c490e3a2b2996a8c028fa766093f6b72228a3e1a6e0f69f8eafe8199e2";
       libraryHaskellDepends = [
         base comonad containers contravariant distributive semigroups
         transformers transformers-compat
       ];
       testHaskellDepends = [ base doctest Glob ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/ekmett/semigroupoids";
       description = "Semigroupoids: Category sans id";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "semigroupoids_5_0_0_3" = callPackage
    ({ mkDerivation, base, base-orphans, bifunctors, comonad
     , containers, contravariant, directory, distributive, doctest
     , filepath, semigroups, tagged, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "semigroupoids";
       version = "5.0.0.3";
       sha256 = "17dc07085806c6b8c79863f489f0ad534713578a529935b081691830bab4d292";
       libraryHaskellDepends = [
         base base-orphans bifunctors comonad containers contravariant
         distributive semigroups tagged transformers transformers-compat
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/ekmett/semigroupoids";
       description = "Semigroupoids: Category sans id";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "semigroupoids_5_0_0_4" = callPackage
    ({ mkDerivation, base, base-orphans, bifunctors, comonad
     , containers, contravariant, directory, distributive, doctest
     , filepath, semigroups, tagged, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "semigroupoids";
       version = "5.0.0.4";
       sha256 = "cde047e36c4072dd32fcda5846155a3dd4e844f441e4c651b886ee069d95c7c9";
       libraryHaskellDepends = [
         base base-orphans bifunctors comonad containers contravariant
         distributive semigroups tagged transformers transformers-compat
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/ekmett/semigroupoids";
       description = "Semigroupoids: Category sans id";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "semigroupoids" = callPackage
    ({ mkDerivation, base, base-orphans, bifunctors, comonad
     , containers, contravariant, directory, distributive, doctest
     , filepath, semigroups, tagged, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "semigroupoids";
       version = "5.0.1";
       sha256 = "0ce989b8b0dc02ebe9aa19c47982a6bc802b8dc973c39c7ac40ea7a21cdbd616";
       revision = "1";
       editedCabalFile = "94d9167b701f148cb429e6746dd2bbb3b6559521b7fc2e98ce47339ad09af9f2";
       libraryHaskellDepends = [
         base base-orphans bifunctors comonad containers contravariant
         distributive semigroups tagged transformers transformers-compat
       ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/ekmett/semigroupoids";
       description = "Semigroupoids: Category sans id";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "semigroupoids-syntax" = callPackage
    ({ mkDerivation, base, comonad, containers, contravariant
     , directory, distributive, doctest, filepath, QuickCheck
     , semigroupoids, semigroups, template-haskell, transformers
     }:
     mkDerivation {
       pname = "semigroupoids-syntax";
       version = "0.0.1";
       sha256 = "f0938dba523273496e9e95f72c807c1ad6474b4d93f09e7013c8b2f5b8f76be4";
       libraryHaskellDepends = [
         base comonad containers contravariant distributive semigroupoids
         semigroups transformers
       ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck template-haskell
       ];
       jailbreak = true;
       homepage = "https://github.com/NICTA/semigroupoids-syntax";
       description = "RebindableSyntax using the semigroupoids package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "semigroups_0_16" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, hashable
     , nats, text, unordered-containers
     }:
     mkDerivation {
       pname = "semigroups";
       version = "0.16";
       sha256 = "9aa84736cb419802ed81216de79e373b34b9c9a74a01197257727ce0af610557";
       libraryHaskellDepends = [
         base bytestring containers deepseq hashable nats text
         unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/semigroups/";
       description = "Anything that associates";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "semigroups_0_16_0_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, hashable
     , nats, text, unordered-containers
     }:
     mkDerivation {
       pname = "semigroups";
       version = "0.16.0.1";
       sha256 = "46ef9e651bf69634f8e8f0dbe2330629153a7e0c4278af5edaa03f4d6b3113c8";
       revision = "1";
       editedCabalFile = "60b69c696b5a74aeada898545cbc55f5e4f6edbe6601fdaef787c8b88bd10c52";
       libraryHaskellDepends = [
         base bytestring containers deepseq hashable nats text
         unordered-containers
       ];
       homepage = "http://github.com/ekmett/semigroups/";
       description = "Anything that associates";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "semigroups_0_16_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, hashable
     , nats, text, unordered-containers
     }:
     mkDerivation {
       pname = "semigroups";
       version = "0.16.1";
       sha256 = "4d0d0706eae1dce2c0abb878b12c8f2b267e00f700fb76339b8bf3f56b3fde39";
       revision = "1";
       editedCabalFile = "7f321fed6eaa98ed2c343173ed31f8535582a2cda92571a50fcc05b360b90daf";
       libraryHaskellDepends = [
         base bytestring containers deepseq hashable nats text
         unordered-containers
       ];
       homepage = "http://github.com/ekmett/semigroups/";
       description = "Anything that associates";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "semigroups_0_16_2_2" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, hashable
     , nats, text, unordered-containers
     }:
     mkDerivation {
       pname = "semigroups";
       version = "0.16.2.2";
       sha256 = "d17e3e42c8e2457286d5c583dad5d0df57678ce4dcf12acc8a7667e80bd8ed57";
       revision = "1";
       editedCabalFile = "6d7c9c6f7ccb8754b270341b33f39e373906380da03bc198cd008270fb9bd4a0";
       libraryHaskellDepends = [
         base bytestring containers deepseq hashable nats text
         unordered-containers
       ];
       homepage = "http://github.com/ekmett/semigroups/";
       description = "Anything that associates";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "semigroups_0_18_0_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, hashable
     , tagged, text, unordered-containers
     }:
     mkDerivation {
       pname = "semigroups";
       version = "0.18.0.1";
       sha256 = "f6e787519acf261e823d529cc3e5d4fca019075f39f8986649f21891d06d3115";
       revision = "1";
       editedCabalFile = "4b2725ee1abfe9519881e4b4da90cd984eee5f7814217e283dd940ebef629003";
       libraryHaskellDepends = [
         base bytestring containers deepseq hashable tagged text
         unordered-containers
       ];
       homepage = "http://github.com/ekmett/semigroups/";
       description = "Anything that associates";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "semigroups" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , hashable, tagged, text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "semigroups";
       version = "0.18.1";
       sha256 = "ae7607fb2b497a53192c378dc84c00b45610fdc5de0ac8c1ac3234ec7acee807";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq hashable tagged text
         transformers unordered-containers
       ];
       homepage = "http://github.com/ekmett/semigroups/";
       description = "Anything that associates";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "semigroups-actions" = callPackage
    ({ mkDerivation, base, containers, semigroups }:
     mkDerivation {
       pname = "semigroups-actions";
       version = "0.1";
       sha256 = "0bc3b74e14ef6f214f1aebee98ddadde9cca08753969112219fc6bc8da16da6e";
       libraryHaskellDepends = [ base containers semigroups ];
       jailbreak = true;
       homepage = "http://github.com/ppetr/semigroups-actions/";
       description = "Semigroups actions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "semiring" = callPackage
    ({ mkDerivation, base, Boolean, containers, HUnit, monoids
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "semiring";
       version = "0.3";
       sha256 = "befab81cfef9ae6499f44fdd93a2bc892f118b335462bcf2010aba4254f1a6ac";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base Boolean containers monoids ];
       executableHaskellDepends = [
         base Boolean containers HUnit monoids QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/srush/SemiRings/tree/master";
       description = "Semirings, ring-like structures used for dynamic programming applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "semiring-simple" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "semiring-simple";
       version = "0.2.1.0";
       sha256 = "5655c761de3f2123f1c4e6eaa042148cb795fc95bfa173a5441d4a6317ba9c1c";
       libraryHaskellDepends = [ base ];
       description = "A module for dealing with semirings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "semver" = callPackage
    ({ mkDerivation, attoparsec, base, deepseq, tasty, tasty-hunit
     , text
     }:
     mkDerivation {
       pname = "semver";
       version = "0.3.3.1";
       sha256 = "36d3369706836d60f3bc517f30c6860734481866363723904b8768823b6bc8b1";
       libraryHaskellDepends = [ attoparsec base deepseq text ];
       testHaskellDepends = [ base tasty tasty-hunit text ];
       homepage = "https://github.com/brendanhay/semver";
       description = "Representation, manipulation, and de/serialisation of Semantic Versions";
       license = "unknown";
     }) {};

  "semver-range" = callPackage
    ({ mkDerivation, base, classy-prelude, parsec, text
     , unordered-containers
     }:
     mkDerivation {
       pname = "semver-range";
       version = "0.1.1";
       sha256 = "162a7149c50908cd1669ecc16193e2a1bc5cee99bf9e78baa985550592b421d7";
       libraryHaskellDepends = [
         base classy-prelude parsec text unordered-containers
       ];
       description = "An implementation of semver and semantic version ranges";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sendfile" = callPackage
    ({ mkDerivation, base, bytestring, network }:
     mkDerivation {
       pname = "sendfile";
       version = "0.7.9";
       sha256 = "102fdf6db8c00f5a5981c6eed5acba1368a2d79b2970ce5b22ceb180aa0fdc42";
       libraryHaskellDepends = [ base bytestring network ];
       homepage = "http://hub.darcs.net/stepcut/sendfile";
       description = "A portable sendfile library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sendgrid-haskell" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, exceptions
     , http-conduit, monad-control, text, transformers
     }:
     mkDerivation {
       pname = "sendgrid-haskell";
       version = "1.0";
       sha256 = "977ad1e70dfe9e0c94a300ff3f41851294c5743a57f97cae7654dd24095bba4c";
       libraryHaskellDepends = [
         aeson base bytestring containers exceptions http-conduit
         monad-control text transformers
       ];
       homepage = "https://owainlewis.com";
       description = "Sengrid API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "sensenet" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, process, stm
     , zeromq3-haskell
     }:
     mkDerivation {
       pname = "sensenet";
       version = "0.1.0.0";
       sha256 = "e1c2bb14157f376bf5af833688619d05bd470b3dafede531efcbb7e69e0df0fb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring containers process stm zeromq3-haskell
       ];
       jailbreak = true;
       homepage = "https://github.com/rossdylan/sensenet";
       description = "Distributed sensor network for the raspberry pi";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sentry" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, cereal, cmdargs
     , directory, filepath, old-locale, old-time, process, safecopy
     , time, unix
     }:
     mkDerivation {
       pname = "sentry";
       version = "0.1.0";
       sha256 = "1d6bdcb1a37f6bc11a96c46e35c1e659eb853c97d0e8e5c4223d8da36ba364cf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base bytestring cereal cmdargs directory filepath
         old-locale old-time process safecopy time unix
       ];
       executableHaskellDepends = [ base directory filepath unix ];
       jailbreak = true;
       homepage = "https://github.com/noteed/sentry";
       description = "Process monitoring tool written and configured in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "senza" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "senza";
       version = "0.1";
       sha256 = "10242178d5b2a59de08c1b16fa7ffba8eb370b95795a47a5fabf119e346b875e";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "separated" = callPackage
    ({ mkDerivation, base, bifunctors, directory, doctest, filepath
     , lens, QuickCheck, semigroupoids, semigroups, template-haskell
     }:
     mkDerivation {
       pname = "separated";
       version = "0.1.0";
       sha256 = "028a783f2427dfe73d1ec9dcb92014a4b27d567997f03887ff7046400d4b6ba2";
       libraryHaskellDepends = [
         base bifunctors lens semigroupoids semigroups
       ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck template-haskell
       ];
       homepage = "https://github.com/tonymorris/separated";
       description = "A data type with elements separated by values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "seqaid" = callPackage
    ({ mkDerivation, array, base, Cabal, containers, cpphs
     , deepseq-bounded, directory, exceptions, filepath, ghc, ghc-paths
     , mtl, process, regex-base, regex-pcre, syb, template-haskell
     , temporary, transformers
     }:
     mkDerivation {
       pname = "seqaid";
       version = "0.4.0.0";
       sha256 = "16a7b7e01ca70a2062c4f1cd18485f609561c35ed803ca95c414841f66ffbf4e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers cpphs deepseq-bounded exceptions filepath ghc
         ghc-paths mtl regex-pcre syb template-haskell temporary
         transformers
       ];
       executableHaskellDepends = [
         base Cabal cpphs directory process regex-base regex-pcre temporary
       ];
       jailbreak = true;
       homepage = "http://fremissant.net/seqaid";
       description = "Dynamic strictness control, including space leak repair";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "seqalign" = callPackage
    ({ mkDerivation, base, bytestring, vector }:
     mkDerivation {
       pname = "seqalign";
       version = "0.2.0.4";
       sha256 = "4ea194658d865890157d3df882ed21b0c089cdff7f80ea613ae25c5f3d744305";
       libraryHaskellDepends = [ base bytestring vector ];
       description = "Sequence Alignment";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "seqid_0_1_0" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "seqid";
       version = "0.1.0";
       sha256 = "c0d3be7fe6ce3395db637e4567345aeb0c54782cf1e76c40c2116e9527d2bb60";
       libraryHaskellDepends = [ base transformers ];
       jailbreak = true;
       description = "Sequence ID production and consumption";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "seqid" = callPackage
    ({ mkDerivation, base, mtl, transformers }:
     mkDerivation {
       pname = "seqid";
       version = "0.4.1";
       sha256 = "e04b5e0403eddd50f8aeefd6fcefacbf517c918acc12a9506911fec89de0cf51";
       libraryHaskellDepends = [ base mtl transformers ];
       description = "Sequence ID production and consumption";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "seqid-streams_0_1_0" = callPackage
    ({ mkDerivation, base, io-streams, seqid }:
     mkDerivation {
       pname = "seqid-streams";
       version = "0.1.0";
       sha256 = "a299e90a0124e585ccf66feb25206b61c9af8712d95ffb1b266b504fcd61e08d";
       libraryHaskellDepends = [ base io-streams seqid ];
       jailbreak = true;
       description = "Sequence ID IO-Streams";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "seqid-streams" = callPackage
    ({ mkDerivation, base, io-streams, seqid }:
     mkDerivation {
       pname = "seqid-streams";
       version = "0.4.1";
       sha256 = "07d9499db3a11f7e0f3d1c8611315e9b84d76cc576056aeb4cd005f5cc737f36";
       libraryHaskellDepends = [ base io-streams seqid ];
       description = "Sequence ID IO-Streams";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "seqloc_0_6" = callPackage
    ({ mkDerivation, attoparsec, base, biocore, bytestring, hashable
     , QuickCheck, random, unordered-containers, vector
     }:
     mkDerivation {
       pname = "seqloc";
       version = "0.6";
       sha256 = "47007327c14efc547688969990b8969383ec38885494c8301f295943bb606285";
       libraryHaskellDepends = [
         attoparsec base biocore bytestring hashable unordered-containers
         vector
       ];
       testHaskellDepends = [
         attoparsec base biocore bytestring hashable QuickCheck random
         unordered-containers vector
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://www.ingolia-lab.org/seqloc-tutorial.html";
       description = "Handle sequence locations for bioinformatics";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "seqloc_0_6_1" = callPackage
    ({ mkDerivation, attoparsec, base, biocore, bytestring, hashable
     , QuickCheck, random, unordered-containers, vector
     }:
     mkDerivation {
       pname = "seqloc";
       version = "0.6.1";
       sha256 = "8ac3174863585f1228d0ae5233be1d70aef4bb364827eddce0b8ca62d305ac7a";
       libraryHaskellDepends = [
         attoparsec base biocore bytestring hashable unordered-containers
         vector
       ];
       testHaskellDepends = [
         attoparsec base biocore bytestring hashable QuickCheck random
         unordered-containers vector
       ];
       homepage = "http://www.ingolia-lab.org/seqloc-tutorial.html";
       description = "Handle sequence locations for bioinformatics";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "seqloc" = callPackage
    ({ mkDerivation, attoparsec, base, biocore, bytestring, hashable
     , QuickCheck, random, unordered-containers, vector
     }:
     mkDerivation {
       pname = "seqloc";
       version = "0.6.1.1";
       sha256 = "4435e76ba86417612b6bd6a173dc99444d5fe9184a9822b1edf13c808d4f55c3";
       libraryHaskellDepends = [
         attoparsec base biocore bytestring hashable unordered-containers
         vector
       ];
       testHaskellDepends = [
         attoparsec base biocore bytestring hashable QuickCheck random
         unordered-containers vector
       ];
       homepage = "http://www.ingolia-lab.org/seqloc-tutorial.html";
       description = "Handle sequence locations for bioinformatics";
       license = stdenv.lib.licenses.mit;
     }) {};

  "seqloc-datafiles" = callPackage
    ({ mkDerivation, attoparsec, base, biocore, bytestring, cmdtheline
     , conduit, conduit-extra, directory, filepath, hashable, iteratee
     , lifted-base, monads-tf, pretty, process, QuickCheck, random
     , resourcet, seqloc, transformers, transformers-base
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "seqloc-datafiles";
       version = "0.4.2";
       sha256 = "4ae6868b23900be02f7ea72555609ea7453b6a25c07c1b752f5d6dd1a38bb69c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base biocore bytestring conduit conduit-extra hashable
         iteratee lifted-base resourcet seqloc transformers-base
         unordered-containers
       ];
       executableHaskellDepends = [
         attoparsec base biocore bytestring cmdtheline conduit conduit-extra
         filepath hashable iteratee lifted-base monads-tf pretty QuickCheck
         random resourcet seqloc transformers transformers-base
         unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base biocore bytestring conduit conduit-extra directory
         hashable iteratee lifted-base process QuickCheck random seqloc
         transformers transformers-base unordered-containers vector
       ];
       homepage = "http://www.ingolia-lab.org/seqloc-datafiles-tutorial.html";
       description = "Read and write BED and GTF format genome annotations";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sequence" = callPackage
    ({ mkDerivation, base, containers, transformers }:
     mkDerivation {
       pname = "sequence";
       version = "0.9.8";
       sha256 = "50cb62a24e07849f5dbba389ef76f57c656a36a58029e9ef0409aab928f0dd2b";
       libraryHaskellDepends = [ base containers transformers ];
       homepage = "https://github.com/atzeus/sequence";
       description = "A type class for sequences and various sequence data structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sequent-core" = callPackage
    ({ mkDerivation, base, bytestring, containers, ghc, transformers }:
     mkDerivation {
       pname = "sequent-core";
       version = "0.5.0.1";
       sha256 = "cd0a56a9fad3b7b0f53fd2e913f16a7d3c9472d0925f2ec56ed0da6c41ce39e1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers ghc transformers
       ];
       executableHaskellDepends = [ base bytestring containers ];
       homepage = "https://github.com/lukemaurer/sequent-core";
       description = "Alternative Core language for GHC plugins";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sequential-index" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "sequential-index";
       version = "0.2.0.1";
       sha256 = "c60f94e2d49b9344d2dba3ff023918689fbfd77fd3907561ee7aa7d267b6a76d";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "https://github.com/aristidb/sequential-index";
       description = "Sequential numbers that allow arbitrarily inserting numbers - for containers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sequor" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers, mtl
     , nlp-scores, pretty, split, text, vector
     }:
     mkDerivation {
       pname = "sequor";
       version = "0.7.2";
       sha256 = "ba9edb69ef6164f17998509a96f7248e40f9b7dd18d508c64bf4abb7cef481d4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers mtl nlp-scores pretty split
         text vector
       ];
       executableHaskellDepends = [
         array base binary bytestring containers mtl nlp-scores pretty split
         text vector
       ];
       homepage = "https://bitbucket.org/gchrupala/sequor";
       description = "A sequence labeler based on Collins's sequence perceptron";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "serf" = callPackage
    ({ mkDerivation, attoparsec, base, conduit, conduit-extra, mtl
     , operational, process, resourcet, text
     }:
     mkDerivation {
       pname = "serf";
       version = "0.1.1.0";
       sha256 = "d6c9c6ddf99a2119c6686732caf9f04ef8e9c4df5519a8bbd4ac7f5531d4c067";
       libraryHaskellDepends = [
         attoparsec base conduit conduit-extra mtl operational process
         resourcet text
       ];
       homepage = "http://github.com/sanetracker/serf";
       description = "Interact with Serf via Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "serial" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "serial";
       version = "0.2.7";
       sha256 = "d86de1e1f465f308737aaf081a5e82d108987880f1147ccaad0a2e242282a2c0";
       libraryHaskellDepends = [ base unix ];
       description = "POSIX serial port wrapper";
       license = "LGPL";
     }) {};

  "serial-test-generators" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, cereal, here
     , hspec, QuickCheck, system-fileio, transformers
     }:
     mkDerivation {
       pname = "serial-test-generators";
       version = "0.1.3";
       sha256 = "5af96e02de6f1b09a83c52fd49c7f3dc2993eb7ed8ed75b7a8d4ca2191df3133";
       libraryHaskellDepends = [
         aeson base binary bytestring cereal here
       ];
       testHaskellDepends = [
         aeson base binary bytestring cereal here hspec QuickCheck
         system-fileio transformers
       ];
       description = "Test your 'Aeson' 'Serialize' and 'Binary' instances for stability over time";
       license = stdenv.lib.licenses.mit;
     }) {};

  "serialport" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, unix }:
     mkDerivation {
       pname = "serialport";
       version = "0.4.7";
       sha256 = "077c210212ff92611b3d8a3578f3ea1f78586c094057ccc5d1dcc3170fcf4dfc";
       libraryHaskellDepends = [ base bytestring unix ];
       testHaskellDepends = [ base bytestring HUnit ];
       homepage = "https://github.com/jputcu/serialport";
       description = "Cross platform serial port library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "serv" = callPackage
    ({ mkDerivation, aeson, base, bytestring, case-insensitive
     , containers, http-media, http-types, HUnit, mtl, QuickCheck
     , tagged, tasty, tasty-ant-xml, tasty-hunit, tasty-quickcheck, text
     , time, transformers, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "serv";
       version = "0.1.0.0";
       sha256 = "29d8124bcd00ae8ed28a37b6b7bcffa333cf4c30b845c9da725c71153274b371";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring case-insensitive containers http-media
         http-types mtl tagged text time transformers wai
       ];
       executableHaskellDepends = [ base text wai warp ];
       testHaskellDepends = [
         base HUnit QuickCheck tasty tasty-ant-xml tasty-hunit
         tasty-quickcheck text wai wai-extra
       ];
       homepage = "http://github.com/tel/serv#readme";
       description = "Dependently typed API server framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "servant_0_2_2" = callPackage
    ({ mkDerivation, base, hspec, parsec, QuickCheck
     , string-conversions, template-haskell, text
     }:
     mkDerivation {
       pname = "servant";
       version = "0.2.2";
       sha256 = "0c7e08e10e458a2d3f12b4917263ca0a99aa756a75f13c454b23059c95ad74dd";
       libraryHaskellDepends = [
         base parsec string-conversions template-haskell text
       ];
       testHaskellDepends = [
         base hspec parsec QuickCheck string-conversions text
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "A family of combinators for defining webservices APIs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant_0_4_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , bytestring-conversion, case-insensitive, directory, doctest
     , filemanip, filepath, hspec, http-media, http-types, network-uri
     , parsec, QuickCheck, quickcheck-instances, string-conversions
     , text, url
     }:
     mkDerivation {
       pname = "servant";
       version = "0.4.4";
       sha256 = "d2b95b9f9b8173fe83d08166707d564b2cb60526493fc7b4099e09f9480a16ec";
       revision = "1";
       editedCabalFile = "8744311d3ae2ecbd905ab71e1b4c568b02d5179346c3d085bdd19d8632b98dc5";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring bytestring-conversion
         case-insensitive http-media http-types network-uri
         string-conversions text
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring directory doctest filemanip
         filepath hspec parsec QuickCheck quickcheck-instances
         string-conversions text url
       ];
       jailbreak = true;
       homepage = "http://haskell-servant.github.io/";
       description = "A family of combinators for defining webservices APIs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant_0_4_4_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , bytestring-conversion, case-insensitive, directory, doctest
     , filemanip, filepath, hspec, http-media, http-types, network-uri
     , parsec, QuickCheck, quickcheck-instances, string-conversions
     , text, url
     }:
     mkDerivation {
       pname = "servant";
       version = "0.4.4.2";
       sha256 = "fc5c80822fef28b63d8a63bd63efd0bdd86c7d13f06d1cc6e9b0768c4efe61aa";
       revision = "1";
       editedCabalFile = "230a38d3c063c561c11a5570bb725f715bff776e507a734a62dac5aa463b5c08";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring bytestring-conversion
         case-insensitive http-media http-types network-uri
         string-conversions text
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring directory doctest filemanip
         filepath hspec parsec QuickCheck quickcheck-instances
         string-conversions text url
       ];
       jailbreak = true;
       homepage = "http://haskell-servant.github.io/";
       description = "A family of combinators for defining webservices APIs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant_0_4_4_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , bytestring-conversion, case-insensitive, directory, doctest
     , filemanip, filepath, hspec, http-media, http-types, network-uri
     , parsec, QuickCheck, quickcheck-instances, string-conversions
     , text, url
     }:
     mkDerivation {
       pname = "servant";
       version = "0.4.4.4";
       sha256 = "182842071c4905a3429c1ccbff020af255b6abfd1e7a6473253713c0da80f280";
       revision = "1";
       editedCabalFile = "5bcd8a6a295b2e58c802750441e3ffac259cfa6e12037b7ccd176b1ef8381288";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring bytestring-conversion
         case-insensitive http-media http-types network-uri
         string-conversions text
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring directory doctest filemanip
         filepath hspec parsec QuickCheck quickcheck-instances
         string-conversions text url
       ];
       jailbreak = true;
       homepage = "http://haskell-servant.github.io/";
       description = "A family of combinators for defining webservices APIs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant_0_4_4_5" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , bytestring-conversion, case-insensitive, directory, doctest
     , filemanip, filepath, hspec, http-media, http-types, network-uri
     , parsec, QuickCheck, quickcheck-instances, string-conversions
     , text, url
     }:
     mkDerivation {
       pname = "servant";
       version = "0.4.4.5";
       sha256 = "b82abafe5bd1357c64c36c344ab38dc8fa8ad8f40126b86323da9bfc4047f544";
       revision = "1";
       editedCabalFile = "a6c733d905643e01e57adeb803dc15951eca7c7f4d7f09abac650b1c3efcc89c";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring bytestring-conversion
         case-insensitive http-media http-types network-uri
         string-conversions text
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring directory doctest filemanip
         filepath hspec parsec QuickCheck quickcheck-instances
         string-conversions text url
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "A family of combinators for defining webservices APIs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , bytestring-conversion, case-insensitive, directory, doctest
     , filemanip, filepath, hspec, http-media, http-types, network-uri
     , parsec, QuickCheck, quickcheck-instances, string-conversions
     , text, url
     }:
     mkDerivation {
       pname = "servant";
       version = "0.4.4.6";
       sha256 = "6adeba12f74f809c3bd9846d2563e1bffb9826d8731084bcea17bce7a145ee6a";
       revision = "1";
       editedCabalFile = "821919911076b83763ba559388851ea582c40c2171ae38b95006ee2fb717ac6b";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring bytestring-conversion
         case-insensitive http-media http-types network-uri
         string-conversions text
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring directory doctest filemanip
         filepath hspec parsec QuickCheck quickcheck-instances
         string-conversions text url
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "A family of combinators for defining webservices APIs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "servant-JuicyPixels_0_1_0_0" = callPackage
    ({ mkDerivation, base, bytestring, http-media, JuicyPixels, servant
     , servant-server, wai, warp
     }:
     mkDerivation {
       pname = "servant-JuicyPixels";
       version = "0.1.0.0";
       sha256 = "12914a3047b8e0e00db4f2d37a4d6f3aee0d1aa93bb76e815fdf2282ccf4d4ba";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring http-media JuicyPixels servant
       ];
       executableHaskellDepends = [
         base JuicyPixels servant servant-server wai warp
       ];
       homepage = "https://github.com/tvh/servant-JuicyPixels";
       description = "servant-JuicyPixels";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-JuicyPixels" = callPackage
    ({ mkDerivation, base, bytestring, http-media, JuicyPixels, servant
     , servant-server, wai, warp
     }:
     mkDerivation {
       pname = "servant-JuicyPixels";
       version = "0.3.0.0";
       sha256 = "c80d49e5c38cf465db16efc43155a6639e309b03b6108bc21435dfe116359a81";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring http-media JuicyPixels servant
       ];
       executableHaskellDepends = [
         base JuicyPixels servant servant-server wai warp
       ];
       homepage = "https://github.com/tvh/servant-JuicyPixels";
       description = "Servant support for JuicyPixels";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "servant-blaze" = callPackage
    ({ mkDerivation, base, blaze-html, http-media, servant }:
     mkDerivation {
       pname = "servant-blaze";
       version = "0.4.4.6";
       sha256 = "ef7ec4007b43679fd50133c097afb3ed33f64696fb44b03a281160384f693f91";
       libraryHaskellDepends = [ base blaze-html http-media servant ];
       homepage = "http://haskell-servant.github.io/";
       description = "Blaze-html support for servant";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "servant-cassava" = callPackage
    ({ mkDerivation, base, cassava, http-media, servant, vector }:
     mkDerivation {
       pname = "servant-cassava";
       version = "0.4.4.6";
       sha256 = "2d5b3be61d67d89b95dd3156d4bf5201452f30031517276c4dd7cde4a7456769";
       libraryHaskellDepends = [ base cassava http-media servant vector ];
       homepage = "http://haskell-servant.github.io/";
       description = "Servant CSV content-type for cassava";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "servant-client_0_2_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, deepseq
     , either, exceptions, hspec, http-client, http-client-tls
     , http-types, network, network-uri, QuickCheck, safe, servant
     , servant-server, string-conversions, text, transformers, wai, warp
     }:
     mkDerivation {
       pname = "servant-client";
       version = "0.2.2";
       sha256 = "b95c4b1f7f97395be4c3d1cea440ce4ece03d04cdb777559e34a1116e953262d";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either exceptions http-client
         http-client-tls http-types network-uri safe servant
         string-conversions text transformers
       ];
       testHaskellDepends = [
         aeson base bytestring deepseq either hspec http-types network
         QuickCheck servant servant-server wai warp
       ];
       jailbreak = true;
       homepage = "http://haskell-servant.github.io/";
       description = "automatical derivation of querying functions for servant webservices";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-client_0_4_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, deepseq
     , either, exceptions, hspec, http-client, http-client-tls
     , http-media, http-types, HUnit, network, network-uri, QuickCheck
     , safe, servant, servant-server, string-conversions, text
     , transformers, wai, warp
     }:
     mkDerivation {
       pname = "servant-client";
       version = "0.4.4";
       sha256 = "7f1b8835bddbe8b1eafa6dee9dc780561ad851e9b68e8a5c16ea45b32ee2aa54";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either exceptions http-client
         http-client-tls http-media http-types network-uri safe servant
         string-conversions text transformers
       ];
       testHaskellDepends = [
         aeson base bytestring deepseq either hspec http-client http-media
         http-types HUnit network QuickCheck servant servant-server text wai
         warp
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "automatical derivation of querying functions for servant webservices";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-client_0_4_4_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, deepseq
     , either, exceptions, hspec, http-client, http-client-tls
     , http-media, http-types, HUnit, network, network-uri, QuickCheck
     , safe, servant, servant-server, string-conversions, text
     , transformers, wai, warp
     }:
     mkDerivation {
       pname = "servant-client";
       version = "0.4.4.2";
       sha256 = "d5b95b943215aa227f390c284f84043d7c0db2531416ff44511e0d209bc498c3";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either exceptions http-client
         http-client-tls http-media http-types network-uri safe servant
         string-conversions text transformers
       ];
       testHaskellDepends = [
         aeson base bytestring deepseq either hspec http-client http-media
         http-types HUnit network QuickCheck servant servant-server text wai
         warp
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "automatical derivation of querying functions for servant webservices";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-client_0_4_4_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, deepseq
     , either, exceptions, hspec, http-client, http-client-tls
     , http-media, http-types, HUnit, network, network-uri, QuickCheck
     , safe, servant, servant-server, string-conversions, text
     , transformers, wai, warp
     }:
     mkDerivation {
       pname = "servant-client";
       version = "0.4.4.4";
       sha256 = "650e5aa48c060238a25328e9b9193d20102010359946f7b1979ef328eb1c4134";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either exceptions http-client
         http-client-tls http-media http-types network-uri safe servant
         string-conversions text transformers
       ];
       testHaskellDepends = [
         aeson base bytestring deepseq either hspec http-client http-media
         http-types HUnit network QuickCheck servant servant-server text wai
         warp
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "automatical derivation of querying functions for servant webservices";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-client_0_4_4_5" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, deepseq
     , either, exceptions, hspec, http-client, http-client-tls
     , http-media, http-types, HUnit, network, network-uri, QuickCheck
     , safe, servant, servant-server, string-conversions, text
     , transformers, wai, warp
     }:
     mkDerivation {
       pname = "servant-client";
       version = "0.4.4.5";
       sha256 = "7ca47d0bb95268222fe19d34b31acf501ea89d7a9a4ce77a3ebc0cd18386b953";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either exceptions http-client
         http-client-tls http-media http-types network-uri safe servant
         string-conversions text transformers
       ];
       testHaskellDepends = [
         aeson base bytestring deepseq either hspec http-client http-media
         http-types HUnit network QuickCheck servant servant-server text wai
         warp
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "automatical derivation of querying functions for servant webservices";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-client" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, deepseq
     , either, exceptions, hspec, http-client, http-client-tls
     , http-media, http-types, HUnit, network, network-uri, QuickCheck
     , safe, servant, servant-server, string-conversions, text
     , transformers, wai, warp
     }:
     mkDerivation {
       pname = "servant-client";
       version = "0.4.4.6";
       sha256 = "c4604c462f44963fce5ac32c330281880351ea39f5a206876af95d9945408383";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either exceptions http-client
         http-client-tls http-media http-types network-uri safe servant
         string-conversions text transformers
       ];
       testHaskellDepends = [
         aeson base bytestring deepseq either hspec http-client http-media
         http-types HUnit network QuickCheck servant servant-server text wai
         warp
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "automatical derivation of querying functions for servant webservices";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "servant-docs_0_3_1" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring, hashable
     , lens, servant, string-conversions, system-filepath, text
     , unordered-containers
     }:
     mkDerivation {
       pname = "servant-docs";
       version = "0.3.1";
       sha256 = "a4b9e2bee4767e65f298fc96bce079a80c7d6ae4ed24d628cb56f9d263897cf5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty base bytestring hashable lens servant
         string-conversions system-filepath text unordered-containers
       ];
       executableHaskellDepends = [ aeson base servant text ];
       jailbreak = true;
       homepage = "http://haskell-servant.github.io/";
       description = "generate API docs for your servant webservice";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-docs_0_4_4" = callPackage
    ({ mkDerivation, aeson, base, bytestring, bytestring-conversion
     , case-insensitive, hashable, hspec, http-media, http-types, lens
     , servant, string-conversions, text, unordered-containers
     }:
     mkDerivation {
       pname = "servant-docs";
       version = "0.4.4";
       sha256 = "ccf92b38df3506b25e6fe93d7ded665db8c1cef76a73913afa72aa2e0d19e54e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring bytestring-conversion case-insensitive hashable
         http-media http-types lens servant string-conversions text
         unordered-containers
       ];
       executableHaskellDepends = [
         aeson base bytestring-conversion lens servant string-conversions
         text
       ];
       testHaskellDepends = [
         aeson base hspec lens servant string-conversions
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "generate API docs for your servant webservice";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-docs_0_4_4_2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, bytestring-conversion
     , case-insensitive, hashable, hspec, http-media, http-types, lens
     , servant, string-conversions, text, unordered-containers
     }:
     mkDerivation {
       pname = "servant-docs";
       version = "0.4.4.2";
       sha256 = "449ff2c953c4282f768c7d514f0c5a68e7d8541bde973d0ebe50372987355d90";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring bytestring-conversion case-insensitive hashable
         http-media http-types lens servant string-conversions text
         unordered-containers
       ];
       executableHaskellDepends = [
         aeson base bytestring-conversion lens servant string-conversions
         text
       ];
       testHaskellDepends = [
         aeson base hspec lens servant string-conversions
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "generate API docs for your servant webservice";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-docs_0_4_4_4" = callPackage
    ({ mkDerivation, aeson, base, bytestring, bytestring-conversion
     , case-insensitive, hashable, hspec, http-media, http-types, lens
     , servant, string-conversions, text, unordered-containers
     }:
     mkDerivation {
       pname = "servant-docs";
       version = "0.4.4.4";
       sha256 = "9a854eafd12e7707764899f16a0868f712eb022eb0fa2f9eeeaaea8bea4bc4f2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring bytestring-conversion case-insensitive hashable
         http-media http-types lens servant string-conversions text
         unordered-containers
       ];
       executableHaskellDepends = [
         aeson base bytestring-conversion lens servant string-conversions
         text
       ];
       testHaskellDepends = [
         aeson base hspec lens servant string-conversions
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "generate API docs for your servant webservice";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-docs_0_4_4_5" = callPackage
    ({ mkDerivation, aeson, base, bytestring, bytestring-conversion
     , case-insensitive, hashable, hspec, http-media, http-types, lens
     , servant, string-conversions, text, unordered-containers
     }:
     mkDerivation {
       pname = "servant-docs";
       version = "0.4.4.5";
       sha256 = "55f4c036cc96aebac19eeea43af412f696002a8e3497a95ff4aa25429c7c474e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring bytestring-conversion case-insensitive hashable
         http-media http-types lens servant string-conversions text
         unordered-containers
       ];
       executableHaskellDepends = [
         aeson base bytestring-conversion lens servant string-conversions
         text
       ];
       testHaskellDepends = [
         aeson base hspec lens servant string-conversions
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "generate API docs for your servant webservice";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-docs" = callPackage
    ({ mkDerivation, aeson, base, bytestring, bytestring-conversion
     , case-insensitive, hashable, hspec, http-media, http-types, lens
     , servant, string-conversions, text, unordered-containers
     }:
     mkDerivation {
       pname = "servant-docs";
       version = "0.4.4.6";
       sha256 = "bc3a1209e98f55a1c67c175a5c117bfb5a1b5a0a1b9aebeb31ad93fbc90efd2b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring bytestring-conversion case-insensitive hashable
         http-media http-types lens servant string-conversions text
         unordered-containers
       ];
       executableHaskellDepends = [
         aeson base bytestring-conversion lens servant string-conversions
         text
       ];
       testHaskellDepends = [
         aeson base hspec lens servant string-conversions
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "generate API docs for your servant webservice";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "servant-ede" = callPackage
    ({ mkDerivation, aeson, base, bytestring, ede, either, filepath
     , http-media, http-types, semigroups, servant, servant-server, text
     , transformers, unordered-containers, vector, warp, xss-sanitize
     }:
     mkDerivation {
       pname = "servant-ede";
       version = "0.5.1";
       sha256 = "54e929c1c77acb04e808aabc485cf80f19724330e233ae5b6255d41d45ac957c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring ede either filepath http-media http-types
         semigroups servant text transformers unordered-containers vector
         xss-sanitize
       ];
       executableHaskellDepends = [
         base ede http-media servant-server warp
       ];
       jailbreak = true;
       homepage = "http://github.com/alpmestan/servant-ede";
       description = "Combinators for rendering EDE templates in servant web applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "servant-elm" = callPackage
    ({ mkDerivation, aeson, base, data-default, elm-export, hspec, lens
     , servant, servant-foreign, text
     }:
     mkDerivation {
       pname = "servant-elm";
       version = "0.1.0.1";
       sha256 = "8e44d664e4484135c4b19d2477131b1f75863c999ff747a6b69052ac12f6d15d";
       libraryHaskellDepends = [
         base elm-export lens servant servant-foreign text
       ];
       testHaskellDepends = [
         aeson base data-default elm-export hspec servant
       ];
       jailbreak = true;
       homepage = "http://github.com/mattjbray/servant-elm#readme";
       description = "Automatically derive Elm functions to query servant webservices";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {elm-export = null; servant-foreign = null;};

  "servant-examples" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, either
     , http-types, js-jquery, lucid, random, servant, servant-client
     , servant-docs, servant-jquery, servant-lucid, servant-server, text
     , time, transformers, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "servant-examples";
       version = "0.4.4.6";
       sha256 = "8901e5d619234600d69341f314de044c6659f88e1fd1c6ceed71929565bac0ee";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring directory either http-types js-jquery lucid
         random servant servant-client servant-docs servant-jquery
         servant-lucid servant-server text time transformers wai wai-extra
         warp
       ];
       jailbreak = true;
       homepage = "http://haskell-servant.github.io/";
       description = "Example programs for servant";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-github" = callPackage
    ({ mkDerivation, aeson, base, either, hspec, http-link-header
     , QuickCheck, servant, servant-client, text, transformers
     }:
     mkDerivation {
       pname = "servant-github";
       version = "0.1.0.2";
       sha256 = "3d1c03791297bcde37c7ef369b0e672d00122ac17b4f176c6a3fa52a9dba4cd8";
       libraryHaskellDepends = [
         aeson base either http-link-header servant servant-client text
         transformers
       ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "http://github.com/finlay/servant-github#readme";
       description = "Bindings to GitHub API using servant";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "servant-jquery_0_2_2_1" = callPackage
    ({ mkDerivation, aeson, base, filepath, hspec, language-ecmascript
     , lens, servant, servant-server, stm, transformers, warp
     }:
     mkDerivation {
       pname = "servant-jquery";
       version = "0.2.2.1";
       sha256 = "f1235f1ad45c5e04b9b1ced1c22f4321cf85c6fe9403fcad5b60187f65416c68";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base lens servant ];
       executableHaskellDepends = [
         aeson base filepath servant servant-server stm transformers warp
       ];
       testHaskellDepends = [ base hspec language-ecmascript servant ];
       homepage = "http://haskell-servant.github.io/";
       description = "Automatically derive (jquery) javascript functions to query servant webservices";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-jquery_0_4_4" = callPackage
    ({ mkDerivation, aeson, base, charset, filepath, hspec
     , hspec-expectations, language-ecmascript, lens, servant
     , servant-server, stm, text, transformers, warp
     }:
     mkDerivation {
       pname = "servant-jquery";
       version = "0.4.4";
       sha256 = "6d5726b74ee4b83d84ab62d8f3af1afc0743715d9624056d97148a9ebb654212";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base charset lens servant text ];
       executableHaskellDepends = [
         aeson base filepath servant servant-server stm transformers warp
       ];
       testHaskellDepends = [
         base hspec hspec-expectations language-ecmascript lens servant
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "Automatically derive (jquery) javascript functions to query servant webservices";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-jquery_0_4_4_2" = callPackage
    ({ mkDerivation, aeson, base, charset, filepath, hspec
     , hspec-expectations, language-ecmascript, lens, servant
     , servant-server, stm, text, transformers, warp
     }:
     mkDerivation {
       pname = "servant-jquery";
       version = "0.4.4.2";
       sha256 = "c807d103b47b4f7c31708deb92786171a9b7fce2314232400caf2be74b7225ad";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base charset lens servant text ];
       executableHaskellDepends = [
         aeson base filepath servant servant-server stm transformers warp
       ];
       testHaskellDepends = [
         base hspec hspec-expectations language-ecmascript lens servant
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "Automatically derive (jquery) javascript functions to query servant webservices";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-jquery_0_4_4_4" = callPackage
    ({ mkDerivation, aeson, base, charset, filepath, hspec
     , hspec-expectations, language-ecmascript, lens, servant
     , servant-server, stm, text, transformers, warp
     }:
     mkDerivation {
       pname = "servant-jquery";
       version = "0.4.4.4";
       sha256 = "66fbe8414ac6bf6e17fd12b31d6a1fa766ea91f3a2932c22c3accf048e8f7076";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base charset lens servant text ];
       executableHaskellDepends = [
         aeson base filepath servant servant-server stm transformers warp
       ];
       testHaskellDepends = [
         base hspec hspec-expectations language-ecmascript lens servant
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "Automatically derive (jquery) javascript functions to query servant webservices";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-jquery_0_4_4_5" = callPackage
    ({ mkDerivation, aeson, base, charset, filepath, hspec
     , hspec-expectations, language-ecmascript, lens, servant
     , servant-server, stm, text, transformers, warp
     }:
     mkDerivation {
       pname = "servant-jquery";
       version = "0.4.4.5";
       sha256 = "33059d2a707bfad6fcd3f92cdaac69da9767dce1f2e11f7c4c9b2ad9df1d1b3c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base charset lens servant text ];
       executableHaskellDepends = [
         aeson base filepath servant servant-server stm transformers warp
       ];
       testHaskellDepends = [
         base hspec hspec-expectations language-ecmascript lens servant
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "Automatically derive (jquery) javascript functions to query servant webservices";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-jquery" = callPackage
    ({ mkDerivation, aeson, base, charset, filepath, hspec
     , hspec-expectations, language-ecmascript, lens, servant
     , servant-server, stm, text, transformers, warp
     }:
     mkDerivation {
       pname = "servant-jquery";
       version = "0.4.4.6";
       sha256 = "6d144efd7d8a267e88ea9b94da766cae8373614673e58e38ff17a95b0e827e7d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base charset lens servant text ];
       executableHaskellDepends = [
         aeson base filepath servant servant-server stm transformers warp
       ];
       testHaskellDepends = [
         base hspec hspec-expectations language-ecmascript lens servant
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "Automatically derive (jquery) javascript functions to query servant webservices";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "servant-lucid" = callPackage
    ({ mkDerivation, base, http-media, lucid, servant }:
     mkDerivation {
       pname = "servant-lucid";
       version = "0.4.4.6";
       sha256 = "9dede15f6a6032a3e815bd949e2c83f243a6c15aaca8ee65ee97c163515fdf4b";
       libraryHaskellDepends = [ base http-media lucid servant ];
       homepage = "http://haskell-servant.github.io/";
       description = "Servant support for lucid";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "servant-mock" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-types, QuickCheck
     , servant, servant-server, transformers, wai, warp
     }:
     mkDerivation {
       pname = "servant-mock";
       version = "0.4.4.6";
       sha256 = "eaf6d4b7635bc0549c2d1fba1e4b6d5130281880e345180f0f78cf78ba7a0665";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring http-types QuickCheck servant servant-server
         transformers wai
       ];
       executableHaskellDepends = [
         aeson base QuickCheck servant-server warp
       ];
       homepage = "http://github.com/haskell-servant/servant";
       description = "Derive a mock server for free from your servant API types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "servant-pandoc_0_4_1_1" = callPackage
    ({ mkDerivation, base, bytestring, http-media, lens, pandoc-types
     , servant-docs, text, unordered-containers
     }:
     mkDerivation {
       pname = "servant-pandoc";
       version = "0.4.1.1";
       sha256 = "d39a886cd43c321a56d0a48ff4def26f8d5f3e60e591957a03dfbb50ccf69401";
       revision = "1";
       editedCabalFile = "ee2eff37865c8a5c246021f6d05aae5f075ba5910cac6d650312aafb2f4bf091";
       libraryHaskellDepends = [
         base bytestring http-media lens pandoc-types servant-docs text
         unordered-containers
       ];
       jailbreak = true;
       description = "Use Pandoc to render servant API documentation";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-pandoc" = callPackage
    ({ mkDerivation, base, bytestring, http-media, lens, pandoc-types
     , servant-docs, text, unordered-containers
     }:
     mkDerivation {
       pname = "servant-pandoc";
       version = "0.4.1.2";
       sha256 = "e98cc2e8483b97698e526798143a570d6398b19830cab4a72ff68a2f8f2c6237";
       libraryHaskellDepends = [
         base bytestring http-media lens pandoc-types servant-docs text
         unordered-containers
       ];
       jailbreak = true;
       description = "Use Pandoc to render servant API documentation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "servant-pool" = callPackage
    ({ mkDerivation, base, resource-pool, servant, time }:
     mkDerivation {
       pname = "servant-pool";
       version = "0.1";
       sha256 = "c938fcd6d2e6a6d5b45932fd7d01622c2f09b7f947a63f2d25ad5d0756a7c445";
       revision = "1";
       editedCabalFile = "f84940c58e21db3616aa0f6846ae89395aa2589de5ad8cdb91bc7e21acec8c97";
       libraryHaskellDepends = [ base resource-pool servant time ];
       jailbreak = true;
       homepage = "http://github.com/zalora/servant-pool";
       description = "Utility functions for creating servant 'Context's with \"context/connection pooling\" support";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-postgresql" = callPackage
    ({ mkDerivation, base, bytestring, postgresql-simple, servant
     , servant-pool, servant-response
     }:
     mkDerivation {
       pname = "servant-postgresql";
       version = "0.1";
       sha256 = "12e6ce41a43e13f41f763eba8ad730597d63f97198e88af407f816aacd0e7eeb";
       libraryHaskellDepends = [
         base bytestring postgresql-simple servant servant-pool
         servant-response
       ];
       homepage = "http://github.com/zalora/servant-postgresql";
       description = "Useful functions and instances for using servant with a PostgreSQL context";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-response" = callPackage
    ({ mkDerivation, aeson, base, http-types, text }:
     mkDerivation {
       pname = "servant-response";
       version = "0.1";
       sha256 = "1e32b385757555a03c29fa6a8e02d5ae1ce8c436997db8ed923bb851ad89ff6d";
       revision = "1";
       editedCabalFile = "5ee181fcc10725b2f8a2188716dfcc36d134c7aef11458cc4e85902f67611dd2";
       libraryHaskellDepends = [ aeson base http-types text ];
       homepage = "http://github.com/zalora/servant";
       description = "Machinery to express how servant should turn results of database operations into proper JSON-encodable response types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "servant-scotty" = callPackage
    ({ mkDerivation, aeson, base, http-types, scotty, servant
     , servant-response, text, transformers
     }:
     mkDerivation {
       pname = "servant-scotty";
       version = "0.1.1";
       sha256 = "031d68f2d688e4f97b65366ce5ef5c6fc124998e01498b7ffc315ca1d4617e34";
       revision = "1";
       editedCabalFile = "5355af06c17f104c8276672de58b2cbcb3c0e7e200d0f596622740326c0a32fa";
       libraryHaskellDepends = [
         aeson base http-types scotty servant servant-response text
         transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/zalora/servant";
       description = "Generate a web service for servant 'Resource's using scotty and JSON";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-server_0_2_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, directory
     , either, exceptions, hspec, hspec-wai, http-types, network
     , network-uri, parsec, QuickCheck, safe, servant, split
     , string-conversions, system-filepath, temporary, text
     , transformers, wai, wai-app-static, wai-extra, warp
     }:
     mkDerivation {
       pname = "servant-server";
       version = "0.2.4";
       sha256 = "20de585f81ea73be65b4ebce3a9f7ce86f2cd2690dac79044f0fef09ffd16d85";
       revision = "1";
       editedCabalFile = "7b8f1536e02ddf426943993ce5a0b72dcf33f216be7d8607da178692fef8bb85";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either http-types network-uri safe
         servant split string-conversions system-filepath text transformers
         wai wai-app-static warp
       ];
       executableHaskellDepends = [ aeson base servant text wai warp ];
       testHaskellDepends = [
         aeson base bytestring directory either exceptions hspec hspec-wai
         http-types network parsec QuickCheck servant string-conversions
         temporary text transformers wai wai-extra warp
       ];
       jailbreak = true;
       homepage = "http://haskell-servant.github.io/";
       description = "A family of combinators for defining webservices APIs and serving them";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-server_0_4_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , bytestring-conversion, directory, doctest, either, exceptions
     , filemanip, filepath, hspec, hspec-wai, http-types, mmorph, mtl
     , network, network-uri, parsec, QuickCheck, safe, servant, split
     , string-conversions, system-filepath, temporary, text
     , transformers, wai, wai-app-static, wai-extra, warp
     }:
     mkDerivation {
       pname = "servant-server";
       version = "0.4.4";
       sha256 = "49291f8f7009477eaeea5ab6e76350eeb90c7992218ea1172a65cb703cbddd2f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either filepath http-types mmorph
         mtl network-uri safe servant split string-conversions
         system-filepath text transformers wai wai-app-static warp
       ];
       executableHaskellDepends = [ aeson base servant text wai warp ];
       testHaskellDepends = [
         aeson base bytestring bytestring-conversion directory doctest
         either exceptions filemanip filepath hspec hspec-wai http-types mtl
         network parsec QuickCheck servant string-conversions temporary text
         transformers wai wai-extra warp
       ];
       jailbreak = true;
       homepage = "http://haskell-servant.github.io/";
       description = "A family of combinators for defining webservices APIs and serving them";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-server_0_4_4_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , bytestring-conversion, directory, doctest, either, exceptions
     , filemanip, filepath, hspec, hspec-wai, http-types, mmorph, mtl
     , network, network-uri, parsec, QuickCheck, safe, servant, split
     , string-conversions, system-filepath, temporary, text
     , transformers, wai, wai-app-static, wai-extra, warp
     }:
     mkDerivation {
       pname = "servant-server";
       version = "0.4.4.1";
       sha256 = "4889f732694a34232660660332cfd61b1e404f5adedd2b96a21a42dfdb51556a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either filepath http-types mmorph
         mtl network-uri safe servant split string-conversions
         system-filepath text transformers wai wai-app-static warp
       ];
       executableHaskellDepends = [ aeson base servant text wai warp ];
       testHaskellDepends = [
         aeson base bytestring bytestring-conversion directory doctest
         either exceptions filemanip filepath hspec hspec-wai http-types mtl
         network parsec QuickCheck servant string-conversions temporary text
         transformers wai wai-extra warp
       ];
       jailbreak = true;
       homepage = "http://haskell-servant.github.io/";
       description = "A family of combinators for defining webservices APIs and serving them";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-server_0_4_4_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , bytestring-conversion, directory, doctest, either, exceptions
     , filemanip, filepath, hspec, hspec-wai, http-types, mmorph, mtl
     , network, network-uri, parsec, QuickCheck, safe, servant, split
     , string-conversions, system-filepath, temporary, text
     , transformers, wai, wai-app-static, wai-extra, warp
     }:
     mkDerivation {
       pname = "servant-server";
       version = "0.4.4.2";
       sha256 = "9c937f01f0ce3ae354097406e8617ee10bbcbd86513c5808b3c430ecba4f7fff";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either filepath http-types mmorph
         mtl network-uri safe servant split string-conversions
         system-filepath text transformers wai wai-app-static warp
       ];
       executableHaskellDepends = [ aeson base servant text wai warp ];
       testHaskellDepends = [
         aeson base bytestring bytestring-conversion directory doctest
         either exceptions filemanip filepath hspec hspec-wai http-types mtl
         network parsec QuickCheck servant string-conversions temporary text
         transformers wai wai-extra warp
       ];
       jailbreak = true;
       homepage = "http://haskell-servant.github.io/";
       description = "A family of combinators for defining webservices APIs and serving them";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-server_0_4_4_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , bytestring-conversion, directory, doctest, either, exceptions
     , filemanip, filepath, hspec, hspec-wai, http-types, mmorph, mtl
     , network, network-uri, parsec, QuickCheck, safe, servant, split
     , string-conversions, system-filepath, temporary, text
     , transformers, wai, wai-app-static, wai-extra, warp
     }:
     mkDerivation {
       pname = "servant-server";
       version = "0.4.4.4";
       sha256 = "056947b96664674f1a6c65af30001e9e2343357efa96e153198ec0f833f3fdd0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either filepath http-types mmorph
         mtl network-uri safe servant split string-conversions
         system-filepath text transformers wai wai-app-static warp
       ];
       executableHaskellDepends = [ aeson base servant text wai warp ];
       testHaskellDepends = [
         aeson base bytestring bytestring-conversion directory doctest
         either exceptions filemanip filepath hspec hspec-wai http-types mtl
         network parsec QuickCheck servant string-conversions temporary text
         transformers wai wai-extra warp
       ];
       jailbreak = true;
       homepage = "http://haskell-servant.github.io/";
       description = "A family of combinators for defining webservices APIs and serving them";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-server_0_4_4_5" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , bytestring-conversion, directory, doctest, either, exceptions
     , filemanip, filepath, hspec, hspec-wai, http-types, mmorph, mtl
     , network, network-uri, parsec, QuickCheck, safe, servant, split
     , string-conversions, system-filepath, temporary, text
     , transformers, wai, wai-app-static, wai-extra, warp
     }:
     mkDerivation {
       pname = "servant-server";
       version = "0.4.4.5";
       sha256 = "30d9668ff406911356a0ebcba7591924c5bb5c55a228e5682e394a66ee593a58";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either filepath http-types mmorph
         mtl network-uri safe servant split string-conversions
         system-filepath text transformers wai wai-app-static warp
       ];
       executableHaskellDepends = [ aeson base servant text wai warp ];
       testHaskellDepends = [
         aeson base bytestring bytestring-conversion directory doctest
         either exceptions filemanip filepath hspec hspec-wai http-types mtl
         network parsec QuickCheck servant string-conversions temporary text
         transformers wai wai-extra warp
       ];
       jailbreak = true;
       homepage = "http://haskell-servant.github.io/";
       description = "A family of combinators for defining webservices APIs and serving them";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-server" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring
     , bytestring-conversion, directory, doctest, either, exceptions
     , filemanip, filepath, hspec, hspec-wai, http-types, mmorph, mtl
     , network, network-uri, parsec, QuickCheck, safe, servant, split
     , string-conversions, system-filepath, temporary, text
     , transformers, wai, wai-app-static, wai-extra, warp
     }:
     mkDerivation {
       pname = "servant-server";
       version = "0.4.4.6";
       sha256 = "04d5b9518ccbb88a9f492ca3ffceb4f382ca4d06ef11524f5f1f691298856a4b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring either filepath http-types mmorph
         mtl network-uri safe servant split string-conversions
         system-filepath text transformers wai wai-app-static warp
       ];
       executableHaskellDepends = [ aeson base servant text wai warp ];
       testHaskellDepends = [
         aeson base bytestring bytestring-conversion directory doctest
         either exceptions filemanip filepath hspec hspec-wai http-types mtl
         network parsec QuickCheck servant string-conversions temporary text
         transformers wai wai-extra warp
       ];
       homepage = "http://haskell-servant.github.io/";
       description = "A family of combinators for defining webservices APIs and serving them";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "servant-swagger_0_1_1" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, bytestring, hspec
     , http-media, lens, servant, swagger2, text, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "servant-swagger";
       version = "0.1.1";
       sha256 = "d89df7e8ee82978f6db32c2f278591df26bcdd6ef4282dff53933d3417d53a6c";
       revision = "1";
       editedCabalFile = "4982e79b812758d953cf852474e97882f826f194b09ba66eed74ec52fceb6f8e";
       libraryHaskellDepends = [
         aeson base bytestring http-media lens servant swagger2 text
         unordered-containers
       ];
       testHaskellDepends = [
         aeson aeson-qq base hspec lens servant swagger2 text time
       ];
       homepage = "https://github.com/dmjio/servant-swagger";
       description = "Generate Swagger specification for your servant API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-swagger_0_1_2" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, bytestring, hspec
     , http-media, lens, servant, swagger2, text, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "servant-swagger";
       version = "0.1.2";
       sha256 = "44b189a3dabe0b2f6dd5fe8366b81df5622bd9435674670a8fe3e67ecf1e9c1b";
       libraryHaskellDepends = [
         aeson base bytestring http-media lens servant swagger2 text
         unordered-containers
       ];
       testHaskellDepends = [
         aeson aeson-qq base hspec lens servant swagger2 text time
       ];
       jailbreak = true;
       homepage = "https://github.com/dmjio/servant-swagger";
       description = "Generate Swagger specification for your servant API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "servant-swagger" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, bytestring, doctest, Glob
     , hspec, http-media, lens, QuickCheck, servant, swagger2, text
     , time, unordered-containers
     }:
     mkDerivation {
       pname = "servant-swagger";
       version = "1.0.3";
       sha256 = "ea1b3c7f33ae1c788ef33858c9c74849f450155c1bd81dcd472a36389aa17597";
       libraryHaskellDepends = [
         aeson base bytestring hspec http-media lens QuickCheck servant
         swagger2 text unordered-containers
       ];
       testHaskellDepends = [
         aeson aeson-qq base doctest Glob hspec lens QuickCheck servant
         swagger2 text time
       ];
       homepage = "https://github.com/haskell-servant/servant-swagger";
       description = "Generate Swagger specification for your servant API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "servant-yaml" = callPackage
    ({ mkDerivation, aeson, base, base-compat, bytestring, http-media
     , servant, servant-server, wai, warp, yaml
     }:
     mkDerivation {
       pname = "servant-yaml";
       version = "0.1.0.0";
       sha256 = "c917d9b046b06a9c4386f743a78142c27cf7f0ec1ad8562770ab9828f2ee3204";
       revision = "2";
       editedCabalFile = "3ef09bca6255336c4a1dfd58b27a0d24957ea31e42d51d3b9334790518818ed0";
       libraryHaskellDepends = [
         base bytestring http-media servant yaml
       ];
       testHaskellDepends = [
         aeson base base-compat bytestring http-media servant servant-server
         wai warp yaml
       ];
       homepage = "https://github.com/phadej/servant-yaml#readme";
       description = "Servant support for yaml";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "serversession" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , containers, data-default, hashable, hspec, nonce, path-pieces
     , QuickCheck, text, time, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "serversession";
       version = "1.0.1";
       sha256 = "3ffbefd87017e8d46fbbe380f59e24672aa9c06b999da5f9ae0b052094d94822";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring data-default hashable nonce
         path-pieces text time transformers unordered-containers
       ];
       testHaskellDepends = [
         aeson base base64-bytestring bytestring containers data-default
         hspec nonce path-pieces QuickCheck text time transformers
         unordered-containers
       ];
       homepage = "https://github.com/yesodweb/serversession";
       description = "Secure, modular server-side sessions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "serversession-backend-acid-state_1_0_1" = callPackage
    ({ mkDerivation, acid-state, base, containers, hspec, mtl, safecopy
     , serversession, unordered-containers
     }:
     mkDerivation {
       pname = "serversession-backend-acid-state";
       version = "1.0.1";
       sha256 = "470d11dc0d4a445babe240698ef4b6abc3fd48ab832ff52907ad5f81fcdd85c1";
       libraryHaskellDepends = [
         acid-state base containers mtl safecopy serversession
         unordered-containers
       ];
       testHaskellDepends = [
         acid-state base containers hspec mtl safecopy serversession
         unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/yesodweb/serversession";
       description = "Storage backend for serversession using acid-state";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "serversession-backend-acid-state_1_0_2" = callPackage
    ({ mkDerivation, acid-state, base, containers, hspec, mtl, safecopy
     , serversession, unordered-containers
     }:
     mkDerivation {
       pname = "serversession-backend-acid-state";
       version = "1.0.2";
       sha256 = "3495c43b0ba669ee623a8b5365d7df1388f4f0326bb0999c5aff4310bcbcf026";
       libraryHaskellDepends = [
         acid-state base containers mtl safecopy serversession
         unordered-containers
       ];
       testHaskellDepends = [
         acid-state base containers hspec mtl safecopy serversession
         unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/yesodweb/serversession";
       description = "Storage backend for serversession using acid-state";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "serversession-backend-acid-state" = callPackage
    ({ mkDerivation, acid-state, base, containers, hspec, mtl, safecopy
     , serversession, unordered-containers
     }:
     mkDerivation {
       pname = "serversession-backend-acid-state";
       version = "1.0.3";
       sha256 = "005317d6b31500738979d5affc858c5d2642dc86122b360c28a0737aac2a7ce6";
       libraryHaskellDepends = [
         acid-state base containers mtl safecopy serversession
         unordered-containers
       ];
       testHaskellDepends = [
         acid-state base containers hspec mtl safecopy serversession
         unordered-containers
       ];
       homepage = "https://github.com/yesodweb/serversession";
       description = "Storage backend for serversession using acid-state";
       license = stdenv.lib.licenses.mit;
     }) {};

  "serversession-backend-persistent_1_0_1" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring, cereal
     , hspec, monad-logger, path-pieces, persistent
     , persistent-postgresql, persistent-sqlite, persistent-template
     , QuickCheck, resource-pool, serversession, tagged, text, time
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "serversession-backend-persistent";
       version = "1.0.1";
       sha256 = "530890ab3aa6c59fb3894e7186a6a98eed1acc65cd60ba88cae1d1ef1e149458";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring cereal path-pieces
         persistent serversession tagged text time transformers
         unordered-containers
       ];
       testHaskellDepends = [
         aeson base base64-bytestring bytestring cereal hspec monad-logger
         path-pieces persistent persistent-postgresql persistent-sqlite
         persistent-template QuickCheck resource-pool serversession text
         time transformers unordered-containers
       ];
       homepage = "https://github.com/yesodweb/serversession";
       description = "Storage backend for serversession using persistent and an RDBMS";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "serversession-backend-persistent" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring, cereal
     , hspec, monad-logger, path-pieces, persistent
     , persistent-postgresql, persistent-sqlite, persistent-template
     , QuickCheck, resource-pool, serversession, tagged, text, time
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "serversession-backend-persistent";
       version = "1.0.2";
       sha256 = "19dfb2c55d64168e3fa2ceb6476ac55c67e69a750e0a39b400d9b3b0fbd3be4b";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring cereal path-pieces
         persistent serversession tagged text time transformers
         unordered-containers
       ];
       testHaskellDepends = [
         aeson base base64-bytestring bytestring cereal hspec monad-logger
         path-pieces persistent persistent-postgresql persistent-sqlite
         persistent-template QuickCheck resource-pool serversession text
         time transformers unordered-containers
       ];
       homepage = "https://github.com/yesodweb/serversession";
       description = "Storage backend for serversession using persistent and an RDBMS";
       license = stdenv.lib.licenses.mit;
     }) {};

  "serversession-backend-redis_1_0" = callPackage
    ({ mkDerivation, base, bytestring, hedis, hspec, path-pieces
     , serversession, tagged, text, time, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "serversession-backend-redis";
       version = "1.0";
       sha256 = "42da6e2519a4c8fd3f9b134cdf08771855ca8f639a37a6f5251a20fe8bc83f64";
       libraryHaskellDepends = [
         base bytestring hedis path-pieces serversession tagged text time
         transformers unordered-containers
       ];
       testHaskellDepends = [
         base bytestring hedis hspec path-pieces serversession text time
         transformers unordered-containers
       ];
       doCheck = false;
       homepage = "https://github.com/yesodweb/serversession";
       description = "Storage backend for serversession using Redis";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "serversession-backend-redis" = callPackage
    ({ mkDerivation, base, bytestring, hedis, hspec, path-pieces
     , serversession, tagged, text, time, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "serversession-backend-redis";
       version = "1.0.1";
       sha256 = "b4b30860fa2e431fd7101b3fb5541e7a687bce71886ca164564c35fbf104af4f";
       libraryHaskellDepends = [
         base bytestring hedis path-pieces serversession tagged text time
         transformers unordered-containers
       ];
       testHaskellDepends = [
         base bytestring hedis hspec path-pieces serversession text time
         transformers unordered-containers
       ];
       doCheck = false;
       homepage = "https://github.com/yesodweb/serversession";
       description = "Storage backend for serversession using Redis";
       license = stdenv.lib.licenses.mit;
     }) {};

  "serversession-frontend-snap" = callPackage
    ({ mkDerivation, base, bytestring, nonce, path-pieces
     , serversession, snap, snap-core, text, time, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "serversession-frontend-snap";
       version = "1.0";
       sha256 = "91719ff595a845f26a670c4f41c9a1d405d78ee4f213e666fa2e98ede46049d8";
       libraryHaskellDepends = [
         base bytestring nonce path-pieces serversession snap snap-core text
         time transformers unordered-containers
       ];
       homepage = "https://github.com/yesodweb/serversession";
       description = "Snap bindings for serversession";
       license = stdenv.lib.licenses.mit;
     }) {};

  "serversession-frontend-wai" = callPackage
    ({ mkDerivation, base, bytestring, cookie, data-default
     , path-pieces, serversession, text, time, transformers
     , unordered-containers, vault, wai, wai-session
     }:
     mkDerivation {
       pname = "serversession-frontend-wai";
       version = "1.0";
       sha256 = "0b48130e3d3915dc46ec2392984e7862d066f6ddd454127a98b0c21c2574b167";
       libraryHaskellDepends = [
         base bytestring cookie data-default path-pieces serversession text
         time transformers unordered-containers vault wai wai-session
       ];
       homepage = "https://github.com/yesodweb/serversession";
       description = "wai-session bindings for serversession";
       license = stdenv.lib.licenses.mit;
     }) {};

  "serversession-frontend-yesod" = callPackage
    ({ mkDerivation, base, bytestring, containers, cookie, data-default
     , path-pieces, serversession, text, time, transformers
     , unordered-containers, wai, yesod-core
     }:
     mkDerivation {
       pname = "serversession-frontend-yesod";
       version = "1.0";
       sha256 = "063946df7bf693e26973f81dd72b3586115dfac6b358421e4a7ada48e47c6753";
       libraryHaskellDepends = [
         base bytestring containers cookie data-default path-pieces
         serversession text time transformers unordered-containers wai
         yesod-core
       ];
       homepage = "https://github.com/yesodweb/serversession";
       description = "Yesod bindings for serversession";
       license = stdenv.lib.licenses.mit;
     }) {};

  "servius" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, bytestring
     , http-types, markdown, shakespeare, text, wai, wai-app-static
     }:
     mkDerivation {
       pname = "servius";
       version = "1.2.0.1";
       sha256 = "3839d725b5b01be2baf46bb93a5c3090494a43aefa09e2a300a7e96b826f9a01";
       revision = "2";
       editedCabalFile = "9f2fe5d7ad9f90e4314675f47634a41ba37a14746c0b72d576323d672f1ca580";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-builder blaze-html bytestring http-types markdown
         shakespeare text wai wai-app-static
       ];
       homepage = "http://github.com/snoyberg/servius#readme";
       description = "Warp web server with template rendering";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ses-html" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-html, byteable
     , bytestring, cryptohash, HsOpenSSL, http-streams, tagsoup, time
     }:
     mkDerivation {
       pname = "ses-html";
       version = "0.3.0.1";
       sha256 = "07ce0cc9777d9fac050cb2546de72c56625a47769a046e49b9d11f74c9c8bccf";
       libraryHaskellDepends = [
         base base64-bytestring blaze-html byteable bytestring cryptohash
         HsOpenSSL http-streams tagsoup time
       ];
       description = "Send HTML formatted emails using Amazon's SES REST API with blaze";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ses-html-snaplet" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, configurator
     , ses-html, snap, text, transformers
     }:
     mkDerivation {
       pname = "ses-html-snaplet";
       version = "0.1.0.0";
       sha256 = "231df3f3b903f63be94f6e4a02a9eb5f8dd28e49fd2c9ff6f7b29df9821839d3";
       libraryHaskellDepends = [
         base blaze-html bytestring configurator ses-html snap text
         transformers
       ];
       jailbreak = true;
       description = "Snaplet for the ses-html package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sessions" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, mtl, network
     }:
     mkDerivation {
       pname = "sessions";
       version = "2008.7.18";
       sha256 = "5adca740a72355a5e38a168fba9cf607f91e5e6b6a5bb44401d00d39d572327e";
       libraryHaskellDepends = [
         base binary bytestring containers mtl network
       ];
       homepage = "http://www.wellquite.org/sessions/";
       description = "Session Types for Haskell";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "set-cover" = callPackage
    ({ mkDerivation, base, containers, enummapset, psqueues, utility-ht
     }:
     mkDerivation {
       pname = "set-cover";
       version = "0.0.8";
       sha256 = "186d3a1b6e824e3bd1d479347d8310dba9f1cba98e90bc03d885c42558ea95d1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers enummapset psqueues utility-ht
       ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/thielema/set-cover/";
       description = "Solve exact set cover problems like Sudoku, 8 Queens, Soma Cube, Tetris Cube";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "set-extra" = callPackage
    ({ mkDerivation, base, containers, mtl, syb }:
     mkDerivation {
       pname = "set-extra";
       version = "1.3.2";
       sha256 = "f7842446f8961a29de96fa14423d8e23978cfef3db6ec0324358536d6bf8dd53";
       libraryHaskellDepends = [ base containers mtl syb ];
       homepage = "https://github.com/ddssff/set-extra";
       description = "Functions that could be added to Data.Set.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "set-monad" = callPackage
    ({ mkDerivation, base, containers, deepseq }:
     mkDerivation {
       pname = "set-monad";
       version = "0.2.0.0";
       sha256 = "eb2b4312c4a71024ea1c85683065c1052b0065b7d96df68cd1c4390c1ab2afdb";
       libraryHaskellDepends = [ base containers deepseq ];
       description = "Set monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "set-with" = callPackage
    ({ mkDerivation, base, containers, invariant, QuickCheck
     , quickcheck-instances, tasty, tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "set-with";
       version = "0.0.1";
       sha256 = "04026d13255315973acacda95c65950378670f1b3cbe0effc02b4a381f216c56";
       libraryHaskellDepends = [ base containers invariant ];
       testHaskellDepends = [
         base QuickCheck quickcheck-instances tasty tasty-hunit
         tasty-quickcheck
       ];
       description = "Set of elements sorted by a different data type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "setdown" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, cmdargs, containers
     , directory, filepath, happy, mtl, split, text, uuid
     }:
     mkDerivation {
       pname = "setdown";
       version = "0.1.0.1";
       sha256 = "afe89e857793e3189b1fde9372a33fb3edff9c1c82ccc5d2a8b67a74c3620780";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring cmdargs containers directory filepath mtl
         split text uuid
       ];
       executableToolDepends = [ alex happy ];
       jailbreak = true;
       homepage = "http://bitbucket.org/robertmassaioli/setdown";
       description = "Treating files as sets to perform rapid set manipulation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "setenv_0_1_1_1" = callPackage
    ({ mkDerivation, base, process, unix }:
     mkDerivation {
       pname = "setenv";
       version = "0.1.1.1";
       sha256 = "230d87b0d04b2b05460ddf5a31569250ee1c3df6f91762733a29c434b7def32b";
       libraryHaskellDepends = [ base unix ];
       testHaskellDepends = [ base process ];
       doHaddock = false;
       doCheck = false;
       description = "A cross-platform library for setting environment variables";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "setenv" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "setenv";
       version = "0.1.1.3";
       sha256 = "e358df39afc03d5a39e2ec650652d845c85c80cc98fe331654deafb4767ecb32";
       revision = "1";
       editedCabalFile = "c5916ac0d2a828473cd171261328a290afe0abd799db1ac8c310682fe778c45b";
       libraryHaskellDepends = [ base unix ];
       doCheck = false;
       description = "A cross-platform library for setting environment variables";
       license = stdenv.lib.licenses.mit;
     }) {};

  "setgame" = callPackage
    ({ mkDerivation, base, random, vty }:
     mkDerivation {
       pname = "setgame";
       version = "1.1";
       sha256 = "34b0c18e84023bc1785a18386663be136ac3d02f901cf8106942d4d3c89a22c3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base random vty ];
       executableHaskellDepends = [ base ];
       description = "A console interface to the game of Set";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "setlocale" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "setlocale";
       version = "1.0.0.3";
       sha256 = "4d638b5906ed83eb9a0a4d97aaca832b8a73ce94efdb8a2b2b1329e6d738c19e";
       revision = "1";
       editedCabalFile = "9180b0e49613d699ec136db7db2befdb5874dc7df32393cc6196be03a7fa34f4";
       libraryHaskellDepends = [ base ];
       homepage = "https://bitbucket.org/IchUndNichtDu/haskell-setlocale";
       description = "Haskell bindings to setlocale";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "setops" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "setops";
       version = "0.1.2";
       sha256 = "6f5fa7821041e6274153d258a087d1d9e839d05e180531ca74f9a6872e224ad6";
       libraryHaskellDepends = [ base containers ];
       description = "Uniform names (and Unicode operators) for set operations on data structures";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "sets" = callPackage
    ({ mkDerivation, base, commutative, composition, containers
     , contravariant, hashable, invariant, keys, mtl, QuickCheck
     , quickcheck-instances, semigroupoids, semigroups, tasty
     , tasty-hunit, tasty-quickcheck, transformers, transformers-base
     , unordered-containers, witherable
     }:
     mkDerivation {
       pname = "sets";
       version = "0.0.5";
       sha256 = "78772618d3a85cbf91a20f0289eb833c4304d6a93c78bb266c38b60e85d2717b";
       revision = "1";
       editedCabalFile = "6a3f99b425c6a4ed373e1f1d2836a40b09e462f4e2744b76227f27a133acb34e";
       libraryHaskellDepends = [
         base commutative composition containers contravariant hashable
         invariant keys mtl QuickCheck semigroupoids semigroups transformers
         transformers-base unordered-containers witherable
       ];
       testHaskellDepends = [
         base commutative composition containers contravariant hashable
         invariant keys mtl QuickCheck quickcheck-instances semigroupoids
         semigroups tasty tasty-hunit tasty-quickcheck transformers
         transformers-base unordered-containers witherable
       ];
       description = "Various set implementations in Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "setters" = callPackage
    ({ mkDerivation, base, mtl, template-haskell }:
     mkDerivation {
       pname = "setters";
       version = "0.1";
       sha256 = "5f2820de0e25847ace980132c04913c7ec61333e2b20cce49e2062765caa8967";
       libraryHaskellDepends = [ base mtl template-haskell ];
       description = "Small (TH) library to declare setters for typical `record' data type fields";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "settings" = callPackage
    ({ mkDerivation, base, text, unordered-containers }:
     mkDerivation {
       pname = "settings";
       version = "0.3.0.0";
       sha256 = "48e36d5337bcfe077acd4db4d1a2c03b15f0423cf02731a87c4cc494b2c8cbc2";
       libraryHaskellDepends = [ base text unordered-containers ];
       homepage = "http://rel4tion.org/projects/settings/";
       description = "Runtime-editable program settings";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "sexp" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, cmdargs, containers
     , dlist, ghc-prim, HUnit, mtl, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "sexp";
       version = "0.7";
       sha256 = "568cc9f7256e9235906322600976be22d6803baef4ff42bad7a9eaf5ad9974a5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring containers dlist ghc-prim mtl vector
       ];
       executableHaskellDepends = [ base bytestring cmdargs ];
       testHaskellDepends = [
         base bytestring containers HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/scvalex/sexp";
       description = "S-Expression parsing/printing made fun and easy";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sexp-grammar" = callPackage
    ({ mkDerivation, array, base, containers, mtl, QuickCheck
     , scientific, semigroups, split, stack-prism, tasty, tasty-hunit
     , tasty-quickcheck, template-haskell, text, wl-pprint-text
     }:
     mkDerivation {
       pname = "sexp-grammar";
       version = "1.1.1";
       sha256 = "4737183b0201c27d4c0824418644abff466bdfe653c411cb8da8c53899d6dbd6";
       libraryHaskellDepends = [
         array base containers mtl scientific semigroups split stack-prism
         template-haskell text wl-pprint-text
       ];
       testHaskellDepends = [
         base QuickCheck scientific semigroups stack-prism tasty tasty-hunit
         tasty-quickcheck
       ];
       homepage = "https://github.com/esmolanka/sexp-grammar";
       description = "Invertible parsers for S-expressions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sexp-show" = callPackage
    ({ mkDerivation, base, pretty-show }:
     mkDerivation {
       pname = "sexp-show";
       version = "0.1.1.0";
       sha256 = "c53f5242eb1146d0005b4754c927159705044692286018c78aa6892f7cf0e1c6";
       revision = "1";
       editedCabalFile = "314f05a4542c657517d485faa31ec23324458782cf0112acda948fb7092a154c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base pretty-show ];
       description = "Produce a s-expression representation of Show values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sexpr" = callPackage
    ({ mkDerivation, base, base64-string, binary, bytestring, pretty
     , QuickCheck, random
     }:
     mkDerivation {
       pname = "sexpr";
       version = "0.2.1";
       sha256 = "7724dc079ba390c8302079483ddf5f12bb425c2461133f94be71fe62402edab9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-string binary bytestring pretty
       ];
       executableHaskellDepends = [ QuickCheck random ];
       description = "S-expression printer and parser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sext" = callPackage
    ({ mkDerivation, base, bytestring, template-haskell, text }:
     mkDerivation {
       pname = "sext";
       version = "0.1.0.2";
       sha256 = "b5101154373eac70dee9d56854333ea33735a88b7697f2877846c746dd048c3a";
       libraryHaskellDepends = [ base bytestring template-haskell text ];
       homepage = "http://github.com/dzhus/sext/";
       description = "Lists, Texts and ByteStrings with type-encoded length";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sfml-audio" = callPackage
    ({ mkDerivation, base, bytestring, libsndfile, openal }:
     mkDerivation {
       pname = "sfml-audio";
       version = "0.7.1.1816";
       sha256 = "6a85a127e21de533ba64be40b73535fb826d045f3d4e3007b941d3d5c507ff14";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ libsndfile openal ];
       homepage = "http://patch-tag.com/r/shahn/sfml-audio";
       description = "minimal bindings to the audio module of sfml";
       license = "unknown";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) libsndfile; inherit (pkgs) openal;};

  "sfmt" = callPackage
    ({ mkDerivation, base, bytestring, entropy, primitive }:
     mkDerivation {
       pname = "sfmt";
       version = "0.1.1";
       sha256 = "e6862db41ac95e52e9110d666683f5c931b6175c86fc500aaf74cf39c8d49fcb";
       libraryHaskellDepends = [ base bytestring entropy primitive ];
       homepage = "https://github.com/philopon/sfmt-hs";
       description = "SIMD-oriented Fast Mersenne Twister(SFMT) binding";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sgd" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , filepath, lazy-io, logfloat, monad-par, mtl, primitive, random
     , temporary, vector
     }:
     mkDerivation {
       pname = "sgd";
       version = "0.3.7";
       sha256 = "04e032eff0677cfa8b69a39ee502d48c9a1941324b66c754cf5e8bb96a409cfc";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq filepath lazy-io logfloat
         monad-par mtl primitive random temporary vector
       ];
       jailbreak = true;
       homepage = "https://github.com/kawu/sgd";
       description = "Stochastic gradient descent";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sgf" = callPackage
    ({ mkDerivation, base, containers, encoding, extensible-exceptions
     , mtl, parsec, split, time, transformers
     }:
     mkDerivation {
       pname = "sgf";
       version = "0.1.3.1";
       sha256 = "8cc7b71d1f58df2d50e184846cc17247a242eff6262440111691cfb916bc8eaf";
       libraryHaskellDepends = [
         base containers encoding extensible-exceptions mtl parsec split
         time transformers
       ];
       homepage = "https://github.com/tonicebrian/sgf";
       description = "SGF (Smart Game Format) parser";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sgrep" = callPackage
    ({ mkDerivation, base, bio, regex-compat }:
     mkDerivation {
       pname = "sgrep";
       version = "0.0";
       sha256 = "f1f966cee314c875b0c8313bfa98aee281a2c52b7152de2365b4485ec691292a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bio regex-compat ];
       homepage = "http://blog.malde.org/";
       description = "Sgrep - grep Fasta files for sequences matching a regular expression";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sha-streams" = callPackage
    ({ mkDerivation, base, binary, bytestring, io-streams, SHA }:
     mkDerivation {
       pname = "sha-streams";
       version = "0.2.1";
       sha256 = "920bb61aed58612510d27c6bbe8ca21444717c13f7b2e658f3c545f32cf09370";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base binary bytestring io-streams SHA ];
       executableHaskellDepends = [ base io-streams SHA ];
       homepage = "https://github.com/noteed/sha-streams";
       description = "SHA hashes for io-streams";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shadower" = callPackage
    ({ mkDerivation, base, doctest, filemanip, fsnotify, MissingH, mtl
     , process, safe, system-filepath, text
     }:
     mkDerivation {
       pname = "shadower";
       version = "0.1.0.6";
       sha256 = "d1ba84b536cbb6e147a10c28b6b47350f7338bbc98d02295956614dbabed1fd4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base doctest filemanip fsnotify MissingH mtl process safe
         system-filepath text
       ];
       testHaskellDepends = [
         base doctest filemanip fsnotify MissingH mtl process safe
         system-filepath text
       ];
       homepage = "http://github.com/karun012/shadower";
       description = "An automated way to run doctests in files that are changing";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shadowsocks" = callPackage
    ({ mkDerivation, aeson, async, base, binary, bytestring
     , conduit-combinators, conduit-extra, containers, cryptohash
     , HsOpenSSL, HUnit, iproute, network, optparse-applicative, process
     , streaming-commons, unordered-containers
     }:
     mkDerivation {
       pname = "shadowsocks";
       version = "1.20151028";
       sha256 = "b75248cba2eee03c168a8188eb6cd92015912b167f99953c58d6d3f91f85837c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson async base binary bytestring conduit-combinators
         conduit-extra containers cryptohash HsOpenSSL iproute network
         optparse-applicative streaming-commons unordered-containers
       ];
       testHaskellDepends = [
         base binary bytestring containers cryptohash HUnit process
       ];
       homepage = "https://github.com/rnons/shadowsocks-haskell";
       description = "A fast SOCKS5 proxy that help you get through firewalls";
       license = stdenv.lib.licenses.mit;
     }) {};

  "shady-gen" = callPackage
    ({ mkDerivation, applicative-numbers, base, Boolean, containers
     , data-treify, MemoTrie, mtl, ty, TypeCompose, vector-space
     , wl-pprint
     }:
     mkDerivation {
       pname = "shady-gen";
       version = "0.5.1";
       sha256 = "c8ba385e3d8362862961b0883d08f2c1aa0e009149b56e62b18f3d6ba00253ef";
       libraryHaskellDepends = [
         applicative-numbers base Boolean containers data-treify MemoTrie
         mtl ty TypeCompose vector-space wl-pprint
       ];
       homepage = "http://haskell.org/haskellwiki/shady";
       description = "Functional GPU programming - DSEL & compiler";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shady-graphics" = callPackage
    ({ mkDerivation, applicative-numbers, base, Boolean, containers
     , data-treify, MemoTrie, mtl, shady-gen, ty, TypeCompose
     , vector-space, wl-pprint
     }:
     mkDerivation {
       pname = "shady-graphics";
       version = "0.5.0";
       sha256 = "64363978a67b76886f7f053cd07ef25c97e3c4ae1e41ec6524da3b79ebf3f4f3";
       libraryHaskellDepends = [
         applicative-numbers base Boolean containers data-treify MemoTrie
         mtl shady-gen ty TypeCompose vector-space wl-pprint
       ];
       homepage = "http://haskell.org/haskellwiki/shady";
       description = "Functional GPU programming - DSEL & compiler";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shake_0_14_2" = callPackage
    ({ mkDerivation, base, binary, bytestring, deepseq, directory
     , extra, filepath, hashable, js-flot, js-jquery, old-time, process
     , QuickCheck, random, time, transformers, unix
     , unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "shake";
       version = "0.14.2";
       sha256 = "551ced177d3e00e6dbb183db8bca75f1217ffc123f6de76478ea193eedce6471";
       revision = "1";
       editedCabalFile = "95a4831294d1b631faa73f2adb7e92f36b3872ca309dd7a75441c5b39fb62eec";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process random time transformers unix
         unordered-containers utf8-string
       ];
       executableHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process random time transformers unix
         unordered-containers utf8-string
       ];
       testHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process QuickCheck random time
         transformers unix unordered-containers utf8-string
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.shakebuild.com/";
       description = "Build system library, like Make, but more accurate dependencies";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shake_0_14_3" = callPackage
    ({ mkDerivation, base, binary, bytestring, deepseq, directory
     , extra, filepath, hashable, js-flot, js-jquery, old-time, process
     , QuickCheck, random, time, transformers, unix
     , unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "shake";
       version = "0.14.3";
       sha256 = "74a362a2561d815c08e19518a76f4835bf676bf2a0ed206cb3fb8e5980a8bde8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process random time transformers unix
         unordered-containers utf8-string
       ];
       executableHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process random time transformers unix
         unordered-containers utf8-string
       ];
       testHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process QuickCheck random time
         transformers unix unordered-containers utf8-string
       ];
       doCheck = false;
       homepage = "http://www.shakebuild.com/";
       description = "Build system library, like Make, but more accurate dependencies";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shake_0_15" = callPackage
    ({ mkDerivation, base, binary, bytestring, deepseq, directory
     , extra, filepath, hashable, js-flot, js-jquery, old-time, process
     , QuickCheck, random, time, transformers, unix
     , unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "shake";
       version = "0.15";
       sha256 = "1376b82cce3fdc977e9affe72fb01888173d0fcf465a10a0357b3b44449df80b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process random time transformers unix
         unordered-containers utf8-string
       ];
       executableHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process random time transformers unix
         unordered-containers utf8-string
       ];
       testHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process QuickCheck random time
         transformers unix unordered-containers utf8-string
       ];
       doCheck = false;
       homepage = "http://www.shakebuild.com/";
       description = "Build system library, like Make, but more accurate dependencies";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shake_0_15_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, deepseq, directory
     , extra, filepath, hashable, js-flot, js-jquery, old-time, process
     , QuickCheck, random, time, transformers, unix
     , unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "shake";
       version = "0.15.1";
       sha256 = "c9d7708d4b6b4b6cb35b7aaf9e6e4bc2c220f8d9864bb4799b0b5b46d915bd2d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process random time transformers unix
         unordered-containers utf8-string
       ];
       executableHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process random time transformers unix
         unordered-containers utf8-string
       ];
       testHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process QuickCheck random time
         transformers unix unordered-containers utf8-string
       ];
       doCheck = false;
       homepage = "http://shakebuild.com";
       description = "Build system library, like Make, but more accurate dependencies";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shake_0_15_2" = callPackage
    ({ mkDerivation, base, binary, bytestring, deepseq, directory
     , extra, filepath, hashable, js-flot, js-jquery, old-time, process
     , QuickCheck, random, time, transformers, unix
     , unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "shake";
       version = "0.15.2";
       sha256 = "ae65f65d898d075833535ea83ca4a2f8b69e145b2998a7807144c9ca74755bee";
       revision = "1";
       editedCabalFile = "06a507e0523ae0f9c2b9a663732b9f0a758c584d51027692fb9dbd305b70d936";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process random time transformers unix
         unordered-containers utf8-string
       ];
       executableHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process random time transformers unix
         unordered-containers utf8-string
       ];
       testHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process QuickCheck random time
         transformers unix unordered-containers utf8-string
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://shakebuild.com";
       description = "Build system library, like Make, but more accurate dependencies";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shake" = callPackage
    ({ mkDerivation, base, binary, bytestring, deepseq, directory
     , extra, filepath, hashable, js-flot, js-jquery, old-time, process
     , QuickCheck, random, time, transformers, unix
     , unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "shake";
       version = "0.15.5";
       sha256 = "2c806824c9e8a619f364c3ec6bb910d7b1d0b0d3ba39ab472bffb60311f373a3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process random time transformers unix
         unordered-containers utf8-string
       ];
       executableHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process random time transformers unix
         unordered-containers utf8-string
       ];
       testHaskellDepends = [
         base binary bytestring deepseq directory extra filepath hashable
         js-flot js-jquery old-time process QuickCheck random time
         transformers unix unordered-containers utf8-string
       ];
       doCheck = false;
       homepage = "http://shakebuild.com";
       description = "Build system library, like Make, but more accurate dependencies";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shake-cabal-build" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, process }:
     mkDerivation {
       pname = "shake-cabal-build";
       version = "0.1.0";
       sha256 = "14d951d872735dde4abf2a25579032d971182d00aa8989d9aa4e0b474ce082e2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal directory filepath process
       ];
       jailbreak = true;
       homepage = "https://github.com/samplecount/shake-cabal-build";
       description = "Utility for building Shake build systems using Cabal sandboxes";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "shake-extras" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, directory, filepath
     , shake
     }:
     mkDerivation {
       pname = "shake-extras";
       version = "0.1.1";
       sha256 = "9fae9507f8dbafcec5a4913210ceb612ad3324d941924e4f8f10226c1a6c1f63";
       libraryHaskellDepends = [
         base bytestring cmdargs directory filepath shake
       ];
       jailbreak = true;
       homepage = "http://thoughtpolice.github.com/shake-extras";
       description = "Extra utilities for shake build systems";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shake-language-c_0_6_3" = callPackage
    ({ mkDerivation, base, data-default-class, directory, doctest
     , fclabels, hspec, process, shake, split, unordered-containers
     }:
     mkDerivation {
       pname = "shake-language-c";
       version = "0.6.3";
       sha256 = "5543513e649a2b170e1e23730eeb5cbff28f5fc7aed1c5d8865a4ede3c98449f";
       libraryHaskellDepends = [
         base data-default-class fclabels process shake split
         unordered-containers
       ];
       testHaskellDepends = [ base directory doctest hspec shake ];
       doCheck = false;
       homepage = "https://github.com/samplecount/shake-language-c";
       description = "Utilities for cross-compiling with Shake";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shake-language-c_0_6_4" = callPackage
    ({ mkDerivation, base, data-default-class, directory, doctest
     , fclabels, hspec, process, shake, split, unordered-containers
     }:
     mkDerivation {
       pname = "shake-language-c";
       version = "0.6.4";
       sha256 = "df0735bb3e72bc289c5105981d8173133c2ac7e34747df10391b9dce6448c4f2";
       libraryHaskellDepends = [
         base data-default-class fclabels process shake split
         unordered-containers
       ];
       testHaskellDepends = [ base directory doctest hspec shake ];
       doCheck = false;
       homepage = "https://github.com/samplecount/shake-language-c";
       description = "Utilities for cross-compiling with Shake";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shake-language-c_0_8_0" = callPackage
    ({ mkDerivation, base, data-default-class, directory, doctest
     , fclabels, hspec, process, shake, split, unordered-containers
     }:
     mkDerivation {
       pname = "shake-language-c";
       version = "0.8.0";
       sha256 = "65d408c47b622ef0cce3f1c17faa0ab67457a1268941db0ce83ebe7c5988feac";
       libraryHaskellDepends = [
         base data-default-class fclabels process shake split
         unordered-containers
       ];
       testHaskellDepends = [ base directory doctest hspec shake ];
       doCheck = false;
       homepage = "https://github.com/samplecount/shake-language-c";
       description = "Utilities for cross-compiling with Shake";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shake-language-c_0_8_1" = callPackage
    ({ mkDerivation, base, data-default-class, directory, doctest
     , fclabels, hspec, process, shake, split, unordered-containers
     }:
     mkDerivation {
       pname = "shake-language-c";
       version = "0.8.1";
       sha256 = "707631799b102d375610a4b5bff567c8ad5b62e36616d162bac1ca8617915073";
       libraryHaskellDepends = [
         base data-default-class fclabels process shake split
         unordered-containers
       ];
       testHaskellDepends = [ base directory doctest hspec shake ];
       doCheck = false;
       homepage = "https://github.com/samplecount/shake-language-c";
       description = "Utilities for cross-compiling with Shake";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shake-language-c_0_8_3" = callPackage
    ({ mkDerivation, base, data-default-class, directory, doctest
     , fclabels, hspec, process, shake, split, unordered-containers
     }:
     mkDerivation {
       pname = "shake-language-c";
       version = "0.8.3";
       sha256 = "b5257f49823fa1553b40242a95e0235f8505562215381e170d3c0e36a7a5be28";
       libraryHaskellDepends = [
         base data-default-class fclabels process shake split
         unordered-containers
       ];
       testHaskellDepends = [ base directory doctest hspec shake ];
       doCheck = false;
       homepage = "https://github.com/samplecount/shake-language-c";
       description = "Utilities for cross-compiling with Shake";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shake-language-c" = callPackage
    ({ mkDerivation, base, data-default-class, directory, doctest
     , fclabels, hspec, process, shake, split, unordered-containers
     }:
     mkDerivation {
       pname = "shake-language-c";
       version = "0.8.4";
       sha256 = "c2cb7de12f645b63d3990579a493a4f81bb4b676f05f5436f5ea43318feab3ce";
       libraryHaskellDepends = [
         base data-default-class fclabels process shake split
         unordered-containers
       ];
       testHaskellDepends = [ base directory doctest hspec shake ];
       doCheck = false;
       homepage = "https://github.com/samplecount/shake-language-c";
       description = "Utilities for cross-compiling with Shake";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "shake-minify" = callPackage
    ({ mkDerivation, base, bytestring, css-text, hjsmin, shake, text }:
     mkDerivation {
       pname = "shake-minify";
       version = "0.1.4";
       sha256 = "398e175fc24de04c43a40a850417f3a435f17b9fafd366f480897623e5ef009f";
       libraryHaskellDepends = [
         base bytestring css-text hjsmin shake text
       ];
       homepage = "https://github.com/LukeHoersten/shake-minify";
       description = "Shake Minify Rules";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shake-pack" = callPackage
    ({ mkDerivation, base, bytestring, bzlib, shake, tar }:
     mkDerivation {
       pname = "shake-pack";
       version = "0.1.2";
       sha256 = "413dc10d9b141ba885b3067b2ab76aee7f2978a930e874885fa0baf3d8b1c247";
       libraryHaskellDepends = [ base bytestring bzlib shake tar ];
       jailbreak = true;
       homepage = "https://github.com/LukeHoersten/shake-pack";
       description = "Shake File Pack Rule";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shake-persist" = callPackage
    ({ mkDerivation, base, binary, directory, shake, template-haskell
     }:
     mkDerivation {
       pname = "shake-persist";
       version = "0.1.0.0";
       sha256 = "2404cd39d67a8bbd36afb3e658375faae1d6f54941a2de06abf85155ef87986a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary directory shake template-haskell
       ];
       executableHaskellDepends = [ base shake ];
       homepage = "https://anonscm.debian.org/cgit/users/kaction-guest/haskell-shake-persist.git";
       description = "Shake build system on-disk caching";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "shaker" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, containers, directory
     , filepath, ghc, ghc-paths, haskeline, haskell-src, HUnit, mtl
     , old-time, parsec3, QuickCheck, regex-posix, template-haskell
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "shaker";
       version = "0.5.1";
       sha256 = "0e725accd3f3b9ece747436b35d62ea6d3148fb5b027a6cb33af967cf73d8bd4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring Cabal containers directory filepath ghc ghc-paths
         haskeline haskell-src HUnit mtl old-time parsec3 QuickCheck
         regex-posix template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       executableHaskellDepends = [
         base bytestring Cabal containers directory filepath ghc ghc-paths
         haskeline haskell-src HUnit mtl old-time parsec3 QuickCheck
         regex-posix template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/bonnefoa/Shaker";
       description = "simple and interactive command-line build tool";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shakespeare_2_0_2_1" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , containers, directory, exceptions, ghc-prim, hspec, HUnit, parsec
     , process, system-fileio, system-filepath, template-haskell, text
     , time, transformers
     }:
     mkDerivation {
       pname = "shakespeare";
       version = "2.0.2.1";
       sha256 = "ea430c50871296a7a1b37af6023f6c5345a7063ece748701e5e339c626b5e3e8";
       revision = "1";
       editedCabalFile = "b1117f4070aef0dfa8af80b945eb166f9597af0795e9260bd2675d820e552692";
       libraryHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim parsec process system-fileio system-filepath
         template-haskell text time transformers
       ];
       testHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim hspec HUnit parsec process system-fileio
         system-filepath template-haskell text time transformers
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/shakespearean-templates";
       description = "A toolkit for making compile-time interpolated templates";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "shakespeare_2_0_2_2" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , containers, directory, exceptions, ghc-prim, hspec, HUnit, parsec
     , process, system-fileio, system-filepath, template-haskell, text
     , time, transformers
     }:
     mkDerivation {
       pname = "shakespeare";
       version = "2.0.2.2";
       sha256 = "c5a6416595ff5d4add5fc19bdae165b9387f97ddad2558821da7d4a0d2c58434";
       revision = "1";
       editedCabalFile = "36ca3ffa4453c8bc5c73d5db90859e8cd107d6c8cd6f5be1e1e40e4dedd4dbcf";
       libraryHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim parsec process system-fileio system-filepath
         template-haskell text time transformers
       ];
       testHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim hspec HUnit parsec process system-fileio
         system-filepath template-haskell text time transformers
       ];
       homepage = "http://www.yesodweb.com/book/shakespearean-templates";
       description = "A toolkit for making compile-time interpolated templates";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "shakespeare_2_0_3" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , containers, directory, exceptions, ghc-prim, hspec, HUnit, parsec
     , process, system-fileio, system-filepath, template-haskell, text
     , time, transformers
     }:
     mkDerivation {
       pname = "shakespeare";
       version = "2.0.3";
       sha256 = "148dcc05e3e126fb7bcb2b767475ef4e965f9dde0bc6433e52a3b0a09aea864d";
       revision = "1";
       editedCabalFile = "4b2d1c2a417f058287dc40c7920d3404edd51e6c35d9d72890c6c94815f829f2";
       libraryHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim parsec process system-fileio system-filepath
         template-haskell text time transformers
       ];
       testHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim hspec HUnit parsec process system-fileio
         system-filepath template-haskell text time transformers
       ];
       homepage = "http://www.yesodweb.com/book/shakespearean-templates";
       description = "A toolkit for making compile-time interpolated templates";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "shakespeare_2_0_4" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , containers, directory, exceptions, ghc-prim, hspec, HUnit, parsec
     , process, system-fileio, system-filepath, template-haskell, text
     , time, transformers
     }:
     mkDerivation {
       pname = "shakespeare";
       version = "2.0.4";
       sha256 = "cbb2dede1165cd0f81299e1a58b23c5b37389ac21b2796d5244c57fc468db7a8";
       revision = "1";
       editedCabalFile = "4f4118e0ff326cdc503e7efc841c1c768fbdbc473e62cde2fd05a8e75fcdb4a1";
       libraryHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim parsec process system-fileio system-filepath
         template-haskell text time transformers
       ];
       testHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim hspec HUnit parsec process system-fileio
         system-filepath template-haskell text time transformers
       ];
       homepage = "http://www.yesodweb.com/book/shakespearean-templates";
       description = "A toolkit for making compile-time interpolated templates";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "shakespeare_2_0_4_1" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , containers, directory, exceptions, ghc-prim, hspec, HUnit, parsec
     , process, system-fileio, system-filepath, template-haskell, text
     , time, transformers
     }:
     mkDerivation {
       pname = "shakespeare";
       version = "2.0.4.1";
       sha256 = "f1e3845a43616c26347c7120fa434e482ab108dbcec9123258d94e3947e06a7c";
       revision = "1";
       editedCabalFile = "662b1acf8c3adb1066044c3d89b5bc273d03e1321e7a3832aa222c2bbb63d4b9";
       libraryHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim parsec process system-fileio system-filepath
         template-haskell text time transformers
       ];
       testHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim hspec HUnit parsec process system-fileio
         system-filepath template-haskell text time transformers
       ];
       homepage = "http://www.yesodweb.com/book/shakespearean-templates";
       description = "A toolkit for making compile-time interpolated templates";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "shakespeare_2_0_5" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , containers, directory, exceptions, ghc-prim, hspec, HUnit, parsec
     , process, template-haskell, text, time, transformers
     }:
     mkDerivation {
       pname = "shakespeare";
       version = "2.0.5";
       sha256 = "f0ff00f9262f874512ce7624c45c0e9f6e90dd1c4bf9e81891f7e34f5faeb549";
       revision = "1";
       editedCabalFile = "c3cde3794b87e5f99500aac7199a66ad95985ba716170551fe40e82452a61ebc";
       libraryHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim parsec process template-haskell text time
         transformers
       ];
       testHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim hspec HUnit parsec process template-haskell
         text time transformers
       ];
       homepage = "http://www.yesodweb.com/book/shakespearean-templates";
       description = "A toolkit for making compile-time interpolated templates";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "shakespeare_2_0_6" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , containers, directory, exceptions, ghc-prim, hspec, HUnit, parsec
     , process, template-haskell, text, time, transformers
     }:
     mkDerivation {
       pname = "shakespeare";
       version = "2.0.6";
       sha256 = "5c0ae56bb5c06a3f9d86279c93b2e760e923cd476e7dbaaa556a1cdb78ff97ce";
       libraryHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim parsec process template-haskell text time
         transformers
       ];
       testHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim hspec HUnit parsec process template-haskell
         text time transformers
       ];
       homepage = "http://www.yesodweb.com/book/shakespearean-templates";
       description = "A toolkit for making compile-time interpolated templates";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "shakespeare" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , containers, directory, exceptions, ghc-prim, hspec, HUnit, parsec
     , process, scientific, template-haskell, text, time, transformers
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "shakespeare";
       version = "2.0.7";
       sha256 = "7a567d6effb68c7b39903fb1fccee54e6a1222a4746b5135da5623c406281668";
       revision = "1";
       editedCabalFile = "466ed38d1ca4b1fcc297793cfb3508c29b1ddb9714432c2f872ce7b656b1c57c";
       libraryHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim parsec process scientific template-haskell text
         time transformers unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring containers directory
         exceptions ghc-prim hspec HUnit parsec process template-haskell
         text time transformers
       ];
       homepage = "http://www.yesodweb.com/book/shakespearean-templates";
       description = "A toolkit for making compile-time interpolated templates";
       license = stdenv.lib.licenses.mit;
       maintainers = with stdenv.lib.maintainers; [ psibi ];
     }) {};

  "shakespeare-babel" = callPackage
    ({ mkDerivation, base, classy-prelude, data-default, directory
     , process, shakespeare, template-haskell
     }:
     mkDerivation {
       pname = "shakespeare-babel";
       version = "0.2.0.0";
       sha256 = "cf3f66f382407464059f7091d3a3c83c61ab32e0fcee9c6dd70d38623bce6bdf";
       libraryHaskellDepends = [
         base classy-prelude data-default directory process shakespeare
         template-haskell
       ];
       jailbreak = true;
       description = "compile es2015";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "shakespeare-css" = callPackage
    ({ mkDerivation, base, shakespeare }:
     mkDerivation {
       pname = "shakespeare-css";
       version = "1.1.0";
       sha256 = "9f7b42cf07d14c5cec63be0fcef58601b2aa0a3f32dcd4dc4d52019d5d9fa0a1";
       libraryHaskellDepends = [ base shakespeare ];
       doHaddock = false;
       homepage = "http://www.yesodweb.com/book/shakespearean-templates";
       description = "Stick your haskell variables into css at compile time. (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "shakespeare-i18n" = callPackage
    ({ mkDerivation, base, shakespeare }:
     mkDerivation {
       pname = "shakespeare-i18n";
       version = "1.1.0";
       sha256 = "4518987cf113b8c8a52f8043dcb60f70f2cad12d778dd181ed6da276727a102a";
       libraryHaskellDepends = [ base shakespeare ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://www.yesodweb.com/book/shakespearean-templates";
       description = "A type-based approach to internationalization. (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "shakespeare-js" = callPackage
    ({ mkDerivation, base, shakespeare }:
     mkDerivation {
       pname = "shakespeare-js";
       version = "1.3.0";
       sha256 = "e4ca4b7603781fcfc53b77db1a980f004ffdd69f176fc35fd696b8bf5f663042";
       libraryHaskellDepends = [ base shakespeare ];
       doHaddock = false;
       homepage = "http://www.yesodweb.com/book/shakespearean-templates";
       description = "Stick your haskell variables into javascript/coffeescript at compile time. (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "shakespeare-text" = callPackage
    ({ mkDerivation, base, shakespeare }:
     mkDerivation {
       pname = "shakespeare-text";
       version = "1.1.0";
       sha256 = "2c1b041116648d5b0a13e524e94024f5bd17e2649d2e9e3418c66295568f3da2";
       libraryHaskellDepends = [ base shakespeare ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://www.yesodweb.com/book/shakespearean-templates";
       description = "Interpolation with quasi-quotation: put variables strings (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "shana" = callPackage
    ({ mkDerivation, base, directory, regex-posix }:
     mkDerivation {
       pname = "shana";
       version = "2009.12.1";
       sha256 = "1eec7b29bae850e4b9eb97acf1e1e82515e2c26f7f29a7476b1764109735e139";
       libraryHaskellDepends = [ base directory regex-posix ];
       homepage = "http://github.com/nfjinjing/hack/tree/master";
       description = "treat haskell functions as unix pipes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shapefile" = callPackage
    ({ mkDerivation, base, binary, bytestring, data-binary-ieee754, dbf
     , filepath, rwlock
     }:
     mkDerivation {
       pname = "shapefile";
       version = "0.0.0.1";
       sha256 = "861b8690801627c30a7fc29d9265cde40cd4a69cdf9776c752c71cf96200cc48";
       libraryHaskellDepends = [
         base binary bytestring data-binary-ieee754 dbf filepath rwlock
       ];
       homepage = "http://code.haskell.org/~mokus/shapefile";
       description = "Parser and related tools for ESRI shapefile format";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "shapely-data" = callPackage
    ({ mkDerivation, base, containers, proxy-kindness, QuickCheck
     , tagged, template-haskell
     }:
     mkDerivation {
       pname = "shapely-data";
       version = "0.1";
       sha256 = "c8c60ff6a754d58cb3bf40daaf9e880bfa5ba2e687fcfb2c19481a4f6accc1fa";
       libraryHaskellDepends = [
         base proxy-kindness tagged template-haskell
       ];
       testHaskellDepends = [
         base containers proxy-kindness QuickCheck tagged template-haskell
       ];
       homepage = "http://github.com/jberryman/shapely-data";
       description = "Generics using @(,)@ and @Either@, with algebraic operations and typed conversions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sharc-timbre" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "sharc-timbre";
       version = "0.1";
       sha256 = "cbdedf5c24664d362be1b4a285c4c0021c17126e9a9562c17f23eb174249184d";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/anton-k/sharc";
       description = "Sandell Harmonic Archive. A collection of stable phases for all instruments in the orchestra.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shared-buffer" = callPackage
    ({ mkDerivation, base, bytestring, QuickCheck, test-framework
     , test-framework-quickcheck2, unix
     }:
     mkDerivation {
       pname = "shared-buffer";
       version = "0.2.2";
       sha256 = "6c0e66cbee85380dad6dcf69466670047ed947f75cca7cc824ad5cebf1522a0c";
       libraryHaskellDepends = [ base bytestring unix ];
       testHaskellDepends = [
         base bytestring QuickCheck test-framework
         test-framework-quickcheck2 unix
       ];
       jailbreak = true;
       description = "A circular buffer built on shared memory";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shared-fields" = callPackage
    ({ mkDerivation, base, Cabal, hspec, lens, template-haskell, text
     }:
     mkDerivation {
       pname = "shared-fields";
       version = "0.2.0.0";
       sha256 = "a7044f887276d9d630f613313c961af265027c6aa1ba8acf8ec402db0837f680";
       libraryHaskellDepends = [ base template-haskell ];
       testHaskellDepends = [ base Cabal hspec lens text ];
       homepage = "http://github.com/intolerable/shared-fields";
       description = "a tiny library for using shared lens fields";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shared-memory" = callPackage
    ({ mkDerivation, base, bytestring, unix }:
     mkDerivation {
       pname = "shared-memory";
       version = "0.1.0.0";
       sha256 = "047d623f92bd4674105cbd05da0fa77b939f92c6eada1b4c6f276d8103920496";
       libraryHaskellDepends = [ base unix ];
       testHaskellDepends = [ base bytestring unix ];
       homepage = "https://github.com/nh2/shared-memory";
       description = "POSIX shared memory";
       license = stdenv.lib.licenses.mit;
     }) {};

  "sharedio" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "sharedio";
       version = "0.1.0";
       sha256 = "fb9f7973b81b952538f336749026daf337d54d4522dd6b5b8e970a6bc5aa1522";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/nh2/haskell-sharedio";
       description = "Bundles shared calls to IO functions to perform them only once";
       license = stdenv.lib.licenses.mit;
     }) {};

  "she" = callPackage
    ({ mkDerivation, base, filepath, mtl }:
     mkDerivation {
       pname = "she";
       version = "0.6";
       sha256 = "6cff306f22d7d8d99a1e61dfc0f9fb09ad3f8e21129eabb6ea68014998607274";
       revision = "1";
       editedCabalFile = "a81a091b54a4da7f992291e8985919456775776078d3bf1e5e5a81eca66b7a38";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base filepath mtl ];
       executableHaskellDepends = [ base filepath mtl ];
       jailbreak = true;
       homepage = "http://personal.cis.strath.ac.uk/~conor/pub/she";
       description = "A Haskell preprocessor adding miscellaneous features";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shelduck" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, async, base, bytestring
     , directory, exceptions, hastache, hspec, http-client, lens
     , lens-aeson, mtl, random, regex-compat, shelly, Spock, stm, text
     , time, transformers, unix, unordered-containers, uuid, wreq, yesod
     }:
     mkDerivation {
       pname = "shelduck";
       version = "0.2.0.0";
       sha256 = "3e63b7e155ae45eb3bd7756e7afbcbfa34c5e4481ef50a6687ab82947192ffc1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty async base bytestring directory exceptions
         hastache http-client lens lens-aeson mtl random shelly Spock stm
         text time transformers unordered-containers uuid wreq yesod
       ];
       executableHaskellDepends = [
         aeson aeson-pretty async base bytestring directory exceptions
         hastache http-client lens lens-aeson mtl random shelly Spock stm
         text time transformers unix unordered-containers uuid wreq yesod
       ];
       testHaskellDepends = [
         aeson base hspec http-client lens mtl regex-compat stm text
         transformers wreq
       ];
       description = "Test webhooks locally";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "shell-conduit_4_5" = callPackage
    ({ mkDerivation, async, base, bytestring, conduit, conduit-extra
     , control-monad-loop, directory, filepath, monad-control, monads-tf
     , process, resourcet, semigroups, split, template-haskell, text
     , transformers, transformers-base, unix
     }:
     mkDerivation {
       pname = "shell-conduit";
       version = "4.5";
       sha256 = "2f10ce3d80b6c64ce97d5c09d8b2cb99f6942714db21a2b845db8269d472f8ed";
       libraryHaskellDepends = [
         async base bytestring conduit conduit-extra control-monad-loop
         directory filepath monad-control monads-tf process resourcet
         semigroups split template-haskell text transformers
         transformers-base unix
       ];
       homepage = "https://github.com/chrisdone/shell-conduit";
       description = "Write shell scripts with Conduit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shell-conduit_4_5_1" = callPackage
    ({ mkDerivation, async, base, bytestring, conduit, conduit-extra
     , control-monad-loop, directory, filepath, monad-control, monads-tf
     , process, resourcet, semigroups, split, template-haskell, text
     , transformers, transformers-base, unix
     }:
     mkDerivation {
       pname = "shell-conduit";
       version = "4.5.1";
       sha256 = "92fe4fe4ba526503b5663f36a5849582f6e7d794f6404f4407ebeb491c020811";
       libraryHaskellDepends = [
         async base bytestring conduit conduit-extra control-monad-loop
         directory filepath monad-control monads-tf process resourcet
         semigroups split template-haskell text transformers
         transformers-base unix
       ];
       homepage = "https://github.com/chrisdone/shell-conduit";
       description = "Write shell scripts with Conduit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shell-conduit" = callPackage
    ({ mkDerivation, async, base, bytestring, conduit, conduit-extra
     , control-monad-loop, directory, filepath, monad-control, monads-tf
     , process, resourcet, semigroups, split, template-haskell, text
     , transformers, transformers-base, unix
     }:
     mkDerivation {
       pname = "shell-conduit";
       version = "4.5.2";
       sha256 = "427bc36d11b0b67f6cdfabc85a2dea95e65aed1dc16223af68832f4cff4b6c12";
       libraryHaskellDepends = [
         async base bytestring conduit conduit-extra control-monad-loop
         directory filepath monad-control monads-tf process resourcet
         semigroups split template-haskell text transformers
         transformers-base unix
       ];
       homepage = "https://github.com/chrisdone/shell-conduit";
       description = "Write shell scripts with Conduit";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shell-escape" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, vector }:
     mkDerivation {
       pname = "shell-escape";
       version = "0.2.0";
       sha256 = "e23c9ba94a27e45430cb39e6bb236557e789d24129257c3def377f441b2cba4a";
       libraryHaskellDepends = [
         base binary bytestring containers vector
       ];
       homepage = "http://github.com/solidsnack/shell-escape";
       description = "Shell escaping library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shell-monad" = callPackage
    ({ mkDerivation, base, containers, text, unix }:
     mkDerivation {
       pname = "shell-monad";
       version = "0.6.4";
       sha256 = "23c4d4bd1cdff86c7a7f5496e86ba3b436cd3124d07b99e74a7f5dd2c586b1f2";
       libraryHaskellDepends = [ base containers text unix ];
       description = "shell monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shell-pipe" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "shell-pipe";
       version = "0.1";
       sha256 = "deef9196866f3d81d490479e625a4bb497bda55d9f70f4ebf51e69286acfca77";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       homepage = "http://gnu.rtin.bz/directory/devel/prog/other/shell-haskell.html";
       description = "Pipe streams through external shell commands";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shellish" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, mtl
     , process, strict, time, unix-compat
     }:
     mkDerivation {
       pname = "shellish";
       version = "0.1.4";
       sha256 = "56b97529b71d2a0932925f3808d3d0446f288eddebbdfa8d9f9e5770448bbcd1";
       libraryHaskellDepends = [
         base bytestring directory filepath mtl process strict time
         unix-compat
       ];
       homepage = "http://repos.mornfall.net/shellish";
       description = "shell-/perl- like (systems) programming in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shellmate" = callPackage
    ({ mkDerivation, base, bytestring, directory, feed, filepath, HTTP
     , network-uri, process, tagsoup, temporary, transformers, xml
     }:
     mkDerivation {
       pname = "shellmate";
       version = "0.2.3";
       sha256 = "a1769617a819289400a8be95a967d8873d196aad4f696396016ea4f7f65cdf65";
       libraryHaskellDepends = [
         base bytestring directory feed filepath HTTP network-uri process
         tagsoup temporary transformers xml
       ];
       jailbreak = true;
       homepage = "http://github.com/valderman/shellmate";
       description = "Simple interface for shell scripting in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shelltestrunner" = callPackage
    ({ mkDerivation, base, cmdargs, Diff, directory, filemanip
     , filepath, HUnit, parsec, pretty-show, process, regex-tdfa, safe
     , test-framework, test-framework-hunit, utf8-string
     }:
     mkDerivation {
       pname = "shelltestrunner";
       version = "1.3.5";
       sha256 = "4265eb9cc87c352655099da26f49fb7829f5163edd03a20105b7a25609d3a829";
       revision = "1";
       editedCabalFile = "4ccce28f099594a89bbb8ff9c8f6408955b4be02a01eb2d552e1ce7165dce3aa";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs Diff directory filemanip filepath HUnit parsec
         pretty-show process regex-tdfa safe test-framework
         test-framework-hunit utf8-string
       ];
       homepage = "http://joyful.com/shelltestrunner";
       description = "A tool for testing command-line programs";
       license = "GPL";
     }) {};

  "shelly_1_5_6" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, directory
     , enclosed-exceptions, exceptions, lifted-async, lifted-base
     , monad-control, mtl, process, system-fileio, system-filepath, text
     , time, transformers, transformers-base, unix-compat
     }:
     mkDerivation {
       pname = "shelly";
       version = "1.5.6";
       sha256 = "f45f778d21661f616cfc849f7729e5aecef7250687e5b30c12e6d8118706d6ee";
       libraryHaskellDepends = [
         async base bytestring containers directory enclosed-exceptions
         exceptions lifted-async lifted-base monad-control mtl process
         system-fileio system-filepath text time transformers
         transformers-base unix-compat
       ];
       jailbreak = true;
       homepage = "https://github.com/yesodweb/Shelly.hs";
       description = "shell-like (systems) programming in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shelly_1_5_7" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, directory
     , enclosed-exceptions, exceptions, lifted-async, lifted-base
     , monad-control, mtl, process, system-fileio, system-filepath, text
     , time, transformers, transformers-base, unix-compat
     }:
     mkDerivation {
       pname = "shelly";
       version = "1.5.7";
       sha256 = "764770923deefe2c52b2ddeb5343d7c07bfadb1cecfe1828d5f57beb33bace85";
       libraryHaskellDepends = [
         async base bytestring containers directory enclosed-exceptions
         exceptions lifted-async lifted-base monad-control mtl process
         system-fileio system-filepath text time transformers
         transformers-base unix-compat
       ];
       jailbreak = true;
       homepage = "https://github.com/yesodweb/Shelly.hs";
       description = "shell-like (systems) programming in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shelly_1_6_1_2" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, directory
     , enclosed-exceptions, exceptions, lifted-async, lifted-base
     , monad-control, mtl, process, system-fileio, system-filepath, text
     , time, transformers, transformers-base, unix-compat
     }:
     mkDerivation {
       pname = "shelly";
       version = "1.6.1.2";
       sha256 = "719a60b951654365574cc5af5f5499acd4fb8b3e0c573d48572c2f6ce8f56047";
       libraryHaskellDepends = [
         async base bytestring containers directory enclosed-exceptions
         exceptions lifted-async lifted-base monad-control mtl process
         system-fileio system-filepath text time transformers
         transformers-base unix-compat
       ];
       homepage = "https://github.com/yesodweb/Shelly.hs";
       description = "shell-like (systems) programming in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shelly_1_6_3_3" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, directory
     , enclosed-exceptions, exceptions, hspec, HUnit, lifted-async
     , lifted-base, monad-control, mtl, process, system-fileio
     , system-filepath, text, time, transformers, transformers-base
     , unix-compat
     }:
     mkDerivation {
       pname = "shelly";
       version = "1.6.3.3";
       sha256 = "1a6624db16198b7af4d06d2b79f46346c1c459bcccbdf2958533b396dcf56a9c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base bytestring containers directory enclosed-exceptions
         exceptions lifted-async lifted-base monad-control mtl process
         system-fileio system-filepath text time transformers
         transformers-base unix-compat
       ];
       testHaskellDepends = [
         async base bytestring containers directory enclosed-exceptions
         exceptions hspec HUnit lifted-async lifted-base monad-control mtl
         process system-fileio system-filepath text time transformers
         transformers-base unix-compat
       ];
       doCheck = false;
       homepage = "https://github.com/yesodweb/Shelly.hs";
       description = "shell-like (systems) programming in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shelly_1_6_3_4" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, directory
     , enclosed-exceptions, exceptions, hspec, HUnit, lifted-async
     , lifted-base, monad-control, mtl, process, system-fileio
     , system-filepath, text, time, transformers, transformers-base
     , unix-compat
     }:
     mkDerivation {
       pname = "shelly";
       version = "1.6.3.4";
       sha256 = "57abc8d9605c67bedc9d294bf9898a9ccd80e5e098f2351fbdcdf6dc716875d5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base bytestring containers directory enclosed-exceptions
         exceptions lifted-async lifted-base monad-control mtl process
         system-fileio system-filepath text time transformers
         transformers-base unix-compat
       ];
       testHaskellDepends = [
         async base bytestring containers directory enclosed-exceptions
         exceptions hspec HUnit lifted-async lifted-base monad-control mtl
         process system-fileio system-filepath text time transformers
         transformers-base unix-compat
       ];
       doCheck = false;
       homepage = "https://github.com/yesodweb/Shelly.hs";
       description = "shell-like (systems) programming in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shelly_1_6_4" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, directory
     , enclosed-exceptions, exceptions, hspec, HUnit, lifted-async
     , lifted-base, monad-control, mtl, process, system-fileio
     , system-filepath, text, time, transformers, transformers-base
     , unix-compat
     }:
     mkDerivation {
       pname = "shelly";
       version = "1.6.4";
       sha256 = "e723b4b93b8b5507e965e80ba912128166296b5a7a79e106af7a16cd4312fd8b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base bytestring containers directory enclosed-exceptions
         exceptions lifted-async lifted-base monad-control mtl process
         system-fileio system-filepath text time transformers
         transformers-base unix-compat
       ];
       testHaskellDepends = [
         async base bytestring containers directory enclosed-exceptions
         exceptions hspec HUnit lifted-async lifted-base monad-control mtl
         process system-fileio system-filepath text time transformers
         transformers-base unix-compat
       ];
       doCheck = false;
       homepage = "https://github.com/yesodweb/Shelly.hs";
       description = "shell-like (systems) programming in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shelly_1_6_4_1" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, directory
     , enclosed-exceptions, exceptions, hspec, HUnit, lifted-async
     , lifted-base, monad-control, mtl, process, system-fileio
     , system-filepath, text, time, transformers, transformers-base
     , unix-compat
     }:
     mkDerivation {
       pname = "shelly";
       version = "1.6.4.1";
       sha256 = "99548d6a33ea7a8ed2c12f625c923ee14d9c2d04ecb9b46bef2c1e6c8ff567ab";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base bytestring containers directory enclosed-exceptions
         exceptions lifted-async lifted-base monad-control mtl process
         system-fileio system-filepath text time transformers
         transformers-base unix-compat
       ];
       testHaskellDepends = [
         async base bytestring containers directory enclosed-exceptions
         exceptions hspec HUnit lifted-async lifted-base monad-control mtl
         process system-fileio system-filepath text time transformers
         transformers-base unix-compat
       ];
       doCheck = false;
       homepage = "https://github.com/yesodweb/Shelly.hs";
       description = "shell-like (systems) programming in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shelly" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, directory
     , enclosed-exceptions, exceptions, hspec, HUnit, lifted-async
     , lifted-base, monad-control, mtl, process, system-fileio
     , system-filepath, text, time, transformers, transformers-base
     , unix-compat
     }:
     mkDerivation {
       pname = "shelly";
       version = "1.6.5";
       sha256 = "bdfd09b01f3de8e7e58e98591ab1a42ad5a74308ff29f19acd16d7cc85b71cdc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base bytestring containers directory enclosed-exceptions
         exceptions lifted-async lifted-base monad-control mtl process
         system-fileio system-filepath text time transformers
         transformers-base unix-compat
       ];
       testHaskellDepends = [
         async base bytestring containers directory enclosed-exceptions
         exceptions hspec HUnit lifted-async lifted-base monad-control mtl
         process system-fileio system-filepath text time transformers
         transformers-base unix-compat
       ];
       doCheck = false;
       homepage = "https://github.com/yesodweb/Shelly.hs";
       description = "shell-like (systems) programming in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shelly-extra" = callPackage
    ({ mkDerivation, async, base, hspec, HUnit, mtl, SafeSemaphore
     , shelly, text
     }:
     mkDerivation {
       pname = "shelly-extra";
       version = "0.3.0.1";
       sha256 = "0502062de043c0322d3cddf379847c1148e515c4fa18f19db835210d422d85d5";
       libraryHaskellDepends = [ async base mtl SafeSemaphore shelly ];
       testHaskellDepends = [
         async base hspec HUnit mtl SafeSemaphore shelly text
       ];
       homepage = "https://github.com/yesodweb/Shelly.hs";
       description = "shelly features that require extra dependencies";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shivers-cfg" = callPackage
    ({ mkDerivation, base, containers, directory, HPDF, language-dot
     , mtl, pretty, process
     }:
     mkDerivation {
       pname = "shivers-cfg";
       version = "0.1.1";
       sha256 = "ecf4dfb70e6a98f9a5304329d8f4893f88e7c51904f6a599961b9f4b9f7664c1";
       libraryHaskellDepends = [
         base containers directory HPDF language-dot mtl pretty process
       ];
       description = "Implementation of Shivers' Control-Flow Analysis";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shoap" = callPackage
    ({ mkDerivation, base, curl }:
     mkDerivation {
       pname = "shoap";
       version = "0.2";
       sha256 = "3b153cd9b93959cb3f90bc98755898653bd27f4e52a475b5d818df36dd428b7b";
       libraryHaskellDepends = [ base curl ];
       jailbreak = true;
       homepage = "http://richardfergie.com/shoap";
       description = "A very basic SOAP package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shortcircuit" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "shortcircuit";
       version = "0.1";
       sha256 = "dfd08116f853c3f0f28864606f11bf21d3b5da4104e97628d172864b9fc9ec09";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/aristidb/shortcircuit";
       description = "Short-circuit values and expressions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shortcut-links_0_4_0_0" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "shortcut-links";
       version = "0.4.0.0";
       sha256 = "280f7fa996fb81c1baa072a53a23782a91c940623dca7d1e768927fe1f2c2ac5";
       libraryHaskellDepends = [ base text ];
       homepage = "http://github.com/aelve/shortcut-links";
       description = "Link shortcuts for use in text markup";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shortcut-links" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "shortcut-links";
       version = "0.4.1.0";
       sha256 = "35fe3fa93c4f28999792ddf68369a5d327c09856a89a6731890dda6e811723d7";
       libraryHaskellDepends = [ base text ];
       homepage = "http://github.com/aelve/shortcut-links";
       description = "Link shortcuts for use in text markup";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shorten-strings" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "shorten-strings";
       version = "0.1.0.1";
       sha256 = "83771a79080efe72a813cd7839266b95badcf03c9ea4fd6907f6873e055b38eb";
       libraryHaskellDepends = [ base text ];
       jailbreak = true;
       homepage = "https://github.com/Tarrasch/shorten-strings";
       description = "Shorten a variety of string-like types adding ellipsis";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "should-not-typecheck" = callPackage
    ({ mkDerivation, base, deepseq, hspec, hspec-expectations, HUnit }:
     mkDerivation {
       pname = "should-not-typecheck";
       version = "2.0.1";
       sha256 = "16db8833aeba3c868195c3833024484711903b2c4fa5f8aabd8fc19de4247d12";
       libraryHaskellDepends = [ base deepseq HUnit ];
       testHaskellDepends = [
         base deepseq hspec hspec-expectations HUnit
       ];
       homepage = "http://github.com/CRogers/should-not-typecheck";
       description = "A HUnit/hspec assertion library to verify that an expression does not typecheck";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "show" = callPackage
    ({ mkDerivation, base, syb }:
     mkDerivation {
       pname = "show";
       version = "0.6";
       sha256 = "4f57a947a538d021406f649049dde27d4d8d0b44aac3ba38fa64806c9d737b95";
       libraryHaskellDepends = [ base syb ];
       description = "'Show' instances for Lambdabot";
       license = "GPL";
     }) {};

  "show-type" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "show-type";
       version = "0.1.1";
       sha256 = "dbfb5b2771a51116a494a62e4e39096809e1330beca97d3e7fe7b120378af7ea";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/Kinokkory/show-type";
       description = "convert types into string values in haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "showdown" = callPackage
    ({ mkDerivation, base, glade, gtk, random }:
     mkDerivation {
       pname = "showdown";
       version = "0.5.3";
       sha256 = "30db60268dcf6068572d32357bc051696b1c4392691c1651d3b6fec2295af2be";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base glade gtk random ];
       jailbreak = true;
       description = "A simple gtk based Russian Roulette game";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shpider" = callPackage
    ({ mkDerivation, base, bytestring, containers, curl, mtl
     , regex-posix, tagsoup, tagsoup-parsec, time, url, web-encodings
     }:
     mkDerivation {
       pname = "shpider";
       version = "0.2.1.1";
       sha256 = "8d4f42c2263354d5cb144f52b97ebc6e2f0200a00f57ed961cd70955e90fe4a4";
       libraryHaskellDepends = [
         base bytestring containers curl mtl regex-posix tagsoup
         tagsoup-parsec time url web-encodings
       ];
       homepage = "http://github.com/ozataman/shpider";
       description = "Web automation library in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "shplit" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "shplit";
       version = "0.3";
       sha256 = "b9636aaea1b87d01115bdbd67fdadde4c310004ebf1bccab442b0e82503fb472";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base mtl ];
       homepage = "http://personal.cis.strath.ac.uk/~conor/pub/shplit";
       description = "A Haskell pattern splitter with emacs attachments";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "shqq" = callPackage
    ({ mkDerivation, base, parsec, posix-escape, process
     , template-haskell, unix
     }:
     mkDerivation {
       pname = "shqq";
       version = "0.1";
       sha256 = "954197351bfd112485c080b3e01846df099fed793978406ba73a00802db5ad22";
       libraryHaskellDepends = [
         base parsec posix-escape process template-haskell unix
       ];
       description = "Embed shell commands with interpolated Haskell variables, and capture output";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "shuffle" = callPackage
    ({ mkDerivation, array, base, Cabal, containers, directory
     , filepath, network, network-uri, process, uhc-util, uuagc
     , uuagc-cabal, uulib
     }:
     mkDerivation {
       pname = "shuffle";
       version = "0.1.3.3";
       sha256 = "2de785a94947c3e34d17643ca96a6a65421a53b28290ff87571d0d34ee50fb59";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base Cabal containers directory filepath network network-uri
         process uhc-util uuagc uuagc-cabal uulib
       ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/UU-ComputerScience/shuffle";
       description = "Shuffle tool for UHC";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sieve" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "sieve";
       version = "0.1.0.1";
       sha256 = "15156000b39d8f8ef7cd330e64306be70f2aecf9abee9c7e2f14a338e0e7f2a7";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.the-singleton.com";
       description = "Sieve is an implementation of the Sieve abstract data type";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "sifflet" = callPackage
    ({ mkDerivation, base, cairo, containers, directory, fgl, filepath
     , glib, gtk, hxt, mtl, parsec, process, sifflet-lib, unix
     }:
     mkDerivation {
       pname = "sifflet";
       version = "2.2.1";
       sha256 = "927045ed0cd2e524db59361f80bebba48d9a2d79bc9bdcf2166bcfa043d25075";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cairo containers directory fgl filepath glib gtk hxt mtl
         parsec process sifflet-lib unix
       ];
       jailbreak = true;
       homepage = "http://mypage.iu.edu/~gdweber/software/sifflet/";
       description = "A simple, visual, functional programming language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sifflet-lib" = callPackage
    ({ mkDerivation, base, cairo, containers, directory, fgl, filepath
     , gdk_x11, glib, gtk, gtk_x11, hxt, mtl, parsec, process, unix
     }:
     mkDerivation {
       pname = "sifflet-lib";
       version = "2.2.1";
       sha256 = "c41690960ae9b101257f3438c87115e25b7e6f42636af11615994c4d37c0caea";
       libraryHaskellDepends = [
         base cairo containers directory fgl filepath glib gtk hxt mtl
         parsec process unix
       ];
       librarySystemDepends = [ gdk_x11 gtk_x11 ];
       jailbreak = true;
       homepage = "http://mypage.iu.edu/~gdweber/software/sifflet/";
       description = "Library of modules shared by sifflet and its tests and its exporters";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {gdk_x11 = null; gtk_x11 = null;};

  "sign" = callPackage
    ({ mkDerivation, base, containers, deepseq, hashable, HUnit
     , lattices, QuickCheck, tasty, tasty-hunit, tasty-quickcheck
     , tasty-th, universe-base
     }:
     mkDerivation {
       pname = "sign";
       version = "0.4.3";
       sha256 = "77855b6953a17cdba1459efc5241b7174cd628629583245ced96684dfd1f7544";
       libraryHaskellDepends = [
         base containers deepseq hashable lattices universe-base
       ];
       testHaskellDepends = [
         base containers deepseq HUnit lattices QuickCheck tasty tasty-hunit
         tasty-quickcheck tasty-th universe-base
       ];
       description = "Arithmetic over signs and sets of signs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "signal" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "signal";
       version = "0.1.0.3";
       sha256 = "1df5108befee3eaefb5a826eb83df60f192ff3f3e264d998a7e491d60f388ac7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base unix ];
       executableHaskellDepends = [ base ];
       homepage = "http://github.com/pmlodawski/signal";
       description = "Multiplatform signal support for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "signals" = callPackage
    ({ mkDerivation, base, containers, hashable, imperative-edsl-vhdl
     , language-vhdl, mtl, observable-sharing, operational-alacarte
     }:
     mkDerivation {
       pname = "signals";
       version = "0.2.0.2";
       sha256 = "2dc14b0a4f9c20efb16d00be1f6cc6e1aa0a586f56c67d3506f14cf12b8ee4aa";
       libraryHaskellDepends = [
         base containers hashable imperative-edsl-vhdl language-vhdl mtl
         observable-sharing operational-alacarte
       ];
       description = "Synchronous signal processing for DSLs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "signed-multiset" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "signed-multiset";
       version = "0.4";
       sha256 = "871c2890e4817a2fab924e5e40f7279a53a969040e470d4d4faeab92c033b15f";
       libraryHaskellDepends = [ base containers ];
       jailbreak = true;
       description = "Multisets with negative membership";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "silently_1_2_4_1" = callPackage
    ({ mkDerivation, base, deepseq, directory, nanospec }:
     mkDerivation {
       pname = "silently";
       version = "1.2.4.1";
       sha256 = "a2b8f53e7e7bc0272852852c49d8b27ff250accc73e25cbe9f1e20f3fee0ad0c";
       libraryHaskellDepends = [ base deepseq directory ];
       testHaskellDepends = [ base deepseq directory nanospec ];
       homepage = "https://github.com/trystan/silently";
       description = "Prevent or capture writing to stdout and other handles";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "silently" = callPackage
    ({ mkDerivation, base, deepseq, directory, nanospec, temporary }:
     mkDerivation {
       pname = "silently";
       version = "1.2.5";
       sha256 = "cef625635053a46032ca53b43d311921875a437910b6568ded17027fdca83839";
       libraryHaskellDepends = [ base deepseq directory ];
       testHaskellDepends = [ base deepseq directory nanospec temporary ];
       homepage = "https://github.com/hspec/silently";
       description = "Prevent or capture writing to stdout and other handles";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simd" = callPackage
    ({ mkDerivation, base, ghc-prim, primitive, vector }:
     mkDerivation {
       pname = "simd";
       version = "0.1.0.1";
       sha256 = "1559eddddc48827fd7f7432c5ee0960218779198713c67ed8181cc334b38b766";
       libraryHaskellDepends = [ base ghc-prim primitive vector ];
       jailbreak = true;
       homepage = "http://github.com/mikeizbicki/simd";
       description = "simple interface to GHC's SIMD instructions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simgi" = callPackage
    ({ mkDerivation, base, containers, haskell98
     , mersenne-random-pure64, mtl, parsec, random
     }:
     mkDerivation {
       pname = "simgi";
       version = "0.3";
       sha256 = "6a05ee3727c9166a4236104992c3962a257d31c25ed52286251e699fd2490dfb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers haskell98 mersenne-random-pure64 mtl parsec random
       ];
       jailbreak = true;
       homepage = "http://simgi.sourceforge.net/";
       description = "stochastic simulation engine";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simple" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, cmdargs, directory, filepath, hspec
     , hspec-contrib, http-types, mime-types, monad-control, mtl
     , process, setenv, simple-templates, text, transformers
     , transformers-base, unordered-containers, vector, wai, wai-extra
     }:
     mkDerivation {
       pname = "simple";
       version = "0.11.1";
       sha256 = "74c3cfb9a92cbaebb47e8abbc7d918947a05340fd0d4fab1661ff8e777f5e815";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base64-bytestring blaze-builder bytestring directory
         filepath http-types mime-types monad-control mtl simple-templates
         text transformers transformers-base unordered-containers vector wai
         wai-extra
       ];
       executableHaskellDepends = [
         aeson attoparsec base bytestring cmdargs directory filepath process
         setenv simple-templates text unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base base64-bytestring blaze-builder bytestring directory
         filepath hspec hspec-contrib http-types mime-types monad-control
         mtl simple-templates text transformers transformers-base
         unordered-containers vector wai wai-extra
       ];
       homepage = "http://simple.cx";
       description = "A minimalist web framework for the WAI server interface";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simple-actors" = callPackage
    ({ mkDerivation, base, chan-split, contravariant, mtl, transformers
     }:
     mkDerivation {
       pname = "simple-actors";
       version = "0.4.0";
       sha256 = "45f01ff746bf4d6a99e794ec9042f62e2953ba438c40a56cecbe14f74cf6b28f";
       libraryHaskellDepends = [
         base chan-split contravariant mtl transformers
       ];
       homepage = "http://brandon.si/code/simple-actors-0-1-0-released/";
       description = "A library for more structured concurrent programming, based on the Actor Model";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-atom" = callPackage
    ({ mkDerivation, base, containers, deepseq }:
     mkDerivation {
       pname = "simple-atom";
       version = "0.2";
       sha256 = "27a86db825f2612e758626ea689fb7de65215f83c32abf77a777803cbc5213cf";
       libraryHaskellDepends = [ base containers deepseq ];
       jailbreak = true;
       homepage = "http://github.com/nominolo/simple-atom";
       description = "Atom (or symbol) datatype for fast comparision and sorting";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-bluetooth" = callPackage
    ({ mkDerivation, base, bluetooth, bytestring, network }:
     mkDerivation {
       pname = "simple-bluetooth";
       version = "0.1.0.0";
       sha256 = "c44903818723dc28cfc22b77be471b43740d5858760032563383b22d3cde34e3";
       libraryHaskellDepends = [ base bytestring network ];
       librarySystemDepends = [ bluetooth ];
       description = "Simple Bluetooth API for Windows and Linux (bluez)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {bluetooth = null;};

  "simple-c-value" = callPackage
    ({ mkDerivation, base, checkers, DebugTraceHelpers, derive, dlist
     , ghc-prim, HUnit, mtl, QuickCheck, template-haskell
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , tuple, uniplate
     }:
     mkDerivation {
       pname = "simple-c-value";
       version = "0.0.0.1";
       sha256 = "faa1bc552624fab7eed87c250ebee3691a4b026de4874035ea9014c668f4c04f";
       libraryHaskellDepends = [
         base DebugTraceHelpers dlist ghc-prim tuple
       ];
       testHaskellDepends = [
         base checkers DebugTraceHelpers derive dlist ghc-prim HUnit mtl
         QuickCheck template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2 tuple uniplate
       ];
       homepage = "https://github.com/jfischoff/simple-c-value";
       description = "A simple C value type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simple-conduit" = callPackage
    ({ mkDerivation, base, bifunctors, bytestring, chunked-data
     , containers, either, exceptions, filepath, free, lifted-async
     , lifted-base, mmorph, monad-control, mono-traversable, mtl
     , mwc-random, primitive, semigroups, stm, streaming-commons, text
     , transformers, transformers-base, vector
     }:
     mkDerivation {
       pname = "simple-conduit";
       version = "0.5.1";
       sha256 = "f997a94736b90abfd6abc08a56e59c02cd42ab549f35148c68ce40c11b03c7cb";
       libraryHaskellDepends = [
         base bifunctors bytestring chunked-data containers either
         exceptions filepath free lifted-async lifted-base mmorph
         monad-control mono-traversable mtl mwc-random primitive semigroups
         stm streaming-commons text transformers transformers-base vector
       ];
       jailbreak = true;
       homepage = "http://github.com/jwiegley/simple-conduit";
       description = "A simple streaming I/O library based on monadic folds";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simple-config" = callPackage
    ({ mkDerivation, base, bytestring, data-default, hspec, network-uri
     , parsec, template-haskell, transformers
     }:
     mkDerivation {
       pname = "simple-config";
       version = "1.2.2.1";
       sha256 = "b3b402f162294712e98df54f70d876d490e402d7f78d8daaf435338f2ffdacd9";
       libraryHaskellDepends = [
         base bytestring data-default network-uri parsec template-haskell
         transformers
       ];
       testHaskellDepends = [ base hspec ];
       homepage = "https://github.com/yunomu/simple-config";
       description = "Simple config file parser generator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-css" = callPackage
    ({ mkDerivation, base, blaze-html, hashable, language-css
     , unordered-containers
     }:
     mkDerivation {
       pname = "simple-css";
       version = "0.0.4";
       sha256 = "2daa84af038988c43214d5913d500b425568379708d2a26fe127ca97aef342a5";
       libraryHaskellDepends = [
         base blaze-html hashable language-css unordered-containers
       ];
       description = "simple binding of css and html";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simple-eval" = callPackage
    ({ mkDerivation, base, parsec, text, transformers }:
     mkDerivation {
       pname = "simple-eval";
       version = "0.1.0.1";
       sha256 = "d451a131fd79265a7c828e583cc73a4805ef9070b639a900f72aacc3dc7dada0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base parsec text transformers ];
       executableHaskellDepends = [ base text ];
       jailbreak = true;
       homepage = "https://github.com/gitfoxi/Language.Eval";
       description = "Evaluate a Text to an Integer: \"1 + 1\" -> 2";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "simple-firewire" = callPackage
    ({ mkDerivation, base, bindings-dc1394, CV }:
     mkDerivation {
       pname = "simple-firewire";
       version = "0.1.3.4";
       sha256 = "6a0262e44884355ec4ff12ab9e9f9e61d251770c8328d9df7eae4ebcc71fd091";
       libraryHaskellDepends = [ base bindings-dc1394 CV ];
       homepage = "https://github.com/aleator/simple-firewire";
       description = "Simplified interface for firewire cameras";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simple-form" = callPackage
    ({ mkDerivation, base, blaze-html, digestive-functors
     , email-validate, network-uri, old-locale, text, time, transformers
     }:
     mkDerivation {
       pname = "simple-form";
       version = "0.5.0";
       sha256 = "a368dd06d7f0a9b49ebe40efb776a744d2854319e7a1c09d18aeef91cab9f806";
       libraryHaskellDepends = [
         base blaze-html digestive-functors email-validate network-uri
         old-locale text time transformers
       ];
       homepage = "https://github.com/singpolyma/simple-form-haskell";
       description = "Forms that configure themselves based on type";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simple-genetic-algorithm" = callPackage
    ({ mkDerivation, base, deepseq, parallel, random }:
     mkDerivation {
       pname = "simple-genetic-algorithm";
       version = "0.2.0.0";
       sha256 = "112762752cf5b12e0fe8f2baea2db1575fe27eabf5b70a43fb01ed3deb42fe91";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base parallel random ];
       executableHaskellDepends = [ base deepseq parallel random ];
       jailbreak = true;
       homepage = "http://eax.me/haskell-genetic-algorithm/";
       description = "Simple parallel genetic algorithm implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-genetic-algorithm-mr" = callPackage
    ({ mkDerivation, base, deepseq, MonadRandom, parallel, random
     , transformers
     }:
     mkDerivation {
       pname = "simple-genetic-algorithm-mr";
       version = "0.4.0.0";
       sha256 = "fe291cea3efeb0661f2fc725b6bebf171a82fa047613589082adde562c1176a4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base MonadRandom parallel random transformers
       ];
       executableHaskellDepends = [
         base deepseq MonadRandom parallel random transformers
       ];
       homepage = "http://eax.me/haskell-genetic-algorithm/";
       description = "Simple parallel genetic algorithm implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-get-opt" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "simple-get-opt";
       version = "0.1.0.0";
       sha256 = "855a59d47d3e1170fe7c887ccd9d08fc8af2b791bbcecc4b34dbdad1e5342ac2";
       libraryHaskellDepends = [ base ];
       description = "A simple library for processing command-line options";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-index" = callPackage
    ({ mkDerivation, base, containers, hashable, safecopy
     , unordered-containers
     }:
     mkDerivation {
       pname = "simple-index";
       version = "0.1.0.1";
       sha256 = "feb5e62c9aaed9a347a39216db0d8e18b614aee96f172eed5b2d87bd14c4b670";
       libraryHaskellDepends = [
         base containers hashable safecopy unordered-containers
       ];
       jailbreak = true;
       description = "Allows simple indexation on any data type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-log" = callPackage
    ({ mkDerivation, async, base, containers, deepseq, directory
     , filepath, MonadCatchIO-transformers, mtl, SafeSemaphore, text
     , time, transformers
     }:
     mkDerivation {
       pname = "simple-log";
       version = "0.3.4";
       sha256 = "7d81fdfb91a2ee88d73dc4a5680be4f0e8b44faa460ce15d41a33d3a975c84f9";
       libraryHaskellDepends = [
         async base containers deepseq directory filepath
         MonadCatchIO-transformers mtl SafeSemaphore text time transformers
       ];
       homepage = "http://github.com/mvoidex/simple-log";
       description = "Simple log for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-log-syslog" = callPackage
    ({ mkDerivation, base, hsyslog, simple-log, text }:
     mkDerivation {
       pname = "simple-log-syslog";
       version = "0.2.0";
       sha256 = "6430e132a9159897a58bf15796049508c2762229af472621af4e95ffba962998";
       libraryHaskellDepends = [ base hsyslog simple-log text ];
       jailbreak = true;
       homepage = "http://github.com/mvoidex/simple-log-syslog";
       description = "Syslog backend for simple-log";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simple-neural-networks" = callPackage
    ({ mkDerivation, base, containers, deepseq, parallel, random, split
     }:
     mkDerivation {
       pname = "simple-neural-networks";
       version = "0.2.0.1";
       sha256 = "7e9fe8d8fefa25f6e71c3436178647ddf379fde00f0dede35df9e214b4db791d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers deepseq parallel random split
       ];
       executableHaskellDepends = [
         base containers deepseq parallel random split
       ];
       jailbreak = true;
       homepage = "http://eax.me/haskell-neural-networks/";
       description = "Simple parallel neural networks implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-nix" = callPackage
    ({ mkDerivation, base, classy-prelude, error-list, hspec
     , hspec-expectations, MissingH, mtl, parsec, system-filepath, text
     , text-render, unordered-containers
     }:
     mkDerivation {
       pname = "simple-nix";
       version = "0.1.0.4";
       sha256 = "0ec00ae2b76da265d9cadf599545c90b3e99a52f2af52bc334aefd7467cfcacf";
       libraryHaskellDepends = [
         base classy-prelude error-list MissingH mtl parsec system-filepath
         text text-render unordered-containers
       ];
       testHaskellDepends = [
         base classy-prelude error-list hspec hspec-expectations MissingH
         mtl parsec system-filepath text text-render unordered-containers
       ];
       homepage = "https://github.com/adnelson/simple-nix";
       description = "Simple parsing/pretty printing for Nix expressions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "simple-observer" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "simple-observer";
       version = "0.0.1";
       sha256 = "99080b3da7bed2d64654a1e98592081bc9af52de91f7b96a96976625bfe15fda";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/gimbo/observer.hs";
       description = "The Observer pattern";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-pascal" = callPackage
    ({ mkDerivation, base, containers, filepath, mtl, parsec
     , simple-stacked-vm
     }:
     mkDerivation {
       pname = "simple-pascal";
       version = "0.1";
       sha256 = "73b631583fe71c2da265f35b9c92726bcb118e3b94842d697f223ffd942835db";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers filepath mtl parsec simple-stacked-vm
       ];
       description = "Simplified Pascal language to SSVM compiler";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simple-pipe" = callPackage
    ({ mkDerivation, base, bytestring, lifted-base, monad-control
     , monads-tf, stm, transformers-base
     }:
     mkDerivation {
       pname = "simple-pipe";
       version = "0.0.0.29";
       sha256 = "d01bdd5971a18ba739d2dad2b68fcbe71d03c4fd0db3d18be9010251023a8c46";
       libraryHaskellDepends = [
         base bytestring lifted-base monad-control monads-tf stm
         transformers-base
       ];
       homepage = "https://github.com/YoshikuniJujo/simple-pipe/wiki";
       description = "simple pipeline library like conduit";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-postgresql-orm" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath
     , postgresql-orm, postgresql-simple, resource-pool, simple
     , transformers
     }:
     mkDerivation {
       pname = "simple-postgresql-orm";
       version = "0.9.0.1";
       sha256 = "3f0fe86dac2b70662340c5b36d42b11083a57e0beb16df62931d32c73d313b48";
       libraryHaskellDepends = [
         base bytestring directory filepath postgresql-orm postgresql-simple
         resource-pool simple transformers
       ];
       homepage = "http://simple.cx";
       description = "Connector package for integrating postgresql-orm with the Simple web framework";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simple-reflect" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "simple-reflect";
       version = "0.3.2";
       sha256 = "38224eb3d0d5eafc7101ad48fa92001c3e753a015d53bb12753a3836b871ecb6";
       libraryHaskellDepends = [ base ];
       homepage = "http://twanvl.nl/blog/haskell/simple-reflection-of-expressions";
       description = "Simple reflection of expressions containing variables";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-rope" = callPackage
    ({ mkDerivation, base, bytestring, QuickCheck }:
     mkDerivation {
       pname = "simple-rope";
       version = "0.1";
       sha256 = "f4e67aa1a80392fc5208e1866cec8126570465dec06a8b6ab17b478bec83efa0";
       libraryHaskellDepends = [ base bytestring QuickCheck ];
       homepage = "http://github.com/jkff/haskell-rope";
       description = "Memory-efficient strings with concatenation and splitting";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-sendfile_0_2_18" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , directory, hspec, HUnit, network, process, resourcet, unix
     }:
     mkDerivation {
       pname = "simple-sendfile";
       version = "0.2.18";
       sha256 = "8978aad04b6ca53a84ce6dca6b3e70bdff66648a5b0b94ea82ee7336176187b5";
       libraryHaskellDepends = [ base bytestring network unix ];
       testHaskellDepends = [
         base bytestring conduit conduit-extra directory hspec HUnit network
         process resourcet unix
       ];
       doHaddock = false;
       doCheck = false;
       description = "Cross platform library for the sendfile system call";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simple-sendfile_0_2_20" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , directory, hspec, HUnit, network, process, resourcet, unix
     }:
     mkDerivation {
       pname = "simple-sendfile";
       version = "0.2.20";
       sha256 = "6379fcb2c37011a3e665e65e3faf7c6cf3970536f67942bfb749d26a87a4fd3b";
       libraryHaskellDepends = [ base bytestring network unix ];
       testHaskellDepends = [
         base bytestring conduit conduit-extra directory hspec HUnit network
         process resourcet unix
       ];
       doCheck = false;
       description = "Cross platform library for the sendfile system call";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simple-sendfile" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , directory, hspec, HUnit, network, process, resourcet, unix
     }:
     mkDerivation {
       pname = "simple-sendfile";
       version = "0.2.21";
       sha256 = "61239d6c5e94ec76067d88d8a09589b53ca0a5d1806fd9f3e042d007cc67fd77";
       libraryHaskellDepends = [ base bytestring network unix ];
       testHaskellDepends = [
         base bytestring conduit conduit-extra directory hspec HUnit network
         process resourcet unix
       ];
       doCheck = false;
       description = "Cross platform library for the sendfile system call";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-server" = callPackage
    ({ mkDerivation, base, bytestring, concurrent-extra, containers
     , hashtables, network, time, unbounded-delays
     }:
     mkDerivation {
       pname = "simple-server";
       version = "0.0.3";
       sha256 = "99713528713f4a5cb85cda6100c5b9d6fdd83c29117081b0764cfa193d9bb862";
       libraryHaskellDepends = [
         base bytestring concurrent-extra containers hashtables network time
         unbounded-delays
       ];
       description = "Simple Server interface";
       license = "GPL";
     }) {};

  "simple-session" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, byteable
     , bytestring, containers, cookie, cryptohash, http-types, simple
     , transformers, wai, wai-extra
     }:
     mkDerivation {
       pname = "simple-session";
       version = "0.10.1.1";
       sha256 = "8a9c9cb7a80080b6440a80549919d3cee3409af6c516b3d10d1392708b48e7c1";
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder byteable bytestring containers
         cookie cryptohash http-types simple transformers wai wai-extra
       ];
       homepage = "http://simple.cx";
       description = "Cookie-based session management for the Simple web framework";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simple-sessions" = callPackage
    ({ mkDerivation, base, indexed, synchronous-channels }:
     mkDerivation {
       pname = "simple-sessions";
       version = "0.1.3";
       sha256 = "c5cf055d0f41d68332363f676720c742b110d2d622b466af14f7a51ac3534b21";
       libraryHaskellDepends = [ base indexed synchronous-channels ];
       homepage = "http://www.eecs.harvard.edu/~tov/pubs/haskell-session-types/";
       description = "A simple implementation of session types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-smt" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "simple-smt";
       version = "0.6.0";
       sha256 = "0cb4d409cb0cf99a9f26c405dc7626c1206d5bffec925ce202f42327b769b695";
       libraryHaskellDepends = [ base process ];
       description = "A simple way to interact with an SMT solver process";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-sql-parser" = callPackage
    ({ mkDerivation, base, HUnit, mtl, parsec, pretty, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "simple-sql-parser";
       version = "0.4.1";
       sha256 = "18fd27a8b274ab74a4949a1738498c0903e9e74645f40b113324263b1753e543";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl parsec pretty ];
       executableHaskellDepends = [ base mtl parsec pretty ];
       testHaskellDepends = [
         base HUnit mtl parsec pretty test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://jakewheat.github.io/simple-sql-parser/";
       description = "A parser for SQL queries";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-stacked-vm" = callPackage
    ({ mkDerivation, array, base, binary-state, containers, filepath
     , mtl, parsec
     }:
     mkDerivation {
       pname = "simple-stacked-vm";
       version = "0.1.1";
       sha256 = "ed0aafb33a8620b8c5c76c6fc9a7de9e62a522a52fd459e2a4349a6f9c6a30bf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary-state containers filepath mtl parsec
       ];
       description = "Simple stacked virtual machine: assembler, disassembler, bytecode interpreter";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simple-tabular" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "simple-tabular";
       version = "0.1.0.0";
       sha256 = "faa78536335a8b7579bb68a4f7d79e6ed3b7c4a0674566ae028fc36c3c6af95c";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://github.com/BartMassey/simple-tabular";
       description = "Simple tabular-text formatter";
       license = stdenv.lib.licenses.mit;
     }) {};

  "simple-templates" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, hspec, HUnit, scientific
     , text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "simple-templates";
       version = "0.8.0.1";
       sha256 = "28e10f916320bb5097d9ed323a1726d88d17a51b0ac0290a91806d97840bca8e";
       libraryHaskellDepends = [
         aeson attoparsec base scientific text unordered-containers vector
       ];
       testHaskellDepends = [
         aeson attoparsec base hspec HUnit scientific vector
       ];
       homepage = "http://simple.cx";
       description = "A basic template language for the Simple web framework";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simple-vec3" = callPackage
    ({ mkDerivation, base, vector }:
     mkDerivation {
       pname = "simple-vec3";
       version = "0.1.0.1";
       sha256 = "441b08acf63ad72fc20acd3f5e02cb5c2957dab2e4ff765652803c9e1b42fdef";
       libraryHaskellDepends = [ base vector ];
       jailbreak = true;
       homepage = "http://github.com/dzhus/simple-vec3/";
       description = "Three-dimensional vectors of doubles with basic operations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simpleargs" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "simpleargs";
       version = "0.2.1";
       sha256 = "d750a8afc1bec827da07650453e90fcfdd34d3317681a64db6fca431d69532bf";
       libraryHaskellDepends = [ base ];
       homepage = "http://malde.org/~ketil/simpleargs";
       description = "Provides a more flexible getArgs function with better error reporting";
       license = "LGPL";
     }) {};

  "simpleirc" = callPackage
    ({ mkDerivation, base, bytestring, connection, containers, hspec
     , HUnit, knob, network, old-locale, time
     }:
     mkDerivation {
       pname = "simpleirc";
       version = "0.3.1";
       sha256 = "8573184d344d1e0217d693a30e00a70b424e9c5b126a80178568f8f58ac290d7";
       libraryHaskellDepends = [
         base bytestring connection containers network old-locale time
       ];
       testHaskellDepends = [ base bytestring hspec HUnit knob ];
       homepage = "http://github.com/dom96/SimpleIRC";
       description = "Simple IRC Library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simpleirc-lens" = callPackage
    ({ mkDerivation, base, bytestring, simpleirc }:
     mkDerivation {
       pname = "simpleirc-lens";
       version = "0.2.0.0";
       sha256 = "7c09809b424c5cbee69d38d516d88eb21dcfb11ae31a06c2673a284f87a5bfb2";
       libraryHaskellDepends = [ base bytestring simpleirc ];
       homepage = "https://github.com/relrod/simpleirc-lens";
       description = "Lenses for simpleirc types";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simplenote" = callPackage
    ({ mkDerivation, base, bytestring, curl, dataenc, download-curl
     , HTTP, json, time, utf8-string
     }:
     mkDerivation {
       pname = "simplenote";
       version = "1.0";
       sha256 = "7b004409af4f10c31879c54c30d0b09dccab6f1718ef8386c43aff0dd7b6ef4d";
       libraryHaskellDepends = [
         base bytestring curl dataenc download-curl HTTP json time
         utf8-string
       ];
       description = "Haskell interface for the simplenote API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simpleprelude" = callPackage
    ({ mkDerivation, base, ghc-paths, haskell-src-exts, process
     , uniplate
     }:
     mkDerivation {
       pname = "simpleprelude";
       version = "1.0.1.3";
       sha256 = "12922614ab11b6946418202b23529b3525c3577fd3ff061347d095426a829062";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [
         base ghc-paths haskell-src-exts process uniplate
       ];
       jailbreak = true;
       description = "A simplified Haskell prelude for teaching";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simplesmtpclient" = callPackage
    ({ mkDerivation, array, base, directory, network, old-time }:
     mkDerivation {
       pname = "simplesmtpclient";
       version = "0.2";
       sha256 = "48b65ada82fa8ac73216437f2ffb17606b8b31ca3a6264a11f705b2184400f7d";
       revision = "1";
       editedCabalFile = "e6021c7bbf5e50c15433dca491f4618483229203c810a7b71e7c42094e13ad25";
       libraryHaskellDepends = [ array base directory network old-time ];
       description = "Very simple SMTP Client";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simplessh" = callPackage
    ({ mkDerivation, base, bytestring, mtl, ssh2 }:
     mkDerivation {
       pname = "simplessh";
       version = "0.2.0.5";
       sha256 = "78ad83c1af758c0171e9fa6299bd5b3eff669a92320a2bde4aa632a8d16419b8";
       libraryHaskellDepends = [ base bytestring mtl ];
       librarySystemDepends = [ ssh2 ];
       homepage = "http://hub.darcs.net/thoferon/simplessh";
       description = "Simple wrapper around libssh2";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {ssh2 = null;};

  "simplest-sqlite" = callPackage
    ({ mkDerivation, base, bytestring, exception-hierarchy, sqlite
     , template-haskell, text
     }:
     mkDerivation {
       pname = "simplest-sqlite";
       version = "0.0.0.14";
       sha256 = "5534a0e32ca607ca8004b6f8a666812eeb6cf9750e8bffd206a15c3a8f067d18";
       libraryHaskellDepends = [
         base bytestring exception-hierarchy template-haskell text
       ];
       librarySystemDepends = [ sqlite ];
       homepage = "comming soon";
       description = "Simplest SQLite3 binding";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) sqlite;};

  "simplex" = callPackage
    ({ mkDerivation, base, directory, filepath, mtl, process, random
     , regex-compat, split, time
     }:
     mkDerivation {
       pname = "simplex";
       version = "0.3.8";
       sha256 = "0291a7838c825ae9994f2956afb703d3085a1ef25985236891b1f936c8d31e7d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath mtl process random regex-compat split time
       ];
       homepage = "http://github.com/scravy/simplex";
       description = "A simple markup language that translates to LaTeX";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "simplex-basic" = callPackage
    ({ mkDerivation, base, bifunctors, containers, hspec
     , linear-grammar, mtl, QuickCheck, transformers
     }:
     mkDerivation {
       pname = "simplex-basic";
       version = "0.0.0.1";
       sha256 = "f8a30128d4e16714f75fee3b16fd3d4b24832a30f17ff29936a1c5a066b60ba0";
       libraryHaskellDepends = [
         base bifunctors linear-grammar mtl QuickCheck transformers
       ];
       testHaskellDepends = [
         base bifunctors containers hspec linear-grammar mtl QuickCheck
         transformers
       ];
       description = "Very basic simplex implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "simseq" = callPackage
    ({ mkDerivation, base, bio, bytestring, random }:
     mkDerivation {
       pname = "simseq";
       version = "0.0";
       sha256 = "d58c4d03d4c9862562b270269a4d96650d27b66c0bfe5e5e060db05ea29ec044";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bio bytestring random ];
       homepage = "http://malde.org/~ketil/";
       description = "Simulate sequencing with different models for priming and errors";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "simtreelo" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "simtreelo";
       version = "0.1.1.0";
       sha256 = "820e7189bb824c3480bb5492ddaf04a3b8200fea747084ab35e15ad46815f8c8";
       libraryHaskellDepends = [ base containers ];
       description = "Loader for data organized in a tree";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "sindre" = callPackage
    ({ mkDerivation, array, attoparsec, base, bytestring, containers
     , libXft, mtl, parsec, permute, process, regex-pcre, setlocale
     , text, unix, utf8-string, X11, X11-rm, x11-xim, X11-xshape
     }:
     mkDerivation {
       pname = "sindre";
       version = "0.4";
       sha256 = "a2caab6c96a0e1f2b305c561820c19f394d9fc9123af7b43e1d95c01a6cee65c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array attoparsec base bytestring containers mtl parsec permute
         process regex-pcre setlocale text unix utf8-string X11 X11-rm
         x11-xim X11-xshape
       ];
       libraryPkgconfigDepends = [ libXft ];
       executableHaskellDepends = [
         array attoparsec base bytestring containers mtl parsec permute
         process regex-pcre setlocale text unix utf8-string X11 X11-rm
         x11-xim X11-xshape
       ];
       executablePkgconfigDepends = [ libXft ];
       jailbreak = true;
       homepage = "http://sigkill.dk/programs/sindre";
       description = "A programming language for simple GUIs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.xorg) libXft;};

  "singleton-nats" = callPackage
    ({ mkDerivation, base, singletons }:
     mkDerivation {
       pname = "singleton-nats";
       version = "0.4.0.1";
       sha256 = "4914fba386076d7581dbf9911a644086662f578e421618bdaded4e3f36785e4d";
       libraryHaskellDepends = [ base singletons ];
       homepage = "https://github.com/AndrasKovacs/singleton-nats";
       description = "Unary natural numbers relying on the singletons infrastructure";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "singletons_1_0" = callPackage
    ({ mkDerivation, base, Cabal, constraints, containers, filepath
     , mtl, process, tasty, tasty-golden, template-haskell, th-desugar
     }:
     mkDerivation {
       pname = "singletons";
       version = "1.0";
       sha256 = "6fd249e196320d35c816df32cef988c4e50022faea34d9c4a318c2c79138a1e5";
       revision = "1";
       editedCabalFile = "a16e79659af16eee0fd4d5062a002c143dfbe306ed758f6989dab2f97ac6830f";
       libraryHaskellDepends = [
         base containers mtl template-haskell th-desugar
       ];
       testHaskellDepends = [
         base Cabal constraints filepath process tasty tasty-golden
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.cis.upenn.edu/~eir/packages/singletons";
       description = "A framework for generating singleton types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "singletons_1_1_1" = callPackage
    ({ mkDerivation, base, Cabal, constraints, containers, filepath
     , mtl, process, tasty, tasty-golden, template-haskell, th-desugar
     }:
     mkDerivation {
       pname = "singletons";
       version = "1.1.1";
       sha256 = "ca10219a342fa9332031b81f5f0b0e2ba874fddb5813379c1ebcf62da2207fdd";
       libraryHaskellDepends = [
         base containers mtl template-haskell th-desugar
       ];
       testHaskellDepends = [
         base Cabal constraints filepath process tasty tasty-golden
       ];
       doCheck = false;
       homepage = "http://www.cis.upenn.edu/~eir/packages/singletons";
       description = "A framework for generating singleton types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "singletons_1_1_2" = callPackage
    ({ mkDerivation, base, Cabal, constraints, containers, filepath
     , mtl, process, tasty, tasty-golden, template-haskell, th-desugar
     }:
     mkDerivation {
       pname = "singletons";
       version = "1.1.2";
       sha256 = "8dd0a8c1bfb3b3a73e439439baba094375a9cd8652afba1126c9858968ed5780";
       libraryHaskellDepends = [
         base containers mtl template-haskell th-desugar
       ];
       testHaskellDepends = [
         base Cabal constraints filepath process tasty tasty-golden
       ];
       doCheck = false;
       homepage = "http://www.cis.upenn.edu/~eir/packages/singletons";
       description = "A framework for generating singleton types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "singletons_1_1_2_1" = callPackage
    ({ mkDerivation, base, Cabal, constraints, containers, filepath
     , mtl, process, tasty, tasty-golden, template-haskell, th-desugar
     }:
     mkDerivation {
       pname = "singletons";
       version = "1.1.2.1";
       sha256 = "0b56d0f50887cc98274b1c399df0c2fb188fd9c77f64360e9dab18cc9d54abd3";
       libraryHaskellDepends = [
         base containers mtl template-haskell th-desugar
       ];
       testHaskellDepends = [
         base Cabal constraints filepath process tasty tasty-golden
       ];
       doCheck = false;
       homepage = "http://www.cis.upenn.edu/~eir/packages/singletons";
       description = "A framework for generating singleton types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "singletons" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, filepath, mtl
     , process, syb, tasty, tasty-golden, template-haskell, th-desugar
     }:
     mkDerivation {
       pname = "singletons";
       version = "2.0.1";
       sha256 = "fd149d3da367eebe81728a7a61389f18bb18b3cddd611b7aed6c0b265110ba41";
       libraryHaskellDepends = [
         base containers mtl syb template-haskell th-desugar
       ];
       testHaskellDepends = [
         base Cabal directory filepath process tasty tasty-golden
       ];
       doCheck = false;
       homepage = "http://www.github.com/goldfirere/singletons";
       description = "A framework for generating singleton types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sink" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "sink";
       version = "0.1.0.1";
       sha256 = "f7e736ffe4b73cb6b4d818ea0fe17a636afef60ecad80764e0b40a080a49de12";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "An alternative to lazy I/O that doesn't conflate execution with evaluation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "siphash" = callPackage
    ({ mkDerivation, base, bytestring, cpu, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "siphash";
       version = "1.0.3";
       sha256 = "cf81ce41c6ca40c4fec9add5dcebc161cb2d31f522f9ad727df23d30ac6a05f3";
       libraryHaskellDepends = [ base bytestring cpu ];
       testHaskellDepends = [
         base bytestring QuickCheck test-framework
         test-framework-quickcheck2
       ];
       homepage = "http://github.com/vincenthz/hs-siphash";
       description = "siphash: a fast short input PRF";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sirkel" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, hashtables
     , haskell98, random, remote, SHA, transformers
     }:
     mkDerivation {
       pname = "sirkel";
       version = "0.1";
       sha256 = "56fd4bb8fd54d4bcad49ba984e6f718bbbeb9f3e37c6fccb5709b3bf1b841742";
       libraryHaskellDepends = [
         base binary bytestring containers hashtables haskell98 random
         remote SHA transformers
       ];
       description = "Sirkel, a Chord DHT";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sitemap" = callPackage
    ({ mkDerivation, base, lens, taggy, taggy-lens, text }:
     mkDerivation {
       pname = "sitemap";
       version = "0.1.2";
       sha256 = "6d05b3460b11642ddc4a901d9d5ddadc63af47777bfa60f8c3faab6938104b5a";
       libraryHaskellDepends = [ base lens taggy taggy-lens text ];
       homepage = "http://github.com/alpmestan/sitemap";
       description = "Sitemap parser";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sized" = callPackage
    ({ mkDerivation, base, constraints, containers, ListLike
     , monomorphic, type-natural, vector
     }:
     mkDerivation {
       pname = "sized";
       version = "0.1.0.0";
       sha256 = "14beecab5676c30cec8b3a94e60feb9752ebeb8ca9a520896f868d39cf72c902";
       libraryHaskellDepends = [
         base constraints containers ListLike monomorphic type-natural
         vector
       ];
       jailbreak = true;
       description = "Sized sequence data-types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sized-types" = callPackage
    ({ mkDerivation, array, base, base-compat, containers, QuickCheck
     , singletons
     }:
     mkDerivation {
       pname = "sized-types";
       version = "0.5.1";
       sha256 = "c76772fc89028f5407906bc699e7dd98e02328d0fe98c151706100e49f4899db";
       revision = "1";
       editedCabalFile = "b6a0520904cba8a44505d78d4188a94ccdf67be3c376c0cbd49c92e07943d17c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base base-compat containers singletons
       ];
       executableHaskellDepends = [ base base-compat ];
       testHaskellDepends = [ base QuickCheck ];
       homepage = "http://www.ittc.ku.edu/csdl/fpg/Tools";
       description = "Sized types in Haskell using the GHC Nat kind";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sized-vector" = callPackage
    ({ mkDerivation, base, constraints, deepseq, equational-reasoning
     , hashable, monomorphic, singletons, template-haskell, type-natural
     }:
     mkDerivation {
       pname = "sized-vector";
       version = "1.4.3.0";
       sha256 = "319fe06e8879373ec7019de6549fcc9a36851f5d4ab62d614bac3782f38d11e4";
       libraryHaskellDepends = [
         base constraints deepseq equational-reasoning hashable monomorphic
         singletons template-haskell type-natural
       ];
       homepage = "https://github.com/konn/sized-vector";
       description = "Size-parameterized vector types and functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sizes" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, deepseq, dlist, lens
     , parallel-io, regex-posix, system-fileio, system-filepath, text
     , unix
     }:
     mkDerivation {
       pname = "sizes";
       version = "2.3.2";
       sha256 = "afe1f8a9b1e75e7004796ccdcd343eba2b1d1cb600f6aab70c7ac2396807da76";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs deepseq dlist lens parallel-io regex-posix
         system-fileio system-filepath text unix
       ];
       homepage = "https://github.com/jwiegley/sizes";
       description = "Recursively show space (size and i-nodes) used in subdirectories";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sjsp" = callPackage
    ({ mkDerivation, alex, base, blaze-builder, bytestring, filepath
     , ghc-prim, happy, language-javascript, syb, unordered-containers
     }:
     mkDerivation {
       pname = "sjsp";
       version = "0.1.0";
       sha256 = "74117748b466651b379696565687215dd8f89f5a45105b9c967146507f86e674";
       revision = "1";
       editedCabalFile = "309e00100db2c1bae2d292c485f2dc1a68e1c72a848a2142c3f0637c494dd727";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-builder bytestring filepath ghc-prim language-javascript
         syb unordered-containers
       ];
       executableToolDepends = [ alex happy ];
       description = "Simple JavaScript Profiler";
       license = stdenv.lib.licenses.mit;
     }) {};

  "skein_1_0_9_1" = callPackage
    ({ mkDerivation, base, bytestring, cereal, crypto-api, filepath
     , hspec, tagged
     }:
     mkDerivation {
       pname = "skein";
       version = "1.0.9.1";
       sha256 = "88b7423af8b1d27548e85d2b246c82b03489e9bcbc5cbb7a9f71271be92b5a15";
       libraryHaskellDepends = [
         base bytestring cereal crypto-api tagged
       ];
       testHaskellDepends = [
         base bytestring cereal crypto-api filepath hspec tagged
       ];
       jailbreak = true;
       homepage = "https://github.com/meteficha/skein";
       description = "Skein, a family of cryptographic hash functions. Includes Skein-MAC as well.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "skein_1_0_9_2" = callPackage
    ({ mkDerivation, base, bytestring, cereal, crypto-api, filepath
     , hspec, tagged
     }:
     mkDerivation {
       pname = "skein";
       version = "1.0.9.2";
       sha256 = "fc85e895caf22fc70f12982132a1ef663790c578226cb230693be5222a860bc9";
       revision = "1";
       editedCabalFile = "824638ce2aaf27614e10fe56fe886e486969fb9483e722a025b38fff3fb099ab";
       libraryHaskellDepends = [
         base bytestring cereal crypto-api tagged
       ];
       testHaskellDepends = [
         base bytestring cereal crypto-api filepath hspec tagged
       ];
       jailbreak = true;
       homepage = "https://github.com/meteficha/skein";
       description = "Skein, a family of cryptographic hash functions. Includes Skein-MAC as well.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "skein_1_0_9_3" = callPackage
    ({ mkDerivation, base, bytestring, cereal, crypto-api, filepath
     , hspec, tagged
     }:
     mkDerivation {
       pname = "skein";
       version = "1.0.9.3";
       sha256 = "c7bab12dbad3af29fd8d3b10f418198fe22315e8f849539bf9d7efe9495df14c";
       libraryHaskellDepends = [
         base bytestring cereal crypto-api tagged
       ];
       testHaskellDepends = [
         base bytestring cereal crypto-api filepath hspec tagged
       ];
       jailbreak = true;
       homepage = "https://github.com/meteficha/skein";
       description = "Skein, a family of cryptographic hash functions. Includes Skein-MAC as well.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "skein" = callPackage
    ({ mkDerivation, base, bytestring, cereal, crypto-api, filepath
     , hspec, tagged
     }:
     mkDerivation {
       pname = "skein";
       version = "1.0.9.4";
       sha256 = "f882ca0cc5ed336ef898fb3c89579e392900259296b2320edf968b9fc16cb8c9";
       libraryHaskellDepends = [
         base bytestring cereal crypto-api tagged
       ];
       testHaskellDepends = [
         base bytestring cereal crypto-api filepath hspec tagged
       ];
       doCheck = false;
       homepage = "https://github.com/meteficha/skein";
       description = "Skein, a family of cryptographic hash functions. Includes Skein-MAC as well.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "skeleton" = callPackage
    ({ mkDerivation, argparser, attoparsec, base, bytestring, filepath
     , hex, posix-escape, process, time
     }:
     mkDerivation {
       pname = "skeleton";
       version = "0.1.0.0";
       sha256 = "8be93118b4cb2c2a67a7573bd550b6797dcfeeaee45155efcabe1e4e28e16c81";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         argparser attoparsec base bytestring filepath hex posix-escape
         process time
       ];
       description = "a tool to access the OSX keychain";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "skeletons" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, containers, directory
     , filepath, text, tinytemplate, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "skeletons";
       version = "0.4.0";
       sha256 = "3dd5045d09131434a794b9452980b4a54da4312d2e1116ac455bbc9bdf6fbcc6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-wl-pprint base containers directory filepath text tinytemplate
         transformers transformers-compat
       ];
       homepage = "https://github.com/jb55/skeletons";
       description = "Manage project skeletons";
       license = stdenv.lib.licenses.mit;
       maintainers = with stdenv.lib.maintainers; [ jb55 ];
     }) {};

  "skell" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, containers
     , http-types, text, wai
     }:
     mkDerivation {
       pname = "skell";
       version = "0.1.0.0";
       sha256 = "9792ec6f54a177f74aeaffb4090f80ee947a4da0b10cdca07e65535d38c3d452";
       libraryHaskellDepends = [
         base blaze-html bytestring containers http-types text wai
       ];
       jailbreak = true;
       homepage = "https://github.com/pharpend/skell";
       description = "An overly complex Haskell web framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "skemmtun" = callPackage
    ({ mkDerivation, base, bytestring, data-default, http-client
     , http-types, lens, text, time, wreq, xml-conduit
     }:
     mkDerivation {
       pname = "skemmtun";
       version = "0.1.0.0";
       sha256 = "9602063e569741878f18dc1820a7281a3387ff6fdfdc394e32511f2abaab6c11";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring data-default http-client http-types lens text time
         wreq xml-conduit
       ];
       jailbreak = true;
       homepage = "https://github.com/nyorem/skemmtun";
       description = "A MyAnimeList.net client.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "skype4hs" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, lifted-base
     , monad-control, mtl, stm, text, time, transformers-base, word8
     , X11
     }:
     mkDerivation {
       pname = "skype4hs";
       version = "0.0.0.0";
       sha256 = "97beee10c2a51ab6fb4ad380e56e18887a4a600e20965de8d8b5f7eafc302d57";
       libraryHaskellDepends = [
         attoparsec base bytestring lifted-base monad-control mtl stm text
         time transformers-base word8 X11
       ];
       homepage = "https://github.com/emonkak/haskell-skype";
       description = "Skype Desktop API binding for Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "skypelogexport" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , directory, filepath, ghc-binary, haskell98, IfElse, old-locale
     , regex-pcre, time, utf8-string
     }:
     mkDerivation {
       pname = "skypelogexport";
       version = "0.2";
       sha256 = "1c32717ba2064ebb64eda6141dfc2c402f7bf8e350923ae5ff472bc35daa6966";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base bytestring containers directory filepath ghc-binary
         haskell98 IfElse old-locale regex-pcre time utf8-string
       ];
       jailbreak = true;
       homepage = "https://github.com/jdevelop/skypelogexport/wiki";
       description = "Export Skype chat logs to text files";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {ghc-binary = null;};

  "slack" = callPackage
    ({ mkDerivation, aeson, base, containers, either, http-conduit, mtl
     , old-locale, text, time, transformers
     }:
     mkDerivation {
       pname = "slack";
       version = "0.1.0.0";
       sha256 = "c7281f14699bcab05f75b4dbdf8c3be7a52b3a4e066dcb506aad6fc5d123116b";
       libraryHaskellDepends = [
         aeson base containers either http-conduit mtl old-locale text time
         transformers
       ];
       jailbreak = true;
       description = "Haskell API for interacting with Slack";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "slack-api" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, errors
     , HsOpenSSL, io-streams, lens, lens-aeson, monad-loops, mtl
     , network, network-uri, openssl-streams, text, time
     , time-locale-compat, transformers, websockets, wreq
     }:
     mkDerivation {
       pname = "slack-api";
       version = "0.6";
       sha256 = "9e4c7ef5387dcf06fd5f56c2076e124af96db8b5e2830b91ee0137c59072204f";
       libraryHaskellDepends = [
         aeson base bytestring containers errors HsOpenSSL io-streams lens
         lens-aeson monad-loops mtl network network-uri openssl-streams text
         time time-locale-compat transformers websockets wreq
       ];
       testHaskellDepends = [ base ];
       description = "Bindings to the Slack RTM API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "slack-notify-haskell" = callPackage
    ({ mkDerivation, base, bytestring, containers, HTTP, http-client
     , http-client-tls, network, text
     }:
     mkDerivation {
       pname = "slack-notify-haskell";
       version = "0.2.3";
       sha256 = "87cd11fbd8f1c88140c1b09c50bec6bd112f215df66286fe6d189d05c82ee06b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers HTTP http-client http-client-tls network
         text
       ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/tattsun/slack-notify-haskell";
       description = "Slack notifier for Haskell project";
       license = stdenv.lib.licenses.mit;
     }) {};

  "slave-thread_0_1_4" = callPackage
    ({ mkDerivation, base, base-prelude, HTF, list-t, mmorph
     , partial-handler, QuickCheck, quickcheck-instances, SafeSemaphore
     , stm-containers, transformers
     }:
     mkDerivation {
       pname = "slave-thread";
       version = "0.1.4";
       sha256 = "dfbce6de3e2473cfec752d9a99b0ca6238b07e8b59eb06796b222e8e88f23229";
       libraryHaskellDepends = [
         base base-prelude list-t mmorph partial-handler stm-containers
         transformers
       ];
       testHaskellDepends = [
         base base-prelude HTF QuickCheck quickcheck-instances SafeSemaphore
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/slave-thread";
       description = "A principal solution to ghost threads and silent exceptions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "slave-thread_0_1_5" = callPackage
    ({ mkDerivation, base, base-prelude, HTF, list-t, mmorph
     , partial-handler, QuickCheck, quickcheck-instances, SafeSemaphore
     , stm-containers, transformers
     }:
     mkDerivation {
       pname = "slave-thread";
       version = "0.1.5";
       sha256 = "84c3be875bae9d6abd995f629b4ffd3a8d83f445509712cdb66d410388618463";
       libraryHaskellDepends = [
         base base-prelude list-t mmorph partial-handler stm-containers
         transformers
       ];
       testHaskellDepends = [
         base base-prelude HTF QuickCheck quickcheck-instances SafeSemaphore
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/slave-thread";
       description = "A principal solution to ghost threads and silent exceptions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "slave-thread_0_1_6" = callPackage
    ({ mkDerivation, base, base-prelude, HTF, list-t, mmorph
     , partial-handler, QuickCheck, quickcheck-instances, SafeSemaphore
     , stm-containers, transformers
     }:
     mkDerivation {
       pname = "slave-thread";
       version = "0.1.6";
       sha256 = "4fe359f3c1927c494494fd06ecbda2210163720ee7abbaac47fd591643efd3a6";
       libraryHaskellDepends = [
         base base-prelude list-t mmorph partial-handler stm-containers
         transformers
       ];
       testHaskellDepends = [
         base base-prelude HTF QuickCheck quickcheck-instances SafeSemaphore
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/slave-thread";
       description = "A principal solution to ghost threads and silent exceptions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "slave-thread_1_0_0_0" = callPackage
    ({ mkDerivation, base, base-prelude, HTF, list-t, mmorph
     , partial-handler, QuickCheck, quickcheck-instances, SafeSemaphore
     , stm-containers, transformers
     }:
     mkDerivation {
       pname = "slave-thread";
       version = "1.0.0.0";
       sha256 = "298c1959030bcc6b4e4cba134fae7232210acab77fb54697c0e92823c206d36a";
       libraryHaskellDepends = [
         base base-prelude list-t mmorph partial-handler stm-containers
         transformers
       ];
       testHaskellDepends = [
         base base-prelude HTF QuickCheck quickcheck-instances SafeSemaphore
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/slave-thread";
       description = "A principal solution to ghost threads and silent exceptions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "slave-thread" = callPackage
    ({ mkDerivation, base, base-prelude, HTF, list-t, mmorph
     , partial-handler, QuickCheck, quickcheck-instances, SafeSemaphore
     , stm-containers, transformers
     }:
     mkDerivation {
       pname = "slave-thread";
       version = "1.0.1";
       sha256 = "c1396bd77b21997e5d1e86b212a08b7d453030374b8baddef51593922337d755";
       libraryHaskellDepends = [
         base base-prelude list-t mmorph partial-handler stm-containers
         transformers
       ];
       testHaskellDepends = [
         base base-prelude HTF QuickCheck quickcheck-instances SafeSemaphore
       ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/slave-thread";
       description = "A principal solution to ghost threads and silent exceptions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "slice-cpp-gen" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, containers, directory
     , filepath, language-slice, MissingH
     }:
     mkDerivation {
       pname = "slice-cpp-gen";
       version = "0.3.0.0";
       sha256 = "de0fc18e97165a212d14fc644d421e5f3c1d1a0f274652fc6a6720a421927257";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs containers directory filepath
         language-slice MissingH
       ];
       homepage = "https://github.com/paulkoerbitz/slice-cpp-gen";
       description = "Generate C++ skeletons from slice files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "slidemews" = callPackage
    ({ mkDerivation, aeson, base, bytestring, MonadCatchIO-transformers
     , mtl, pandoc, snap-core, snap-server, utf8-string
     }:
     mkDerivation {
       pname = "slidemews";
       version = "0.3";
       sha256 = "c0fdddbeb642f1af0db8142891625837f41fb5ca0d11c9afc63a398edba6cb74";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring MonadCatchIO-transformers mtl pandoc
         snap-core snap-server utf8-string
       ];
       description = "ws convert markdown to reveal-js";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sloane" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, attoparsec, base
     , bloomfilter, bytestring, conduit, conduit-extra, containers
     , directory, filepath, http-conduit, http-types
     , optparse-applicative, resourcet, stringsearch, terminal-size
     , text, transformers
     }:
     mkDerivation {
       pname = "sloane";
       version = "4.2.0";
       sha256 = "cd2bf21a9ea502ded331780b074991e4b5e06e7b276a6874c9b921bc70ba3595";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson ansi-terminal attoparsec base bloomfilter bytestring conduit
         conduit-extra containers directory filepath http-conduit http-types
         optparse-applicative resourcet stringsearch terminal-size text
         transformers
       ];
       homepage = "http://akc.is/sloane";
       description = "A command line interface to Sloane's OEIS";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "slot-lambda" = callPackage
    ({ mkDerivation, base, containers, haskell-src-exts
     , haskell-src-meta, syb, template-haskell, vector
     }:
     mkDerivation {
       pname = "slot-lambda";
       version = "0.1.0.3";
       sha256 = "31197ad4636b6f7bbb70ecc990ebb6610a978f0c524ffe6d892b2ba8fcb1f1da";
       libraryHaskellDepends = [
         base containers haskell-src-exts haskell-src-meta syb
         template-haskell vector
       ];
       homepage = "https://github.com/ducis/pa_slot";
       description = "Write lambdas without naming the parameters";
       license = stdenv.lib.licenses.mit;
     }) {};

  "sloth" = callPackage
    ({ mkDerivation, base, mtl, process }:
     mkDerivation {
       pname = "sloth";
       version = "0.0.2";
       sha256 = "095fad381ced5fdbcdab934c1b35598e7518225826f739873878d0856be07174";
       libraryHaskellDepends = [ base mtl process ];
       description = "Testing for minimal strictness";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "slug_0_1_1" = callPackage
    ({ mkDerivation, aeson, base, exceptions, path-pieces, persistent
     , QuickCheck, test-framework, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "slug";
       version = "0.1.1";
       sha256 = "4512ca905017cc32a03e757b4cfc21e232dd35c671a068615b89de01d80bcec2";
       libraryHaskellDepends = [
         aeson base exceptions path-pieces persistent text
       ];
       testHaskellDepends = [
         base exceptions path-pieces QuickCheck test-framework
         test-framework-quickcheck2 text
       ];
       homepage = "https://github.com/mrkkrp/slug";
       description = "Type-safe slugs for Yesod ecosystem";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "slug" = callPackage
    ({ mkDerivation, aeson, base, exceptions, path-pieces, persistent
     , QuickCheck, test-framework, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "slug";
       version = "0.1.2";
       sha256 = "4f4a85b88dbac7b11aae52ad22947328dfdbfb1f0472d70dbd52aa63098c9d5d";
       libraryHaskellDepends = [
         aeson base exceptions path-pieces persistent text
       ];
       testHaskellDepends = [
         base exceptions path-pieces QuickCheck test-framework
         test-framework-quickcheck2 text
       ];
       homepage = "https://github.com/mrkkrp/slug";
       description = "Type-safe slugs for Yesod ecosystem";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "smallarray" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, hashable }:
     mkDerivation {
       pname = "smallarray";
       version = "0.2.2.4";
       sha256 = "3fe81a5c7d280618033899e48dc59982cf8513aa7568d24cc7b0e7879eeecf99";
       libraryHaskellDepends = [ base bytestring deepseq hashable ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~aslatter/code/bytearray";
       description = "low-level unboxed arrays, with minimal features";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "smallcaps" = callPackage
    ({ mkDerivation, attoparsec, base, containers, data-default
     , directory, filepath, parsec, text, transformers
     }:
     mkDerivation {
       pname = "smallcaps";
       version = "0.6.0.1";
       sha256 = "b20b7527ee8b9957504e3126161c205fde04a82d460812a60aea1ee3c3549e38";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base containers data-default directory filepath parsec
         text transformers
       ];
       executableHaskellDepends = [ base containers data-default text ];
       testHaskellDepends = [
         attoparsec base containers data-default parsec text
       ];
       description = "Flatten camel case text in LaTeX files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "smallcheck" = callPackage
    ({ mkDerivation, base, ghc-prim, logict, mtl, pretty }:
     mkDerivation {
       pname = "smallcheck";
       version = "1.1.1";
       sha256 = "4d17607c1a620491e7e495a17575b73952932c761e7f9bdfa87e0102fb52f9f9";
       revision = "1";
       editedCabalFile = "b19c841b12cc34f6379c2b72bc4c250da9b0346c46690dae419caaa0310478fa";
       libraryHaskellDepends = [ base ghc-prim logict mtl pretty ];
       homepage = "https://github.com/feuerbach/smallcheck";
       description = "A property-based testing library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "smallcheck-laws" = callPackage
    ({ mkDerivation, base, smallcheck, smallcheck-series }:
     mkDerivation {
       pname = "smallcheck-laws";
       version = "0.3";
       sha256 = "87d8ee55131915b5549a0053b605729222e3d6c79be94f8bb35aa263f50ad6cb";
       libraryHaskellDepends = [ base smallcheck smallcheck-series ];
       homepage = "http://github.com/jdnavarro/smallcheck-laws";
       description = "SmallCheck properties for common laws";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "smallcheck-lens" = callPackage
    ({ mkDerivation, base, lens, smallcheck, smallcheck-series
     , transformers
     }:
     mkDerivation {
       pname = "smallcheck-lens";
       version = "0.3";
       sha256 = "0123159b7534f0315f376e24b1811c7290a417354a783134d33fa07d447818ef";
       libraryHaskellDepends = [
         base lens smallcheck smallcheck-series transformers
       ];
       homepage = "https://github.com/jdnavarro/smallcheck-lens";
       description = "SmallCheck properties for lens";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "smallcheck-series" = callPackage
    ({ mkDerivation, base, bytestring, containers, doctest, Glob
     , logict, smallcheck, text, transformers
     }:
     mkDerivation {
       pname = "smallcheck-series";
       version = "0.5.1";
       sha256 = "8bee99c89c9437bbaf7f5c203957ed73b0d2e419956f7e509ed5bc8a19728cdd";
       libraryHaskellDepends = [
         base bytestring containers logict smallcheck text transformers
       ];
       testHaskellDepends = [ base doctest Glob ];
       homepage = "https://github.com/jdnavarro/smallcheck-series";
       description = "Extra SmallCheck series and utilities";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "smallpt-hs" = callPackage
    ({ mkDerivation, base, vector }:
     mkDerivation {
       pname = "smallpt-hs";
       version = "0.1";
       sha256 = "a95cdea0d1bd6e1d727c214f6c44f354e0ca5ac2607b42e9a8f3a6219f168fbc";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base vector ];
       jailbreak = true;
       homepage = "http://github.com/noteed/smallpt-hs";
       description = "A Haskell port of the smallpt path tracer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "smallstring" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, hashable, smallarray
     , text, utf8-string
     }:
     mkDerivation {
       pname = "smallstring";
       version = "0.3.3";
       sha256 = "a51cef929034bfa6a4f8870bba71d9682b9d7248fb4243673465a66ea75d6ff2";
       libraryHaskellDepends = [
         base bytestring deepseq hashable smallarray text utf8-string
       ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~aslatter/code/smallstring/";
       description = "A Unicode text type, optimized for low memory overhead";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "smaoin" = callPackage
    ({ mkDerivation, base, bytestring, QuickCheck, random, text, uuid
     }:
     mkDerivation {
       pname = "smaoin";
       version = "0.3.0.0";
       sha256 = "378bff0ab90d63ddc20a3cbe42a0b441d97f8f54c291958e09603dee6fbb2848";
       revision = "1";
       editedCabalFile = "1644cbb1dc0081d93276a72cc5c5471bed4647d833e6fd67282cfb62c7f81936";
       libraryHaskellDepends = [ base bytestring random text uuid ];
       testHaskellDepends = [ base bytestring QuickCheck ];
       homepage = "http://rel4tion.org/projects/smaoin-hs/";
       description = "Utilities for the Smaoin semantic information model";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "smartGroup" = callPackage
    ({ mkDerivation, base, bytestring, containers, template-haskell }:
     mkDerivation {
       pname = "smartGroup";
       version = "0.3.0";
       sha256 = "d75e168013d50ee1e950cac3592b5cf82d52a00b50f72ea85ea4d07ed02e8b83";
       libraryHaskellDepends = [
         base bytestring containers template-haskell
       ];
       homepage = "http://patch-tag.com/r/salazar/smartGroup";
       description = "group strings or bytestrings by words in common";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "smartcheck" = callPackage
    ({ mkDerivation, base, containers, generic-deriving, ghc-prim, mtl
     , QuickCheck, random
     }:
     mkDerivation {
       pname = "smartcheck";
       version = "0.2.2";
       sha256 = "3a0aacd5fa0ae6a1748fc3ca19e53a675d46b14b4ddc482c572b63934f1185f1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers generic-deriving ghc-prim mtl QuickCheck random
       ];
       executableHaskellDepends = [
         base containers generic-deriving ghc-prim mtl QuickCheck random
       ];
       homepage = "https://github.com/leepike/SmartCheck";
       description = "A smarter QuickCheck";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "smartconstructor" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "smartconstructor";
       version = "0.2.0.0";
       sha256 = "9b6e462fa7a53608df161ac051e88829447cff44e7463c55ea9d340e6fd40281";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/frerich/smartconstructor";
       description = "A package exposing a helper function for generating smart constructors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "smartword" = callPackage
    ({ mkDerivation, base, haskell98, pretty, unix, utf8-string }:
     mkDerivation {
       pname = "smartword";
       version = "0.0.0.5";
       sha256 = "832ec110258149946e512c516c27178ca21dbe72b9559f8515e9335e9f24bc37";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base haskell98 pretty unix utf8-string
       ];
       homepage = "http://kyagrd.dyndns.org/~kyagrd/project/smartword/";
       description = "Web based flash card for Word Smart I and II vocabularies";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sme" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "sme";
       version = "0.1";
       sha256 = "45a8ea56dda7f3427bad8d0886e7c4cd50a35cf7695f1357b9877d3eb59773b4";
       libraryHaskellDepends = [ base ];
       description = "A library for Secure Multi-Execution in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "smoothie_0_1_3" = callPackage
    ({ mkDerivation, base, linear, vector }:
     mkDerivation {
       pname = "smoothie";
       version = "0.1.3";
       sha256 = "3abc07e79bad598c5894737c449619a1e045e0d4da61eb595f373a6a2386468c";
       libraryHaskellDepends = [ base linear vector ];
       jailbreak = true;
       homepage = "https://github.com/phaazon/smoothie";
       description = "Smooth curves via several splines and polynomials";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "smoothie_0_4_0_2" = callPackage
    ({ mkDerivation, aeson, base, linear, text, vector }:
     mkDerivation {
       pname = "smoothie";
       version = "0.4.0.2";
       sha256 = "d1224f685e481751462c6cc464af897d0d1008077960230b89706574519954bc";
       libraryHaskellDepends = [ aeson base linear text vector ];
       jailbreak = true;
       homepage = "https://github.com/phaazon/smoothie";
       description = "Smooth curves via several interpolation modes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "smoothie_0_4_1" = callPackage
    ({ mkDerivation, aeson, base, linear, text, vector }:
     mkDerivation {
       pname = "smoothie";
       version = "0.4.1";
       sha256 = "f29484ce5a765334798b1107be91b4ef555f1e67a81bd3eb1049a91eec9e6e2e";
       libraryHaskellDepends = [ aeson base linear text vector ];
       homepage = "https://github.com/phaazon/smoothie";
       description = "Smooth curves via several interpolation modes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "smoothie_0_4_2_1" = callPackage
    ({ mkDerivation, aeson, base, linear, text, vector }:
     mkDerivation {
       pname = "smoothie";
       version = "0.4.2.1";
       sha256 = "9b3dcba5880be61a4ebbd895ec711a9d137e6a246f55ee1575170c4e413ebade";
       libraryHaskellDepends = [ aeson base linear text vector ];
       homepage = "https://github.com/phaazon/smoothie";
       description = "Smooth curves via several interpolation modes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "smoothie" = callPackage
    ({ mkDerivation, aeson, base, linear, text, vector }:
     mkDerivation {
       pname = "smoothie";
       version = "0.4.2.2";
       sha256 = "be4f9b24ca5a1dc99165b2a1f5484b48b6baf16e5700514689875dbb2a0e4133";
       libraryHaskellDepends = [ aeson base linear text vector ];
       homepage = "https://github.com/phaazon/smoothie";
       description = "Smooth curves via several interpolation modes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "smsaero" = callPackage
    ({ mkDerivation, aeson, base, either, lens, servant, servant-client
     , servant-docs, text, time
     }:
     mkDerivation {
       pname = "smsaero";
       version = "0.4.1";
       sha256 = "8b6904d906ce541ce637bb9421162d3a6cedf6e54f8ec99e2bf72ec68c75efc5";
       libraryHaskellDepends = [
         aeson base either lens servant servant-client servant-docs text
         time
       ];
       homepage = "https://github.com/GetShopTV/smsaero";
       description = "SMSAero API and HTTP client based on servant library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "smt-lib" = callPackage
    ({ mkDerivation, array, base, directory, polyparse }:
     mkDerivation {
       pname = "smt-lib";
       version = "0.0.2";
       sha256 = "7e4ec60e6504f23cd275e676863e24177ea72e74b588fb73bf19aaa52e2815de";
       libraryHaskellDepends = [ array base directory polyparse ];
       jailbreak = true;
       homepage = "http://tomahawkins.org";
       description = "Parsing and printing SMT-LIB";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "smtLib" = callPackage
    ({ mkDerivation, base, pretty }:
     mkDerivation {
       pname = "smtLib";
       version = "1.0.7";
       sha256 = "6e660125d16c7ad42120df7fb0bd53d1d0614532ed3956aa34f6bcd3413ac2ca";
       revision = "1";
       editedCabalFile = "7a1d7c3e0e90bddb41538fa724f410e2a6915793ab14df4dfc4074c9d09d448e";
       libraryHaskellDepends = [ base pretty ];
       description = "A library for working with the SMTLIB format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "smtlib2" = callPackage
    ({ mkDerivation, array, atto-lisp, attoparsec, base, blaze-builder
     , bytestring, constraints, containers, data-fix, mtl, process
     , tagged, text, transformers
     }:
     mkDerivation {
       pname = "smtlib2";
       version = "0.3";
       sha256 = "dc6458cb27956bcbd037c51955597d74d540e7e1fcbc00fa8c072fb04d0d2c22";
       libraryHaskellDepends = [
         array atto-lisp attoparsec base blaze-builder bytestring
         constraints containers data-fix mtl process tagged text
         transformers
       ];
       description = "A type-safe interface to communicate with an SMT solver";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "smtp-mail" = callPackage
    ({ mkDerivation, array, base, base16-bytestring, base64-bytestring
     , bytestring, cryptohash, filepath, mime-mail, network, text
     }:
     mkDerivation {
       pname = "smtp-mail";
       version = "0.1.4.5";
       sha256 = "dcb32836cdcc165442d9c182866fa05d959bf22a8349e952e3525dbf585e0e04";
       libraryHaskellDepends = [
         array base base16-bytestring base64-bytestring bytestring
         cryptohash filepath mime-mail network text
       ];
       homepage = "http://github.com/jhickner/smtp-mail";
       description = "Simple email sending via SMTP";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "smtp-mail-ng" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring
     , base64-bytestring, bytestring, crypto-random, cryptohash
     , filepath, haskeline, mime-mail, mtl, network, stringsearch, text
     , tls, transformers, transformers-compat, x509-store, x509-system
     }:
     mkDerivation {
       pname = "smtp-mail-ng";
       version = "0.1.0.2";
       sha256 = "70bd0d1ff9705a8dc76640673698867f4958bb778f1ebcc10ae70aa1ef58724b";
       libraryHaskellDepends = [
         attoparsec base base16-bytestring base64-bytestring bytestring
         crypto-random cryptohash filepath haskeline mime-mail mtl network
         stringsearch text tls transformers transformers-compat x509-store
         x509-system
       ];
       homepage = "https://github.com/avieth/smtp-mail-ng";
       description = "An SMTP client EDSL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "smtp2mta" = callPackage
    ({ mkDerivation, base, haskell98, network, process }:
     mkDerivation {
       pname = "smtp2mta";
       version = "0.2";
       sha256 = "022488ceec1d5f993d5169b26802f8187c68bc68c544c58f460f7603f3fe667c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskell98 network process ];
       homepage = "https://github.com/singpolyma/sock2stream";
       description = "Listen for SMTP traffic and send it to an MTA script";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "smtps-gmail" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, bytestring
     , conduit, conduit-extra, data-default, filepath, mime-mail
     , network, resourcet, stringsearch, text, tls, transformers
     }:
     mkDerivation {
       pname = "smtps-gmail";
       version = "1.3.1";
       sha256 = "d70bbd06bd3dec44a96dbaff9a8ddb1af6e67703775df7c297e771e4cdadd39b";
       libraryHaskellDepends = [
         attoparsec base base64-bytestring bytestring conduit conduit-extra
         data-default filepath mime-mail network resourcet stringsearch text
         tls transformers
       ];
       homepage = "https://github.com/enzoh/smtps-gmail";
       description = "Gmail SMTP Client";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snake-game" = callPackage
    ({ mkDerivation, base, GLUT, OpenGL, random }:
     mkDerivation {
       pname = "snake-game";
       version = "1.2";
       sha256 = "6d65ed96f5ff22c7683a3f85f3dcf2c23831d18ce1d813db5328b14681a8c3c7";
       libraryHaskellDepends = [ base GLUT OpenGL random ];
       description = "Snake Game Using OpenGL";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap_0_13_3_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal
     , clientsession, comonad, configurator, containers, directory
     , directory-tree, dlist, errors, filepath, hashable, heist, lens
     , logict, MonadCatchIO-transformers, mtl, mwc-random, old-time
     , pwstore-fast, regex-posix, snap-core, snap-server, stm, syb
     , template-haskell, text, time, transformers, unordered-containers
     , vector, vector-algorithms, xmlhtml
     }:
     mkDerivation {
       pname = "snap";
       version = "0.13.3.2";
       sha256 = "3733879096fef9dd5e2e8d211a5dbede74161fc73e974db65b137fc4b968dacc";
       revision = "3";
       editedCabalFile = "2ffeb6e3e6d6d54819bc8c7d58c4bdabf1911599c4e83ededbda4f5719c0298f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring cereal clientsession comonad
         configurator containers directory directory-tree dlist errors
         filepath hashable heist lens logict MonadCatchIO-transformers mtl
         mwc-random pwstore-fast regex-posix snap-core snap-server stm syb
         text time transformers unordered-containers vector
         vector-algorithms xmlhtml
       ];
       executableHaskellDepends = [
         base bytestring containers directory directory-tree filepath
         hashable old-time snap-server template-haskell text
       ];
       jailbreak = true;
       homepage = "http://snapframework.com/";
       description = "Top-level package for the Snap Web Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap_0_14_0_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal
     , clientsession, comonad, configurator, containers, directory
     , directory-tree, dlist, errors, filepath, hashable, heist, lens
     , logict, MonadCatchIO-transformers, mtl, mwc-random, old-time
     , pwstore-fast, regex-posix, snap-core, snap-server, stm, syb
     , template-haskell, text, time, transformers, unordered-containers
     , vector, vector-algorithms, xmlhtml
     }:
     mkDerivation {
       pname = "snap";
       version = "0.14.0.1";
       sha256 = "f0bed6762e676a5e66fce723c8b12c8c42c9b90c36eb9d783e2c2ed0aa37acd6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring cereal clientsession comonad
         configurator containers directory directory-tree dlist errors
         filepath hashable heist lens logict MonadCatchIO-transformers mtl
         mwc-random pwstore-fast regex-posix snap-core snap-server stm syb
         text time transformers unordered-containers vector
         vector-algorithms xmlhtml
       ];
       executableHaskellDepends = [
         base bytestring containers directory directory-tree filepath
         hashable old-time snap-server template-haskell text
       ];
       jailbreak = true;
       homepage = "http://snapframework.com/";
       description = "Top-level package for the Snap Web Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap_0_14_0_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal
     , clientsession, comonad, configurator, containers, directory
     , directory-tree, dlist, errors, filepath, hashable, heist, lens
     , logict, MonadCatchIO-transformers, mtl, mwc-random, old-time
     , pwstore-fast, regex-posix, snap-core, snap-server, stm, syb
     , template-haskell, text, time, transformers, unordered-containers
     , vector, vector-algorithms, xmlhtml
     }:
     mkDerivation {
       pname = "snap";
       version = "0.14.0.2";
       sha256 = "f978b57bb146147d670a93cac2e1ff306cbb1f622762df1b3b0deb15a7d561fb";
       revision = "3";
       editedCabalFile = "f47d27406ebc3a2de593f5f303aa4b8c295777ed652648b848672ee4fda91bf7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring cereal clientsession comonad
         configurator containers directory directory-tree dlist errors
         filepath hashable heist lens logict MonadCatchIO-transformers mtl
         mwc-random pwstore-fast regex-posix snap-core snap-server stm syb
         text time transformers unordered-containers vector
         vector-algorithms xmlhtml
       ];
       executableHaskellDepends = [
         base bytestring containers directory directory-tree filepath
         hashable old-time snap-server template-haskell text
       ];
       jailbreak = true;
       homepage = "http://snapframework.com/";
       description = "Top-level package for the Snap Web Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap_0_14_0_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal
     , clientsession, comonad, configurator, containers, directory
     , directory-tree, dlist, errors, filepath, hashable, heist, lens
     , logict, MonadCatchIO-transformers, mtl, mwc-random, old-time
     , pwstore-fast, regex-posix, snap-core, snap-server, stm, syb
     , template-haskell, text, time, transformers, unordered-containers
     , vector, vector-algorithms, xmlhtml
     }:
     mkDerivation {
       pname = "snap";
       version = "0.14.0.3";
       sha256 = "5a41b5d24978d88cf3ead4f3c47e845bef9ef7043993bd4e7a97ccca621c896c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring cereal clientsession comonad
         configurator containers directory directory-tree dlist errors
         filepath hashable heist lens logict MonadCatchIO-transformers mtl
         mwc-random pwstore-fast regex-posix snap-core snap-server stm syb
         text time transformers unordered-containers vector
         vector-algorithms xmlhtml
       ];
       executableHaskellDepends = [
         base bytestring containers directory directory-tree filepath
         hashable old-time snap-server template-haskell text
       ];
       jailbreak = true;
       homepage = "http://snapframework.com/";
       description = "Top-level package for the Snap Web Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap_0_14_0_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal
     , clientsession, comonad, configurator, containers, directory
     , directory-tree, dlist, errors, filepath, hashable, heist, lens
     , logict, MonadCatchIO-transformers, mtl, mwc-random, old-time
     , pwstore-fast, regex-posix, snap-core, snap-server, stm, syb
     , template-haskell, text, time, transformers, unordered-containers
     , vector, vector-algorithms, xmlhtml
     }:
     mkDerivation {
       pname = "snap";
       version = "0.14.0.4";
       sha256 = "ba9374423fbe56eb7e81d05124f550a6fc941b1a07f3a60c5d0c15f362331c7c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring cereal clientsession comonad
         configurator containers directory directory-tree dlist errors
         filepath hashable heist lens logict MonadCatchIO-transformers mtl
         mwc-random pwstore-fast regex-posix snap-core snap-server stm syb
         text time transformers unordered-containers vector
         vector-algorithms xmlhtml
       ];
       executableHaskellDepends = [
         base bytestring containers directory directory-tree filepath
         hashable old-time snap-server template-haskell text
       ];
       jailbreak = true;
       homepage = "http://snapframework.com/";
       description = "Top-level package for the Snap Web Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap_0_14_0_5" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal
     , clientsession, comonad, configurator, containers, directory
     , directory-tree, dlist, errors, filepath, hashable, heist, lens
     , logict, MonadCatchIO-transformers, mtl, mwc-random, old-time
     , pwstore-fast, regex-posix, snap-core, snap-server, stm
     , template-haskell, text, time, transformers, unordered-containers
     , vector, vector-algorithms, xmlhtml
     }:
     mkDerivation {
       pname = "snap";
       version = "0.14.0.5";
       sha256 = "d9c734d6314c6ceebc835fa606d33f9f7c79bbe42f49718aec54f85c0de72e72";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring cereal clientsession comonad
         configurator containers directory directory-tree dlist errors
         filepath hashable heist lens logict MonadCatchIO-transformers mtl
         mwc-random pwstore-fast regex-posix snap-core snap-server stm text
         time transformers unordered-containers vector vector-algorithms
         xmlhtml
       ];
       executableHaskellDepends = [
         base bytestring containers directory directory-tree filepath
         hashable old-time snap-server template-haskell text
       ];
       jailbreak = true;
       homepage = "http://snapframework.com/";
       description = "Top-level package for the Snap Web Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, cereal
     , clientsession, comonad, configurator, containers, directory
     , directory-tree, dlist, either, filepath, hashable, heist, lens
     , logict, MonadCatchIO-transformers, mtl, mwc-random, old-time
     , pwstore-fast, regex-posix, snap-core, snap-server, stm
     , template-haskell, text, time, transformers, unordered-containers
     , vector, vector-algorithms, xmlhtml
     }:
     mkDerivation {
       pname = "snap";
       version = "0.14.0.6";
       sha256 = "fa9ffc7bf5c6729f7e204daecd50765a220a0ffc2feaf3f6b29977370d8db617";
       revision = "3";
       editedCabalFile = "a1c4d4668cc563516ac38acfe5b869eeff5cf98042d960593ab08e1ded09fe1d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring cereal clientsession comonad
         configurator containers directory directory-tree dlist either
         filepath hashable heist lens logict MonadCatchIO-transformers mtl
         mwc-random pwstore-fast regex-posix snap-core snap-server stm text
         time transformers unordered-containers vector vector-algorithms
         xmlhtml
       ];
       executableHaskellDepends = [
         base bytestring containers directory directory-tree filepath
         hashable old-time snap-server template-haskell text
       ];
       homepage = "http://snapframework.com/";
       description = "Top-level package for the Snap Web Framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snap-accept" = callPackage
    ({ mkDerivation, base, http-media, snap-core }:
     mkDerivation {
       pname = "snap-accept";
       version = "0.1.0";
       sha256 = "35387bd97314e8c24219cb2a9d4c6dece133847af14c67884cfeacad123e56a7";
       libraryHaskellDepends = [ base http-media snap-core ];
       jailbreak = true;
       homepage = "http://github.com/zimothy/snap-accept";
       description = "Accept header branching for the Snap web framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap-app" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "snap-app";
       version = "0.7.0";
       sha256 = "118aad91dca7d174ef5c90ee58a4abcc19a90f02f1c64372a45736d5f7ff71ec";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snap-auth-cli" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, bytestring
     , clientsession, cmdargs, snap, text, unordered-containers
     , utf8-string
     }:
     mkDerivation {
       pname = "snap-auth-cli";
       version = "0.1.0.1";
       sha256 = "14c283de9645f8ed6c40eea444985ac46ff494279500d059f627b4affeb1ed6a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson aeson-pretty base bytestring clientsession cmdargs snap text
         unordered-containers utf8-string
       ];
       jailbreak = true;
       homepage = "https://github.com/dzhus/snap-auth-cli";
       description = "Command-line tool to manage Snap AuthManager database";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snap-blaze" = callPackage
    ({ mkDerivation, base, blaze-html, snap-core }:
     mkDerivation {
       pname = "snap-blaze";
       version = "0.2.1.3";
       sha256 = "95d6ef50ff08d7b1883ab65acb4729a8dbec6b770f9f31799870b5fdf0f4f14a";
       libraryHaskellDepends = [ base blaze-html snap-core ];
       homepage = "http://github.com/jaspervdj/snap-blaze";
       description = "blaze-html integration for Snap";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snap-blaze-clay" = callPackage
    ({ mkDerivation, base, blaze-html, clay, snap-core }:
     mkDerivation {
       pname = "snap-blaze-clay";
       version = "0.1.0.0";
       sha256 = "3eba034f63ecd902395b2e359e3565d95511b282a5428fa4b4bf9fd1644ef117";
       libraryHaskellDepends = [ base blaze-html clay snap-core ];
       jailbreak = true;
       homepage = "http://github.com/deckool/snap-blaze-clay";
       description = "blaze-html-clay integration for Snap";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snap-configuration-utilities" = callPackage
    ({ mkDerivation, base, configurator, text, unordered-containers }:
     mkDerivation {
       pname = "snap-configuration-utilities";
       version = "0.1.0.0";
       sha256 = "5f2878df034aaf6269a3674df41cfea47c7402ad1531c7952ba8fc753630951d";
       libraryHaskellDepends = [
         base configurator text unordered-containers
       ];
       jailbreak = true;
       description = "Methods to manipulate Configurator objects for Snap & Snaplets";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snap-core_0_9_6_3" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , blaze-builder, blaze-builder-enumerator, bytestring
     , bytestring-mmap, case-insensitive, containers, deepseq, directory
     , enumerator, filepath, hashable, HUnit, MonadCatchIO-transformers
     , mtl, random, regex-posix, text, time, unix, unix-compat
     , unordered-containers, vector, zlib-enum
     }:
     mkDerivation {
       pname = "snap-core";
       version = "0.9.6.3";
       sha256 = "81b70058ec42b9344b779b3fac0c86086f96e9510d7a88b53954c4df67a06f44";
       revision = "1";
       editedCabalFile = "0c1361f733b60982de16c8085b38b06fc9d3bfd6538c557963406fe4fbe3483e";
       libraryHaskellDepends = [
         attoparsec attoparsec-enumerator base blaze-builder
         blaze-builder-enumerator bytestring bytestring-mmap
         case-insensitive containers deepseq directory enumerator filepath
         hashable HUnit MonadCatchIO-transformers mtl random regex-posix
         text time unix unix-compat unordered-containers vector zlib-enum
       ];
       jailbreak = true;
       homepage = "http://snapframework.com/";
       description = "Snap: A Haskell Web Framework (core interfaces and types)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap-core_0_9_6_4" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , blaze-builder, blaze-builder-enumerator, bytestring
     , bytestring-mmap, case-insensitive, containers, deepseq, directory
     , enumerator, filepath, hashable, HUnit, MonadCatchIO-transformers
     , mtl, random, regex-posix, text, time, unix, unix-compat
     , unordered-containers, vector, zlib-enum
     }:
     mkDerivation {
       pname = "snap-core";
       version = "0.9.6.4";
       sha256 = "71d3e4133a5da4d0ec8b3feb71996f60c9280bc84a01472bca9151167d2fef2b";
       libraryHaskellDepends = [
         attoparsec attoparsec-enumerator base blaze-builder
         blaze-builder-enumerator bytestring bytestring-mmap
         case-insensitive containers deepseq directory enumerator filepath
         hashable HUnit MonadCatchIO-transformers mtl random regex-posix
         text time unix unix-compat unordered-containers vector zlib-enum
       ];
       jailbreak = true;
       homepage = "http://snapframework.com/";
       description = "Snap: A Haskell Web Framework (core interfaces and types)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap-core_0_9_7_0" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , blaze-builder, blaze-builder-enumerator, bytestring
     , bytestring-mmap, case-insensitive, containers, deepseq, directory
     , enumerator, filepath, hashable, HUnit, MonadCatchIO-transformers
     , mtl, random, regex-posix, text, time, unix, unix-compat
     , unordered-containers, vector, zlib-enum
     }:
     mkDerivation {
       pname = "snap-core";
       version = "0.9.7.0";
       sha256 = "dc9a11cbfc6a2dffd59b9d8ff803096c18f50a91c6932a0ce7e6ec32f099ab2a";
       revision = "1";
       editedCabalFile = "052dd91058bbdf948c75693679c257ae4511bcf8c46428f975d8d31e78e860a4";
       libraryHaskellDepends = [
         attoparsec attoparsec-enumerator base blaze-builder
         blaze-builder-enumerator bytestring bytestring-mmap
         case-insensitive containers deepseq directory enumerator filepath
         hashable HUnit MonadCatchIO-transformers mtl random regex-posix
         text time unix unix-compat unordered-containers vector zlib-enum
       ];
       jailbreak = true;
       homepage = "http://snapframework.com/";
       description = "Snap: A Haskell Web Framework (core interfaces and types)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap-core_0_9_7_2" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , blaze-builder, blaze-builder-enumerator, bytestring
     , bytestring-mmap, case-insensitive, containers, deepseq, directory
     , enumerator, filepath, hashable, HUnit, MonadCatchIO-transformers
     , mtl, old-locale, random, regex-posix, text, time, unix
     , unix-compat, unordered-containers, vector, zlib-enum
     }:
     mkDerivation {
       pname = "snap-core";
       version = "0.9.7.2";
       sha256 = "526a8ebb758c8da5e966a37449fdb072af333275c1b7726ab6317ac93875f651";
       revision = "1";
       editedCabalFile = "d39520edcc970d9d1f683af9631ccbcad39536b9f88040b93efb66cbe7aefc55";
       libraryHaskellDepends = [
         attoparsec attoparsec-enumerator base blaze-builder
         blaze-builder-enumerator bytestring bytestring-mmap
         case-insensitive containers deepseq directory enumerator filepath
         hashable HUnit MonadCatchIO-transformers mtl old-locale random
         regex-posix text time unix unix-compat unordered-containers vector
         zlib-enum
       ];
       homepage = "http://snapframework.com/";
       description = "Snap: A Haskell Web Framework (core interfaces and types)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap-core" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , blaze-builder, blaze-builder-enumerator, bytestring
     , bytestring-mmap, case-insensitive, containers, deepseq, directory
     , enumerator, filepath, hashable, HUnit, MonadCatchIO-transformers
     , mtl, old-locale, random, regex-posix, text, time, unix
     , unix-compat, unordered-containers, vector, zlib-enum
     }:
     mkDerivation {
       pname = "snap-core";
       version = "0.9.8.0";
       sha256 = "47310fcd9c347883f5985c27c1fbcfac8c5783472a01afcc720bcc850622d2db";
       libraryHaskellDepends = [
         attoparsec attoparsec-enumerator base blaze-builder
         blaze-builder-enumerator bytestring bytestring-mmap
         case-insensitive containers deepseq directory enumerator filepath
         hashable HUnit MonadCatchIO-transformers mtl old-locale random
         regex-posix text time unix unix-compat unordered-containers vector
         zlib-enum
       ];
       homepage = "http://snapframework.com/";
       description = "Snap: A Haskell Web Framework (core interfaces and types)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snap-cors" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, case-insensitive
     , hashable, network, network-uri, snap, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "snap-cors";
       version = "1.2.9";
       sha256 = "8dc9ff4c21966a79afee54a9a76aa6bc6897f01f10872e3fa026e5466da2cb68";
       libraryHaskellDepends = [
         attoparsec base bytestring case-insensitive hashable network
         network-uri snap text transformers unordered-containers
       ];
       homepage = "http://github.com/ocharles/snap-cors";
       description = "Add CORS headers to Snap applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snap-elm" = callPackage
    ({ mkDerivation, base, bytestring, directory, Elm, filepath
     , process, snap-core, text, transformers
     }:
     mkDerivation {
       pname = "snap-elm";
       version = "0.1.1.2";
       sha256 = "791afab882397d3e51db8596fb6caec225fc4529648db0e7fe853fec8b36e7d2";
       libraryHaskellDepends = [
         base bytestring directory Elm filepath process snap-core text
         transformers
       ];
       description = "Serve Elm files through the Snap web framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snap-error-collector" = callPackage
    ({ mkDerivation, async, base, containers, monad-loops
     , MonadCatchIO-transformers, snap, stm, time, transformers
     }:
     mkDerivation {
       pname = "snap-error-collector";
       version = "1.1.1";
       sha256 = "9dadb634f69f0a9549c951c18c24c176db7c1b8024594563c55dfe00e6d21cac";
       libraryHaskellDepends = [
         async base containers monad-loops MonadCatchIO-transformers snap
         stm time transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ocharles/snap-error-collector";
       description = "Collect errors in batches and dispatch them";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snap-extras" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, blaze-html, bytestring
     , case-insensitive, configurator, containers, data-default
     , digestive-functors, digestive-functors-heist
     , digestive-functors-snap, directory-tree, filepath, heist, jmacro
     , lens, mtl, pcre-light, QuickCheck, readable, safe, snap
     , snap-core, tasty, tasty-hunit, tasty-quickcheck, text, time
     , transformers, wl-pprint-text, xmlhtml
     }:
     mkDerivation {
       pname = "snap-extras";
       version = "0.11.0.2";
       sha256 = "15e8ab812bf53b3f7ab0377e945b3e3448d5b8d4b89404751f83d51d722deb5e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base blaze-builder blaze-html bytestring case-insensitive
         configurator containers data-default digestive-functors
         digestive-functors-heist digestive-functors-snap directory-tree
         filepath heist jmacro lens mtl pcre-light readable safe snap
         snap-core text time transformers wl-pprint-text xmlhtml
       ];
       testHaskellDepends = [
         base bytestring containers QuickCheck snap-core tasty tasty-hunit
         tasty-quickcheck
       ];
       description = "A collection of useful helpers and utilities for Snap web applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap-language" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , snap-core
     }:
     mkDerivation {
       pname = "snap-language";
       version = "0.1.0.0";
       sha256 = "a8b4de97769afd815ebde10ad778ad20d9ba81883680e1a2514a7989bce32a41";
       libraryHaskellDepends = [
         attoparsec base bytestring containers snap-core
       ];
       homepage = "https://github.com/jonpetterbergman/snap-accept-language";
       description = "Language handling for Snap";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snap-loader-dynamic" = callPackage
    ({ mkDerivation, base, directory, directory-tree, hint, mtl
     , snap-core, template-haskell, time, unix
     }:
     mkDerivation {
       pname = "snap-loader-dynamic";
       version = "0.10.0.3";
       sha256 = "7cd7ac11071c0479dcea5a798aab57e4043a50a3a31bf76ed1ce39dba79d645a";
       libraryHaskellDepends = [
         base directory directory-tree hint mtl snap-core template-haskell
         time unix
       ];
       homepage = "http://snapframework.com/";
       description = "Snap: A Haskell Web Framework: dynamic loader";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snap-loader-static" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "snap-loader-static";
       version = "0.9.0.2";
       sha256 = "357cde7b671a623d0d0b6b6a658a900bba74d886bb43c0a714daf9ec8d3dda34";
       revision = "1";
       editedCabalFile = "c927448783c28f56bd57c7b09d147965b96e7b4c7320524b26c83bf10ab89c21";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://snapframework.com/";
       description = "Snap: A Haskell Web Framework: static loader";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snap-predicates" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, case-insensitive
     , containers, HUnit, monads-tf, QuickCheck, snap-core
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, transformers
     }:
     mkDerivation {
       pname = "snap-predicates";
       version = "0.3.1";
       sha256 = "c5a3e0eabaacaa198c2e2973b27d26ae448a39357f846190a2f77174c5d2330b";
       revision = "1";
       editedCabalFile = "6fbedca064ea734b7fb4c14324a4b128a54a5bd4e3e18416b9d87087392a46ad";
       libraryHaskellDepends = [
         attoparsec base bytestring case-insensitive containers monads-tf
         snap-core text transformers
       ];
       testHaskellDepends = [
         attoparsec base bytestring case-insensitive containers HUnit
         monads-tf QuickCheck snap-core test-framework test-framework-hunit
         test-framework-quickcheck2 text transformers
       ];
       description = "Declarative routing for Snap";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap-server_0_9_4_5" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , blaze-builder, blaze-builder-enumerator, bytestring
     , case-insensitive, containers, enumerator, HsOpenSSL
     , MonadCatchIO-transformers, mtl, network, old-locale, snap-core
     , text, time, unix, unix-compat
     }:
     mkDerivation {
       pname = "snap-server";
       version = "0.9.4.5";
       sha256 = "37ae3557c43dcecf6938df76af1ee274b575e50a8085d12b8f80c587e94e6924";
       revision = "3";
       editedCabalFile = "46fea11bd1c4b34a4a8848b05e70b7bf3a50ad30ba40ade2f25076560fa8bb99";
       configureFlags = [ "-fopenssl" ];
       libraryHaskellDepends = [
         attoparsec attoparsec-enumerator base blaze-builder
         blaze-builder-enumerator bytestring case-insensitive containers
         enumerator HsOpenSSL MonadCatchIO-transformers mtl network
         old-locale snap-core text time unix unix-compat
       ];
       jailbreak = true;
       homepage = "http://snapframework.com/";
       description = "A fast, iteratee-based, epoll-enabled web server for the Snap Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap-server_0_9_4_6" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , blaze-builder, blaze-builder-enumerator, bytestring
     , case-insensitive, containers, enumerator, HsOpenSSL
     , MonadCatchIO-transformers, mtl, network, old-locale, snap-core
     , text, time, unix, unix-compat
     }:
     mkDerivation {
       pname = "snap-server";
       version = "0.9.4.6";
       sha256 = "f766d84fb2399f345c0f3eac857db318fe448fa51af85d340106733c0cc30e07";
       revision = "1";
       editedCabalFile = "32c4388b62e047caebb4a51bd79cb592032a0cb4f2aa56c7eb8bff15e85588bf";
       configureFlags = [ "-fopenssl" ];
       libraryHaskellDepends = [
         attoparsec attoparsec-enumerator base blaze-builder
         blaze-builder-enumerator bytestring case-insensitive containers
         enumerator HsOpenSSL MonadCatchIO-transformers mtl network
         old-locale snap-core text time unix unix-compat
       ];
       jailbreak = true;
       homepage = "http://snapframework.com/";
       description = "A fast, iteratee-based, epoll-enabled web server for the Snap Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap-server_0_9_5_0" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , blaze-builder, blaze-builder-enumerator, bytestring
     , case-insensitive, containers, enumerator, HsOpenSSL
     , MonadCatchIO-transformers, mtl, network, old-locale, snap-core
     , text, time, unix, unix-compat
     }:
     mkDerivation {
       pname = "snap-server";
       version = "0.9.5.0";
       sha256 = "1160d42d7ffec40ecd179bc30f2c6f20f1878296a4c143e87d96219afb1f56e7";
       configureFlags = [ "-fopenssl" ];
       libraryHaskellDepends = [
         attoparsec attoparsec-enumerator base blaze-builder
         blaze-builder-enumerator bytestring case-insensitive containers
         enumerator HsOpenSSL MonadCatchIO-transformers mtl network
         old-locale snap-core text time unix unix-compat
       ];
       jailbreak = true;
       homepage = "http://snapframework.com/";
       description = "A fast, iteratee-based, epoll-enabled web server for the Snap Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap-server" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , blaze-builder, blaze-builder-enumerator, bytestring
     , case-insensitive, containers, enumerator, HsOpenSSL
     , MonadCatchIO-transformers, mtl, network, old-locale, snap-core
     , text, time, unix, unix-compat
     }:
     mkDerivation {
       pname = "snap-server";
       version = "0.9.5.1";
       sha256 = "af8f2344b90f701dd1924743d6073546206384d5a904a1338bb784e18c8d3ea3";
       revision = "1";
       editedCabalFile = "7909ad539e7d3f23f3c799d736d1a54d0a9098dd55fd6be75c13b57794bfaa5c";
       configureFlags = [ "-fopenssl" ];
       libraryHaskellDepends = [
         attoparsec attoparsec-enumerator base blaze-builder
         blaze-builder-enumerator bytestring case-insensitive containers
         enumerator HsOpenSSL MonadCatchIO-transformers mtl network
         old-locale snap-core text time unix unix-compat
       ];
       homepage = "http://snapframework.com/";
       description = "A fast, iteratee-based, epoll-enabled web server for the Snap Framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snap-testing" = callPackage
    ({ mkDerivation, async, base, bytestring, containers
     , digestive-functors, HandsomeSoup, hxt, io-streams, lens, mtl
     , process, QuickCheck, snap, snap-core, text, transformers
     }:
     mkDerivation {
       pname = "snap-testing";
       version = "0.6.0.0";
       sha256 = "136f1a8e3d541aaa591230c307e911faca486e208ee405e3673743a81c6deccf";
       libraryHaskellDepends = [
         async base bytestring containers digestive-functors HandsomeSoup
         hxt io-streams mtl process QuickCheck snap snap-core text
         transformers
       ];
       testHaskellDepends = [
         async base bytestring containers digestive-functors HandsomeSoup
         hxt io-streams lens mtl process QuickCheck snap snap-core text
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/dbp/snap-testing";
       description = "A library for BDD-style testing with the Snap Web Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap-utils" = callPackage
    ({ mkDerivation, base, bytestring, heist, http-types
     , MonadCatchIO-transformers, mtl, snap, snap-core, text, xmlhtml
     }:
     mkDerivation {
       pname = "snap-utils";
       version = "0.1.2";
       sha256 = "210d35b7f76915e793573fc7a4c1519e2962f9033314c5aad3463b19a44b20cf";
       libraryHaskellDepends = [
         base bytestring heist http-types MonadCatchIO-transformers mtl snap
         snap-core text xmlhtml
       ];
       jailbreak = true;
       homepage = "https://github.com/LukeHoersten/snap-utils";
       description = "Snap Framework utilities";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snap-web-routes" = callPackage
    ({ mkDerivation, base, bytestring, heist, mtl, snap, snap-core
     , text, web-routes, xmlhtml
     }:
     mkDerivation {
       pname = "snap-web-routes";
       version = "0.5.1.0";
       sha256 = "a2d2257193d69613fe504a81596b21d6453a5e41fee959c904de2565c7bc8de0";
       libraryHaskellDepends = [
         base bytestring heist mtl snap snap-core text web-routes xmlhtml
       ];
       homepage = "https://github.com/lukerandall/snap-web-routes";
       description = "Type safe URLs for Snap";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-acid-state" = callPackage
    ({ mkDerivation, acid-state, base, mtl, snap, text, transformers }:
     mkDerivation {
       pname = "snaplet-acid-state";
       version = "0.2.7";
       sha256 = "fd99ea6005b6355e5ec5937665b7982cf4f5e21266f3bf0fac1b5d705965586e";
       libraryHaskellDepends = [
         acid-state base mtl snap text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/mightybyte/snaplet-acid-state";
       description = "acid-state snaplet for Snap Framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-actionlog" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring
     , digestive-functors, digestive-functors-heist
     , digestive-functors-snap, errors, heist, persistent
     , persistent-postgresql, persistent-template, readable
     , restful-snap, snap, snap-extras, snaplet-persistent, text, time
     , transformers, unordered-containers, xmlhtml
     }:
     mkDerivation {
       pname = "snaplet-actionlog";
       version = "0.2.0.1";
       sha256 = "7b279a0b0591ac0efd6c4aa5032509bb7b84a948beacd4602a10d3edd20aea9c";
       libraryHaskellDepends = [
         base blaze-builder bytestring digestive-functors
         digestive-functors-heist digestive-functors-snap errors heist
         persistent persistent-postgresql persistent-template readable
         restful-snap snap snap-extras snaplet-persistent text time
         transformers unordered-containers xmlhtml
       ];
       jailbreak = true;
       homepage = "https://github.com/soostone/snaplet-actionlog";
       description = "Generic action log snaplet for the Snap Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-amqp" = callPackage
    ({ mkDerivation, amqp, base, bytestring, configurator, lens
     , monad-control, mtl, network, resource-pool, snap, transformers
     }:
     mkDerivation {
       pname = "snaplet-amqp";
       version = "1.1.0.0";
       sha256 = "21cdfa3bff6cbf189db1ac011a340d8038e81bf2675d2a0099dabba82e121c07";
       libraryHaskellDepends = [
         amqp base bytestring configurator lens monad-control mtl network
         resource-pool snap transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/ixmatus/snaplet-amqp";
       description = "Snap framework snaplet for the AMQP library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-auth-acid" = callPackage
    ({ mkDerivation, acid-state, aeson, attoparsec, base, cereal
     , clientsession, directory, errors, filepath, hashable, lens
     , MonadCatchIO-transformers, mtl, safecopy, scientific, snap
     , snap-core, text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "snaplet-auth-acid";
       version = "0.1.0";
       sha256 = "95eb134e5ef69c03f42778e1c6acd075e975d741db767712dd716e21b3f01744";
       libraryHaskellDepends = [
         acid-state aeson attoparsec base cereal clientsession directory
         errors filepath hashable lens MonadCatchIO-transformers mtl
         safecopy scientific snap snap-core text time unordered-containers
         vector
       ];
       jailbreak = true;
       description = "Provides an Acid-State backend for the Auth Snaplet";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-coffee" = callPackage
    ({ mkDerivation, base, bytestring, configurator, directory
     , filepath, haskell-coffee, mtl, snap, snap-core
     }:
     mkDerivation {
       pname = "snaplet-coffee";
       version = "0.1.0.2";
       sha256 = "ce5efb29b77639f89f0ce6540421db13835f2d72797848a9d2a48454d1b4bdcf";
       libraryHaskellDepends = [
         base bytestring configurator directory filepath haskell-coffee mtl
         snap snap-core
       ];
       homepage = "https://github.com/AtticHacker/snaplet-coffee";
       description = "CoffeeScript for Snap, auto-compilation and pre-compilation";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "snaplet-css-min" = callPackage
    ({ mkDerivation, base, bytestring, css-text, directory, filepath
     , lens, snap, text, utf8-string
     }:
     mkDerivation {
       pname = "snaplet-css-min";
       version = "0.1.2";
       sha256 = "3282cbeeec88fcceb9beecb5bb96f5f6698e6d5f738645eea2eeb6013af0e6ae";
       libraryHaskellDepends = [
         base bytestring css-text directory filepath lens snap text
         utf8-string
       ];
       jailbreak = true;
       homepage = "https://github.com/zmthy/snaplet-css-min";
       description = "A Snaplet for CSS minification";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-environments" = callPackage
    ({ mkDerivation, base, bson, configurator, mtl, regex-tdfa, snap
     , snap-core, text, unordered-containers
     }:
     mkDerivation {
       pname = "snaplet-environments";
       version = "0.1.1";
       sha256 = "70f807e7279325e7cf3263d9ddeafd104300ec41afc20179ad6c9c9f82cf62ce";
       libraryHaskellDepends = [
         base bson configurator mtl regex-tdfa snap snap-core text
         unordered-containers
       ];
       jailbreak = true;
       description = "DEPRECATED! You should use standard Snap >= 0.9 \"environments\" functionality. It provided ability to easly read configuration based on given app environment given at command line, envs are defined in app configuration file";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-fay_0_3_3_8" = callPackage
    ({ mkDerivation, aeson, base, bytestring, configurator, directory
     , fay, filepath, mtl, snap, snap-core, transformers
     }:
     mkDerivation {
       pname = "snaplet-fay";
       version = "0.3.3.8";
       sha256 = "5207899b2f179e2f832ea3f1844ace29cc26606cb964c5806bfa14b523ebf87b";
       revision = "2";
       editedCabalFile = "55720147ad82fc1041d5c6163d016c5c1149cbb2175439e0ec77a7fd1794c00f";
       libraryHaskellDepends = [
         aeson base bytestring configurator directory fay filepath mtl snap
         snap-core transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/faylang/snaplet-fay";
       description = "Fay integration for Snap with request- and pre-compilation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-fay_0_3_3_9" = callPackage
    ({ mkDerivation, aeson, base, bytestring, configurator, directory
     , fay, filepath, mtl, snap, snap-core, transformers
     }:
     mkDerivation {
       pname = "snaplet-fay";
       version = "0.3.3.9";
       sha256 = "4fec61f1cb08a38dbded44eb25ec549b810a08343e10fa2c74a0c710a6733f05";
       revision = "2";
       editedCabalFile = "44d2d0e93d6b6aa765cd05def57d533eb416d8149f63f89af05dea8fe71c70cd";
       libraryHaskellDepends = [
         aeson base bytestring configurator directory fay filepath mtl snap
         snap-core transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/faylang/snaplet-fay";
       description = "Fay integration for Snap with request- and pre-compilation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-fay_0_3_3_10" = callPackage
    ({ mkDerivation, aeson, base, bytestring, configurator, directory
     , fay, filepath, mtl, snap, snap-core, transformers
     }:
     mkDerivation {
       pname = "snaplet-fay";
       version = "0.3.3.10";
       sha256 = "94163607b1d1af6f315a10bb6a0c4d376fccf30739296482311f14b34238f795";
       revision = "2";
       editedCabalFile = "a58dbf2ddfa2c4998d4b2409576a7f69a8b7e634aafddcdb55ccdb73f8f07be4";
       libraryHaskellDepends = [
         aeson base bytestring configurator directory fay filepath mtl snap
         snap-core transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/faylang/snaplet-fay";
       description = "Fay integration for Snap with request- and pre-compilation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-fay_0_3_3_11" = callPackage
    ({ mkDerivation, aeson, base, bytestring, configurator, directory
     , fay, filepath, mtl, snap, snap-core, transformers
     }:
     mkDerivation {
       pname = "snaplet-fay";
       version = "0.3.3.11";
       sha256 = "59ba4480c52f57099bd4b73d5b9d38453fcae3151b9355ff192f11b6230ee6a1";
       revision = "2";
       editedCabalFile = "6b536ac4ad158ceed55ca18802caf4e970caabce93af33d95579ac431a003e9d";
       libraryHaskellDepends = [
         aeson base bytestring configurator directory fay filepath mtl snap
         snap-core transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/faylang/snaplet-fay";
       description = "Fay integration for Snap with request- and pre-compilation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-fay_0_3_3_12" = callPackage
    ({ mkDerivation, aeson, base, bytestring, configurator, directory
     , fay, filepath, mtl, snap, snap-core, transformers
     }:
     mkDerivation {
       pname = "snaplet-fay";
       version = "0.3.3.12";
       sha256 = "fac218332df80f9c109aa1a0479c3956d286487769840b229d9faa1fda8733c9";
       revision = "1";
       editedCabalFile = "9986472ebb3e6f8761004d4d2d3da8e937b786428ffaf39a338eabd364c4a974";
       libraryHaskellDepends = [
         aeson base bytestring configurator directory fay filepath mtl snap
         snap-core transformers
       ];
       homepage = "https://github.com/faylang/snaplet-fay";
       description = "Fay integration for Snap with request- and pre-compilation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-fay" = callPackage
    ({ mkDerivation, aeson, base, bytestring, configurator, directory
     , fay, filepath, mtl, snap, snap-core, transformers
     }:
     mkDerivation {
       pname = "snaplet-fay";
       version = "0.3.3.13";
       sha256 = "39810748b7177b45a0fab785e48ac497d81587e48dde9dc8ad75e8d704bdda3f";
       revision = "2";
       editedCabalFile = "43c3a484e0e34f13bf2f372850d33b98de9d8057fd33e9d79be0fcc0a5013559";
       libraryHaskellDepends = [
         aeson base bytestring configurator directory fay filepath mtl snap
         snap-core transformers
       ];
       homepage = "https://github.com/faylang/snaplet-fay";
       description = "Fay integration for Snap with request- and pre-compilation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-ghcjs" = callPackage
    ({ mkDerivation, base, directory, filepath, lens, mtl, process
     , snap, snap-core, string-conversions, transformers
     }:
     mkDerivation {
       pname = "snaplet-ghcjs";
       version = "0.1.0.0";
       sha256 = "9661f47bf1ce7ef88b61aabddd81be04616a723afc2de4c8e66471f1fa95c229";
       libraryHaskellDepends = [
         base directory filepath lens mtl process snap snap-core
         string-conversions transformers
       ];
       description = "Serve javascript files compiled with GHCJS";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-hasql" = callPackage
    ({ mkDerivation, aeson, base, bytestring, clientsession
     , configurator, hasql, hasql-backend, lens, mtl, snap, text, time
     }:
     mkDerivation {
       pname = "snaplet-hasql";
       version = "1.0.2";
       sha256 = "9bcd6129294b22e0669e0483142e1b24536935a6df82f00f935c83b74d02fd21";
       libraryHaskellDepends = [
         aeson base bytestring clientsession configurator hasql
         hasql-backend lens mtl snap text time
       ];
       homepage = "https://github.com/mikeplus64/snaplet-hasql";
       description = "A Hasql snaplet";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-haxl" = callPackage
    ({ mkDerivation, base, haxl, MonadCatchIO-transformers, snap
     , transformers
     }:
     mkDerivation {
       pname = "snaplet-haxl";
       version = "0.0.0.2";
       sha256 = "94131edef6f07fd1ed79619b592c33facece953cbc1400cc8c207f98b1301f77";
       libraryHaskellDepends = [
         base haxl MonadCatchIO-transformers snap transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/ChristopherBiscardi/snaplet-haxl";
       description = "Snaplet for Facebook's Haxl";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-hdbc" = callPackage
    ({ mkDerivation, base, bytestring, clientsession, containers
     , convertible, data-lens, data-lens-template, HDBC
     , MonadCatchIO-transformers, mtl, resource-pool-catchio, snap, text
     , time, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "snaplet-hdbc";
       version = "0.9.1";
       sha256 = "d523856747f83b0da0dbdd8bfcb615efc65ed611609d3883b7ce32c16854279f";
       libraryHaskellDepends = [
         base bytestring clientsession containers convertible data-lens
         data-lens-template HDBC MonadCatchIO-transformers mtl
         resource-pool-catchio snap text time transformers
         unordered-containers
       ];
       jailbreak = true;
       homepage = "http://norm2782.com/";
       description = "HDBC snaplet for Snap Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-hslogger" = callPackage
    ({ mkDerivation, base, configurator, hslogger, mtl, snap
     , transformers
     }:
     mkDerivation {
       pname = "snaplet-hslogger";
       version = "1.0.0.2";
       sha256 = "1dac250b49129bb7aaf136cb118e3410adb997aac1fca7015a10873b7ebc9b95";
       libraryHaskellDepends = [
         base configurator hslogger mtl snap transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/ixmatus/snaplet-logger";
       description = "Snap framework snaplet for the Logger API library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-i18n" = callPackage
    ({ mkDerivation, base, bytestring, configurator, filepath, heist
     , lens, snap, snap-loader-static, text, xmlhtml
     }:
     mkDerivation {
       pname = "snaplet-i18n";
       version = "0.0.5";
       sha256 = "62b279c4b82358d62273911c917a21f96386c8198a8db5d95738dc32f746827a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base configurator filepath heist lens snap snap-loader-static text
         xmlhtml
       ];
       executableHaskellDepends = [
         base bytestring configurator filepath heist lens snap
         snap-loader-static text xmlhtml
       ];
       jailbreak = true;
       homepage = "https://github.com/HaskellCNOrg/snaplet-i18n";
       description = "snaplet-i18n";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-influxdb" = callPackage
    ({ mkDerivation, base, bytestring, configurator, http-client
     , influxdb, lens, monad-control, mtl, network, snap, text
     , transformers
     }:
     mkDerivation {
       pname = "snaplet-influxdb";
       version = "1.0.1.1";
       sha256 = "f2c870ea7536bedd8a9bd11e8a05fa483879a8d3b3c7158a58807eca320068b7";
       libraryHaskellDepends = [
         base bytestring configurator http-client influxdb lens
         monad-control mtl network snap text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/ixmatus/snaplet-influxdb";
       description = "Snap framework snaplet for the InfluxDB library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-lss" = callPackage
    ({ mkDerivation, base, directory, filepath, heist, hspec-snap
     , hspec2, lens, lss, snap, text, xmlhtml
     }:
     mkDerivation {
       pname = "snaplet-lss";
       version = "0.1.0.0";
       sha256 = "fd0100244a68f83f272a1a8c4a4cfae631bdb305715d12d52e1daa5e4c4e943e";
       libraryHaskellDepends = [
         base directory filepath heist lss snap text xmlhtml
       ];
       testHaskellDepends = [ base hspec-snap hspec2 lens snap text ];
       jailbreak = true;
       homepage = "https://github.com/dbp/lss";
       description = "Lexical Style Sheets - Snap Web Framework adaptor";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-mandrill" = callPackage
    ({ mkDerivation, base, configurator, mandrill, mtl, network, snap
     , transformers
     }:
     mkDerivation {
       pname = "snaplet-mandrill";
       version = "0.1.0.3";
       sha256 = "c2a4cdf7e4099395943e06d6cdb7b888260ec8be08f4b80bef6693d01606cb7b";
       libraryHaskellDepends = [
         base configurator mandrill mtl network snap transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/ixmatus/snaplet-mandrill";
       description = "Snap framework snaplet for the Mandrill API library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-mongoDB" = callPackage
    ({ mkDerivation, base, bson, bytestring, compact-string-fix
     , containers, haskell-src-exts, MonadCatchIO-transformers, mongoDB
     , mtl, parsec, regular, safe, snap, snap-core, template-haskell
     , text, time
     }:
     mkDerivation {
       pname = "snaplet-mongoDB";
       version = "0.2";
       sha256 = "5c5d95e169758160f3e2f06b32041373ce47841ea5bb46be26f0a1b5e112f542";
       libraryHaskellDepends = [
         base bson bytestring compact-string-fix containers haskell-src-exts
         MonadCatchIO-transformers mongoDB mtl parsec regular safe snap
         snap-core template-haskell text time
       ];
       jailbreak = true;
       description = "Snap Framework MongoDB support as Snaplet";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-mongodb-minimalistic" = callPackage
    ({ mkDerivation, base, lens, mongoDB, mtl, snap, text, transformers
     }:
     mkDerivation {
       pname = "snaplet-mongodb-minimalistic";
       version = "0.0.6.12";
       sha256 = "56e5f66271843a59593b79da86c4be0f194d9b1a2dc0cf4721ed938b81b51034";
       libraryHaskellDepends = [
         base lens mongoDB mtl snap text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/Palmik/snaplet-mongodb-minimalistic";
       description = "Minimalistic MongoDB Snaplet";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-mysql-simple" = callPackage
    ({ mkDerivation, base, bytestring, clientsession, configurator
     , containers, errors, lens, MonadCatchIO-transformers, mtl, mysql
     , mysql-simple, resource-pool-catchio, snap, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "snaplet-mysql-simple";
       version = "0.2.1.0";
       sha256 = "21db42dc3ddf618fd3faf7dedc3fb663d9705a3b7e5db11b9b09813275470543";
       libraryHaskellDepends = [
         base bytestring clientsession configurator containers errors lens
         MonadCatchIO-transformers mtl mysql mysql-simple
         resource-pool-catchio snap text transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/ibotty/snaplet-mysql-simple";
       description = "mysql-simple snaplet for the Snap Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-oauth" = callPackage
    ({ mkDerivation, aeson, base, bytestring, bytestring-show
     , data-lens, data-lens-template, failure, hashable, heist, hoauth2
     , http-conduit, http-types, HUnit, MonadCatchIO-mtl, snap
     , snap-core, snap-loader-dynamic, snap-loader-static
     , test-framework, test-framework-hunit, text, unordered-containers
     }:
     mkDerivation {
       pname = "snaplet-oauth";
       version = "0.0.6";
       sha256 = "d48ffb556f6af5824473e53d4467e2e71f4c34813ff5c46ffa9fda90fed5fe9c";
       libraryHaskellDepends = [
         aeson base bytestring bytestring-show data-lens data-lens-template
         failure hashable heist hoauth2 http-conduit http-types
         MonadCatchIO-mtl snap snap-core snap-loader-dynamic
         snap-loader-static text unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring bytestring-show HUnit test-framework
         test-framework-hunit text
       ];
       jailbreak = true;
       homepage = "https://github.com/HaskellCNOrg/snaplet-oauth";
       description = "snaplet-oauth";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-persistent" = callPackage
    ({ mkDerivation, base, bytestring, clientsession, configurator
     , errors, heist, lens, monad-logger, MonadCatchIO-transformers, mtl
     , persistent, persistent-postgresql, persistent-template, readable
     , resource-pool, resourcet, safe, snap, text, time, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "snaplet-persistent";
       version = "0.5";
       sha256 = "b3f41b11dc1ce4978fc29c8b7ccfea55cee7a645d092dc179706a7a7ab9d7dfd";
       libraryHaskellDepends = [
         base bytestring clientsession configurator errors heist lens
         monad-logger MonadCatchIO-transformers mtl persistent
         persistent-postgresql persistent-template readable resource-pool
         resourcet safe snap text time transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/soostone/snaplet-persistent";
       description = "persistent snaplet for the Snap Framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-postgresql-simple" = callPackage
    ({ mkDerivation, base, bytestring, clientsession, configurator
     , lens, MonadCatchIO-transformers, mtl, postgresql-simple
     , resource-pool-catchio, snap, text, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "snaplet-postgresql-simple";
       version = "0.6.0.4";
       sha256 = "44cca67347a81257533edc9570bf9303081a11d40e8000390a75f3f48e071687";
       revision = "2";
       editedCabalFile = "0461cfe249bc8f9b3fd32715e66ed38d0b67805f9ac8d3d2fb6782fd7fe34c94";
       libraryHaskellDepends = [
         base bytestring clientsession configurator lens
         MonadCatchIO-transformers mtl postgresql-simple
         resource-pool-catchio snap text transformers unordered-containers
       ];
       homepage = "https://github.com/mightybyte/snaplet-postgresql-simple";
       description = "postgresql-simple snaplet for the Snap Framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-postmark" = callPackage
    ({ mkDerivation, base, configurator, mtl, postmark, snap, text
     , transformers
     }:
     mkDerivation {
       pname = "snaplet-postmark";
       version = "0.2.0";
       sha256 = "dd72745b378afed63455ea68295baf7d295427e0941f935efa063ead118a0600";
       libraryHaskellDepends = [
         base configurator mtl postmark snap text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/LukeHoersten/snaplet-postmark";
       description = "Postmark snaplet for the Snap Framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-purescript" = callPackage
    ({ mkDerivation, base, configurator, mtl, raw-strings-qq, shelly
     , snap, snap-core, text, transformers
     }:
     mkDerivation {
       pname = "snaplet-purescript";
       version = "0.4.0.0";
       sha256 = "508f797ca18b48c95c1ab371956070df83e1c4365d1cf698e39631e888b224f8";
       libraryHaskellDepends = [
         base configurator mtl raw-strings-qq shelly snap snap-core text
         transformers
       ];
       description = "Automatic (re)compilation of purescript projects";
       license = stdenv.lib.licenses.mit;
     }) {};

  "snaplet-recaptcha" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring
     , configurator, heist, http-conduit, lens
     , MonadCatchIO-transformers, mtl, snap, text, transformers
     }:
     mkDerivation {
       pname = "snaplet-recaptcha";
       version = "1.0.3";
       sha256 = "46eccbd23fbadac5682327b26c6ac0faa8fbb80c4de39c99fff29f0cce76c509";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring configurator heist http-conduit
         lens MonadCatchIO-transformers mtl snap text transformers
       ];
       homepage = "http://github.com/mikeplus64/snaplet-recaptcha";
       description = "A ReCAPTCHA verification snaplet with Heist integration and connection sharing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-redis" = callPackage
    ({ mkDerivation, base, configurator, hedis, lens, mtl, network
     , snap, text, transformers
     }:
     mkDerivation {
       pname = "snaplet-redis";
       version = "0.1.4.2";
       sha256 = "104242331c6069d9edd806e41e432941cb88c06276cd03ad0eac7cf986642566";
       libraryHaskellDepends = [
         base configurator hedis lens mtl network snap text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/dzhus/snaplet-redis/";
       description = "Redis support for Snap Framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-redson" = callPackage
    ({ mkDerivation, aeson, base, bytestring, configurator, containers
     , data-lens, data-lens-template, easy-file, hedis, mtl, snap
     , snap-core, snaplet-redis, text, utf8-string, websockets
     , websockets-snap
     }:
     mkDerivation {
       pname = "snaplet-redson";
       version = "0.1.0.0";
       sha256 = "ad7cd4fdc52ac53a5e8a440428a5491fa15a79f60ff5a22f3bc2b6661db26a5f";
       libraryHaskellDepends = [
         aeson base bytestring configurator containers data-lens
         data-lens-template easy-file hedis mtl snap snap-core snaplet-redis
         text utf8-string websockets websockets-snap
       ];
       jailbreak = true;
       homepage = "https://github.com/dzhus/snaplet-redson/";
       description = "CRUD for JSON data with Redis storage";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-rest" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring
     , case-insensitive, http-media, lens, mtl, snap, snap-accept
     , snap-core, text, utf8-string, xmlhtml
     }:
     mkDerivation {
       pname = "snaplet-rest";
       version = "0.1.0";
       sha256 = "c10302318f4637a812e4b84b66005031661506cffcfc9c8dec15581d7ff12cf0";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring case-insensitive http-media
         lens mtl snap snap-accept snap-core text utf8-string xmlhtml
       ];
       jailbreak = true;
       homepage = "http://github.com/zimothy/snaplet-rest";
       description = "REST resources for the Snap web framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-riak" = callPackage
    ({ mkDerivation, aeson, base, containers, data-lens
     , data-lens-template, mtl, riak, riak-protobuf, snap, snap-core
     , time, transformers
     }:
     mkDerivation {
       pname = "snaplet-riak";
       version = "0.2.0.0";
       sha256 = "004ab45915a7aaf5be4f238982ca0d64a4ba14df502dd3558b3d0ccac0b41560";
       libraryHaskellDepends = [
         aeson base containers data-lens data-lens-template mtl riak
         riak-protobuf snap snap-core time transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/statusfailed/snaplet-riak";
       description = "A Snaplet for the Riak database";
       license = stdenv.lib.licenses.mit;
     }) {};

  "snaplet-sass" = callPackage
    ({ mkDerivation, base, bytestring, configurator, directory
     , filepath, mtl, process, snap, snap-core, transformers
     }:
     mkDerivation {
       pname = "snaplet-sass";
       version = "0.1.2.0";
       sha256 = "3fe5b95f5223c18e273169a87bbb9ed5b56ceebe7a321a6de7bf5352a2b63faa";
       libraryHaskellDepends = [
         base bytestring configurator directory filepath mtl process snap
         snap-core transformers
       ];
       homepage = "https://github.com/lukerandall/snaplet-sass";
       description = "Sass integration for Snap with request- and pre-compilation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-sedna" = callPackage
    ({ mkDerivation, base, bytestring, containers, monad-control, mtl
     , resource-pool, sednaDBXML, snap
     }:
     mkDerivation {
       pname = "snaplet-sedna";
       version = "0.0.1.0";
       sha256 = "4b61482b4fba8370eb77a68be8641aa7defb52a5a84626c0b4c3596575f5a0e5";
       libraryHaskellDepends = [
         base bytestring containers monad-control mtl resource-pool
         sednaDBXML snap
       ];
       jailbreak = true;
       description = "Snaplet for Sedna Bindings. Essentailly a rip of snaplet-hdbc.";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-ses-html" = callPackage
    ({ mkDerivation, adjunctions, base, blaze-html, bytestring
     , configurator, lens, ses-html, snap, text, transformers
     }:
     mkDerivation {
       pname = "snaplet-ses-html";
       version = "0.1.1.0";
       sha256 = "669ee6f6f25aab1b468c98c9bbc6b9977c290ae093c063bc8c815fdb38f4b7e8";
       libraryHaskellDepends = [
         adjunctions base blaze-html bytestring configurator lens ses-html
         snap text transformers
       ];
       description = "Snaplet for the ses-html package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-sqlite-simple" = callPackage
    ({ mkDerivation, aeson, base, bytestring, clientsession
     , configurator, containers, direct-sqlite, directory, errors, HUnit
     , lens, MonadCatchIO-transformers, mtl, SafeSemaphore, snap
     , snap-core, sqlite-simple, stm, test-framework
     , test-framework-hunit, text, time, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "snaplet-sqlite-simple";
       version = "0.4.8.3";
       sha256 = "a3dbe2a2a3f8301454dba81fe0d46081844b76eaef49b3fa609cb0a1d39e8059";
       libraryHaskellDepends = [
         aeson base bytestring clientsession configurator direct-sqlite lens
         MonadCatchIO-transformers mtl snap sqlite-simple text transformers
         unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring clientsession configurator containers
         directory errors HUnit lens MonadCatchIO-transformers mtl
         SafeSemaphore snap snap-core sqlite-simple stm test-framework
         test-framework-hunit text time transformers unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/nurpax/snaplet-sqlite-simple";
       description = "sqlite-simple snaplet for the Snap Framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-stripe" = callPackage
    ({ mkDerivation, base, bytestring, configurator, heist
     , lens-family-core, mtl, snap, stripe, text, text-format
     , transformers, xmlhtml
     }:
     mkDerivation {
       pname = "snaplet-stripe";
       version = "0.3.0";
       sha256 = "9727969f8ad26d02f5e215e2d8173ecc791a9e7e847397d153531b5edddf0549";
       libraryHaskellDepends = [
         base bytestring configurator heist lens-family-core mtl snap stripe
         text text-format transformers xmlhtml
       ];
       jailbreak = true;
       homepage = "https://github.com/LukeHoersten/snaplet-stripe";
       description = "Stripe snaplet for the Snap Framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snaplet-tasks" = callPackage
    ({ mkDerivation, base, bytestring, containers, curl, data-hash
     , haskell98, MissingH, mtl, network, snap, snap-core
     }:
     mkDerivation {
       pname = "snaplet-tasks";
       version = "0.1.2";
       sha256 = "80ed3c41618e53856642b5a2f01939ecbcf136dbddc8402e5c128156a5947072";
       libraryHaskellDepends = [
         base bytestring containers curl data-hash haskell98 MissingH mtl
         network snap snap-core
       ];
       jailbreak = true;
       description = "Snaplet for Snap Framework enabling developers to administrative tasks akin to Rake tasks from Ruby On Rails framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-typed-sessions" = callPackage
    ({ mkDerivation, base, bytestring, cereal, clientsession
     , containers, hashtables, mtl, PSQueue, random, regex-posix, snap
     , snap-core, time
     }:
     mkDerivation {
       pname = "snaplet-typed-sessions";
       version = "0.5";
       sha256 = "fc2d999f413682703efe62aa3a2f26d132ea9173d2dc80c48eecf1a5bbdd863d";
       libraryHaskellDepends = [
         base bytestring cereal clientsession containers hashtables mtl
         PSQueue random regex-posix snap snap-core time
       ];
       jailbreak = true;
       description = "Typed session snaplets and continuation-based programming for the Snap web framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snaplet-wordpress" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, blaze-builder
     , bytestring, configurator, containers, data-default, either, hedis
     , heist, hspec, hspec-core, hspec-snap, lens, map-syntax, mtl, snap
     , snap-core, snaplet-redis, text, time, unordered-containers
     , vector, wreq, xmlhtml
     }:
     mkDerivation {
       pname = "snaplet-wordpress";
       version = "0.1.1.2";
       sha256 = "4bddd4774025dbca93e7500769440d7b3deee973fb82860468de6dd032f7b3ee";
       libraryHaskellDepends = [
         aeson async attoparsec base blaze-builder bytestring configurator
         containers data-default either hedis heist hspec hspec-snap lens
         map-syntax mtl snap snap-core snaplet-redis text time
         unordered-containers vector wreq xmlhtml
       ];
       testHaskellDepends = [
         aeson base blaze-builder containers data-default either hedis heist
         hspec hspec-core hspec-snap lens mtl snap snaplet-redis text
         unordered-containers xmlhtml
       ];
       homepage = "https://github.com/dbp/snaplet-wordpress";
       description = "A snaplet that communicates with wordpress over its api";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snappy" = callPackage
    ({ mkDerivation, base, bytestring, QuickCheck, snappy
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "snappy";
       version = "0.2.0.2";
       sha256 = "0565df326a87c6ea67f8fb638e01acb0562cabd16a67fc6f9ea9cd191de8cd91";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ snappy ];
       testHaskellDepends = [
         base bytestring QuickCheck test-framework
         test-framework-quickcheck2
       ];
       homepage = "http://github.com/bos/snappy";
       description = "Bindings to the Google Snappy library for fast compression/decompression";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) snappy;};

  "snappy-conduit" = callPackage
    ({ mkDerivation, base, bytestring, conduit, snappy }:
     mkDerivation {
       pname = "snappy-conduit";
       version = "0.1.0.0";
       sha256 = "d15d858942f09f91723750f6e927f6dc56373d2ff1d0427c47019deddbd8234d";
       libraryHaskellDepends = [ base bytestring conduit snappy ];
       jailbreak = true;
       homepage = "http://github.com/tatac1/snappy-conduit/";
       description = "Conduit bindings for Snappy (see snappy package)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "snappy-framing" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, snappy }:
     mkDerivation {
       pname = "snappy-framing";
       version = "0.1.0";
       sha256 = "62c960bbe61da6afb89a7e78dacab87e19e0f627f39c76c211f045a42d99ffd4";
       libraryHaskellDepends = [ array base binary bytestring snappy ];
       homepage = "https://github.com/kim/snappy-framing";
       description = "Snappy Framing Format in Haskell";
       license = "unknown";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "snappy-iteratee" = callPackage
    ({ mkDerivation, base, bytestring, iteratee, snappy }:
     mkDerivation {
       pname = "snappy-iteratee";
       version = "0.1";
       sha256 = "b35a1ca7f4412df2253b111a555618e02bd9aa3890f05fad924bcc78f8d65c9e";
       libraryHaskellDepends = [ base bytestring iteratee snappy ];
       jailbreak = true;
       homepage = "http://github.com/iand675/snappy-iteratee";
       description = "An enumeratee that uses Google's snappy compression library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sndfile-enumerators" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, filepath
     , iteratee, listlike-instances, MonadCatchIO-transformers
     , transformers, vector, word24
     }:
     mkDerivation {
       pname = "sndfile-enumerators";
       version = "0.10.0.0";
       sha256 = "99ec2018b40df39ca3b07dbd874506b4d950ce22a50da88521be23542d5cd4da";
       libraryHaskellDepends = [
         base binary bytestring containers filepath iteratee
         listlike-instances MonadCatchIO-transformers transformers vector
         word24
       ];
       jailbreak = true;
       homepage = "http://www.tiresiaspress.us/haskell/sndfile-enumerators";
       description = "Audio file reading/writing";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sneakyterm" = callPackage
    ({ mkDerivation, base, classy-prelude, containers, lens, linear
     , mtl, ncurses, transformers
     }:
     mkDerivation {
       pname = "sneakyterm";
       version = "0.1";
       sha256 = "6dec2306f63d72f7e7931ba16827ff467de4b36d98089ecef8ba5df5346f5687";
       libraryHaskellDepends = [
         base classy-prelude containers lens linear mtl ncurses transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/pmiddend/sneakyterm";
       description = "Tiny, declarative wrapper around ncurses";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "sneathlane-haste" = callPackage
    ({ mkDerivation, base, haste-compiler }:
     mkDerivation {
       pname = "sneathlane-haste";
       version = "2";
       sha256 = "9614de5868379336bbc0eb5e0d013a8c7a2178373abb5ecd153d74988f57dc7b";
       libraryHaskellDepends = [ base haste-compiler ];
       homepage = "http://sneathlane.com";
       description = "A compositional web UI library, which draws to a Canvas element";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "snippet-extractor" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "snippet-extractor";
       version = "0.2.0";
       sha256 = "f50f76b2ec7b04324be47ba481364ea4bb461fde6c1502d586599658ae51de47";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base parsec ];
       description = "Extracts labeled snippets of code to files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snm" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, HsSyck
     , parsec, safe, spoonutil, xhtml
     }:
     mkDerivation {
       pname = "snm";
       version = "0.0.4";
       sha256 = "5142bfd400b03fdb575cf3a9342feb01edcc2ec31927c18d39cadc8ccb904cd8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory filepath HsSyck parsec safe spoonutil
         xhtml
       ];
       executableHaskellDepends = [
         base containers directory filepath HsSyck parsec safe spoonutil
       ];
       homepage = "http://github.com/elginer/snm";
       description = "The Simple Nice-Looking Manual Generator";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snmp_0_2_0_0" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-parse, asn1-types, async, base
     , binary, bytestring, cipher-aes, cipher-des, containers
     , crypto-cipher-types, cryptohash, mtl, network, network-info
     , random, securemem, text, time
     }:
     mkDerivation {
       pname = "snmp";
       version = "0.2.0.0";
       sha256 = "c7b8da17a08c7960c3494da4757fe059e87a4f215927e6f6977a47a2b4bc4b6e";
       libraryHaskellDepends = [
         asn1-encoding asn1-parse asn1-types async base binary bytestring
         cipher-aes cipher-des containers crypto-cipher-types cryptohash mtl
         network network-info random securemem text time
       ];
       description = "API for write snmp client";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snmp" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-parse, asn1-types, async, base
     , binary, bytestring, cipher-aes, cipher-des, containers
     , crypto-cipher-types, cryptohash, mtl, network, network-info
     , random, securemem, text, time
     }:
     mkDerivation {
       pname = "snmp";
       version = "0.2.1.1";
       sha256 = "0737d6fc4299a00d248d263ebdde7b3451f32da3f9a6f5afac0a125eb57384a4";
       libraryHaskellDepends = [
         asn1-encoding asn1-parse asn1-types async base binary bytestring
         cipher-aes cipher-des containers crypto-cipher-types cryptohash mtl
         network network-info random securemem text time
       ];
       description = "API for write snmp client";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snow-white" = callPackage
    ({ mkDerivation, base, binary, bytestring, mps }:
     mkDerivation {
       pname = "snow-white";
       version = "2009.12.1";
       sha256 = "51eb8994f2f5bbf82a34da8c6e59a4756093447ce0b56beb8615c8db50fef000";
       libraryHaskellDepends = [ base binary bytestring mps ];
       homepage = "http://github.com/nfjinjing/snow-white";
       description = "encode any binary instance to white space";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "snowball" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, QuickCheck
     , quickcheck-instances, test-framework-hunit
     , test-framework-quickcheck2, test-framework-th, text, text-icu
     }:
     mkDerivation {
       pname = "snowball";
       version = "1.0.0.1";
       sha256 = "7d5d05f693cc50210a5f2ba7b5e67d8f665f706525ae50acc1583a4742fd7d3b";
       libraryHaskellDepends = [ base bytestring text text-icu ];
       testHaskellDepends = [
         base HUnit QuickCheck quickcheck-instances test-framework-hunit
         test-framework-quickcheck2 test-framework-th text
       ];
       homepage = "http://hub.darcs.net/dag/snowball";
       description = "Bindings to the Snowball library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "snowflake" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "snowflake";
       version = "0.1.1.1";
       sha256 = "f156ca321ae17033fe1cbe7e676fea403136198e1c3a132924a080cd3145cddd";
       libraryHaskellDepends = [ base time ];
       description = "A loose port of Twitter Snowflake to Haskell. Generates arbitrary precision, unique, time-sortable identifiers.";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "snowglobe" = callPackage
    ({ mkDerivation, base, bytestring, containers, gl-capture, GLUT
     , OpenGL, OpenGLRaw, random
     }:
     mkDerivation {
       pname = "snowglobe";
       version = "3.0.0.2";
       sha256 = "43dce4e74fade11b49ff4d423b737e3f044355da664d9dea99840cf52bf0d050";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers gl-capture GLUT OpenGL OpenGLRaw random
       ];
       jailbreak = true;
       homepage = "http://code.mathr.co.uk/snowglobe";
       description = "randomized fractal snowflakes demo";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "soap_0_2_2_5" = callPackage
    ({ mkDerivation, base, bytestring, conduit, configurator
     , data-default, exceptions, hspec, http-client, http-types, HUnit
     , iconv, mtl, resourcet, text, unordered-containers, xml-conduit
     , xml-conduit-writer, xml-types
     }:
     mkDerivation {
       pname = "soap";
       version = "0.2.2.5";
       sha256 = "8767dbb5ba847ce5e907c83219d5b6911ee753f6c944956f40a9015fc54bb0c6";
       libraryHaskellDepends = [
         base bytestring conduit configurator data-default exceptions
         http-client http-types iconv mtl resourcet text
         unordered-containers xml-conduit xml-conduit-writer xml-types
       ];
       testHaskellDepends = [
         base bytestring hspec HUnit text unordered-containers xml-conduit
         xml-conduit-writer
       ];
       homepage = "https://bitbucket.org/dpwiz/haskell-soap";
       description = "SOAP client tools";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "soap" = callPackage
    ({ mkDerivation, base, bytestring, conduit, configurator
     , data-default, exceptions, hspec, http-client, http-types, HUnit
     , iconv, mtl, resourcet, text, unordered-containers, xml-conduit
     , xml-conduit-writer, xml-types
     }:
     mkDerivation {
       pname = "soap";
       version = "0.2.2.7";
       sha256 = "d18cf35ad9c6fae6fd0b1de598416b8f2e323d57e027b8f8ba00997c01cdd10b";
       libraryHaskellDepends = [
         base bytestring conduit configurator data-default exceptions
         http-client http-types iconv mtl resourcet text
         unordered-containers xml-conduit xml-conduit-writer xml-types
       ];
       testHaskellDepends = [
         base bytestring hspec HUnit text unordered-containers xml-conduit
         xml-conduit-writer
       ];
       homepage = "https://bitbucket.org/dpwiz/haskell-soap";
       description = "SOAP client tools";
       license = stdenv.lib.licenses.mit;
     }) {};

  "soap-openssl" = callPackage
    ({ mkDerivation, base, configurator, data-default, HsOpenSSL
     , http-client, http-client-openssl, soap, text
     }:
     mkDerivation {
       pname = "soap-openssl";
       version = "0.1.0.2";
       sha256 = "2008547f4fd22063479ce1cd1c483db926f5f08a2ff6fb0c60fb2f0f7d42830f";
       libraryHaskellDepends = [
         base configurator data-default HsOpenSSL http-client
         http-client-openssl soap text
       ];
       homepage = "https://bitbucket.org/dpwiz/haskell-soap";
       description = "TLS-enabled SOAP transport (using openssl bindings)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "soap-tls" = callPackage
    ({ mkDerivation, base, configurator, connection, data-default
     , http-client, http-client-tls, soap, text, tls, x509, x509-store
     , x509-validation
     }:
     mkDerivation {
       pname = "soap-tls";
       version = "0.1.1.2";
       sha256 = "e43abafb0ed390b9f5f99cc957973367d40e91c8d3ae7e22b3250a08ebe7df76";
       libraryHaskellDepends = [
         base configurator connection data-default http-client
         http-client-tls soap text tls x509 x509-store x509-validation
       ];
       homepage = "https://bitbucket.org/dpwiz/haskell-soap";
       description = "TLS-enabled SOAP transport (using tls package)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "sock2stream" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , haskell98, network
     }:
     mkDerivation {
       pname = "sock2stream";
       version = "0.3";
       sha256 = "f078bb494035208ecc91c1cee904e0cf12d796cc30d67afea658924ed497d9ee";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring containers directory haskell98 network
       ];
       homepage = "https://github.com/singpolyma/sock2stream";
       description = "Tunnel a socket over a single datastream (stdin/stdout)";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sockaddr" = callPackage
    ({ mkDerivation, base, byteorder, bytestring, network }:
     mkDerivation {
       pname = "sockaddr";
       version = "0.0.0";
       sha256 = "422f7e27c550878c9b0b05146cd935d775bf1fbf8f8b163c0923ed1b6f99e4c0";
       libraryHaskellDepends = [ base byteorder bytestring network ];
       description = "Printing SockAddr";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "socket" = callPackage
    ({ mkDerivation, async, base, bytestring }:
     mkDerivation {
       pname = "socket";
       version = "0.5.3.0";
       sha256 = "f9d6ff67fa2a725c4184d38ecd635c955fd90ef83bcac02f16dbbb1179f26066";
       libraryHaskellDepends = [ base bytestring ];
       testHaskellDepends = [ async base bytestring ];
       homepage = "https://github.com/lpeterse/haskell-socket";
       description = "A portable and extensible sockets library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "socket-activation" = callPackage
    ({ mkDerivation, base, network, transformers, unix }:
     mkDerivation {
       pname = "socket-activation";
       version = "0.1.0.1";
       sha256 = "aafe00774b8403edacb04b8d4dc6f38028f5173f57a5c4de43e9d26f02eb3f81";
       libraryHaskellDepends = [ base network transformers unix ];
       homepage = "https://github.com/sakana/haskell-socket-activation";
       description = "systemd socket activation library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "socket-io_1_3_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, engine-io
     , mtl, stm, text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "socket-io";
       version = "1.3.3";
       sha256 = "8783c854892b3fb0078cd7ad67ee7d80d6aad0362d6e385d84414ad9177ac8bf";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring engine-io mtl stm text
         transformers unordered-containers vector
       ];
       homepage = "http://github.com/ocharles/engine.io";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "socket-io_1_3_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, engine-io
     , mtl, stm, text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "socket-io";
       version = "1.3.4";
       sha256 = "58a3dd5b111682bcad608dc7a47c282f3c6d505d23ce5a690df17a4da2cf171f";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring engine-io mtl stm text
         transformers unordered-containers vector
       ];
       homepage = "http://github.com/ocharles/engine.io";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "socket-io" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, engine-io
     , mtl, stm, text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "socket-io";
       version = "1.3.5";
       sha256 = "1604797a7095ef26b733cdff8922bf373fac551ab157c9756b031d191f90903f";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring engine-io mtl stm text
         transformers unordered-containers vector
       ];
       homepage = "http://github.com/ocharles/engine.io";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "socket-sctp" = callPackage
    ({ mkDerivation, base, bytestring, sctp, socket }:
     mkDerivation {
       pname = "socket-sctp";
       version = "0.1.0.0";
       sha256 = "48ef7cae7ac4ed6674173716a598b611f704c38e14c1ac1006f1f730da60b9f5";
       libraryHaskellDepends = [ base bytestring socket ];
       librarySystemDepends = [ sctp ];
       testHaskellDepends = [ base bytestring socket ];
       homepage = "https://github.com/lpeterse/haskell-socket-sctp";
       description = "STCP socket extensions library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {sctp = null;};

  "socketio" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, attoparsec, base
     , blaze-builder, bytestring, conduit, conduit-extra, http-types
     , HUnit, lifted-base, monad-control, mtl, QuickCheck, random
     , scientific, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, transformers-base
     , unordered-containers, vector, wai, warp
     }:
     mkDerivation {
       pname = "socketio";
       version = "0.1.3";
       sha256 = "38f387e0e52ead50f0d87ae6ca6e9d753a76ad9d7f957f9afd434a777a9c3ca7";
       libraryHaskellDepends = [
         aeson ansi-terminal attoparsec base blaze-builder bytestring
         conduit conduit-extra http-types lifted-base monad-control mtl
         random text transformers-base unordered-containers vector wai warp
       ];
       testHaskellDepends = [
         aeson ansi-terminal attoparsec base blaze-builder bytestring
         conduit conduit-extra http-types HUnit lifted-base monad-control
         mtl QuickCheck random scientific test-framework
         test-framework-hunit test-framework-quickcheck2 text
         transformers-base unordered-containers vector wai warp
       ];
       jailbreak = true;
       description = "Socket.IO server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "socks" = callPackage
    ({ mkDerivation, base, bytestring, cereal, network }:
     mkDerivation {
       pname = "socks";
       version = "0.5.4";
       sha256 = "e9b5e1ea78592632bb086e5f4d6da523be01921a4a8998ca78552bdc396db4da";
       libraryHaskellDepends = [ base bytestring cereal network ];
       homepage = "http://github.com/vincenthz/hs-socks";
       description = "Socks proxy (version 5) implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sodium_0_11_0_2" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "sodium";
       version = "0.11.0.2";
       sha256 = "4fe4549b822c52d7739e4be7d3b9f3cd93680017f9c968603715f089ad797154";
       libraryHaskellDepends = [ base containers mtl ];
       jailbreak = true;
       description = "Sodium Reactive Programming (FRP) System";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sodium" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "sodium";
       version = "0.11.0.3";
       sha256 = "ea61f6725d01cf581a086738e9c18bbf567a428545d582824280aa48150b1a03";
       libraryHaskellDepends = [ base containers mtl ];
       description = "Sodium Reactive Programming (FRP) System";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "soegtk" = callPackage
    ({ mkDerivation, base, cairo, gtk, old-time, stm }:
     mkDerivation {
       pname = "soegtk";
       version = "0.12.1";
       sha256 = "594591337ba8244c7387afb6f68fd063551a20edadd9f7792c0816d6394cc405";
       libraryHaskellDepends = [ base cairo gtk old-time stm ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "GUI functions as used in the book \"The Haskell School of Expression\"";
       license = stdenv.lib.licenses.lgpl21;
     }) {};

  "sonic-visualiser" = callPackage
    ({ mkDerivation, array, base, bytestring, bzlib, containers, mtl
     , pretty, utf8-string, xml
     }:
     mkDerivation {
       pname = "sonic-visualiser";
       version = "0.1.1";
       sha256 = "37aaf0cfe4a363cf3f74e0b0c486f08b98b0a956b1c5e4218c47e0afcfd4303e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring bzlib containers mtl pretty utf8-string xml
       ];
       executableHaskellDepends = [
         array base bytestring bzlib containers mtl pretty utf8-string xml
       ];
       homepage = "http://darcs.k-hornz.de/cgi-bin/darcsweb.cgi?r=sonic-visualiser;a=summary";
       description = "Sonic Visualiser";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sophia" = callPackage
    ({ mkDerivation, base, bindings-sophia, bytestring, directory
     , tasty, tasty-hunit
     }:
     mkDerivation {
       pname = "sophia";
       version = "0.1.2";
       sha256 = "8fc702cd72beb2bf831ae180afaa9e3d9f73f820756cb707f80c35aa80775ba3";
       libraryHaskellDepends = [ base bindings-sophia bytestring ];
       testHaskellDepends = [
         base bindings-sophia bytestring directory tasty tasty-hunit
       ];
       jailbreak = true;
       description = "Bindings to Sophia library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sort-by-pinyin" = callPackage
    ({ mkDerivation, air, air-extra, air-th, base, bytestring
     , containers, text
     }:
     mkDerivation {
       pname = "sort-by-pinyin";
       version = "2014.5.19";
       sha256 = "cd891157fc08f557e27efdb8da5a623f4b8a78a80abd1c37f2e23d057fe94ecf";
       libraryHaskellDepends = [
         air air-extra air-th base bytestring containers text
       ];
       homepage = "https://github.com/nfjinjing/sort-by-pinyin";
       description = "Sort simplified Chinese by PinYin";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sorted" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "sorted";
       version = "0.0.1";
       sha256 = "0340a293e80b8babb39a7041a24ef7328d76510c5056ed6d5b9a68c23eecec67";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Efficient, type-safe sorted sequences";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sorted-list" = callPackage
    ({ mkDerivation, base, deepseq }:
     mkDerivation {
       pname = "sorted-list";
       version = "0.1.4.2";
       sha256 = "a10293095a336444ec145c59b20192430917d9fd6a0c5ce6a60374bddded2edf";
       libraryHaskellDepends = [ base deepseq ];
       homepage = "https://github.com/Daniel-Diaz/sorted-list/blob/master/README.md";
       description = "Type-enforced sorted lists and related functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sorting" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "sorting";
       version = "1.0.0.1";
       sha256 = "b60861d8dca5c884544cd255f33c62b65cc1aece9e2a687352329f7b705d5bc4";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/joneshf/sorting";
       description = "Utils for sorting";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sorty" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "sorty";
       version = "0.1.1";
       sha256 = "58b915f393b117336ec17145b079fb811d0b8224e41a5cf6a4192446db8d7911";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bytestring ];
       jailbreak = true;
       description = "Sort lines per file size";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sound-collage" = callPackage
    ({ mkDerivation, array, base, carray, directory, fft, filepath
     , numeric-prelude, optparse-applicative, sample-frame, soxlib
     , storablevector, storablevector-carray, synthesizer-core
     , temporary, transformers, utility-ht
     }:
     mkDerivation {
       pname = "sound-collage";
       version = "0.1";
       sha256 = "b584afca2dc682dfa7e5350b8eb3877b7cf6cedfb5f7ed9a7af006910b86fc87";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base carray directory fft filepath numeric-prelude
         optparse-applicative sample-frame soxlib storablevector
         storablevector-carray synthesizer-core temporary transformers
         utility-ht
       ];
       jailbreak = true;
       description = "Approximate a song from other pieces of sound";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sounddelay" = callPackage
    ({ mkDerivation, base, containers, parseargs, WAVE }:
     mkDerivation {
       pname = "sounddelay";
       version = "0.1.0.2";
       sha256 = "b22715fd2698e70fe5610aae0f15d7a999982ff2445bca2030885fb83e380ad7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers parseargs WAVE ];
       homepage = "http://github.com/BartMassey/sounddelay";
       description = "Audio delay line";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "source-code-server" = callPackage
    ({ mkDerivation, base, bytestring, containers, curl, data-default
     , directory, filepath, hack, hack-contrib, hack-handler-happstack
     , haskell98, HDBC, HDBC-sqlite3, json, loli, mps, mtl, process
     , safe, StateVar, stm, template-haskell, time, unix
     }:
     mkDerivation {
       pname = "source-code-server";
       version = "2010.9.1";
       sha256 = "8899edf8eb3661421b0ec391c64d581bcc2e69856f283761ab672076235764a4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers curl data-default directory filepath
         hack hack-contrib hack-handler-happstack haskell98 HDBC
         HDBC-sqlite3 json loli mps mtl process safe StateVar stm
         template-haskell time unix
       ];
       homepage = "http://github.com/nfjinjing/source-code-server";
       description = "The server backend for the source code iPhone app";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sourcemap_0_1_3_0" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, process, text
     , unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "sourcemap";
       version = "0.1.3.0";
       sha256 = "65cec57183b568913b304513a812d229c0be57645bb0ba39fef28b2fb4d48eba";
       revision = "1";
       editedCabalFile = "aa8b674ddb6f30642da0a391ad3481b44241f9f1cb2ee661503e59dac3ca2053";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring process text unordered-containers
         utf8-string
       ];
       description = "Implementation of source maps as proposed by Google and Mozilla";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sourcemap" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, process, text
     , unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "sourcemap";
       version = "0.1.6";
       sha256 = "b9a04cccb4fe7eea8b37a2eaf2bc776eae5640038ab76fb948c5a3ea09a9ce7a";
       revision = "1";
       editedCabalFile = "5d35341a581af4ba98187f832cac8b25e463bd1ce451aa1dbad161931521f8b8";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring process text unordered-containers
         utf8-string
       ];
       testHaskellDepends = [
         aeson base bytestring process text unordered-containers utf8-string
       ];
       doCheck = false;
       description = "Implementation of source maps as proposed by Google and Mozilla";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sousit" = callPackage
    ({ mkDerivation, base, bytestring, cereal, mtl, QuickCheck
     , resourcet, stm, test-framework, test-framework-quickcheck2
     , transformers
     }:
     mkDerivation {
       pname = "sousit";
       version = "0.4";
       sha256 = "99ff3b9ee866c42de7f6a1c955afd7cc6d3fe33a443757ae58daf13f28a1cf6d";
       libraryHaskellDepends = [
         base bytestring cereal mtl resourcet stm transformers
       ];
       testHaskellDepends = [
         base mtl QuickCheck test-framework test-framework-quickcheck2
       ];
       homepage = "https://github.com/msiegenthaler/SouSiT";
       description = "Source/Sink/Transform: An alternative to lazy IO and iteratees";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sox" = callPackage
    ({ mkDerivation, base, containers, explicit-exception
     , extensible-exceptions, process, sample-frame, transformers, unix
     , utility-ht
     }:
     mkDerivation {
       pname = "sox";
       version = "0.2.2.6";
       sha256 = "d4f486e14d67bc7f714d14ac7a1605166962a8af1405bc978a4eb59385f9fb12";
       libraryHaskellDepends = [
         base containers explicit-exception extensible-exceptions process
         sample-frame transformers unix utility-ht
       ];
       homepage = "http://www.haskell.org/haskellwiki/Sox";
       description = "Play, write, read, convert audio signals using Sox";
       license = "GPL";
     }) {};

  "soxlib" = callPackage
    ({ mkDerivation, base, containers, explicit-exception
     , extensible-exceptions, sample-frame, sox, storablevector
     , transformers, utility-ht
     }:
     mkDerivation {
       pname = "soxlib";
       version = "0.0.2.1";
       sha256 = "91e25a3919149abce1956e46d831c01c6875ad23cb9be79420792e52f9690a0a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers explicit-exception extensible-exceptions
         sample-frame storablevector transformers utility-ht
       ];
       libraryPkgconfigDepends = [ sox ];
       homepage = "http://www.haskell.org/haskellwiki/Sox";
       description = "Write, read, convert audio signals using libsox";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) sox;};

  "soyuz" = callPackage
    ({ mkDerivation, base, bytestring, cereal, cmdargs, containers
     , pretty, QuickCheck, trifecta, uniplate, vector
     }:
     mkDerivation {
       pname = "soyuz";
       version = "0.0.0";
       sha256 = "777846536e15728f8b717c04b5fa779ea4482c8f92bfc028ba726816f36c0af1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal cmdargs containers pretty QuickCheck
         trifecta uniplate vector
       ];
       homepage = "https://github.com/amtal/0x10c";
       description = "DCPU-16 architecture utilities for Notch's 0x10c game";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "spacefill" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "spacefill";
       version = "0.1";
       sha256 = "53e338b52610985990a12c6a03788ff4c5b477915d04f012895978a1eff3a155";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       homepage = "https://github.com/knz/spacefill";
       description = "Generators for space-filling curves";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "spacepart" = callPackage
    ({ mkDerivation, base, vector-space }:
     mkDerivation {
       pname = "spacepart";
       version = "0.1.0.0";
       sha256 = "579aaef6f85be8355094c8353295a5e11443664d1c9308c395a4f42812641c85";
       libraryHaskellDepends = [ base vector-space ];
       jailbreak = true;
       homepage = "http://code.haskell.org/data-spacepart";
       description = "Space partition data structures. Currently only a QuadTree.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "spaceprobe" = callPackage
    ({ mkDerivation, base, clock, containers, erf, mtl, QuickCheck
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "spaceprobe";
       version = "0.3.0";
       sha256 = "be3a487fd30ae0474d51c4e875cb00e2ddda6727b154ccc408f937570bb67727";
       libraryHaskellDepends = [ base clock containers erf mtl ];
       testHaskellDepends = [
         base clock containers erf mtl QuickCheck test-framework
         test-framework-quickcheck2
       ];
       homepage = "https://github.com/SeanRBurton/spaceprobe";
       description = "Optimization over arbitrary search spaces";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "spanout" = callPackage
    ({ mkDerivation, base, containers, gloss, lens, linear, MonadRandom
     , mtl, netwire
     }:
     mkDerivation {
       pname = "spanout";
       version = "0.1";
       sha256 = "64e150c2de26608ef218dfd088cbb7a9d4881ae46c9615f626367b6748bd2162";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers gloss lens linear MonadRandom mtl netwire
       ];
       jailbreak = true;
       homepage = "https://github.com/vtan/spanout";
       description = "A breakout clone written in netwire and gloss";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sparse" = callPackage
    ({ mkDerivation, base, bytestring, containers, contravariant
     , deepseq, directory, doctest, filepath, hlint, hybrid-vectors
     , lens, linear, mtl, primitive, QuickCheck, semigroups
     , simple-reflect, test-framework, test-framework-quickcheck2
     , test-framework-th, transformers, vector, vector-algorithms
     }:
     mkDerivation {
       pname = "sparse";
       version = "0.9.2";
       sha256 = "ed0eeae3389c456d66f825d467cd7ef112cf15603ceb493d202d8fadecad7232";
       libraryHaskellDepends = [
         base contravariant deepseq hybrid-vectors lens primitive
         transformers vector vector-algorithms
       ];
       testHaskellDepends = [
         base bytestring containers deepseq directory doctest filepath hlint
         hybrid-vectors lens linear mtl QuickCheck semigroups simple-reflect
         test-framework test-framework-quickcheck2 test-framework-th
         transformers vector
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/sparse";
       description = "A playground of sparse linear algebra primitives using Morton ordering";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sparse-lin-alg" = callPackage
    ({ mkDerivation, base, containers, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "sparse-lin-alg";
       version = "0.4.3";
       sha256 = "89d57792b0744a8948af65940f080a3d3c179f0a24860d473429985547c0a588";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [
         base containers QuickCheck test-framework
         test-framework-quickcheck2
       ];
       homepage = "http://github.com/laughedelic/sparse-lin-alg";
       description = "Effective linear algebra on sparse matrices";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sparsebit" = callPackage
    ({ mkDerivation, base, haskell98 }:
     mkDerivation {
       pname = "sparsebit";
       version = "0.5";
       sha256 = "07d4ffb50ab6b596c21c4b82afddd6c917bdb0ac790bcd63010bf990abd58fa8";
       libraryHaskellDepends = [ base haskell98 ];
       homepage = "http://kyagrd.dyndns.org/wiki/SparseBitmapsForPatternMatchCoverage";
       description = "Sparse bitmaps for pattern match coverage";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sparsecheck" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "sparsecheck";
       version = "0.1.0.3";
       sha256 = "2545d53de0c1c870b5a19bbb550ba77683a292b3032fa7702e23c2ac8edf09a6";
       libraryHaskellDepends = [ base containers ];
       homepage = "http://www.cs.york.ac.uk/~mfn/sparsecheck/";
       description = "A Logic Programming Library for Test-Data Generation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sparser" = callPackage
    ({ mkDerivation, base, containers, data-default, monadplus, nats
     , pointed, semigroups
     }:
     mkDerivation {
       pname = "sparser";
       version = "0.6.1";
       sha256 = "225f2754d44cef5bc6e3102782d53025efa677d235ff5606b47cef8a359516d6";
       libraryHaskellDepends = [
         base containers data-default monadplus nats pointed semigroups
       ];
       description = "Lightweight parsing library based on partial functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "spata" = callPackage
    ({ mkDerivation, base, dlist, mps, mtl }:
     mkDerivation {
       pname = "spata";
       version = "2010.10.10";
       sha256 = "fecf89404a35b9dc1acdd9b317bf078560feda569e28f6f596262d41056a20b3";
       libraryHaskellDepends = [ base dlist mps mtl ];
       homepage = "http://github.com/nfjinjing/spata";
       description = "brainless form validation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "spatial-math" = callPackage
    ({ mkDerivation, base, binary, cereal, doctest, ghc-prim, lens
     , linear, QuickCheck, test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "spatial-math";
       version = "0.2.7.0";
       sha256 = "a40636d9639ebd4f81b6b10a25ffd3f03af7e3a904d80ac00d2c6892d9ad2859";
       libraryHaskellDepends = [
         base binary cereal ghc-prim lens linear
       ];
       testHaskellDepends = [
         base doctest QuickCheck test-framework test-framework-quickcheck2
       ];
       description = "3d math including quaternions/euler angles/dcms and utility functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "spawn" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "spawn";
       version = "0.3";
       sha256 = "48c663b10c2406c8199edb84009cf2c45395d3105bfec6a57011673038a07376";
       libraryHaskellDepends = [ base ];
       description = "Tiny library for concurrent computations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "spdx_0_2_0_0" = callPackage
    ({ mkDerivation, base, tasty, tasty-quickcheck, transformers }:
     mkDerivation {
       pname = "spdx";
       version = "0.2.0.0";
       sha256 = "58beadfcee82f77de9290c897de57ee8fab9be1297ca8af8c98b81147d9dbf43";
       revision = "1";
       editedCabalFile = "1fd8d3886920b2cf9597d16fcc7ee0c0709c78dc1e88471df6e4a9d567521bfa";
       libraryHaskellDepends = [ base transformers ];
       testHaskellDepends = [ base tasty tasty-quickcheck ];
       homepage = "https://github.com/phadej/spdx";
       description = "SPDX license expression language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "spdx" = callPackage
    ({ mkDerivation, base, tasty, tasty-quickcheck, transformers }:
     mkDerivation {
       pname = "spdx";
       version = "0.2.1.0";
       sha256 = "a7f0d6098e201f5d7b14c13387fe699b9830c95c0192bbd8ceda446a30c980f2";
       revision = "1";
       editedCabalFile = "adba306bc3280e794c4f69da6fb87346d53bd5c72bd9940069d68d1fc194ce61";
       libraryHaskellDepends = [ base transformers ];
       testHaskellDepends = [ base tasty tasty-quickcheck ];
       homepage = "https://github.com/phadej/spdx";
       description = "SPDX license expression language";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "spe" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "spe";
       version = "0.6.3";
       sha256 = "d921bf63ad5e6a8e59adcd5e19d6e0c25afe5f43d212c926cfe397ef93439809";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/akc/spe";
       description = "Combinatorial species lite";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "special-functors" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "special-functors";
       version = "1.0.0.1";
       sha256 = "2def687fadb58e12f15696e0c3e2b0206063884e9e41fd214db663028253c830";
       libraryHaskellDepends = [ base mtl ];
       jailbreak = true;
       description = "Control.Applicative, Data.Foldable, Data.Traversable (compatibility package)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "special-keys" = callPackage
    ({ mkDerivation, aeson, base, blaze-markup, bytestring, cereal
     , deepseq, hashable, mwc-random, path-pieces, primitive, safecopy
     , text, uuid
     }:
     mkDerivation {
       pname = "special-keys";
       version = "0.1.0.3";
       sha256 = "fe3eaf971544206f7beee91f61b27754ad0fb24a007b5891d73cd504fdcfc664";
       libraryHaskellDepends = [
         aeson base blaze-markup bytestring cereal deepseq hashable
         mwc-random path-pieces primitive safecopy text uuid
       ];
       description = "Simple data types that help me here and there";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "specialize-th" = callPackage
    ({ mkDerivation, base, checkers, composition, DebugTraceHelpers
     , derive, HUnit, MissingH, mtl, newtype, newtype-th, QuickCheck
     , template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, th-expand-syns, tuple, type-sub-th
     , uniplate, universe-th
     }:
     mkDerivation {
       pname = "specialize-th";
       version = "0.0.0.8";
       sha256 = "ccca66f88869abbff3716bc690e50301ab90fc2118b89fc6691129f911d02bad";
       libraryHaskellDepends = [
         base composition derive MissingH mtl newtype newtype-th
         template-haskell th-expand-syns tuple type-sub-th uniplate
         universe-th
       ];
       testHaskellDepends = [
         base checkers composition DebugTraceHelpers derive HUnit MissingH
         mtl newtype newtype-th QuickCheck template-haskell test-framework
         test-framework-hunit test-framework-quickcheck2 th-expand-syns
         type-sub-th uniplate universe-th
       ];
       homepage = "https://github.com/jfischoff/specialize-th";
       description = "Create specialized types from polymorphic ones using TH";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "species" = callPackage
    ({ mkDerivation, base, containers, multiset-comb, np-extras
     , numeric-prelude, template-haskell
     }:
     mkDerivation {
       pname = "species";
       version = "0.3.4.2";
       sha256 = "9e1683448aa2152561c65b02fb832e366ce9f47542e5e963abd82d5e08eeb11f";
       libraryHaskellDepends = [
         base containers multiset-comb np-extras numeric-prelude
         template-haskell
       ];
       description = "Computational combinatorial species";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "speculation_1_5_0_1" = callPackage
    ({ mkDerivation, base, ghc-prim, stm, transformers }:
     mkDerivation {
       pname = "speculation";
       version = "1.5.0.1";
       sha256 = "805650c461795c8c06040607bacca7ae4d16d8b09f01dc9b582f5a5719835ace";
       libraryHaskellDepends = [ base ghc-prim stm transformers ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/speculation";
       description = "A framework for safe, programmable, speculative parallelism";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "speculation_1_5_0_2" = callPackage
    ({ mkDerivation, base, ghc-prim, stm, transformers }:
     mkDerivation {
       pname = "speculation";
       version = "1.5.0.2";
       sha256 = "e5c29dc325482c99e871c7a026f3115d0192165096d04e93e85ec19bfad8a485";
       libraryHaskellDepends = [ base ghc-prim stm transformers ];
       homepage = "http://github.com/ekmett/speculation";
       description = "A framework for safe, programmable, speculative parallelism";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "speculation" = callPackage
    ({ mkDerivation, base, ghc-prim, stm, transformers }:
     mkDerivation {
       pname = "speculation";
       version = "1.5.0.3";
       sha256 = "73bf641a87e0d28a2ba233922db936e0776c3dc24ed421f6f963f015e2eb4d3f";
       libraryHaskellDepends = [ base ghc-prim stm transformers ];
       homepage = "http://github.com/ekmett/speculation";
       description = "A framework for safe, programmable, speculative parallelism";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "speculation-transformers" = callPackage
    ({ mkDerivation, speculation }:
     mkDerivation {
       pname = "speculation-transformers";
       version = "0.1.2";
       sha256 = "aa3842dba644461dcd91fb5d43d43d21a544fd71eedab5e0a43ed4848b8fa000";
       libraryHaskellDepends = [ speculation ];
       doHaddock = false;
       homepage = "http://github.com/ekmett/speculation/";
       description = "Merged into 'speculation'. Use that instead.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "speedy-slice" = callPackage
    ({ mkDerivation, base, containers, lens, mcmc-types
     , mwc-probability, pipes, primitive, transformers
     }:
     mkDerivation {
       pname = "speedy-slice";
       version = "0.1.3";
       sha256 = "8be147fe85bf02f1e5bb7cc32e3a61c418354af8875fadb0cd20e4fe804f3992";
       libraryHaskellDepends = [
         base lens mcmc-types mwc-probability pipes primitive transformers
       ];
       testHaskellDepends = [ base containers mwc-probability ];
       homepage = "http://github.com/jtobin/speedy-slice";
       description = "Speedy slice sampling";
       license = stdenv.lib.licenses.mit;
     }) {};

  "spelling-suggest" = callPackage
    ({ mkDerivation, base, edit-distance, parseargs, phonetic-code
     , sqlite
     }:
     mkDerivation {
       pname = "spelling-suggest";
       version = "0.5.2.1";
       sha256 = "56d4a5b8c9a65ab954bda4358342137f5e96c0ba87b71b087af20eb917150b58";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base edit-distance phonetic-code sqlite
       ];
       executableHaskellDepends = [
         base edit-distance parseargs phonetic-code sqlite
       ];
       jailbreak = true;
       homepage = "https://github.com/gregwebs/haskell-spell-suggest";
       description = "Spelling suggestion tool with library and command-line interfaces";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sphero" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, mtl
     , simple-bluetooth
     }:
     mkDerivation {
       pname = "sphero";
       version = "0.1.0.0";
       sha256 = "886c2dcca92c94d7a86610f8ebc68b6c97aa7c3ce911a23793e8f771ef37b1ac";
       libraryHaskellDepends = [
         base bytestring cereal containers mtl simple-bluetooth
       ];
       jailbreak = true;
       description = "Orbotix Sphero client library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sphinx" = callPackage
    ({ mkDerivation, base, binary, bytestring, data-binary-ieee754
     , network, text, text-icu, xml
     }:
     mkDerivation {
       pname = "sphinx";
       version = "0.6.0.1";
       sha256 = "28496ed2f52d5934de64cbb6b045a37848d2590a65b756000280d132932795dd";
       libraryHaskellDepends = [
         base binary bytestring data-binary-ieee754 network text text-icu
         xml
       ];
       homepage = "https://github.com/gregwebs/haskell-sphinx-client";
       description = "Haskell bindings to the Sphinx full-text searching daemon";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sphinx-cli" = callPackage
    ({ mkDerivation, base, sphinx }:
     mkDerivation {
       pname = "sphinx-cli";
       version = "0.1";
       sha256 = "837fb9b75f60ebc10f0aabf26d1a12f9af5b2d8d448acdbd9c5a18625a75d821";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base sphinx ];
       description = "Sphinx CLI and demo of Haskell Sphinx library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "spice" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default, elerea
     , GLFW, JuicyPixels, JuicyPixels-repa, OpenGL
     }:
     mkDerivation {
       pname = "spice";
       version = "0.5.0.0";
       sha256 = "cf4877337916fe9530a0d1f08338dc91fb418cd9bedd3e07b668d0f46e4c40f7";
       libraryHaskellDepends = [
         base bytestring containers data-default elerea GLFW JuicyPixels
         JuicyPixels-repa OpenGL
       ];
       jailbreak = true;
       homepage = "http://github.com/crockeo/spice";
       description = "An FRP-based game engine written in Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "spike" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, glib
     , global-variables, gtk, libsoup, mtl, process, random, rosezipper
     , stm, webkit
     }:
     mkDerivation {
       pname = "spike";
       version = "0.3";
       sha256 = "b661498cd4405e9dc6b4c2b98772cf8cf0171404647defd2d1d7b4551d40b987";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath glib global-variables gtk mtl
         process random rosezipper stm webkit
       ];
       executablePkgconfigDepends = [ libsoup ];
       jailbreak = true;
       homepage = "http://github.com/Tener/spike";
       description = "Experimental web browser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.gnome) libsoup;};

  "spine" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "spine";
       version = "0.1";
       sha256 = "fb2de277774e9eabb14b7f66fcd84221c8c53d1af8b07ed027b92e46f5dc62ea";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/spl/spine";
       description = "Simple implementation of the generic spine view";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "spir-v" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "spir-v";
       version = "0.0.1.0";
       sha256 = "59d7b176ddafbb73aff8dd4b1a8f9557f748728e4f5262a9575108ff6e62d6ca";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/expipiplus1/spir-v";
       description = "Some utilities for reading and writing SPIR-V files";
       license = stdenv.lib.licenses.mit;
     }) {};

  "splay" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "splay";
       version = "0.0.6";
       sha256 = "94295e6e39f7e452595a30d62eec03aafb062df4c7df40d7874b8a4785b105d7";
       libraryHaskellDepends = [ base ];
       description = "Generic splay-based sequence representation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "splaytree" = callPackage
    ({ mkDerivation, base, containers, deepseq, QuickCheck
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "splaytree";
       version = "0.1.5";
       sha256 = "a7b24638b830190af210aed7e6f4abea5cdba20ef745d829d566d670dfc4344a";
       libraryHaskellDepends = [ base deepseq ];
       testHaskellDepends = [
         base containers QuickCheck test-framework
         test-framework-quickcheck2
       ];
       homepage = "http://github.com/JohnLato/splaytree";
       description = "Provides an annotated splay tree";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "splice" = callPackage
    ({ mkDerivation, base, network }:
     mkDerivation {
       pname = "splice";
       version = "0.6.1.1";
       sha256 = "81fabe6652571f0dbf6b8904bd782daaeccc9d89d40f77b15dff46b7499d4e53";
       libraryHaskellDepends = [ base network ];
       homepage = "http://corsis.github.com/splice/";
       description = "Cross-platform Socket to Socket Data Splicing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "spline3" = callPackage
    ({ mkDerivation, base, cmdargs, doctest, filepath, MissingH, repa
     , repa-algorithms, repa-io, tasty, tasty-hunit, tasty-quickcheck
     , vector
     }:
     mkDerivation {
       pname = "spline3";
       version = "0.0.2";
       sha256 = "f84abe1934a22e3a20af5c97423184454986734d723c601bf1978760e17a4a84";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs filepath MissingH repa repa-algorithms repa-io tasty
         tasty-hunit tasty-quickcheck vector
       ];
       testHaskellDepends = [
         base cmdargs doctest filepath MissingH repa repa-algorithms repa-io
         tasty tasty-hunit tasty-quickcheck vector
       ];
       jailbreak = true;
       homepage = "http://michael.orlitzky.com/code/spline3.php";
       description = "A parallel implementation of the Sorokina/Zeilfelder spline scheme";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "splines" = callPackage
    ({ mkDerivation, base, containers, polynomial, QuickCheck
     , test-framework, test-framework-quickcheck2, vector, vector-space
     }:
     mkDerivation {
       pname = "splines";
       version = "0.5.0.1";
       sha256 = "abd004a49a1454660d9a0ea83eabde3a109c7340e35a9576103ccffd23aa05af";
       libraryHaskellDepends = [
         base containers polynomial vector vector-space
       ];
       testHaskellDepends = [
         base containers polynomial QuickCheck test-framework
         test-framework-quickcheck2 vector vector-space
       ];
       description = "B-Splines, other splines, and NURBS";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "split_0_1_4_3" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "split";
       version = "0.1.4.3";
       sha256 = "7e69989206e26bb28f46cc8cf1edff5e439aa6be4adbc5b09118d6fdc1aa3bc5";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~byorgey/code/split";
       description = "Combinator library for splitting lists";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "split_0_2_2" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "split";
       version = "0.2.2";
       sha256 = "f9cf9e571357f227aed5be9a78f5bbf78ef55c99df2edf7fdc659acc1f904375";
       revision = "2";
       editedCabalFile = "066b3484a1880627f3abc187557709b8947d928e82cd9add5812587b2df295c1";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base QuickCheck ];
       description = "Combinator library for splitting lists";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "split" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "split";
       version = "0.2.3";
       sha256 = "a6d100e433fa27eda72127475ba9c55481ca4105cfbb6ff55b67023d00ccead9";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base QuickCheck ];
       description = "Combinator library for splitting lists";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "split-channel" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "split-channel";
       version = "0.2.0.1";
       sha256 = "53ed4e9f68972b1d6db98b040b10e512a194d45c7734802adcaef9e2827c5a70";
       libraryHaskellDepends = [ base ];
       description = "Control.Concurrent.Chan split into sending and receiving halves.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "split-record" = callPackage
    ({ mkDerivation, base, numeric-prelude, soxlib, storablevector
     , synthesizer-core, transformers, utility-ht
     }:
     mkDerivation {
       pname = "split-record";
       version = "0.1.1.1";
       sha256 = "fb7029494472a22583ac20bfb3f7dcb8db50d44b054f79f7406ad511ddb5a334";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base numeric-prelude soxlib storablevector synthesizer-core
         transformers utility-ht
       ];
       homepage = "http://code.haskell.org/~thielema/split-record/";
       description = "Split a big audio file into pieces at positions of silence";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "split-tchan" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "split-tchan";
       version = "0.1.0.0";
       sha256 = "57f47168cec99172dff7b391ab9c05faedaa981f386464eb22996e51ed5e8c63";
       libraryHaskellDepends = [ base stm ];
       description = "STM's TChan split into sending and receiving halves";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "splitter" = callPackage
    ({ mkDerivation, base, directory, filepath, parsec, range }:
     mkDerivation {
       pname = "splitter";
       version = "0.1.0.0";
       sha256 = "066bb3812e860c40d41076496404767db0adc5fff0dada7292429da540ad2bda";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath parsec range
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/robertmassaioli/splitter";
       description = "Use numerical ranges to split out certain lines from a file";
       license = stdenv.lib.licenses.mit;
     }) {};

  "splot" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-lexing, cairo, colour
     , containers, HUnit, mtl, strptime, template-haskell, time
     , vcs-revision
     }:
     mkDerivation {
       pname = "splot";
       version = "0.3.14";
       sha256 = "77b8b2bbe99a21ac0c5b2f7b7cc5cf079302501ebebc4b77fa557ab071e178ed";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring bytestring-lexing cairo colour containers HUnit mtl
         strptime template-haskell time vcs-revision
       ];
       homepage = "http://www.haskell.org/haskellwiki/Splot";
       description = "A tool for visualizing the lifecycle of many concurrent multi-staged processes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "spool" = callPackage
    ({ mkDerivation, base, bytestring, vector }:
     mkDerivation {
       pname = "spool";
       version = "0.1";
       sha256 = "868c72b98aaf9f041f424d949d8cef05c9b859984e4e35d57026fad9d9f873eb";
       libraryHaskellDepends = [ base bytestring vector ];
       description = "Convert between ByteString and Vector.Storable without copying";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "spoon" = callPackage
    ({ mkDerivation, base, deepseq }:
     mkDerivation {
       pname = "spoon";
       version = "0.3.1";
       sha256 = "b9b350b6730e34c246bbf7e228a86b3d4925b52c95542f7676d719ef2a9881d4";
       revision = "1";
       editedCabalFile = "e46c5e919cc9d0c7b0f671cddb631ef0979622a1e2250c59c7e491a799944527";
       libraryHaskellDepends = [ base deepseq ];
       description = "Catch errors thrown from pure computations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "spoonutil" = callPackage
    ({ mkDerivation, base, directory, extensible-exceptions, filepath
     , parsec
     }:
     mkDerivation {
       pname = "spoonutil";
       version = "0.0.1";
       sha256 = "0d5a31fbd426605962762f75ab6ff83f7ea1cbba474b6f7e0b230106aacb6a76";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory extensible-exceptions filepath parsec
       ];
       homepage = "http://github.com/elginer/SpoonUtilities";
       description = "Spoon's utilities. Simple testing and nice looking error reporting.";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "spoty" = callPackage
    ({ mkDerivation, aeson, base, bytestring, lens, lens-aeson, pipes
     , text, unordered-containers, wreq
     }:
     mkDerivation {
       pname = "spoty";
       version = "0.1.0.2";
       sha256 = "a332d923b9fda4ae7a629c49d76ac5984e5041d0bf5794a812d2d31e3db2355c";
       libraryHaskellDepends = [
         aeson base bytestring lens lens-aeson pipes text
         unordered-containers wreq
       ];
       jailbreak = true;
       homepage = "https://github.com/davnils/spoty";
       description = "Spotify web API wrapper";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "spreadsheet" = callPackage
    ({ mkDerivation, base, explicit-exception, transformers, utility-ht
     }:
     mkDerivation {
       pname = "spreadsheet";
       version = "0.1.3.3";
       sha256 = "41b2b7329840fc67dd870f559ddcca0a5836f8f567889697f9cdb815ec6bcce0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base explicit-exception transformers utility-ht
       ];
       homepage = "http://www.haskell.org/haskellwiki/Spreadsheet";
       description = "Read and write spreadsheets from and to CSV files in a lazy way";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "spritz" = callPackage
    ({ mkDerivation, base, lens, mtl, vector }:
     mkDerivation {
       pname = "spritz";
       version = "0.1.0.0";
       sha256 = "d311a5b8d1a9a23d02623142b5d5451290ac3689038412d7325ab0f30115dbeb";
       libraryHaskellDepends = [ base lens mtl vector ];
       jailbreak = true;
       homepage = "https://github.com/relrod/spritz";
       description = "An implementation of the Spritz RC4-like stream cipher in Haskell";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "spsa" = callPackage
    ({ mkDerivation, base, hmatrix, HUnit, mtl, QuickCheck, random
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "spsa";
       version = "0.2.0.0";
       sha256 = "30770c3f729ee6c9dd249ff52e62c9d95ba5a7681ac97329900cbdbae742404a";
       libraryHaskellDepends = [ base hmatrix mtl random ];
       testHaskellDepends = [
         base hmatrix HUnit QuickCheck random test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/yanatan16/haskell-spsa";
       description = "Simultaneous Perturbation Stochastic Approximation Optimization Algorithm";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "spy" = callPackage
    ({ mkDerivation, base, cmdargs, directory, filemanip, filepath
     , fsnotify, HUnit, json, process, QuickCheck, system-filepath
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , time, unix
     }:
     mkDerivation {
       pname = "spy";
       version = "0.10";
       sha256 = "f0020bed11e5e8c42dab4e2f04f00bb0f19a2251738596eca1fcd704408776ac";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs directory filemanip filepath fsnotify json process
         system-filepath time unix
       ];
       testHaskellDepends = [
         base cmdargs directory filemanip filepath fsnotify HUnit json
         process QuickCheck system-filepath test-framework
         test-framework-hunit test-framework-quickcheck2 time unix
       ];
       homepage = "https://bitbucket.org/ssaasen/spy";
       description = "A compact file system watcher for Mac OS X, Linux and Windows";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sql-simple" = callPackage
    ({ mkDerivation, base, containers, exceptions, monad-control, text
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "sql-simple";
       version = "0.3.1";
       sha256 = "905fe82fb568cbcaf826c3795ab43713c6e0911c5917f51f5598187565440fee";
       libraryHaskellDepends = [
         base containers exceptions monad-control text transformers
         transformers-base
       ];
       jailbreak = true;
       homepage = "https://github.com/philopon/sql-simple";
       description = "common middle-level sql client";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sql-simple-mysql" = callPackage
    ({ mkDerivation, base, data-default-class, mysql, mysql-simple
     , sql-simple, text
     }:
     mkDerivation {
       pname = "sql-simple-mysql";
       version = "0.3.0";
       sha256 = "f734eb8d80131fe079b3759e3a83dd02f7e7eb2b5fa1fe2a89b1cb3be87f3dc5";
       libraryHaskellDepends = [
         base data-default-class mysql mysql-simple sql-simple text
       ];
       jailbreak = true;
       homepage = "https://github.com/philopon/sql-simple";
       description = "mysql backend for sql-simple";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sql-simple-pool" = callPackage
    ({ mkDerivation, base, data-default-class, monad-control
     , resource-pool, sql-simple, text, time
     }:
     mkDerivation {
       pname = "sql-simple-pool";
       version = "0.3.0";
       sha256 = "09fec87c0b65cdba8b34912b0054612317ccf3e68bed6799687a07e07153f992";
       libraryHaskellDepends = [
         base data-default-class monad-control resource-pool sql-simple text
         time
       ];
       jailbreak = true;
       homepage = "https://github.com/philopon/sql-simple";
       description = "conection pool for sql-simple";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sql-simple-postgresql" = callPackage
    ({ mkDerivation, base, data-default-class, postgresql-simple
     , sql-simple, text
     }:
     mkDerivation {
       pname = "sql-simple-postgresql";
       version = "0.3.0";
       sha256 = "417ff354c81d3dea337590eaf65e654714fe52cdda8a0b38f69db3f993406236";
       libraryHaskellDepends = [
         base data-default-class postgresql-simple sql-simple text
       ];
       jailbreak = true;
       homepage = "https://github.com/philopon/sql-simple";
       description = "postgresql backend for sql-simple";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sql-simple-sqlite" = callPackage
    ({ mkDerivation, base, sql-simple, sqlite-simple }:
     mkDerivation {
       pname = "sql-simple-sqlite";
       version = "0.3.0";
       sha256 = "c18dc8f87af50e07ee088108e67a66726214c47ab1a19c70e268254cd609511e";
       libraryHaskellDepends = [ base sql-simple sqlite-simple ];
       jailbreak = true;
       homepage = "https://github.com/philopon/sql-simple";
       description = "sqlite backend for sql-simple";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sql-words" = callPackage
    ({ mkDerivation, base, QuickCheck, quickcheck-simple }:
     mkDerivation {
       pname = "sql-words";
       version = "0.1.3.1";
       sha256 = "c9ce5f8402cdfc610e3d58774ad5c3aedaa6f4d0e7724937ecd97a654351b59d";
       revision = "1";
       editedCabalFile = "6de32c6b306d3b438564e263deb20c68698a5cdaa198a3d711ee768954608e17";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base QuickCheck quickcheck-simple ];
       homepage = "http://khibino.github.io/haskell-relational-record/";
       description = "Simple idea SQL keywords data constructor into OverloadedString";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sqlite" = callPackage
    ({ mkDerivation, base, bytestring, directory, pretty, sqlite, time
     , utf8-string
     }:
     mkDerivation {
       pname = "sqlite";
       version = "0.5.2.2";
       sha256 = "372f9824627bebf2adfbd61314a0ff4b737b1cae0b3b14be66b4094cb8d89ec2";
       libraryHaskellDepends = [
         base bytestring directory pretty time utf8-string
       ];
       librarySystemDepends = [ sqlite ];
       description = "Haskell binding to sqlite3";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) sqlite;};

  "sqlite-simple_0_4_8_0" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, blaze-builder
     , blaze-textual, bytestring, containers, direct-sqlite, HUnit, text
     , time, transformers
     }:
     mkDerivation {
       pname = "sqlite-simple";
       version = "0.4.8.0";
       sha256 = "bf6a77d4cd843a61ae9226dac2dfb633a951573a4e0872c0b87a530e900e0d25";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-textual bytestring containers
         direct-sqlite text time transformers
       ];
       testHaskellDepends = [
         base base16-bytestring bytestring direct-sqlite HUnit text time
       ];
       homepage = "http://github.com/nurpax/sqlite-simple";
       description = "Mid-Level SQLite client library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sqlite-simple" = callPackage
    ({ mkDerivation, attoparsec, base, base16-bytestring, blaze-builder
     , blaze-textual, bytestring, containers, direct-sqlite, HUnit, text
     , time, transformers
     }:
     mkDerivation {
       pname = "sqlite-simple";
       version = "0.4.9.0";
       sha256 = "81dfe4a1dd69d2f0334d3be10ba1d6ce91a9ba0602e69170dfbecb84b11f60a3";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-textual bytestring containers
         direct-sqlite text time transformers
       ];
       testHaskellDepends = [
         base base16-bytestring bytestring direct-sqlite HUnit text time
       ];
       homepage = "http://github.com/nurpax/sqlite-simple";
       description = "Mid-Level SQLite client library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sqlite-simple-typed" = callPackage
    ({ mkDerivation, base, haskell-src-meta, sqlite, sqlite-simple
     , template-haskell, typedquery, utf8-string
     }:
     mkDerivation {
       pname = "sqlite-simple-typed";
       version = "0.1.0.0";
       sha256 = "1940910be59f1d0906f7c98f3c93cad305f5387f262a6bef02eaa1cd898cd401";
       libraryHaskellDepends = [
         base haskell-src-meta sqlite sqlite-simple template-haskell
         typedquery utf8-string
       ];
       jailbreak = true;
       homepage = "https://github.com/tolysz/sqlite-simple-typed";
       description = "Typed extension to sqlite simple";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sqlvalue-list" = callPackage
    ({ mkDerivation, base, convertible, HDBC, template-haskell }:
     mkDerivation {
       pname = "sqlvalue-list";
       version = "0.2";
       sha256 = "6017204be425f6e967736cba5198b55dfe4fc6e9d41154ed3d85e652c61d3ee5";
       libraryHaskellDepends = [ base convertible HDBC template-haskell ];
       description = "Class and instances for conversion to list of SqlValue";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "squeeze" = callPackage
    ({ mkDerivation, base, Cabal, directory, factory, filepath, mtl
     , QuickCheck, random, toolshed
     }:
     mkDerivation {
       pname = "squeeze";
       version = "1.0.4.8";
       sha256 = "9d67bb75f209427f4866ad9835b67e8057e2275349a1ef8f820ebbdbafcaf190";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal directory factory filepath mtl toolshed
       ];
       executableHaskellDepends = [
         base Cabal factory filepath mtl random toolshed
       ];
       testHaskellDepends = [ base factory QuickCheck toolshed ];
       homepage = "http://functionalley.eu/Squeeze/squeeze.html";
       description = "A file-packing application";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sr-extra" = callPackage
    ({ mkDerivation, base, bytestring, bzlib, containers, directory
     , filepath, HUnit, mtl, network-uri, old-locale, old-time, pretty
     , process, pureMD5, QuickCheck, random, regex-compat, time, unix
     , Unixutils, zlib
     }:
     mkDerivation {
       pname = "sr-extra";
       version = "1.46.3.1";
       sha256 = "599311f07ae0636aa1ee5fa8e62159bea3f36a30b26882d6efcc4f50a0d9596b";
       libraryHaskellDepends = [
         base bytestring bzlib containers directory filepath HUnit mtl
         network-uri old-locale old-time pretty process pureMD5 QuickCheck
         random regex-compat time unix Unixutils zlib
       ];
       homepage = "https://github.com/seereason/sr-extra";
       description = "A grab bag of modules";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "srcinst" = callPackage
    ({ mkDerivation, base, directory, hslogger, MissingH, network
     , parsec, process, regex-compat, unix
     }:
     mkDerivation {
       pname = "srcinst";
       version = "0.8.10";
       sha256 = "493e80a2ef1093db66a771bf666b6653474c8c46d80d793aeb57dd1b09d4cd17";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory hslogger MissingH network parsec process
         regex-compat unix
       ];
       description = "Build and install Debian packages completely from source";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "srcloc_0_4_1" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "srcloc";
       version = "0.4.1";
       sha256 = "9fa55086a92829f23bdcbc63d28241c24c3994691e914849fc87aadd522ba131";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "Data types for managing source code locations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "srcloc" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "srcloc";
       version = "0.5.1.0";
       sha256 = "e61df6ce79c8ac42a7a9a15ab3553ef5448174c0bfaee7192ff4c3d6a5695aff";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "Data types for managing source code locations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "srec" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "srec";
       version = "0.1.0";
       sha256 = "33c001b30ea1b15e3fcb3fc7e9da1d607ed58124c46976e3f31ab76d3f591a09";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://tomahawkins.org";
       description = "Parsing and processing s-records";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sscgi" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, case-insensitive
     , containers, Glob, MonadCatchIO-mtl, mtl, transformers
     , utf8-string
     }:
     mkDerivation {
       pname = "sscgi";
       version = "0.3.1";
       sha256 = "0925d1a384fae39255bd927f2ffa787e84d270fbd747e703f32ae41af06fcf3b";
       libraryHaskellDepends = [
         attoparsec base bytestring case-insensitive containers Glob
         MonadCatchIO-mtl mtl transformers utf8-string
       ];
       homepage = "https://github.com/jekor/haskell-sscgi";
       description = "Simple SCGI Library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ssh" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, base64-string
     , binary, bytestring, cereal, containers, crypto-api
     , crypto-pubkey-types, cryptohash-cryptoapi, directory, filepath
     , HsOpenSSL, HUnit, integer-gmp, libssh2, network, process
     , pseudomacros, QuickCheck, random, RSA, SHA, SimpleAES, split
     , tasty, tasty-hunit, tasty-quickcheck, template-haskell
     , th-lift-instances, transformers
     }:
     mkDerivation {
       pname = "ssh";
       version = "0.3.2";
       sha256 = "01e7138edb65300fb4285508fb5b31012e9b62ef08984bc5a1c90a80b62626bf";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base base64-string binary bytestring
         cereal containers crypto-api crypto-pubkey-types
         cryptohash-cryptoapi HsOpenSSL integer-gmp network process random
         RSA SHA SimpleAES split transformers
       ];
       testHaskellDepends = [
         base bytestring containers directory filepath HUnit libssh2
         pseudomacros QuickCheck tasty tasty-hunit tasty-quickcheck
         template-haskell th-lift-instances
       ];
       jailbreak = true;
       homepage = "http://hub.darcs.net/ganesh/ssh";
       description = "A pure-Haskell SSH server library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sshd-lint" = callPackage
    ({ mkDerivation, base, containers, hspec, keyword-args
     , nagios-check, parsec
     }:
     mkDerivation {
       pname = "sshd-lint";
       version = "0.1.0.1";
       sha256 = "ecc4f6f380994230a5302b0a3267f15929f77c6571914e5848fa01cb50ff6460";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers keyword-args nagios-check parsec
       ];
       testHaskellDepends = [
         base containers hspec keyword-args nagios-check parsec
       ];
       jailbreak = true;
       description = "Check sshd configuration for adherence to best practices";
       license = stdenv.lib.licenses.mit;
     }) {};

  "sshtun" = callPackage
    ({ mkDerivation, base, containers, curl, directory, hdaemonize
     , hslogger, mtl, process, regex-compat, stm, unix
     }:
     mkDerivation {
       pname = "sshtun";
       version = "1.0.0";
       sha256 = "581acb9dfc796a04abd2dca27ed4b3eb0d4aaa01d076e97ff3f70e02b6de241d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers curl directory hdaemonize hslogger mtl process
         regex-compat stm unix
       ];
       homepage = "http://ui3.info/d/proj/sshtun.html";
       description = "Wrapper daemon to manage an ssh tunnel";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sssp" = callPackage
    ({ mkDerivation, attempt, attoparsec, aws, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, cereal, conduit
     , containers, cryptohash, data-default, http-conduit, http-types
     , mtl, network-conduit, text, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "sssp";
       version = "1.1.1";
       sha256 = "ec5414f303c6df3d218407ddf09d4a74e7b0473f26d1c163c0a3c946b30523db";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attempt attoparsec aws base base64-bytestring blaze-builder
         bytestring case-insensitive cereal conduit containers cryptohash
         data-default http-conduit http-types mtl network-conduit text wai
         wai-extra warp
       ];
       executableHaskellDepends = [
         attempt attoparsec aws base base64-bytestring blaze-builder
         bytestring case-insensitive cereal conduit containers cryptohash
         data-default http-conduit http-types mtl network-conduit text wai
         wai-extra warp
       ];
       jailbreak = true;
       homepage = "http://github.com/erudify/sssp/";
       description = "HTTP proxy for S3";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sstable" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, cmdargs
     , containers, deepseq, directory, iteratee
     }:
     mkDerivation {
       pname = "sstable";
       version = "1.0";
       sha256 = "f531caddc2045f16a4cb8570af49aeeb6dbb1e55a37c8e2fb3da86598e943eea";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers deepseq directory iteratee
       ];
       executableHaskellDepends = [ cmdargs ];
       description = "SSTables in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ssv" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "ssv";
       version = "0.3";
       sha256 = "05670e936dda1a18afa474b009f9a3a89ebf5ce74b83458c7d19a0d1423001fc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [ base containers ];
       homepage = "https://github.com/BartMassey/ssv";
       description = "Comma-separated-value (CSV) read, show and write routines";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stable-heap" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "stable-heap";
       version = "0.1.0.0";
       sha256 = "410f316118037f3fed6dcd58c667b5ad278f4e5bac6053c6366d8b59a9209d93";
       libraryHaskellDepends = [ base ];
       homepage = "http://hub.darcs.net/jmcarthur/stable-heap";
       description = "Purely functional stable heaps (fair priority queues)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stable-maps" = callPackage
    ({ mkDerivation, base, containers, ghc-prim }:
     mkDerivation {
       pname = "stable-maps";
       version = "0.0.5";
       sha256 = "7ce82ad8e32fadbcbd5f5c42df67e27e7f951da0d58e149b48c615b9a66f51ea";
       libraryHaskellDepends = [ base containers ghc-prim ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/stable-maps";
       description = "Heterogeneous maps keyed by StableNames";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stable-marriage" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "stable-marriage";
       version = "0.1.1.0";
       sha256 = "12da2128ef67c7f30e9bf1fef0ccffc323bbdfc0699126945c422a52a25d09b2";
       libraryHaskellDepends = [ base ghc-prim ];
       homepage = "http://github.com/cutsea110/stable-marriage";
       description = "algorithms around stable marriage";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stable-memo" = callPackage
    ({ mkDerivation, base, ghc-prim, hashtables }:
     mkDerivation {
       pname = "stable-memo";
       version = "0.3.1";
       sha256 = "fd8ddc1d5a6200b8cfb192195d0f078545d85088bd6f04aa3f76b310063a65e7";
       libraryHaskellDepends = [ base ghc-prim hashtables ];
       description = "Memoization based on argument identity";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stable-tree" = callPackage
    ({ mkDerivation, base, binary, blaze-builder, bytestring
     , bytestring-arbitrary, cereal, containers, mtl, objectid
     , QuickCheck, tasty, tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "stable-tree";
       version = "0.7.0";
       sha256 = "9750da7897d81696ec445ff7fdadcdb8d9778fa6faa3f6d270daf1a6074a8b55";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary blaze-builder bytestring cereal containers mtl objectid
         text
       ];
       executableHaskellDepends = [ base containers mtl objectid text ];
       testHaskellDepends = [
         base bytestring bytestring-arbitrary cereal containers mtl objectid
         QuickCheck tasty tasty-quickcheck text
       ];
       jailbreak = true;
       homepage = "https://github.com/tsuraan/stable-tree";
       description = "Trees whose branches are resistant to change";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stack_0_1_3_0" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, base16-bytestring
     , base64-bytestring, bifunctors, binary, blaze-builder, byteable
     , bytestring, Cabal, conduit, conduit-combinators, conduit-extra
     , containers, cryptohash, cryptohash-conduit, deepseq
     , deepseq-generics, directory, either, enclosed-exceptions
     , exceptions, extra, fast-logger, file-embed, filelock, filepath
     , fsnotify, hashable, hastache, hspec, http-client, http-client-tls
     , http-conduit, http-types, lifted-base, monad-control
     , monad-logger, monad-loops, mtl, old-locale, optparse-applicative
     , optparse-simple, path, persistent, persistent-sqlite
     , persistent-template, pretty, process, project-template
     , QuickCheck, resourcet, retry, safe, split, stm, streaming-commons
     , tar, template-haskell, temporary, text, time, transformers
     , transformers-base, unix, unix-compat, unordered-containers
     , vector, vector-binary-instances, void, word8, yaml, zlib
     }:
     mkDerivation {
       pname = "stack";
       version = "0.1.3.0";
       sha256 = "e1f5c6cf00d69c15cea76106ab632a4d8edecbce5cee46ebe002a278a672ad10";
       revision = "1";
       editedCabalFile = "a60b5f3f45a807b1d72f2852c078e064f1c80c0f30a8f43148f08b8dd9023e9d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async attoparsec base base16-bytestring base64-bytestring
         bifunctors binary blaze-builder byteable bytestring Cabal conduit
         conduit-combinators conduit-extra containers cryptohash
         cryptohash-conduit deepseq deepseq-generics directory
         enclosed-exceptions exceptions extra fast-logger file-embed
         filelock filepath fsnotify hashable hastache http-client
         http-client-tls http-conduit http-types lifted-base monad-control
         monad-logger monad-loops mtl old-locale optparse-applicative
         optparse-simple path persistent persistent-sqlite
         persistent-template pretty process project-template resourcet retry
         safe split stm streaming-commons tar template-haskell temporary
         text time transformers transformers-base unix unix-compat
         unordered-containers vector vector-binary-instances void word8 yaml
         zlib
       ];
       executableHaskellDepends = [
         base bytestring conduit containers directory either exceptions
         filelock filepath hashable http-client http-conduit lifted-base
         monad-control monad-logger mtl old-locale optparse-applicative
         optparse-simple path process resourcet split text transformers
         unordered-containers
       ];
       testHaskellDepends = [
         async base bytestring Cabal conduit conduit-extra containers
         cryptohash directory exceptions filepath hspec http-conduit
         monad-logger optparse-applicative path process QuickCheck resourcet
         retry temporary text transformers unix-compat
       ];
       jailbreak = true;
       doCheck = false;
       enableSharedExecutables = false;
       postInstall = ''
         exe=$out/bin/stack
         mkdir -p $out/share/bash-completion/completions
         $exe --bash-completion-script $exe >$out/share/bash-completion/completions/stack
       '';
       homepage = "https://github.com/commercialhaskell/stack";
       description = "The Haskell Tool Stack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "stack_0_1_3_1" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, base16-bytestring
     , base64-bytestring, bifunctors, binary, blaze-builder, byteable
     , bytestring, Cabal, conduit, conduit-combinators, conduit-extra
     , containers, cryptohash, cryptohash-conduit, deepseq
     , deepseq-generics, directory, either, enclosed-exceptions
     , exceptions, extra, fast-logger, file-embed, filelock, filepath
     , fsnotify, hashable, hastache, hspec, http-client, http-client-tls
     , http-conduit, http-types, lifted-base, monad-control
     , monad-logger, monad-loops, mtl, old-locale, optparse-applicative
     , optparse-simple, path, persistent, persistent-sqlite
     , persistent-template, pretty, process, project-template
     , QuickCheck, resourcet, retry, safe, split, stm, streaming-commons
     , tar, template-haskell, temporary, text, time, transformers
     , transformers-base, unix, unix-compat, unordered-containers
     , vector, vector-binary-instances, void, word8, yaml, zlib
     }:
     mkDerivation {
       pname = "stack";
       version = "0.1.3.1";
       sha256 = "af5542c838fa33bd633cad5b9cbd411748a259a06bd0b437094c9d79b0e01e6a";
       revision = "1";
       editedCabalFile = "ef43d6148b72148ef97930582deeb0bf990751c94b6924d1a4763572ed166eaa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async attoparsec base base16-bytestring base64-bytestring
         bifunctors binary blaze-builder byteable bytestring Cabal conduit
         conduit-combinators conduit-extra containers cryptohash
         cryptohash-conduit deepseq deepseq-generics directory
         enclosed-exceptions exceptions extra fast-logger file-embed
         filelock filepath fsnotify hashable hastache http-client
         http-client-tls http-conduit http-types lifted-base monad-control
         monad-logger monad-loops mtl old-locale optparse-applicative
         optparse-simple path persistent persistent-sqlite
         persistent-template pretty process project-template resourcet retry
         safe split stm streaming-commons tar template-haskell temporary
         text time transformers transformers-base unix unix-compat
         unordered-containers vector vector-binary-instances void word8 yaml
         zlib
       ];
       executableHaskellDepends = [
         base bytestring conduit containers directory either exceptions
         filelock filepath hashable http-client http-conduit lifted-base
         monad-control monad-logger mtl old-locale optparse-applicative
         optparse-simple path process resourcet split text transformers
         unordered-containers
       ];
       testHaskellDepends = [
         async base bytestring Cabal conduit conduit-extra containers
         cryptohash directory exceptions filepath hspec http-conduit
         monad-logger optparse-applicative path process QuickCheck resourcet
         retry temporary text transformers unix-compat
       ];
       jailbreak = true;
       doCheck = false;
       enableSharedExecutables = false;
       postInstall = ''
         exe=$out/bin/stack
         mkdir -p $out/share/bash-completion/completions
         $exe --bash-completion-script $exe >$out/share/bash-completion/completions/stack
       '';
       homepage = "https://github.com/commercialhaskell/stack";
       description = "The Haskell Tool Stack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "stack_0_1_4_1" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, base16-bytestring
     , base64-bytestring, bifunctors, binary, blaze-builder, byteable
     , bytestring, Cabal, conduit, conduit-combinators, conduit-extra
     , containers, cryptohash, cryptohash-conduit, deepseq
     , deepseq-generics, directory, either, enclosed-exceptions
     , exceptions, extra, fast-logger, file-embed, filelock, filepath
     , fsnotify, gitrev, hashable, hastache, hspec, http-client
     , http-client-tls, http-conduit, http-types, ignore, lifted-base
     , monad-control, monad-logger, monad-loops, mtl, old-locale
     , optparse-applicative, optparse-simple, path, persistent
     , persistent-sqlite, persistent-template, pretty, process
     , project-template, QuickCheck, resourcet, retry, safe, split, stm
     , streaming-commons, tar, template-haskell, temporary, text, time
     , transformers, transformers-base, unix, unix-compat
     , unordered-containers, vector, vector-binary-instances, void
     , word8, yaml, zlib
     }:
     mkDerivation {
       pname = "stack";
       version = "0.1.4.1";
       sha256 = "09a076537d546b005788326fb734b47a203ae9507303a9ce554566179dfdfd24";
       revision = "1";
       editedCabalFile = "96a7234623eab6fffc9c719d272a7569220c16e6b3f6dfac43f8e0a474f35d7d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async attoparsec base base16-bytestring base64-bytestring
         bifunctors binary blaze-builder byteable bytestring Cabal conduit
         conduit-combinators conduit-extra containers cryptohash
         cryptohash-conduit deepseq deepseq-generics directory
         enclosed-exceptions exceptions extra fast-logger file-embed
         filelock filepath fsnotify hashable hastache http-client
         http-client-tls http-conduit http-types ignore lifted-base
         monad-control monad-logger monad-loops mtl old-locale
         optparse-applicative optparse-simple path persistent
         persistent-sqlite persistent-template pretty process
         project-template resourcet retry safe split stm streaming-commons
         tar template-haskell temporary text time transformers
         transformers-base unix unix-compat unordered-containers vector
         vector-binary-instances void word8 yaml zlib
       ];
       executableHaskellDepends = [
         base bytestring Cabal conduit containers directory either
         exceptions filelock filepath gitrev hashable http-client
         http-conduit lifted-base monad-control monad-logger mtl old-locale
         optparse-applicative optparse-simple path process resourcet split
         text transformers unordered-containers
       ];
       testHaskellDepends = [
         async base bytestring Cabal conduit conduit-extra containers
         cryptohash directory exceptions filepath hspec http-conduit
         monad-logger optparse-applicative path process QuickCheck resourcet
         retry temporary text transformers unix-compat
       ];
       jailbreak = true;
       doCheck = false;
       enableSharedExecutables = false;
       postInstall = ''
         exe=$out/bin/stack
         mkdir -p $out/share/bash-completion/completions
         $exe --bash-completion-script $exe >$out/share/bash-completion/completions/stack
       '';
       homepage = "https://github.com/commercialhaskell/stack";
       description = "The Haskell Tool Stack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "stack_0_1_5_0" = callPackage
    ({ mkDerivation, aeson, async, attoparsec, base, base16-bytestring
     , base64-bytestring, bifunctors, binary, binary-tagged
     , blaze-builder, byteable, bytestring, Cabal, conduit
     , conduit-combinators, conduit-extra, containers, cryptohash
     , cryptohash-conduit, deepseq, directory, either
     , enclosed-exceptions, exceptions, extra, fast-logger, file-embed
     , filelock, filepath, fsnotify, gitrev, hashable, hastache, hspec
     , http-client, http-client-tls, http-conduit, http-types, ignore
     , lifted-base, monad-control, monad-logger, monad-loops, mtl
     , old-locale, optparse-applicative, optparse-simple, path
     , persistent, persistent-sqlite, persistent-template, pretty
     , process, project-template, QuickCheck, resourcet, retry, safe
     , split, stm, streaming-commons, tar, template-haskell, temporary
     , text, time, transformers, transformers-base, unix, unix-compat
     , unordered-containers, vector, vector-binary-instances, void
     , word8, yaml, zlib
     }:
     mkDerivation {
       pname = "stack";
       version = "0.1.5.0";
       sha256 = "40a26de423f070fc6c742a77c76e90ffd25d6ff08c6a651b3683f16f63a03e25";
       revision = "1";
       editedCabalFile = "958cbffa4ac1f5ee2c647de9a55c8d3f11dc4ba84fd3f619a962280ed0dee0db";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async attoparsec base base16-bytestring base64-bytestring
         bifunctors binary binary-tagged blaze-builder byteable bytestring
         Cabal conduit conduit-combinators conduit-extra containers
         cryptohash cryptohash-conduit deepseq directory enclosed-exceptions
         exceptions extra fast-logger file-embed filelock filepath fsnotify
         gitrev hashable hastache http-client http-client-tls http-conduit
         http-types ignore lifted-base monad-control monad-logger
         monad-loops mtl old-locale optparse-applicative optparse-simple
         path persistent persistent-sqlite persistent-template pretty
         process project-template resourcet retry safe split stm
         streaming-commons tar template-haskell temporary text time
         transformers transformers-base unix unix-compat
         unordered-containers vector vector-binary-instances void word8 yaml
         zlib
       ];
       executableHaskellDepends = [
         base bytestring Cabal conduit containers directory either
         exceptions filelock filepath gitrev hashable http-client
         http-conduit lifted-base monad-control monad-logger mtl old-locale
         optparse-applicative optparse-simple path process resourcet split
         text transformers unordered-containers
       ];
       testHaskellDepends = [
         async base bytestring Cabal conduit conduit-extra containers
         cryptohash directory exceptions filepath hspec http-conduit
         monad-logger optparse-applicative path process QuickCheck resourcet
         retry temporary text transformers unix-compat
       ];
       jailbreak = true;
       doCheck = false;
       enableSharedExecutables = false;
       postInstall = ''
         exe=$out/bin/stack
         mkdir -p $out/share/bash-completion/completions
         $exe --bash-completion-script $exe >$out/share/bash-completion/completions/stack
       '';
       homepage = "https://github.com/commercialhaskell/stack";
       description = "The Haskell Tool Stack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "stack_0_1_6_0" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, async, attoparsec, base
     , base16-bytestring, base64-bytestring, bifunctors, binary
     , binary-tagged, blaze-builder, byteable, bytestring, Cabal
     , conduit, conduit-combinators, conduit-extra, containers
     , cryptohash, cryptohash-conduit, deepseq, directory, either
     , enclosed-exceptions, exceptions, extra, fast-logger, file-embed
     , filelock, filepath, fsnotify, gitrev, hashable, hastache, hpc
     , hspec, http-client, http-client-tls, http-conduit, http-types
     , ignore, lifted-base, monad-control, monad-logger, monad-loops
     , mtl, old-locale, optparse-applicative, optparse-simple, path
     , persistent, persistent-sqlite, persistent-template, pretty
     , process, project-template, QuickCheck, resourcet, retry, safe
     , split, stm, streaming-commons, tar, template-haskell, temporary
     , text, time, transformers, transformers-base, unix, unix-compat
     , unordered-containers, vector, vector-binary-instances, void
     , word8, yaml, zlib
     }:
     mkDerivation {
       pname = "stack";
       version = "0.1.6.0";
       sha256 = "a47ffc204b9caef8281d1e5daebc21bc9d4d2414ed695dc10d32fcca4d81978d";
       revision = "6";
       editedCabalFile = "c9021f29f8e46134d9036fb8592edcfd31a0a0942dadcb4860b269f2aa463a34";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal async attoparsec base base16-bytestring
         base64-bytestring bifunctors binary binary-tagged blaze-builder
         byteable bytestring Cabal conduit conduit-combinators conduit-extra
         containers cryptohash cryptohash-conduit deepseq directory
         enclosed-exceptions exceptions extra fast-logger file-embed
         filelock filepath fsnotify gitrev hashable hastache hpc http-client
         http-client-tls http-conduit http-types ignore lifted-base
         monad-control monad-logger monad-loops mtl old-locale
         optparse-applicative optparse-simple path persistent
         persistent-sqlite persistent-template pretty process
         project-template resourcet retry safe split stm streaming-commons
         tar template-haskell temporary text time transformers
         transformers-base unix unix-compat unordered-containers vector
         vector-binary-instances void word8 yaml zlib
       ];
       executableHaskellDepends = [
         base bytestring Cabal conduit containers directory either
         exceptions filelock filepath gitrev hashable http-client
         http-conduit lifted-base monad-control monad-logger mtl old-locale
         optparse-applicative optparse-simple path process resourcet split
         text transformers unordered-containers
       ];
       testHaskellDepends = [
         async base bytestring Cabal conduit conduit-extra containers
         cryptohash directory exceptions filepath hspec http-conduit
         monad-logger optparse-applicative path process QuickCheck resourcet
         retry temporary text transformers unix-compat
       ];
       jailbreak = true;
       doCheck = false;
       enableSharedExecutables = false;
       postInstall = ''
         exe=$out/bin/stack
         mkdir -p $out/share/bash-completion/completions
         $exe --bash-completion-script $exe >$out/share/bash-completion/completions/stack
       '';
       homepage = "https://github.com/commercialhaskell/stack";
       description = "The Haskell Tool Stack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "stack_0_1_8_0" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, async, attoparsec, base
     , base16-bytestring, base64-bytestring, bifunctors, binary
     , binary-tagged, blaze-builder, byteable, bytestring, Cabal
     , conduit, conduit-combinators, conduit-extra, containers
     , cryptohash, cryptohash-conduit, deepseq, directory, edit-distance
     , either, enclosed-exceptions, exceptions, extra, fast-logger
     , file-embed, filelock, filepath, fsnotify, gitrev, hashable
     , hastache, hpc, hspec, http-client, http-client-tls, http-conduit
     , http-types, lifted-base, monad-control, monad-logger, monad-loops
     , mtl, old-locale, optparse-applicative, optparse-simple, path
     , persistent, persistent-sqlite, persistent-template, pretty
     , process, project-template, QuickCheck, resourcet, retry, safe
     , semigroups, split, stm, streaming-commons, tar, template-haskell
     , temporary, text, time, transformers, transformers-base, unix
     , unix-compat, unordered-containers, vector
     , vector-binary-instances, void, word8, yaml, zlib
     }:
     mkDerivation {
       pname = "stack";
       version = "0.1.8.0";
       sha256 = "89bca19a39f3148daa55dd51bcee28c9f8aa362732c915dd25a85c7a7c664338";
       revision = "4";
       editedCabalFile = "b44318f1c13bdb7c1a8de14cc7c8707d1f4a215af985f178d19ddd733986a4ab";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal async attoparsec base base16-bytestring
         base64-bytestring bifunctors binary binary-tagged blaze-builder
         byteable bytestring Cabal conduit conduit-combinators conduit-extra
         containers cryptohash cryptohash-conduit deepseq directory
         edit-distance either enclosed-exceptions exceptions extra
         fast-logger file-embed filelock filepath fsnotify gitrev hashable
         hastache hpc http-client http-client-tls http-conduit http-types
         lifted-base monad-control monad-logger monad-loops mtl old-locale
         optparse-applicative path persistent persistent-sqlite
         persistent-template pretty process project-template resourcet retry
         safe semigroups split stm streaming-commons tar template-haskell
         temporary text time transformers transformers-base unix unix-compat
         unordered-containers vector vector-binary-instances void word8 yaml
         zlib
       ];
       executableHaskellDepends = [
         base bytestring Cabal conduit containers directory either
         exceptions filelock filepath gitrev hashable http-client
         http-conduit lifted-base monad-control monad-logger mtl old-locale
         optparse-applicative optparse-simple path process resourcet split
         text transformers unordered-containers
       ];
       testHaskellDepends = [
         async base bytestring Cabal conduit conduit-extra containers
         cryptohash directory exceptions filepath hspec http-conduit
         monad-logger optparse-applicative path process QuickCheck resourcet
         retry temporary text transformers unix-compat
       ];
       jailbreak = true;
       doCheck = false;
       enableSharedExecutables = false;
       postInstall = ''
         exe=$out/bin/stack
         mkdir -p $out/share/bash-completion/completions
         $exe --bash-completion-script $exe >$out/share/bash-completion/completions/stack
       '';
       homepage = "https://github.com/commercialhaskell/stack";
       description = "The Haskell Tool Stack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "stack_0_1_10_0" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, async, attoparsec, base
     , base16-bytestring, base64-bytestring, bifunctors, binary
     , binary-tagged, blaze-builder, byteable, bytestring, Cabal
     , conduit, conduit-combinators, conduit-extra, containers
     , cryptohash, cryptohash-conduit, deepseq, directory, edit-distance
     , either, email-validate, enclosed-exceptions, exceptions, extra
     , fast-logger, file-embed, filelock, filepath, fsnotify, gitrev
     , hashable, hastache, hpc, hspec, http-client, http-client-tls
     , http-conduit, http-types, lifted-base, monad-control
     , monad-logger, monad-loops, mtl, old-locale, optparse-applicative
     , optparse-simple, path, persistent, persistent-sqlite
     , persistent-template, pretty, process, project-template
     , QuickCheck, resourcet, retry, safe, semigroups, split, stm
     , streaming-commons, tar, template-haskell, temporary, text, time
     , transformers, transformers-base, unix, unix-compat
     , unordered-containers, uuid, vector, vector-binary-instances, void
     , word8, yaml, zlib
     }:
     mkDerivation {
       pname = "stack";
       version = "0.1.10.0";
       sha256 = "9b730c2b4b7bb87fc70ccbf0bab0e2fe6f0775644b36972b4dea9088cbcab979";
       revision = "2";
       editedCabalFile = "7e5e72d10fce3a9fad12241e48098219d381dedfda71327034f1899a3da537e1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal async attoparsec base base16-bytestring
         base64-bytestring bifunctors binary binary-tagged blaze-builder
         byteable bytestring Cabal conduit conduit-combinators conduit-extra
         containers cryptohash cryptohash-conduit deepseq directory
         edit-distance either email-validate enclosed-exceptions exceptions
         extra fast-logger file-embed filelock filepath fsnotify hashable
         hastache hpc http-client http-client-tls http-conduit http-types
         lifted-base monad-control monad-logger monad-loops mtl old-locale
         optparse-applicative path persistent persistent-sqlite
         persistent-template pretty process project-template resourcet retry
         safe semigroups split stm streaming-commons tar template-haskell
         temporary text time transformers transformers-base unix unix-compat
         unordered-containers uuid vector vector-binary-instances void word8
         yaml zlib
       ];
       executableHaskellDepends = [
         base bytestring Cabal conduit containers directory either
         exceptions filelock filepath gitrev hashable http-client
         http-conduit lifted-base monad-control monad-logger mtl old-locale
         optparse-applicative optparse-simple path process resourcet split
         text transformers unordered-containers
       ];
       testHaskellDepends = [
         async base bytestring Cabal conduit conduit-extra containers
         cryptohash directory exceptions filepath hspec http-conduit
         monad-logger optparse-applicative path process QuickCheck resourcet
         retry temporary text transformers unix-compat
       ];
       jailbreak = true;
       doCheck = false;
       enableSharedExecutables = false;
       postInstall = ''
         exe=$out/bin/stack
         mkdir -p $out/share/bash-completion/completions
         $exe --bash-completion-script $exe >$out/share/bash-completion/completions/stack
       '';
       homepage = "http://haskellstack.org";
       description = "The Haskell Tool Stack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "stack_0_1_10_1" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, async, attoparsec, base
     , base16-bytestring, base64-bytestring, bifunctors, binary
     , binary-tagged, blaze-builder, byteable, bytestring, Cabal
     , conduit, conduit-combinators, conduit-extra, containers
     , cryptohash, cryptohash-conduit, deepseq, directory, edit-distance
     , either, email-validate, enclosed-exceptions, exceptions, extra
     , fast-logger, file-embed, filelock, filepath, fsnotify, gitrev
     , hashable, hastache, hpc, hspec, http-client, http-client-tls
     , http-conduit, http-types, lifted-base, monad-control
     , monad-logger, monad-loops, mtl, old-locale, optparse-applicative
     , optparse-simple, path, persistent, persistent-sqlite
     , persistent-template, pretty, process, project-template
     , QuickCheck, resourcet, retry, safe, semigroups, split, stm
     , streaming-commons, tar, template-haskell, temporary, text, time
     , transformers, transformers-base, unix, unix-compat
     , unordered-containers, uuid, vector, vector-binary-instances, void
     , word8, yaml, zlib
     }:
     mkDerivation {
       pname = "stack";
       version = "0.1.10.1";
       sha256 = "03d3f1cd03cbb70364f013aa6ccaefa07397a76984bc8b7ce51376e0bdc51a7c";
       revision = "3";
       editedCabalFile = "bc374c4faac1181394f1dfecfda9bf3d3e10176c2ff19410a36d12795a68d05b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal async attoparsec base base16-bytestring
         base64-bytestring bifunctors binary binary-tagged blaze-builder
         byteable bytestring Cabal conduit conduit-combinators conduit-extra
         containers cryptohash cryptohash-conduit deepseq directory
         edit-distance either email-validate enclosed-exceptions exceptions
         extra fast-logger file-embed filelock filepath fsnotify hashable
         hastache hpc http-client http-client-tls http-conduit http-types
         lifted-base monad-control monad-logger monad-loops mtl old-locale
         optparse-applicative path persistent persistent-sqlite
         persistent-template pretty process project-template resourcet retry
         safe semigroups split stm streaming-commons tar template-haskell
         temporary text time transformers transformers-base unix unix-compat
         unordered-containers uuid vector vector-binary-instances void word8
         yaml zlib
       ];
       executableHaskellDepends = [
         base bytestring Cabal conduit containers directory either
         exceptions filelock filepath gitrev hashable http-client
         http-conduit lifted-base monad-control monad-logger mtl old-locale
         optparse-applicative optparse-simple path process resourcet split
         text transformers unordered-containers
       ];
       testHaskellDepends = [
         async base bytestring Cabal conduit conduit-extra containers
         cryptohash directory exceptions filepath hspec http-conduit
         monad-logger optparse-applicative path process QuickCheck resourcet
         retry temporary text transformers unix-compat
       ];
       jailbreak = true;
       doCheck = false;
       enableSharedExecutables = false;
       postInstall = ''
         exe=$out/bin/stack
         mkdir -p $out/share/bash-completion/completions
         $exe --bash-completion-script $exe >$out/share/bash-completion/completions/stack
       '';
       homepage = "http://haskellstack.org";
       description = "The Haskell Tool Stack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "stack_1_0_0" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, async, attoparsec, base
     , base16-bytestring, base64-bytestring, bifunctors, binary
     , binary-tagged, blaze-builder, byteable, bytestring, Cabal
     , conduit, conduit-combinators, conduit-extra, containers
     , cryptohash, cryptohash-conduit, deepseq, directory, edit-distance
     , either, email-validate, enclosed-exceptions, errors, exceptions
     , extra, fast-logger, file-embed, filelock, filepath, fsnotify
     , gitrev, hashable, hastache, hpc, hspec, http-client
     , http-client-tls, http-conduit, http-types, lifted-base
     , monad-control, monad-logger, monad-loops, mtl, old-locale
     , optparse-applicative, optparse-simple, path, persistent
     , persistent-sqlite, persistent-template, pretty, process
     , project-template, QuickCheck, resourcet, retry, safe, semigroups
     , split, stm, streaming-commons, tar, template-haskell, temporary
     , text, text-binary, time, transformers, transformers-base, unix
     , unix-compat, unordered-containers, uuid, vector
     , vector-binary-instances, void, word8, yaml, zlib
     }:
     mkDerivation {
       pname = "stack";
       version = "1.0.0";
       sha256 = "cd2f606d390fe521b6ba0794de87edcba64c4af66856af09594907c2b4f4751d";
       revision = "6";
       editedCabalFile = "d2de14a5f76d0d1b7ff78d1a7647a429e4151ffdda57fa3b061a0c5641272931";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal async attoparsec base base16-bytestring
         base64-bytestring bifunctors binary binary-tagged blaze-builder
         byteable bytestring Cabal conduit conduit-combinators conduit-extra
         containers cryptohash cryptohash-conduit deepseq directory
         edit-distance either email-validate enclosed-exceptions errors
         exceptions extra fast-logger file-embed filelock filepath fsnotify
         hashable hastache hpc http-client http-client-tls http-conduit
         http-types lifted-base monad-control monad-logger monad-loops mtl
         old-locale optparse-applicative path persistent persistent-sqlite
         persistent-template pretty process project-template resourcet retry
         safe semigroups split stm streaming-commons tar template-haskell
         temporary text text-binary time transformers transformers-base unix
         unix-compat unordered-containers uuid vector
         vector-binary-instances void word8 yaml zlib
       ];
       executableHaskellDepends = [
         base bytestring Cabal conduit containers directory either
         exceptions filelock filepath gitrev hashable http-client
         http-conduit lifted-base monad-control monad-logger mtl old-locale
         optparse-applicative optparse-simple path process resourcet split
         text transformers unordered-containers
       ];
       testHaskellDepends = [
         async attoparsec base bytestring Cabal conduit conduit-extra
         containers cryptohash directory exceptions filepath hspec
         http-conduit monad-logger optparse-applicative path process
         QuickCheck resourcet retry temporary text transformers unix-compat
       ];
       doHaddock = false;
       doCheck = false;
       enableSharedExecutables = false;
       postInstall = ''
         exe=$out/bin/stack
         mkdir -p $out/share/bash-completion/completions
         $exe --bash-completion-script $exe >$out/share/bash-completion/completions/stack
       '';
       homepage = "http://haskellstack.org";
       description = "The Haskell Tool Stack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "stack" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, async, attoparsec, base
     , base16-bytestring, base64-bytestring, bifunctors, binary
     , binary-tagged, blaze-builder, byteable, bytestring, Cabal
     , conduit, conduit-combinators, conduit-extra, containers
     , cryptohash, cryptohash-conduit, deepseq, directory, edit-distance
     , either, enclosed-exceptions, errors, exceptions, extra
     , fast-logger, file-embed, filelock, filepath, fsnotify, gitrev
     , hashable, hastache, hpc, hspec, http-client, http-client-tls
     , http-conduit, http-types, lifted-base, monad-control
     , monad-logger, monad-loops, mtl, old-locale, optparse-applicative
     , optparse-simple, path, persistent, persistent-sqlite
     , persistent-template, pretty, process, project-template
     , QuickCheck, resourcet, retry, safe, semigroups, split, stm
     , streaming-commons, tar, template-haskell, temporary, text
     , text-binary, time, transformers, transformers-base, unix
     , unix-compat, unordered-containers, uuid, vector
     , vector-binary-instances, void, word8, yaml, zlib
     }:
     mkDerivation {
       pname = "stack";
       version = "1.0.2";
       sha256 = "4227f4c4016e5008755a974cbf04a9772319d87d1764da32228e74f13153c5c4";
       revision = "3";
       editedCabalFile = "6843a554b3987bb6a0277f59a70e6ed49ff515da73623f97949520877736ef04";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal async attoparsec base base16-bytestring
         base64-bytestring bifunctors binary binary-tagged blaze-builder
         byteable bytestring Cabal conduit conduit-combinators conduit-extra
         containers cryptohash cryptohash-conduit deepseq directory
         edit-distance either enclosed-exceptions errors exceptions extra
         fast-logger file-embed filelock filepath fsnotify hashable hastache
         hpc http-client http-client-tls http-conduit http-types lifted-base
         monad-control monad-logger monad-loops mtl old-locale
         optparse-applicative path persistent persistent-sqlite
         persistent-template pretty process project-template resourcet retry
         safe semigroups split stm streaming-commons tar template-haskell
         temporary text text-binary time transformers transformers-base unix
         unix-compat unordered-containers uuid vector
         vector-binary-instances void word8 yaml zlib
       ];
       executableHaskellDepends = [
         base bytestring Cabal conduit containers directory either
         exceptions filelock filepath gitrev hashable http-client
         http-conduit lifted-base monad-control monad-logger mtl old-locale
         optparse-applicative optparse-simple path process resourcet split
         text transformers unordered-containers
       ];
       testHaskellDepends = [
         async attoparsec base bytestring Cabal conduit conduit-extra
         containers cryptohash directory exceptions filepath hspec
         http-conduit monad-logger optparse-applicative path process
         QuickCheck resourcet retry temporary text transformers unix-compat
       ];
       doHaddock = false;
       doCheck = false;
       enableSharedExecutables = false;
       postInstall = ''
         exe=$out/bin/stack
         mkdir -p $out/share/bash-completion/completions
         $exe --bash-completion-script $exe >$out/share/bash-completion/completions/stack
       '';
       homepage = "http://haskellstack.org";
       description = "The Haskell Tool Stack";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "stack_1_0_4" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, async, attoparsec, base
     , base16-bytestring, base64-bytestring, binary, binary-tagged
     , blaze-builder, byteable, bytestring, Cabal, conduit
     , conduit-extra, containers, cryptohash, cryptohash-conduit
     , deepseq, directory, edit-distance, either, enclosed-exceptions
     , errors, exceptions, extra, fast-logger, filelock, filepath
     , fsnotify, gitrev, hashable, hastache, hpack, hpc, hspec
     , http-client, http-client-tls, http-conduit, http-types
     , lifted-base, monad-control, monad-logger, mtl
     , optparse-applicative, optparse-simple, path, path-io, persistent
     , persistent-sqlite, persistent-template, pretty, process
     , project-template, QuickCheck, resourcet, retry, safe, semigroups
     , split, stm, streaming-commons, tar, template-haskell, temporary
     , text, text-binary, time, transformers, transformers-base, unix
     , unix-compat, unordered-containers, uuid, vector
     , vector-binary-instances, yaml, zip-archive, zlib
     }:
     mkDerivation {
       pname = "stack";
       version = "1.0.4";
       sha256 = "f252c2f916b48d4b32722e2a4f3069ef55ac80454552316ce2dde0c5d486d85f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal async attoparsec base base16-bytestring
         base64-bytestring binary binary-tagged blaze-builder byteable
         bytestring Cabal conduit conduit-extra containers cryptohash
         cryptohash-conduit deepseq directory edit-distance either
         enclosed-exceptions errors exceptions extra fast-logger filelock
         filepath fsnotify hashable hastache hpack hpc http-client
         http-client-tls http-conduit http-types lifted-base monad-control
         monad-logger mtl optparse-applicative path path-io persistent
         persistent-sqlite persistent-template pretty process
         project-template resourcet retry safe semigroups split stm
         streaming-commons tar template-haskell temporary text text-binary
         time transformers transformers-base unix unix-compat
         unordered-containers uuid vector vector-binary-instances yaml
         zip-archive zlib
       ];
       executableHaskellDepends = [
         base bytestring Cabal containers directory filelock filepath gitrev
         http-client lifted-base monad-control monad-logger mtl
         optparse-applicative optparse-simple path path-io text transformers
       ];
       testHaskellDepends = [
         async attoparsec base bytestring Cabal conduit conduit-extra
         containers cryptohash directory exceptions filepath hspec
         http-conduit monad-logger path path-io process QuickCheck resourcet
         retry temporary text transformers unix-compat
       ];
       jailbreak = true;
       enableSharedExecutables = false;
       postInstall = ''
         exe=$out/bin/stack
         mkdir -p $out/share/bash-completion/completions
         $exe --bash-completion-script $exe >$out/share/bash-completion/completions/stack
       '';
       homepage = "http://haskellstack.org";
       description = "The Haskell Tool Stack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "stack-hpc-coveralls" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, deepseq
     , docopt, filepath, hlint, hpc, hspec, hspec-contrib, http-client
     , HUnit, lens, lens-aeson, process, pureMD5, text, time
     , utf8-string, wreq
     }:
     mkDerivation {
       pname = "stack-hpc-coveralls";
       version = "0.0.3.0";
       sha256 = "b7e0811516216cb5d20294c9371787e5d08663126c224f7a976e90101fd6eb22";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers filepath hpc http-client lens
         lens-aeson process pureMD5 text utf8-string wreq
       ];
       executableHaskellDepends = [ aeson base bytestring docopt ];
       testHaskellDepends = [
         aeson base containers deepseq hlint hpc hspec hspec-contrib HUnit
         time
       ];
       homepage = "http://github.com/rubik/stack-hpc-coveralls";
       description = "Initial project template from stack";
       license = stdenv.lib.licenses.isc;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stack-prism" = callPackage
    ({ mkDerivation, base, profunctors, tagged, template-haskell
     , transformers
     }:
     mkDerivation {
       pname = "stack-prism";
       version = "0.1.4";
       sha256 = "4020440962715bf1dd4987d6b96c865a1de3e9d5f26aebd0ab87e9bfa61584d3";
       libraryHaskellDepends = [
         base profunctors tagged template-haskell transformers
       ];
       testHaskellDepends = [ base template-haskell ];
       jailbreak = true;
       homepage = "https://github.com/MedeaMelana/stack-prism";
       description = "Stack prisms";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stack-run" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, Cabal, conduit
     , conduit-extra, directory, filepath, MissingH, projectroot
     }:
     mkDerivation {
       pname = "stack-run";
       version = "0.1.0.5";
       sha256 = "6625d1fbfde871ae88689a3ae18550a4582d68974e5f541e014c45629c1821c7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base bytestring Cabal conduit conduit-extra directory
         filepath MissingH projectroot
       ];
       homepage = "https://github.com/yamadapc/stack-run";
       description = "An equivalent to cabal run for stack";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stack-run-auto" = callPackage
    ({ mkDerivation, async, base, extract-dependencies, file-modules
     , lens, lens-aeson, MissingH, process, stm-containers, text, time
     , wreq
     }:
     mkDerivation {
       pname = "stack-run-auto";
       version = "0.1.1.0";
       sha256 = "2656adb765aa9428868443709e29b6ee0846150f43b99a797272f5ad98b10917";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base extract-dependencies file-modules lens lens-aeson
         MissingH process stm-containers text time wreq
       ];
       executableHaskellDepends = [
         async base extract-dependencies file-modules lens lens-aeson
         MissingH process stm-containers text time wreq
       ];
       testHaskellDepends = [
         async base extract-dependencies file-modules lens lens-aeson
         MissingH process stm-containers text time wreq
       ];
       homepage = "http://github.com/yamadapc/stack-run-auto#readme";
       description = "Initial project template from stack";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage_0_3_1" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, Cabal
     , classy-prelude-conduit, conduit-extra, containers
     , data-default-class, directory, filepath, hspec, http-client
     , http-client-tls, mono-traversable, mtl, old-locale, process
     , QuickCheck, semigroups, stm, streaming-commons, system-fileio
     , system-filepath, tar, temporary, text, time, transformers
     , unix-compat, utf8-string, xml-conduit, yaml, zlib
     }:
     mkDerivation {
       pname = "stackage";
       version = "0.3.1";
       sha256 = "2159e6daa097bb293932dc2831ccc0cbe332ca938caaf1cafcfc8aae150a86f4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bytestring Cabal classy-prelude-conduit
         conduit-extra containers data-default-class directory filepath
         http-client http-client-tls mono-traversable mtl old-locale process
         semigroups stm streaming-commons system-fileio system-filepath tar
         temporary text time transformers unix-compat utf8-string
         xml-conduit yaml zlib
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base Cabal classy-prelude-conduit containers hspec http-client
         http-client-tls QuickCheck text yaml
       ];
       doCheck = false;
       homepage = "https://github.com/fpco/stackage";
       description = "\"Stable Hackage,\" tools for creating a vetted set of packages from Hackage";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage_0_6_0_1" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, Cabal
     , classy-prelude-conduit, conduit, conduit-extra, containers
     , data-default-class, directory, filepath, hspec, http-client
     , http-client-tls, http-conduit, mono-traversable, mtl, old-locale
     , optparse-applicative, process, QuickCheck, semigroups, stm
     , streaming-commons, system-fileio, system-filepath, tar, temporary
     , text, time, transformers, unix-compat, utf8-string, xml-conduit
     , yaml, zlib
     }:
     mkDerivation {
       pname = "stackage";
       version = "0.6.0.1";
       sha256 = "55f4c256507c8e7cd28566b4e8f18fb78167e35292e645a57985e770182be878";
       revision = "1";
       editedCabalFile = "7bf5b1def0845bf7df50241d0c913c32c3fea6fe1a3a907a0ff347461489f9e7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bytestring Cabal classy-prelude-conduit conduit
         conduit-extra containers data-default-class directory filepath
         http-client http-client-tls http-conduit mono-traversable mtl
         old-locale process semigroups stm streaming-commons system-fileio
         system-filepath tar temporary text time transformers unix-compat
         utf8-string xml-conduit yaml zlib
       ];
       executableHaskellDepends = [
         base http-client http-client-tls optparse-applicative
         system-filepath text
       ];
       testHaskellDepends = [
         base Cabal classy-prelude-conduit containers hspec http-client
         http-client-tls QuickCheck text yaml
       ];
       doCheck = false;
       homepage = "https://github.com/fpco/stackage";
       description = "\"Stable Hackage,\" tools for creating a vetted set of packages from Hackage";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage_0_7_2_0" = callPackage
    ({ mkDerivation, base, stackage-build-plan, stackage-cli
     , stackage-install, stackage-update, stackage-upload
     }:
     mkDerivation {
       pname = "stackage";
       version = "0.7.2.0";
       sha256 = "77baadb0aea491673586fa4316242cff8842eeb128b036e33e67bf78651a1263";
       libraryHaskellDepends = [
         base stackage-build-plan stackage-cli stackage-install
         stackage-update stackage-upload
       ];
       doCheck = false;
       homepage = "https://www.stackage.org/";
       description = "Dummy package forcing installation of other Stackage packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage" = callPackage
    ({ mkDerivation, base, stackage-build-plan, stackage-cabal
     , stackage-cli, stackage-install, stackage-sandbox, stackage-setup
     , stackage-update, stackage-upload
     }:
     mkDerivation {
       pname = "stackage";
       version = "0.7.3.2";
       sha256 = "ea6b8fc4ec0bff431f44e75238dff599ac0a082c80ac14f049dfbbd5fdf0f95a";
       libraryHaskellDepends = [
         base stackage-build-plan stackage-cabal stackage-cli
         stackage-install stackage-sandbox stackage-setup stackage-update
         stackage-upload
       ];
       doCheck = false;
       homepage = "https://www.stackage.org/";
       description = "Dummy package forcing installation of other Stackage packages";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stackage-build-plan" = callPackage
    ({ mkDerivation, aeson, base, bytestring, Cabal, containers
     , directory, exceptions, filepath, http-client, http-client-tls
     , mtl, optparse-applicative, stackage-cli, stackage-types, text
     , time, yaml
     }:
     mkDerivation {
       pname = "stackage-build-plan";
       version = "0.1.1.0";
       sha256 = "cf73f80eab84dc34dead04a5750e7f76eb030b4666b88641796b65bb2b9b98ea";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring Cabal containers directory exceptions
         filepath http-client http-client-tls mtl stackage-types text time
         yaml
       ];
       executableHaskellDepends = [
         aeson base optparse-applicative stackage-cli text
       ];
       homepage = "https://github.com/fpco/stackage-build-plan";
       description = "Calculate and print (in different formats) Stackage build plans";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stackage-cabal" = callPackage
    ({ mkDerivation, base, bytestring, exceptions, http-client
     , http-client-tls, http-types, optparse-applicative, parsec
     , process, stackage-cli, system-fileio, text
     }:
     mkDerivation {
       pname = "stackage-cabal";
       version = "0.1.1";
       sha256 = "f2f32812ac46c29fd3ad8e1112a1190930c3cade5d081548c6351452f88f271d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [
         base bytestring exceptions http-client http-client-tls http-types
         optparse-applicative parsec process stackage-cli system-fileio text
       ];
       homepage = "https://www.stackage.org/package/stackage-cabal";
       description = "A CLI executable for cabal-based stackage commands";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stackage-cli" = callPackage
    ({ mkDerivation, base, conduit, directory, either, exceptions
     , filepath, hashable, optparse-applicative, optparse-simple
     , process, split, text, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "stackage-cli";
       version = "0.1.0.2";
       sha256 = "16213bd51f37c4c60f1a8ca91720cf7d0199001ae0aa50acc69facf37ec05a81";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base conduit directory either exceptions filepath hashable
         optparse-applicative optparse-simple process split text
         transformers unordered-containers
       ];
       executableHaskellDepends = [ base text ];
       homepage = "https://www.stackage.org/package/stackage-cli";
       description = "A CLI library for stackage commands";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stackage-curator_0_7_1" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, Cabal
     , classy-prelude-conduit, conduit, conduit-extra, containers
     , data-default-class, directory, filepath, hspec, http-client
     , http-client-tls, http-conduit, mono-traversable, mtl, old-locale
     , optparse-applicative, process, QuickCheck, semigroups
     , stackage-types, stm, streaming-commons, system-fileio
     , system-filepath, tar, temporary, text, time, transformers
     , unix-compat, utf8-string, xml-conduit, yaml, zlib
     }:
     mkDerivation {
       pname = "stackage-curator";
       version = "0.7.1";
       sha256 = "0cd1faf0e4b5a0bd76563041696a711907af0d26e107b729760e5d11638857c4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bytestring Cabal classy-prelude-conduit conduit
         conduit-extra containers data-default-class directory filepath
         http-client http-client-tls http-conduit mono-traversable mtl
         old-locale process semigroups stackage-types stm streaming-commons
         system-fileio system-filepath tar temporary text time transformers
         unix-compat utf8-string xml-conduit yaml zlib
       ];
       executableHaskellDepends = [
         base http-client http-client-tls optparse-applicative
         system-filepath text
       ];
       testHaskellDepends = [
         base Cabal classy-prelude-conduit containers hspec http-client
         http-client-tls QuickCheck text yaml
       ];
       homepage = "https://github.com/fpco/stackage";
       description = "Tools for curating Stackage bundles";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage-curator_0_7_2" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, Cabal
     , classy-prelude-conduit, conduit, conduit-extra, containers
     , data-default-class, directory, filepath, hspec, http-client
     , http-client-tls, http-conduit, mono-traversable, mtl, old-locale
     , optparse-applicative, process, QuickCheck, semigroups
     , stackage-types, stm, streaming-commons, system-fileio
     , system-filepath, tar, temporary, text, time, transformers
     , unix-compat, utf8-string, xml-conduit, yaml, zlib
     }:
     mkDerivation {
       pname = "stackage-curator";
       version = "0.7.2";
       sha256 = "bc9bcbf77d24d0eaa6d308c0e5181cc35d0cb94a465d59a05cb0d77c0376e788";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bytestring Cabal classy-prelude-conduit conduit
         conduit-extra containers data-default-class directory filepath
         http-client http-client-tls http-conduit mono-traversable mtl
         old-locale process semigroups stackage-types stm streaming-commons
         system-fileio system-filepath tar temporary text time transformers
         unix-compat utf8-string xml-conduit yaml zlib
       ];
       executableHaskellDepends = [
         base http-client http-client-tls optparse-applicative
         system-filepath text
       ];
       testHaskellDepends = [
         base Cabal classy-prelude-conduit containers hspec http-client
         http-client-tls QuickCheck text yaml
       ];
       homepage = "https://github.com/fpco/stackage";
       description = "Tools for curating Stackage bundles";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage-curator_0_7_4" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, Cabal
     , classy-prelude-conduit, conduit, conduit-extra, containers
     , data-default-class, directory, filepath, hspec, http-client
     , http-client-tls, http-conduit, mono-traversable, mtl, old-locale
     , optparse-applicative, process, QuickCheck, semigroups
     , stackage-types, stm, streaming-commons, system-fileio
     , system-filepath, tar, temporary, text, time, transformers
     , unix-compat, utf8-string, xml-conduit, yaml, zlib
     }:
     mkDerivation {
       pname = "stackage-curator";
       version = "0.7.4";
       sha256 = "f30d9b15f4e097ded98c28c65f11ece3cf30c4f378fe64d27db481ccb36e3ca0";
       revision = "1";
       editedCabalFile = "4e0d029d79d0224ebe84bcf2891b5fd37cdc3178d4acae146d1ba2148bee86b1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bytestring Cabal classy-prelude-conduit conduit
         conduit-extra containers data-default-class directory filepath
         http-client http-client-tls http-conduit mono-traversable mtl
         old-locale process semigroups stackage-types stm streaming-commons
         system-fileio system-filepath tar temporary text time transformers
         unix-compat utf8-string xml-conduit yaml zlib
       ];
       executableHaskellDepends = [
         base http-client http-client-tls optparse-applicative
         system-filepath text
       ];
       testHaskellDepends = [
         base Cabal classy-prelude-conduit containers hspec http-client
         http-client-tls QuickCheck text yaml
       ];
       homepage = "https://github.com/fpco/stackage";
       description = "Tools for curating Stackage bundles";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage-curator_0_11_0" = callPackage
    ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-s3, async
     , base, base16-bytestring, blaze-html, byteable, bytestring, Cabal
     , classy-prelude-conduit, conduit, conduit-extra, containers
     , cryptohash, cryptohash-conduit, data-default-class, directory
     , filepath, hspec, html-conduit, http-client, http-client-tls
     , http-conduit, lucid, mime-types, monad-unlift, mono-traversable
     , mtl, old-locale, optparse-applicative, optparse-simple, process
     , QuickCheck, resourcet, semigroups, stackage-cli, stackage-install
     , stackage-metadata, stackage-types, stackage-update, stm
     , streaming-commons, system-fileio, system-filepath, tar, temporary
     , text, time, transformers, unix-compat, utf8-string, xml-conduit
     , xml-types, yaml, zlib
     }:
     mkDerivation {
       pname = "stackage-curator";
       version = "0.11.0";
       sha256 = "4e6946926728bbc91d9897e81f43c4dc5f9efa886bba51068014a78576bf754d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson amazonka amazonka-core amazonka-s3 async base
         base16-bytestring blaze-html byteable bytestring Cabal
         classy-prelude-conduit conduit conduit-extra containers cryptohash
         cryptohash-conduit data-default-class directory filepath
         html-conduit http-client http-client-tls http-conduit lucid
         mime-types monad-unlift mono-traversable mtl old-locale process
         resourcet semigroups stackage-install stackage-metadata
         stackage-types stm streaming-commons system-fileio system-filepath
         tar temporary text time transformers unix-compat utf8-string
         xml-conduit xml-types yaml zlib
       ];
       executableHaskellDepends = [
         base http-client http-client-tls optparse-applicative
         optparse-simple stackage-cli stackage-update system-filepath text
       ];
       testHaskellDepends = [
         base Cabal classy-prelude-conduit containers hspec http-client
         http-client-tls QuickCheck text yaml
       ];
       homepage = "https://github.com/fpco/stackage";
       description = "Tools for curating Stackage bundles";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage-curator_0_13_0" = callPackage
    ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-s3, async
     , base, base16-bytestring, binary, binary-tagged, blaze-html
     , byteable, bytestring, Cabal, classy-prelude-conduit, conduit
     , conduit-extra, containers, cryptohash, cryptohash-conduit
     , data-default-class, directory, filepath, hspec, html-conduit
     , http-client, http-client-tls, http-conduit, lucid, mime-types
     , monad-unlift, mono-traversable, mtl, old-locale
     , optparse-applicative, optparse-simple, process, QuickCheck
     , resourcet, semigroups, stackage-cli, stackage-install
     , stackage-metadata, stackage-types, stm, streaming-commons
     , system-fileio, system-filepath, tar, temporary, text, time
     , transformers, unix-compat, utf8-string, xml-conduit, xml-types
     , yaml, zlib
     }:
     mkDerivation {
       pname = "stackage-curator";
       version = "0.13.0";
       sha256 = "fcbc1ff3f378f96a23a169a73a6e081c896cdb88846ecd2ff78afb06b505d612";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson amazonka amazonka-core amazonka-s3 async base
         base16-bytestring binary binary-tagged blaze-html byteable
         bytestring Cabal classy-prelude-conduit conduit conduit-extra
         containers cryptohash cryptohash-conduit data-default-class
         directory filepath html-conduit http-client http-client-tls
         http-conduit lucid mime-types monad-unlift mono-traversable mtl
         old-locale process resourcet semigroups stackage-install
         stackage-metadata stackage-types stm streaming-commons
         system-fileio system-filepath tar temporary text time transformers
         unix-compat utf8-string xml-conduit xml-types yaml zlib
       ];
       executableHaskellDepends = [
         base http-client http-client-tls optparse-applicative
         optparse-simple stackage-cli system-filepath text
       ];
       testHaskellDepends = [
         base Cabal classy-prelude-conduit containers hspec http-client
         http-client-tls QuickCheck text yaml
       ];
       homepage = "https://github.com/fpco/stackage";
       description = "Tools for curating Stackage bundles";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage-curator" = callPackage
    ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-s3, async
     , base, base16-bytestring, binary, binary-tagged, blaze-html
     , byteable, bytestring, Cabal, classy-prelude-conduit, conduit
     , conduit-extra, containers, cryptohash, cryptohash-conduit
     , data-default-class, directory, filepath, hspec, html-conduit
     , http-client, http-client-tls, http-conduit, lucid, mime-types
     , monad-unlift, mono-traversable, mtl, old-locale
     , optparse-applicative, optparse-simple, process, QuickCheck
     , resourcet, semigroups, stackage-cli, stackage-install
     , stackage-metadata, stackage-types, stm, streaming-commons
     , system-fileio, system-filepath, tar, temporary, text, time
     , transformers, unix-compat, utf8-string, xml-conduit, xml-types
     , yaml, zlib
     }:
     mkDerivation {
       pname = "stackage-curator";
       version = "0.13.1";
       sha256 = "3234df1ffa4c7131a5dec91596dd53daef0ca7558245312e4b4ae591a10a1a16";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson amazonka amazonka-core amazonka-s3 async base
         base16-bytestring binary binary-tagged blaze-html byteable
         bytestring Cabal classy-prelude-conduit conduit conduit-extra
         containers cryptohash cryptohash-conduit data-default-class
         directory filepath html-conduit http-client http-client-tls
         http-conduit lucid mime-types monad-unlift mono-traversable mtl
         old-locale process resourcet semigroups stackage-install
         stackage-metadata stackage-types stm streaming-commons
         system-fileio system-filepath tar temporary text time transformers
         unix-compat utf8-string xml-conduit xml-types yaml zlib
       ];
       executableHaskellDepends = [
         base http-client http-client-tls optparse-applicative
         optparse-simple stackage-cli system-filepath text
       ];
       testHaskellDepends = [
         base Cabal classy-prelude-conduit containers directory hspec
         http-client http-client-tls QuickCheck text yaml
       ];
       homepage = "https://github.com/fpco/stackage";
       description = "Tools for curating Stackage bundles";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage-install_0_1_0_3" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, containers
     , cryptohash, directory, filepath, http-client, http-client-tls
     , http-types, process, stm, tar, text
     }:
     mkDerivation {
       pname = "stackage-install";
       version = "0.1.0.3";
       sha256 = "95bcae12cb795d5edae0edd45ec0827a55ae1a0e35199bfadef1bf0077373ed5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bytestring containers cryptohash directory
         filepath http-client http-client-tls http-types process stm tar
         text
       ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/fpco/stackage-install";
       description = "Secure download of packages for cabal-install";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage-install" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, containers
     , cryptohash, directory, filepath, http-client, http-client-tls
     , http-types, process, stm, tar, text
     }:
     mkDerivation {
       pname = "stackage-install";
       version = "0.1.1.1";
       sha256 = "46af3ae310cd7691f3b9edf3e17b0078c38b81c2c136c1485718f81e7068b875";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bytestring containers cryptohash directory
         filepath http-client http-client-tls http-types process stm tar
         text
       ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/fpco/stackage-install";
       description = "Secure download of packages for cabal-install";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stackage-metadata" = callPackage
    ({ mkDerivation, aeson, base, base16-bytestring, bytestring, Cabal
     , conduit, containers, cryptohash, directory, filepath, http-client
     , http-client-tls, pretty, resourcet, stackage-install
     , stackage-update, tar, text, transformers, yaml, zlib
     }:
     mkDerivation {
       pname = "stackage-metadata";
       version = "0.3.0.0";
       sha256 = "5d6b66f326fc1cc7cf833145eb6c4f905725370c8031a5df019101e5ed331a22";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring Cabal conduit containers directory filepath
         pretty resourcet tar text transformers zlib
       ];
       executableHaskellDepends = [
         base base16-bytestring bytestring Cabal conduit containers
         cryptohash directory filepath http-client http-client-tls resourcet
         stackage-install stackage-update tar text transformers yaml
       ];
       homepage = "https://github.com/commercialhaskell/all-cabal-metadata-tool";
       description = "Grab current metadata for all packages";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stackage-sandbox_0_1_5" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, conduit-combinators
     , conduit-extra, directory, filepath, optparse-applicative, process
     , stackage-cli, text
     }:
     mkDerivation {
       pname = "stackage-sandbox";
       version = "0.1.5";
       sha256 = "daaeafd7c23148eec97dc23e1a94fa76d4b6972268b7ff4e3a5b13fb3517b134";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [
         attoparsec base bytestring conduit-combinators conduit-extra
         directory filepath optparse-applicative process stackage-cli text
       ];
       homepage = "https://www.stackage.org/package/stackage-sandbox";
       description = "Work with shared stackage sandboxes";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage-sandbox" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, conduit-combinators
     , conduit-extra, directory, filepath, optparse-applicative, process
     , stackage-cli, text
     }:
     mkDerivation {
       pname = "stackage-sandbox";
       version = "0.1.6";
       sha256 = "ade45f67b92175869594e64e68f3076feba3b50e863b8b588cff69310def1bdb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [
         attoparsec base bytestring conduit-combinators conduit-extra
         directory filepath optparse-applicative process stackage-cli text
       ];
       homepage = "https://www.stackage.org/package/stackage-sandbox";
       description = "Work with shared stackage sandboxes";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stackage-setup" = callPackage
    ({ mkDerivation, aeson, base, bytestring, classy-prelude-conduit
     , cryptohash, cryptohash-conduit, directory, filepath
     , http-client-tls, http-conduit, http-types, optparse-applicative
     , process, stackage-cli, text, unordered-containers, yaml
     }:
     mkDerivation {
       pname = "stackage-setup";
       version = "0.0.2";
       sha256 = "3bae41b72eb7992affedea2937ffb6c66e8f01d2c42ef5a4fc826c21d0d20184";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [
         aeson base bytestring classy-prelude-conduit cryptohash
         cryptohash-conduit directory filepath http-client-tls http-conduit
         http-types optparse-applicative process stackage-cli text
         unordered-containers yaml
       ];
       homepage = "https://www.stackage.org/package/stackage-setup";
       description = "An executable for downloading a Haskell setup";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stackage-types_1_0_0" = callPackage
    ({ mkDerivation, aeson, base, Cabal, containers, exceptions
     , hashable, semigroups, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "stackage-types";
       version = "1.0.0";
       sha256 = "9f2834be99b42f16b68f9be10e4b6e047778566f846a4cdb85d92d41b93a079c";
       libraryHaskellDepends = [
         aeson base Cabal containers exceptions hashable semigroups text
         unordered-containers vector
       ];
       homepage = "https://github.com/fpco/stackage-types";
       description = "Shared data types between various Stackage packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage-types_1_0_1_1" = callPackage
    ({ mkDerivation, aeson, base, Cabal, containers, exceptions
     , hashable, safe, semigroups, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "stackage-types";
       version = "1.0.1.1";
       sha256 = "5fb720226f35c90378e6ce4b963acebf124fd1b7de8d427fa93604c3329ace7d";
       libraryHaskellDepends = [
         aeson base Cabal containers exceptions hashable safe semigroups
         text time unordered-containers vector
       ];
       homepage = "https://github.com/fpco/stackage-types";
       description = "Shared data types between various Stackage packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage-types_1_1_0" = callPackage
    ({ mkDerivation, aeson, base, Cabal, containers, exceptions
     , hashable, safe, semigroups, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "stackage-types";
       version = "1.1.0";
       sha256 = "01c5af9473cc09dd69e314aef138ab99a2e72d528f70924427a5bdfdefb4ce7a";
       libraryHaskellDepends = [
         aeson base Cabal containers exceptions hashable safe semigroups
         text time unordered-containers vector
       ];
       homepage = "https://github.com/fpco/stackage-types";
       description = "Shared data types between various Stackage packages";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage-types" = callPackage
    ({ mkDerivation, aeson, base, Cabal, containers, exceptions
     , hashable, safe, semigroups, text, time, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "stackage-types";
       version = "1.2.0";
       sha256 = "c00255049aa5aac04bb67372cea26feadc4f38442cedbe7035d611baa2edf4cb";
       libraryHaskellDepends = [
         aeson base Cabal containers exceptions hashable safe semigroups
         text time unordered-containers vector
       ];
       homepage = "https://github.com/fpco/stackage-types";
       description = "Shared data types between various Stackage packages";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stackage-update_0_1_1_1" = callPackage
    ({ mkDerivation, base, directory, filepath, process }:
     mkDerivation {
       pname = "stackage-update";
       version = "0.1.1.1";
       sha256 = "eb252123f1d74729f3f7871eafc3447de9d149810fbaf879f29e997cdf1cadf0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory filepath process ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/fpco/stackage-update";
       description = "Update your package index incrementally (requires git)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage-update" = callPackage
    ({ mkDerivation, base, directory, filepath, process }:
     mkDerivation {
       pname = "stackage-update";
       version = "0.1.2";
       sha256 = "72c3b1e60528afe9fd816b8b1dfcdab9a940aa32816f4593b06359a6b70383d3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory filepath process ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/fpco/stackage-update";
       description = "Update your package index incrementally (requires git)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stackage-upload_0_1_0_4" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, filepath
     , http-client, http-client-tls, http-types, optparse-applicative
     , process, stackage-cli, temporary, text
     }:
     mkDerivation {
       pname = "stackage-upload";
       version = "0.1.0.4";
       sha256 = "ea8d4c6a1dc89f24e7b41a6cb8d936883b915171ffe672da51a7c9976c1f4388";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring directory filepath http-client
         http-client-tls http-types process temporary text
       ];
       executableHaskellDepends = [
         base optparse-applicative stackage-cli
       ];
       homepage = "https://github.com/fpco/stackage-upload";
       description = "A more secure version of cabal upload which uses HTTPS";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stackage-upload" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, filepath
     , http-client, http-client-tls, http-types, optparse-applicative
     , process, stackage-cli, temporary, text
     }:
     mkDerivation {
       pname = "stackage-upload";
       version = "0.1.0.5";
       sha256 = "f1353781fc12b09682620c6629ee4edeca3c8ca16001109080d7d0fb3dd3b33b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring directory filepath http-client
         http-client-tls http-types process temporary text
       ];
       executableHaskellDepends = [
         base optparse-applicative stackage-cli
       ];
       homepage = "https://github.com/fpco/stackage-upload";
       description = "A more secure version of cabal upload which uses HTTPS";
       license = stdenv.lib.licenses.mit;
     }) {};

  "standalone-derive-topdown" = callPackage
    ({ mkDerivation, base, mtl, template-haskell }:
     mkDerivation {
       pname = "standalone-derive-topdown";
       version = "0.0.0.1";
       sha256 = "657bcd87ed4ffdf49461529faf3c292a8a480fce8c88c5af1eaa23b1c7e9d765";
       libraryHaskellDepends = [ base mtl template-haskell ];
       homepage = "https://github.com/HaskellZhangSong/TopdownDerive";
       description = "This package will derive class instance along the data type declaration tree";
       license = stdenv.lib.licenses.mit;
     }) {};

  "standalone-haddock" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, filepath
     , optparse-applicative
     }:
     mkDerivation {
       pname = "standalone-haddock";
       version = "1.1.4.4";
       sha256 = "24646ca673a695890424200d9f28e50acef3f23624b45bf713ac1f9b3407410a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal containers directory filepath optparse-applicative
       ];
       homepage = "http://documentup.com/feuerbach/standalone-haddock";
       description = "Generate standalone haddock documentation for a set of packages";
       license = stdenv.lib.licenses.mit;
     }) {};

  "star-to-star" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "star-to-star";
       version = "1.0";
       sha256 = "3267cfd2c2b607853a14e8eefc65022ffa1ba796ad9b9c889a901ade7258b3db";
       libraryHaskellDepends = [ base ];
       description = "the * -> * types, operators, and covariant instances";
       license = "unknown";
     }) {};

  "star-to-star-contra" = callPackage
    ({ mkDerivation, base, star-to-star }:
     mkDerivation {
       pname = "star-to-star-contra";
       version = "1.0";
       sha256 = "a3744150900961b6998e7039fbcf2fd9e28ddd967cbf87cdbe647e194a95b7ce";
       libraryHaskellDepends = [ base star-to-star ];
       description = "contravariant instances for * -> * types and operators";
       license = "unknown";
     }) {};

  "starling" = callPackage
    ({ mkDerivation, base, binary, bytestring, failure, transformers }:
     mkDerivation {
       pname = "starling";
       version = "0.3.0";
       sha256 = "771d90e0a2426f24373f83c727b18a4fb33280b31c3f2bc1dac69725660a0e44";
       libraryHaskellDepends = [
         base binary bytestring failure transformers
       ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~aslatter/starling";
       description = "A memcached client";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "starrover2" = callPackage
    ({ mkDerivation, base, bytestring, directory, EdisonCore, FTGL
     , haskell98, mtl, OpenGL, random, SDL
     }:
     mkDerivation {
       pname = "starrover2";
       version = "0.1.1";
       sha256 = "6a526d662f4d639ba6e217d8ba368f999307e5c5f62380db3e080ae3a1efb365";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory EdisonCore FTGL haskell98 mtl OpenGL
         random SDL
       ];
       homepage = "http://github.com/anttisalonen/starrover2";
       description = "Space simulation game";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stash" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, directory
     , hashable, text, vector
     }:
     mkDerivation {
       pname = "stash";
       version = "0.1";
       sha256 = "95cbf410a73d5cc185f7a2db4d299eacae88c54c0e710894514af0a752d00306";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring directory hashable text vector
       ];
       description = "To be written";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "state" = callPackage
    ({ mkDerivation, arrows, base, mtl }:
     mkDerivation {
       pname = "state";
       version = "0.1";
       sha256 = "a643bd52380c8a68b561c168bf24031a97443104ebd5a9f78b8eb399015cb048";
       libraryHaskellDepends = [ arrows base mtl ];
       jailbreak = true;
       description = "Data.State";
       license = "LGPL";
     }) {};

  "state-plus" = callPackage
    ({ mkDerivation, base, checkers, mtl, QuickCheck }:
     mkDerivation {
       pname = "state-plus";
       version = "0.1.2";
       sha256 = "c6ed155137d40262bf8aa38155bd93ecdc4bdbcb4ac83f5b980eeb8545ee377d";
       libraryHaskellDepends = [ base mtl ];
       testHaskellDepends = [ base checkers mtl QuickCheck ];
       description = "MonadPlus for StateT";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "state-record" = callPackage
    ({ mkDerivation, base, mtl, template-haskell }:
     mkDerivation {
       pname = "state-record";
       version = "0.0.1";
       sha256 = "eff4889b9f1567d42f42d8d1f88b95f798040bf76f94d089296e8a4d5ba038f9";
       libraryHaskellDepends = [ base mtl template-haskell ];
       homepage = "https://github.com/ktvoelker/state-record";
       description = "Better records for State monad states";
       license = "GPL";
     }) {};

  "stateWriter" = callPackage
    ({ mkDerivation, base, free, hspec, mtl, QuickCheck, transformers
     }:
     mkDerivation {
       pname = "stateWriter";
       version = "0.2.6";
       sha256 = "77f9c3bd7cf0fc433f2ba9f70481f6748a18151891ee5af9a4af5b0d06d4bf44";
       libraryHaskellDepends = [ base mtl transformers ];
       testHaskellDepends = [ base free hspec mtl QuickCheck ];
       description = "A faster variant of the RWS monad transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "statechart" = callPackage
    ({ mkDerivation, base, polyparse }:
     mkDerivation {
       pname = "statechart";
       version = "0.1.0";
       sha256 = "46b422f4f41d425ba92d938de39bfdab9ed6672672950a9911c1f63c60da5b88";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base polyparse ];
       homepage = "http://tomahawkins.org";
       description = "Compiles Rhapsody statecharts to C";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stateful-mtl" = callPackage
    ({ mkDerivation, base, MaybeT, mtl }:
     mkDerivation {
       pname = "stateful-mtl";
       version = "1.0.7";
       sha256 = "b0d48df014150a1554d76f9732cb3dfdd132a8cfeb4888f0b39b2dec702ec4a4";
       libraryHaskellDepends = [ base MaybeT mtl ];
       description = "Typeclass instances for monad transformer stacks with an ST thread at the bottom";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stateref" = callPackage
    ({ mkDerivation, base, mtl, stm }:
     mkDerivation {
       pname = "stateref";
       version = "0.3";
       sha256 = "7dd390aab346ca877cde1217d5b62145cdfa6f9390e3b7a53c9296229ee1b741";
       libraryHaskellDepends = [ base mtl stm ];
       homepage = "http://code.haskell.org/~mokus/stateref/";
       description = "Abstraction for things that work like IORef";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "statestack_0_2_0_3" = callPackage
    ({ mkDerivation, base, mtl, transformers }:
     mkDerivation {
       pname = "statestack";
       version = "0.2.0.3";
       sha256 = "fde9b4b172f1eb9277657bf13b5160c3f52d536def0d4554f56e715b25e2bb70";
       libraryHaskellDepends = [ base mtl transformers ];
       jailbreak = true;
       description = "Simple State-like monad transformer with saveable and restorable state";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "statestack_0_2_0_4" = callPackage
    ({ mkDerivation, base, mtl, transformers, transformers-compat }:
     mkDerivation {
       pname = "statestack";
       version = "0.2.0.4";
       sha256 = "0d8a81165e90553fa3aaeda04a0567cff2d92dc257dc8e852fca14b6851b926b";
       libraryHaskellDepends = [
         base mtl transformers transformers-compat
       ];
       jailbreak = true;
       description = "Simple State-like monad transformer with saveable and restorable state";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "statestack" = callPackage
    ({ mkDerivation, base, mtl, transformers, transformers-compat }:
     mkDerivation {
       pname = "statestack";
       version = "0.2.0.5";
       sha256 = "f4eadcf9b08c14cb084436f81e16edf78d6eeda77a3f93e38ba5d7e263ea5f66";
       libraryHaskellDepends = [
         base mtl transformers transformers-compat
       ];
       description = "Simple State-like monad transformer with saveable and restorable state";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "statethread" = callPackage
    ({ mkDerivation, applicative, base, transformers }:
     mkDerivation {
       pname = "statethread";
       version = "0.1.1";
       sha256 = "bfd22eeafac4fb37ae978cd5a3a7587d3e96ba90727d29c4ff23928979b49415";
       libraryHaskellDepends = [ applicative base transformers ];
       jailbreak = true;
       description = "The ST monad and STRefs";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {applicative = null;};

  "statgrab" = callPackage
    ({ mkDerivation, async, base, bytestring, statgrab, time
     , transformers
     }:
     mkDerivation {
       pname = "statgrab";
       version = "0.1.3";
       sha256 = "45eef564af76f12f5ba65cb58460ce05877540f08d86bc7232dbf41b5ef793e5";
       libraryHaskellDepends = [
         async base bytestring time transformers
       ];
       librarySystemDepends = [ statgrab ];
       homepage = "http://github.com/brendanhay/statgrab";
       description = "Collect system level metrics and statistics";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {statgrab = null;};

  "static-canvas" = callPackage
    ({ mkDerivation, base, double-conversion, free, mtl, text }:
     mkDerivation {
       pname = "static-canvas";
       version = "0.2.0.2";
       sha256 = "cec96c54089904e44d2909501da413ee1528f53ab770cae5d2d44bca41e8f0d2";
       libraryHaskellDepends = [ base double-conversion free mtl text ];
       homepage = "https://github.com/jeffreyrosenbluth/static-canvas";
       description = "DSL to generate HTML5 Canvas javascript";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "static-hash" = callPackage
    ({ mkDerivation, array, base, containers, hashable, primes }:
     mkDerivation {
       pname = "static-hash";
       version = "0.0.1";
       sha256 = "147dfc2b5f3510fb8fff7ee9bcb6dcf4568bb961abf221e23f02243434e96f5a";
       libraryHaskellDepends = [ array base containers hashable primes ];
       description = "Immutable hash";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "static-resources" = callPackage
    ({ mkDerivation, base, directory, filepath, hslogger, HUnit
     , MissingH, mtl, old-time, process, syb, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time
     }:
     mkDerivation {
       pname = "static-resources";
       version = "0.1.7";
       sha256 = "a9a2ac8b6759e149a0509e941f6e44dedb4c85dd86e81a2a00380a1aec9dc971";
       libraryHaskellDepends = [
         base directory filepath hslogger MissingH mtl old-time process syb
         time
       ];
       testHaskellDepends = [
         base directory hslogger HUnit MissingH mtl old-time syb
         test-framework test-framework-hunit test-framework-quickcheck2 time
       ];
       description = "JavaScript and Css files concat for http optimization. Now with LESS support.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "staticanalysis" = callPackage
    ({ mkDerivation, base, MissingH }:
     mkDerivation {
       pname = "staticanalysis";
       version = "0.0.0.3";
       sha256 = "8e5369282cbd6bd7c2fe6f2c5e1c8a62a91d9a7da1f77e51893a3a06a247de2c";
       libraryHaskellDepends = [ base MissingH ];
       description = "Reusable static analysis interfaces and modules";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "statistics_0_13_2_1" = callPackage
    ({ mkDerivation, aeson, base, binary, deepseq, erf, HUnit, ieee754
     , math-functions, monad-par, mwc-random, primitive, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , vector, vector-algorithms, vector-binary-instances
     }:
     mkDerivation {
       pname = "statistics";
       version = "0.13.2.1";
       sha256 = "6aef1be73b9f3b2df0f4938d5981e6e343d73b9b11658dfb86b659692f5e313e";
       libraryHaskellDepends = [
         aeson base binary deepseq erf math-functions monad-par mwc-random
         primitive vector vector-algorithms vector-binary-instances
       ];
       testHaskellDepends = [
         base binary erf HUnit ieee754 math-functions mwc-random primitive
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 vector vector-algorithms
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/bos/statistics";
       description = "A library of statistical types, data, and functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "statistics" = callPackage
    ({ mkDerivation, aeson, base, binary, deepseq, erf, HUnit, ieee754
     , math-functions, monad-par, mwc-random, primitive, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , vector, vector-algorithms, vector-binary-instances
     }:
     mkDerivation {
       pname = "statistics";
       version = "0.13.2.3";
       sha256 = "d624b1494959d3c64cfd068c9566778a799d3e3f5d6b22ec3e353ba6d6876fbd";
       libraryHaskellDepends = [
         aeson base binary deepseq erf math-functions monad-par mwc-random
         primitive vector vector-algorithms vector-binary-instances
       ];
       testHaskellDepends = [
         base binary erf HUnit ieee754 math-functions mwc-random primitive
         QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2 vector vector-algorithms
       ];
       doCheck = false;
       homepage = "https://github.com/bos/statistics";
       description = "A library of statistical types, data, and functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "statistics-dirichlet" = callPackage
    ({ mkDerivation, base, deepseq, hmatrix-special
     , nonlinear-optimization, vector
     }:
     mkDerivation {
       pname = "statistics-dirichlet";
       version = "0.6.3";
       sha256 = "7c5126d68df100a2491a025753dbe39861066333675102c111f9ef577687a7eb";
       libraryHaskellDepends = [
         base deepseq hmatrix-special nonlinear-optimization vector
       ];
       description = "Functions for working with Dirichlet densities and mixtures on vectors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "statistics-fusion" = callPackage
    ({ mkDerivation, base, vector }:
     mkDerivation {
       pname = "statistics-fusion";
       version = "1.0.1";
       sha256 = "8ee6e5175cf491d46dda817a577d51d26032c2f3c92e717c727e6525c1df879f";
       libraryHaskellDepends = [ base vector ];
       homepage = "http://code.haskell.org/~dons/code/statistics-fusion";
       description = "An implementation of high performance, minimal statistics functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "statistics-hypergeometric-genvar" = callPackage
    ({ mkDerivation, base, math-functions, mwc-random, primitive
     , statistics
     }:
     mkDerivation {
       pname = "statistics-hypergeometric-genvar";
       version = "0.1.0.0";
       sha256 = "f56caf4fd23a70f0660372763a8e56ab7e6e862bd8134cb21f27723ad51e4816";
       libraryHaskellDepends = [
         base math-functions mwc-random primitive statistics
       ];
       jailbreak = true;
       homepage = "https://github.com/srijs/statistics-hypergeometric-genvar";
       description = "Random variate generation from hypergeometric distributions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "statistics-linreg" = callPackage
    ({ mkDerivation, base, MonadRandom, random, random-shuffle, safe
     , statistics, vector
     }:
     mkDerivation {
       pname = "statistics-linreg";
       version = "0.3";
       sha256 = "6273c2166b8072814ede516c7c9f1e13a158b5013938fdf83a3ea2355aee8909";
       libraryHaskellDepends = [
         base MonadRandom random random-shuffle safe statistics vector
       ];
       homepage = "http://github.com/alpmestan/statistics-linreg";
       description = "Linear regression between two samples, based on the 'statistics' package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stats" = callPackage
    ({ mkDerivation, base, statistics, text, vector }:
     mkDerivation {
       pname = "stats";
       version = "0.1.1";
       sha256 = "ee043d22e98203fd09fc1a8a2028ba99c292f4723f8d9355ac1d6a4cb3252f22";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base statistics text vector ];
       jailbreak = true;
       homepage = "http://github.com/cheecheeo/stats/";
       description = "command line statistics";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "statsd" = callPackage
    ({ mkDerivation, base, bytestring, monad-control, mtl, network
     , random
     }:
     mkDerivation {
       pname = "statsd";
       version = "0.1.0.1";
       sha256 = "410127c4718c8c114eb2de8821ff9241dc3a311fa4d7e5e8d07fe73074c56c8d";
       libraryHaskellDepends = [
         base bytestring monad-control mtl network random
       ];
       jailbreak = true;
       homepage = "https://github.com/mitchellwrosen/statsd-haskell";
       description = "StatsD API";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "statsd-client" = callPackage
    ({ mkDerivation, base, byteable, bytestring, crypto-api, cryptohash
     , digest-pure, DRBG, network, network-uri, old-time, random
     , time-units
     }:
     mkDerivation {
       pname = "statsd-client";
       version = "0.2.0.1";
       sha256 = "7ef148b3909594fe4e845a1ebc49041af5cacaf1c557b4460f117a35a59457a5";
       libraryHaskellDepends = [
         base byteable bytestring crypto-api cryptohash digest-pure DRBG
         network network-uri old-time random time-units
       ];
       homepage = "https://github.com/keithduncan/statsd-client";
       description = "Statsd UDP client";
       license = stdenv.lib.licenses.mit;
     }) {};

  "statsd-datadog" = callPackage
    ({ mkDerivation, base, bytestring, monad-control, network, text
     , transformers-base
     }:
     mkDerivation {
       pname = "statsd-datadog";
       version = "0.2.0.0";
       sha256 = "f32b8f0ee56087c0baf3cc838c03a9b80ef0e3da464339a5eead97e9be7f33b1";
       libraryHaskellDepends = [
         base bytestring monad-control network text transformers-base
       ];
       homepage = "https://bitbucket.org/dpwiz/statsd-datadog";
       description = "DataDog-flavored StatsD client";
       license = stdenv.lib.licenses.mit;
     }) {};

  "statvfs" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "statvfs";
       version = "0.2";
       sha256 = "e1555e07894d222834c1e3da12532dbc4d9a9e75e4dce3ffa1bab8fd5a73e99b";
       libraryHaskellDepends = [ base ];
       description = "Get unix filesystem statistics with statfs, statvfs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stb-image" = callPackage
    ({ mkDerivation, base, bitmap, bytestring }:
     mkDerivation {
       pname = "stb-image";
       version = "0.2.1";
       sha256 = "a238d55f13171cf6bfba932ed77a89e38be90c13eb7a7bb71bc173537089a6d7";
       libraryHaskellDepends = [ base bitmap bytestring ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "A wrapper around Sean Barrett's JPEG/PNG decoder";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "stb-truetype" = callPackage
    ({ mkDerivation, array, base, bytestring, containers }:
     mkDerivation {
       pname = "stb-truetype";
       version = "0.1.2";
       sha256 = "9534fa559bba01a49a8e9c129373c61ff7a86ed10e6a75d62fdc95aee0896bc1";
       libraryHaskellDepends = [ array base bytestring containers ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "A wrapper around Sean Barrett's TrueType rasterizer library";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stdata" = callPackage
    ({ mkDerivation, base, parsec, syb, template-haskell }:
     mkDerivation {
       pname = "stdata";
       version = "0.0.4";
       sha256 = "6ef959485f64beda76e1a7f110292a8935271917c3d5ff2f0b6c136aa7c85146";
       libraryHaskellDepends = [ base parsec syb template-haskell ];
       jailbreak = true;
       description = "Structure Data Library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stdf" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, binary, bytestring
     , containers, data-binary-ieee754, split, text, time, unix-time
     , zlib
     }:
     mkDerivation {
       pname = "stdf";
       version = "0.2.0.0";
       sha256 = "cd7f63b1f3451108455e5e1e019ae1ad8c2ce9c8f6fba95c9f30eb8d51709cae";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base64-bytestring binary bytestring containers
         data-binary-ieee754 split text time unix-time zlib
       ];
       executableHaskellDepends = [
         aeson base base64-bytestring binary bytestring split text
       ];
       jailbreak = true;
       homepage = "https://github.com/gitfoxi/Stdf";
       description = "Parse Structured Test Data Format (STDF)";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "steambrowser" = callPackage
    ({ mkDerivation, base, directory, parsec, transformers }:
     mkDerivation {
       pname = "steambrowser";
       version = "0.1.0.0";
       sha256 = "e41555978df1ad59b540e318b5090447cd837f4f8e0b41aaa6e646010055311c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory parsec transformers ];
       jailbreak = true;
       description = "List and launch steam games from the cli";
       license = stdenv.lib.licenses.mit;
     }) {};

  "steeloverseer" = callPackage
    ({ mkDerivation, ansi-terminal, base, filepath, fsnotify, process
     , regex-tdfa, time, unix
     }:
     mkDerivation {
       pname = "steeloverseer";
       version = "1.1.1.0";
       sha256 = "cb255fce9ec38417473a10e00efd68450699ebb64f1ed0d683348dcd7b86a9eb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base filepath fsnotify process regex-tdfa time unix
       ];
       homepage = "https://github.com/schell/steeloverseer";
       description = "A file watcher";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stemmer" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "stemmer";
       version = "0.5.1";
       sha256 = "a092ccc06783c97f38aa703914e057cae02f1c69a6c10dacfb7c59ec39e43c4a";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.github.com/bgamari/stemmer";
       description = "Haskell bindings to the Snowball stemming library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "step-function" = callPackage
    ({ mkDerivation, base, Cabal, cabal-test-quickcheck, QuickCheck }:
     mkDerivation {
       pname = "step-function";
       version = "0.1.1.0";
       sha256 = "cdfdc05d8724f5ccea56fe600730943b30827c44e032913f865855fa42bded0e";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base Cabal cabal-test-quickcheck QuickCheck
       ];
       homepage = "https://github.com/jonpetterbergman/step-function";
       description = "Step functions, staircase functions or piecewise constant functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stepwise" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "stepwise";
       version = "1.0.2";
       sha256 = "0ebf2a47cf252a3cecee273177dccd2f0e38cdde03d52dc8ec1392c5c7433315";
       libraryHaskellDepends = [ base containers mtl ];
       homepage = "http://www.cs.uu.nl/wiki/HUT/WebHome";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stickyKeysHotKey" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "stickyKeysHotKey";
       version = "0.1.0.2";
       sha256 = "4a24a2e53b818937b3b75ea97df65bd4448444fe7d4dc6e6fa3c13a7878a8147";
       libraryHaskellDepends = [ base ];
       description = "get and set STICKYKEYS.SKF_HOTKEYACTIVE";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stitch" = callPackage
    ({ mkDerivation, base, Cabal, containers, hspec, text, transformers
     }:
     mkDerivation {
       pname = "stitch";
       version = "0.3.2.0";
       sha256 = "672de129731e55e56893ef5f0149f12778ad4fd3db3c2717f9fb578e7c3e16c1";
       libraryHaskellDepends = [ base containers text transformers ];
       testHaskellDepends = [ base Cabal hspec text ];
       description = "lightweight CSS DSL";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stm_2_4_3" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "stm";
       version = "2.4.3";
       sha256 = "3ac21ea4aa37ee064ac2195dfd274b7c528faa0f88b21c89774c97668026fc6f";
       libraryHaskellDepends = [ array base ];
       jailbreak = true;
       description = "Software Transactional Memory";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stm_2_4_4" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "stm";
       version = "2.4.4";
       sha256 = "5dfb588a01b46f427b16a92d6b7843ac81489639bbdfd962e5795c19dbfe883d";
       libraryHaskellDepends = [ array base ];
       description = "Software Transactional Memory";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stm" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "stm";
       version = "2.4.4.1";
       sha256 = "8f999095ed8d50d2056fc6e185035ee8166c50751e1af8de02ac38d382bf3384";
       libraryHaskellDepends = [ array base ];
       description = "Software Transactional Memory";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stm-channelize" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "stm-channelize";
       version = "0.1.1";
       sha256 = "15a6cf4432cf631f8c484bd02b1f633b3522a8ccb2cfaacf5a5a938257fc44aa";
       libraryHaskellDepends = [ base stm ];
       description = "Transactional I/O for duplex streams";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stm-chans_3_0_0_2" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "stm-chans";
       version = "3.0.0.2";
       sha256 = "d07abf7a8bf9689b92f69bb73e9c1b71dc785d7b0a7b512dc24d77e945024aff";
       libraryHaskellDepends = [ base stm ];
       homepage = "http://code.haskell.org/~wren/";
       description = "Additional types of channels for STM";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stm-chans_3_0_0_3" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "stm-chans";
       version = "3.0.0.3";
       sha256 = "b31e9f2098d4a8dd006cb8f4d48583a8b5a6f333202ec2e0a341d42ec28f1515";
       libraryHaskellDepends = [ base stm ];
       homepage = "http://code.haskell.org/~wren/";
       description = "Additional types of channels for STM";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stm-chans" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "stm-chans";
       version = "3.0.0.4";
       sha256 = "2344fc5bfa33d565bad7b009fc0e2c5a7a595060ba149c661f44419fc0d54738";
       libraryHaskellDepends = [ base stm ];
       homepage = "http://code.haskell.org/~wren/";
       description = "Additional types of channels for STM";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stm-chunked-queues" = callPackage
    ({ mkDerivation, async, base, HUnit, stm, tasty, tasty-hunit }:
     mkDerivation {
       pname = "stm-chunked-queues";
       version = "0.1.0.0";
       sha256 = "d2865d12ebfda3efb9a99bec98daa111e9153e8179eaae85f28bc32a7254c408";
       libraryHaskellDepends = [ async base stm ];
       testHaskellDepends = [ async base HUnit stm tasty tasty-hunit ];
       homepage = "http://github.com/kholdstare/stm-chunked-queues/";
       description = "Chunked Communication Queues";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stm-conduit_2_5_2" = callPackage
    ({ mkDerivation, async, base, cereal, cereal-conduit, conduit
     , conduit-extra, directory, HUnit, lifted-async, lifted-base
     , monad-control, monad-loops, QuickCheck, resourcet, stm, stm-chans
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , transformers
     }:
     mkDerivation {
       pname = "stm-conduit";
       version = "2.5.2";
       sha256 = "5da079813e863b6aaca468b30d32a312619b6ec34756301e03ad6f65bf4d14e5";
       libraryHaskellDepends = [
         async base cereal cereal-conduit conduit conduit-extra directory
         lifted-async lifted-base monad-control monad-loops resourcet stm
         stm-chans transformers
       ];
       testHaskellDepends = [
         base conduit directory HUnit QuickCheck resourcet stm stm-chans
         test-framework test-framework-hunit test-framework-quickcheck2
         transformers
       ];
       homepage = "https://github.com/wowus/stm-conduit";
       description = "Introduces conduits to channels, and promotes using conduits concurrently";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stm-conduit_2_5_3" = callPackage
    ({ mkDerivation, async, base, cereal, cereal-conduit, conduit
     , conduit-extra, directory, HUnit, lifted-async, lifted-base
     , monad-control, monad-loops, QuickCheck, resourcet, stm, stm-chans
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , transformers
     }:
     mkDerivation {
       pname = "stm-conduit";
       version = "2.5.3";
       sha256 = "3c86f707b39b3191e41c1106d7ac047de54ec145251a13c2e782e711459251cb";
       libraryHaskellDepends = [
         async base cereal cereal-conduit conduit conduit-extra directory
         lifted-async lifted-base monad-control monad-loops resourcet stm
         stm-chans transformers
       ];
       testHaskellDepends = [
         base conduit directory HUnit QuickCheck resourcet stm stm-chans
         test-framework test-framework-hunit test-framework-quickcheck2
         transformers
       ];
       homepage = "https://github.com/wowus/stm-conduit";
       description = "Introduces conduits to channels, and promotes using conduits concurrently";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stm-conduit_2_5_4" = callPackage
    ({ mkDerivation, async, base, cereal, cereal-conduit, conduit
     , conduit-extra, directory, HUnit, lifted-async, lifted-base
     , monad-control, monad-loops, QuickCheck, resourcet, stm, stm-chans
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , transformers
     }:
     mkDerivation {
       pname = "stm-conduit";
       version = "2.5.4";
       sha256 = "933aa9d4476483f66fa3bd0ecaab605d49a5c58e9ff3512840cf2c224eda9adf";
       libraryHaskellDepends = [
         async base cereal cereal-conduit conduit conduit-extra directory
         lifted-async lifted-base monad-control monad-loops resourcet stm
         stm-chans transformers
       ];
       testHaskellDepends = [
         base conduit directory HUnit QuickCheck resourcet stm stm-chans
         test-framework test-framework-hunit test-framework-quickcheck2
         transformers
       ];
       homepage = "https://github.com/wowus/stm-conduit";
       description = "Introduces conduits to channels, and promotes using conduits concurrently";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stm-conduit_2_6_1" = callPackage
    ({ mkDerivation, async, base, cereal, cereal-conduit, conduit
     , conduit-combinators, conduit-extra, directory, doctest, ghc-prim
     , HUnit, lifted-async, lifted-base, monad-control, monad-loops
     , QuickCheck, resourcet, stm, stm-chans, test-framework
     , test-framework-hunit, test-framework-quickcheck2, transformers
     , void
     }:
     mkDerivation {
       pname = "stm-conduit";
       version = "2.6.1";
       sha256 = "17f4f0431c81c06c79b00a1f6f9d4f94fef5e2ca5e7ab55233997e95a44aa931";
       libraryHaskellDepends = [
         async base cereal cereal-conduit conduit conduit-combinators
         conduit-extra directory ghc-prim lifted-async lifted-base
         monad-control monad-loops resourcet stm stm-chans transformers void
       ];
       testHaskellDepends = [
         base conduit conduit-combinators directory doctest HUnit QuickCheck
         resourcet stm stm-chans test-framework test-framework-hunit
         test-framework-quickcheck2 transformers
       ];
       doHaddock = false;
       homepage = "https://github.com/wowus/stm-conduit";
       description = "Introduces conduits to channels, and promotes using conduits concurrently";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stm-conduit" = callPackage
    ({ mkDerivation, async, base, cereal, cereal-conduit, conduit
     , conduit-combinators, conduit-extra, directory, doctest, ghc-prim
     , HUnit, lifted-async, lifted-base, monad-control, monad-loops
     , QuickCheck, resourcet, stm, stm-chans, test-framework
     , test-framework-hunit, test-framework-quickcheck2, transformers
     , void
     }:
     mkDerivation {
       pname = "stm-conduit";
       version = "2.7.0";
       sha256 = "e3ec32b7b150449f45b55b18dce8a6607177c948824dcffb935c721abba7c5af";
       libraryHaskellDepends = [
         async base cereal cereal-conduit conduit conduit-combinators
         conduit-extra directory ghc-prim lifted-async lifted-base
         monad-control monad-loops resourcet stm stm-chans transformers void
       ];
       testHaskellDepends = [
         base conduit conduit-combinators directory doctest HUnit QuickCheck
         resourcet stm stm-chans test-framework test-framework-hunit
         test-framework-quickcheck2 transformers
       ];
       homepage = "https://github.com/wowus/stm-conduit";
       description = "Introduces conduits to channels, and promotes using conduits concurrently";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stm-containers_0_2_4" = callPackage
    ({ mkDerivation, base, base-prelude, focus, free, hashable, HTF
     , list-t, loch-th, mtl, mtl-prelude, placeholders, primitive
     , QuickCheck, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "stm-containers";
       version = "0.2.4";
       sha256 = "9ee314fe03e56bd4f0817642b779e8e814c3ec4aefab84a728fca4663ff09e63";
       libraryHaskellDepends = [
         base-prelude focus hashable list-t loch-th placeholders primitive
         transformers
       ];
       testHaskellDepends = [
         base base-prelude focus free hashable HTF list-t loch-th mtl
         mtl-prelude placeholders primitive QuickCheck transformers
         unordered-containers
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/stm-containers";
       description = "Containers for STM";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stm-containers_0_2_6" = callPackage
    ({ mkDerivation, base, base-prelude, focus, free, hashable, HTF
     , list-t, loch-th, mtl, mtl-prelude, placeholders, primitive
     , QuickCheck, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "stm-containers";
       version = "0.2.6";
       sha256 = "5eb20d5685e1f3146fb543bd9523dac3f9c258ab06b96e99afab3e88319fb9ce";
       libraryHaskellDepends = [
         base-prelude focus hashable list-t loch-th placeholders primitive
         transformers
       ];
       testHaskellDepends = [
         base base-prelude focus free hashable HTF list-t loch-th mtl
         mtl-prelude placeholders primitive QuickCheck transformers
         unordered-containers
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/stm-containers";
       description = "Containers for STM";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stm-containers_0_2_7" = callPackage
    ({ mkDerivation, base, base-prelude, focus, free, hashable, HTF
     , list-t, loch-th, mtl, mtl-prelude, placeholders, primitive
     , QuickCheck, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "stm-containers";
       version = "0.2.7";
       sha256 = "59c17bc0c267a99c5fa950842216700841ec2865485881bbd02d6ecb58cff5e1";
       libraryHaskellDepends = [
         base-prelude focus hashable list-t loch-th placeholders primitive
         transformers
       ];
       testHaskellDepends = [
         base base-prelude focus free hashable HTF list-t loch-th mtl
         mtl-prelude placeholders primitive QuickCheck transformers
         unordered-containers
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/stm-containers";
       description = "Containers for STM";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stm-containers_0_2_8" = callPackage
    ({ mkDerivation, base, base-prelude, focus, free, hashable, HTF
     , list-t, loch-th, mtl, mtl-prelude, placeholders, primitive
     , QuickCheck, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "stm-containers";
       version = "0.2.8";
       sha256 = "1da8d7c948015cb6ab64100c018fc8a0ee093da0089780d61f09e09552841637";
       libraryHaskellDepends = [
         base-prelude focus hashable list-t loch-th placeholders primitive
         transformers
       ];
       testHaskellDepends = [
         base base-prelude focus free hashable HTF list-t loch-th mtl
         mtl-prelude placeholders primitive QuickCheck transformers
         unordered-containers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/stm-containers";
       description = "Containers for STM";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stm-containers_0_2_9" = callPackage
    ({ mkDerivation, base-prelude, focus, free, hashable, HTF, list-t
     , loch-th, mtl, mtl-prelude, placeholders, primitive, QuickCheck
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "stm-containers";
       version = "0.2.9";
       sha256 = "a25c44e696ee574b4f5d6c240572ff8ea8dedbe91e57e5306b9da1a4c3f7545c";
       libraryHaskellDepends = [
         base-prelude focus hashable list-t loch-th placeholders primitive
         transformers
       ];
       testHaskellDepends = [
         base-prelude focus free hashable HTF list-t loch-th mtl mtl-prelude
         placeholders primitive QuickCheck transformers unordered-containers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/stm-containers";
       description = "Containers for STM";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stm-containers" = callPackage
    ({ mkDerivation, base-prelude, focus, free, hashable, HTF, list-t
     , loch-th, mtl, mtl-prelude, placeholders, primitive, QuickCheck
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "stm-containers";
       version = "0.2.10";
       sha256 = "1dd724fda2456279d2bf70b8666eb1f87604776932b452f3b097236ad1533e6d";
       libraryHaskellDepends = [
         base-prelude focus hashable list-t loch-th placeholders primitive
         transformers
       ];
       testHaskellDepends = [
         base-prelude focus free hashable HTF list-t loch-th mtl mtl-prelude
         placeholders primitive QuickCheck transformers unordered-containers
       ];
       doCheck = false;
       homepage = "https://github.com/nikita-volkov/stm-containers";
       description = "Containers for STM";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stm-delay" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "stm-delay";
       version = "0.1.1.1";
       sha256 = "b132581aac47e6cba6a1691a485e1700fbb047c02b7e1e43ae9bbd8476108a32";
       libraryHaskellDepends = [ base stm ];
       testHaskellDepends = [ base stm ];
       homepage = "https://github.com/joeyadams/haskell-stm-delay";
       description = "Updatable one-shot timer polled with STM";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stm-firehose" = callPackage
    ({ mkDerivation, base, blaze-builder, conduit, hspec, http-types
     , HUnit, resourcet, stm, stm-chans, stm-conduit, transformers, wai
     , wai-conduit, warp
     }:
     mkDerivation {
       pname = "stm-firehose";
       version = "0.3.0.2";
       sha256 = "6519b3fa7eba570e0cbd39ebb1b99eedf27212d3a1d3f63be5758e74858ed7f8";
       libraryHaskellDepends = [
         base blaze-builder conduit http-types resourcet stm stm-chans
         stm-conduit transformers wai wai-conduit warp
       ];
       testHaskellDepends = [ base hspec HUnit stm ];
       jailbreak = true;
       homepage = "https://github.com/bartavelle/stm-firehose";
       description = "Conduits and STM operations for fire hoses";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stm-io-hooks" = callPackage
    ({ mkDerivation, array, base, containers, mtl, stm }:
     mkDerivation {
       pname = "stm-io-hooks";
       version = "1.1.0";
       sha256 = "35014012b671a6964ec0d5f5de2ab13a61d8ee01cb0bbd685a3cc17385fae235";
       libraryHaskellDepends = [ array base containers mtl stm ];
       description = "STM with IO hooks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stm-lifted" = callPackage
    ({ mkDerivation, base, stm, transformers }:
     mkDerivation {
       pname = "stm-lifted";
       version = "0.1.0.0";
       sha256 = "20816d76aa853a7bf0c5052cf511acd4aba004ecba8251ee807e83197def7ef4";
       revision = "1";
       editedCabalFile = "d313721a31d8e7ccc725c3a1542f4ac3f8c84fbcad10094cd1067c133edc6c54";
       libraryHaskellDepends = [ base stm transformers ];
       description = "Software Transactional Memory lifted to MonadIO";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stm-linkedlist" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "stm-linkedlist";
       version = "0.1.0.0";
       sha256 = "7926673f9ec7938210a6d30e511190845e7e040a2cab555d291183ded0f8c5f4";
       libraryHaskellDepends = [ base stm ];
       description = "Mutable, doubly linked lists for STM";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stm-orelse-io" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "stm-orelse-io";
       version = "0.1";
       sha256 = "a496773a80375a3757e53bf6d1f54a9eb0fe21a668966c5c0dc470fa0beb6087";
       libraryHaskellDepends = [ base stm ];
       homepage = "http://nonempty.org/software/stm-orelse-io";
       description = "Choose between the return value of an STM operation and an IO action";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stm-promise" = callPackage
    ({ mkDerivation, base, mtl, process, QuickCheck, stm, unix }:
     mkDerivation {
       pname = "stm-promise";
       version = "0.0.3.1";
       sha256 = "8cbb0b34d0f8c6aa71a22f9cd7ea083b44153e7845882c3fd3abf187905c991f";
       libraryHaskellDepends = [ base mtl process stm unix ];
       testHaskellDepends = [ base QuickCheck stm ];
       homepage = "http://www.github.com/danr/stm-promise";
       description = "Simple STM Promises for IO computations and external processes";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "stm-queue-extras" = callPackage
    ({ mkDerivation, base, stm, stm-chans }:
     mkDerivation {
       pname = "stm-queue-extras";
       version = "0.2.0.0.1";
       sha256 = "00047cb4167a56c6bd809572a33d818714bc74c3bad46cd686fa86f01a8a66fd";
       libraryHaskellDepends = [ base stm stm-chans ];
       description = "Extra queue utilities for STM";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "stm-sbchan" = callPackage
    ({ mkDerivation, base, stm, stm-tlist }:
     mkDerivation {
       pname = "stm-sbchan";
       version = "0.1";
       sha256 = "1a78c0e7e66e59795bc57a0f9a86e427f297a4bca3b6b5c55888a0ec97dbe43b";
       libraryHaskellDepends = [ base stm stm-tlist ];
       homepage = "https://github.com/joeyadams/haskell-stm-sbchan";
       description = "Bounded channel for STM where item sizes can vary";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stm-split" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "stm-split";
       version = "0.0.0.1";
       sha256 = "88f3bd9b210377919218a117fd27d1b8350af6aaf65b2f2df2be72e896456314";
       libraryHaskellDepends = [ base stm ];
       description = "TMVars, TVars and TChans with distinguished input and output side";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stm-stats" = callPackage
    ({ mkDerivation, base, containers, stm, template-haskell, time }:
     mkDerivation {
       pname = "stm-stats";
       version = "0.2.0.0";
       sha256 = "0a4f39b1e9fffe50d6dfaa9c0b04977e510fae8b6bd3d7abb7076e8aa8f01345";
       libraryHaskellDepends = [
         base containers stm template-haskell time
       ];
       description = "retry statistics for STM transactions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stm-tlist" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "stm-tlist";
       version = "0.1.1";
       sha256 = "c66bb64a814c50f977e0fe3101c4ffbd05cb32c8b21070d91ca9a65ae145596b";
       libraryHaskellDepends = [ base stm ];
       homepage = "https://github.com/joeyadams/haskell-stm-tlist";
       description = "Mutable, singly-linked list in STM";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stmcontrol" = callPackage
    ({ mkDerivation, base, haskell98, mtl, stm }:
     mkDerivation {
       pname = "stmcontrol";
       version = "0.1";
       sha256 = "4428e55dcbe7378f839abb782298af877fa05aa175618099c74de1bfedbb8254";
       libraryHaskellDepends = [ base haskell98 mtl stm ];
       homepage = "http://sulzmann.blogspot.com/2008/12/stm-with-control-communication-for.html";
       description = "Control communication among retrying transactions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stomp-conduit" = callPackage
    ({ mkDerivation, base, conduit, mime, mtl, resourcet, stomp-queue
     , stompl
     }:
     mkDerivation {
       pname = "stomp-conduit";
       version = "0.1.0";
       sha256 = "eaaad7f0e859655e9004d3c4ac1dda323ae5e671f4d43d3b652669e7a62bf9e3";
       libraryHaskellDepends = [
         base conduit mime mtl resourcet stomp-queue stompl
       ];
       homepage = "http://github.com/toschoo/mom";
       description = "Stompl Conduit Client";
       license = "LGPL";
     }) {};

  "stomp-patterns" = callPackage
    ({ mkDerivation, base, bytestring, containers, mime, mtl, split
     , stomp-queue, stompl, time
     }:
     mkDerivation {
       pname = "stomp-patterns";
       version = "0.1.0";
       sha256 = "7c3d0c16656be7ac011be7d1317b0aba774ed614f81fcfe32cf248ba0e4cb365";
       libraryHaskellDepends = [
         base bytestring containers mime mtl split stomp-queue stompl time
       ];
       homepage = "http://github.com/toschoo/mom";
       description = "Stompl MOM Stomp Patterns";
       license = "LGPL";
     }) {};

  "stomp-queue" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, conduit
     , conduit-extra, mime, mtl, network-conduit-tls, split, stompl
     , time, utf8-string
     }:
     mkDerivation {
       pname = "stomp-queue";
       version = "0.2.2";
       sha256 = "2ca9ab331d657f1efae64295084fbf3eac05efdb96e186a7f7ba497f24e7d5cf";
       libraryHaskellDepends = [
         attoparsec base bytestring conduit conduit-extra mime mtl
         network-conduit-tls split stompl time utf8-string
       ];
       homepage = "http://github.com/toschoo/mom";
       description = "Stompl Client Library";
       license = "LGPL";
     }) {};

  "stompl" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, mime, split, text
     , utf8-string
     }:
     mkDerivation {
       pname = "stompl";
       version = "0.3.0";
       sha256 = "52897d2b5f0f100d76e1b8ae0d243102b712f6c760cda103146618e11007e5c6";
       libraryHaskellDepends = [
         attoparsec base bytestring mime split text utf8-string
       ];
       homepage = "http://github.com/toschoo/mom";
       description = "Stomp Parser and Utilities";
       license = "LGPL";
     }) {};

  "stopwatch" = callPackage
    ({ mkDerivation, base, clock, hspec, transformers }:
     mkDerivation {
       pname = "stopwatch";
       version = "0.1.0";
       sha256 = "17f488ef8e74a9dc4ad7e8a649abc386d010379a9b63f88d52638a078fbc16f6";
       libraryHaskellDepends = [ base clock transformers ];
       testHaskellDepends = [ base clock hspec ];
       jailbreak = true;
       homepage = "https://github.com/debug-ito/stopwatch";
       description = "A simple stopwatch utility";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "storable" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "storable";
       version = "0.1";
       sha256 = "4f8689dc6e715138d6b392a43c2483606545de86fe3f2ec1bb6e6a375c4d4880";
       libraryHaskellDepends = [ base mtl ];
       homepage = "http://anna.fi.muni.cz/~xjanous3/gitweb/?p=storable.git;a=summary";
       description = "Storable type class for variable-sized data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "storable-complex_0_2_1" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "storable-complex";
       version = "0.2.1";
       sha256 = "5f5d9e1c71de41379e0b9249f4ddc7c5fb6756333ebb1127e790977aa2b6dd36";
       revision = "1";
       editedCabalFile = "2588152721f67330feb42aa33cd969ff8ec4f42fac768740e38711623d6d57c3";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Storable instance for Complex";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "storable-complex" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "storable-complex";
       version = "0.2.2";
       sha256 = "ab076f15c47a2a324a2119c8feee0a78e1d2af488d0d24b7113b4bb7eee47c06";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/cartazio/storable-complex";
       description = "Storable instance for Complex";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "storable-endian" = callPackage
    ({ mkDerivation, base, byteorder }:
     mkDerivation {
       pname = "storable-endian";
       version = "0.2.5";
       sha256 = "e206eecf9480e937347ad0663f6c588da490606a1e55b871c68da8c7c1b44112";
       libraryHaskellDepends = [ base byteorder ];
       description = "Storable instances with endianness";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "storable-record" = callPackage
    ({ mkDerivation, base, transformers, utility-ht }:
     mkDerivation {
       pname = "storable-record";
       version = "0.0.3.1";
       sha256 = "74e5ceee49e0b7625d13759597d21e714843406b8b80e9168a0bb1199ffdadba";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base transformers utility-ht ];
       homepage = "http://code.haskell.org/~thielema/storable-record/";
       description = "Elegant definition of Storable instances for records";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "storable-static-array" = callPackage
    ({ mkDerivation, array, base, tagged, vector }:
     mkDerivation {
       pname = "storable-static-array";
       version = "0.6.1.0";
       sha256 = "b5eb6edeccae1609099e915e00adeadc3c50eab02b998db844033726b6816d2a";
       libraryHaskellDepends = [ array base tagged vector ];
       jailbreak = true;
       description = "Statically-sized array wrappers with Storable instances for FFI marshaling";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "storable-tuple" = callPackage
    ({ mkDerivation, base, base-orphans, storable-record, utility-ht }:
     mkDerivation {
       pname = "storable-tuple";
       version = "0.0.3.2";
       sha256 = "35d3f35bbffc9acc1f81e5718cfac59d6d86ac229c740f6dde22f2374b5e8982";
       libraryHaskellDepends = [
         base base-orphans storable-record utility-ht
       ];
       homepage = "http://code.haskell.org/~thielema/storable-tuple/";
       description = "Storable instance for pairs and triples";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "storablevector" = callPackage
    ({ mkDerivation, base, bytestring, non-negative, QuickCheck, random
     , syb, transformers, unsafe, utility-ht
     }:
     mkDerivation {
       pname = "storablevector";
       version = "0.2.10";
       sha256 = "749d29fb3446695ece50f72fd6b17eddc2c81df49c92a89a3c41940b56922505";
       libraryHaskellDepends = [
         base non-negative QuickCheck syb transformers unsafe utility-ht
       ];
       testHaskellDepends = [
         base bytestring QuickCheck random utility-ht
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Storable_Vector";
       description = "Fast, packed, strict storable arrays with a list interface like ByteString";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "storablevector-carray" = callPackage
    ({ mkDerivation, base, carray, storablevector, utility-ht }:
     mkDerivation {
       pname = "storablevector-carray";
       version = "0.0";
       sha256 = "711070aa6c4288fc89cbafc0dd44f9ce0e51ab16d9a5f1a217b237aa5a730fb3";
       libraryHaskellDepends = [ base carray storablevector utility-ht ];
       homepage = "http://www.haskell.org/haskellwiki/Storable_Vector";
       description = "Conversion between storablevector and carray";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "storablevector-streamfusion" = callPackage
    ({ mkDerivation, base, binary, bytestring, old-time, storablevector
     , stream-fusion, utility-ht
     }:
     mkDerivation {
       pname = "storablevector-streamfusion";
       version = "0.0";
       sha256 = "d52cd96003f494733840cba6e0f83fd2a5900ceaa5e180b38a48b800f254f6e1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base storablevector stream-fusion utility-ht
       ];
       executableHaskellDepends = [
         base binary bytestring old-time stream-fusion
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Storable_Vector";
       description = "Conversion between storablevector and stream-fusion lists with fusion";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "str" = callPackage
    ({ mkDerivation, base, base16-bytestring, bytestring, Crypto
     , hashable, MissingH, text, utf8-string
     }:
     mkDerivation {
       pname = "str";
       version = "0.1.0.0";
       sha256 = "599be5e795ea11e4f9833a92e498e347db73575e5bd6ab1e226fa020e57f6b24";
       libraryHaskellDepends = [
         base base16-bytestring bytestring Crypto hashable MissingH text
         utf8-string
       ];
       jailbreak = true;
       homepage = "http://www.github.com/thinkpad20/str";
       description = "A type class to abstract between many different string types";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stratum-tool" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, bytestring-builder
     , cmdargs, connection, containers, curl, curl-aeson, network, stm
     , text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "stratum-tool";
       version = "0.0.4";
       sha256 = "1795849092ba839864eac66127218a536e550b9f84e305aface85d5dbafda80a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson async base bytestring bytestring-builder cmdargs connection
         containers curl curl-aeson network stm text time
         unordered-containers vector
       ];
       description = "Client for Stratum protocol";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stream-fusion" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "stream-fusion";
       version = "0.1.2.5";
       sha256 = "8679e2feb1ac87aec95afc9254fd37aff67e0e18aa22c72768a9f12607f8ce00";
       libraryHaskellDepends = [ base ];
       homepage = "http://hackage.haskell.org/trac/ghc/ticket/915";
       description = "Faster Haskell lists using stream fusion";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stream-monad" = callPackage
    ({ mkDerivation, base, logict }:
     mkDerivation {
       pname = "stream-monad";
       version = "0.4.0.2";
       sha256 = "86cd5770f903184b47113c42978cc409a483a5bdd2619c9e11f5a2339491210c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base logict ];
       jailbreak = true;
       homepage = "http://github.com/sebfisch/stream-monad";
       description = "Simple, Fair and Terminating Backtracking Monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "streamed" = callPackage
    ({ mkDerivation, alsa-core, alsa-seq, base, containers
     , data-accessor, data-accessor-transformers, event-list, midi
     , midi-alsa, non-negative, random, transformers, utility-ht
     }:
     mkDerivation {
       pname = "streamed";
       version = "0.2";
       sha256 = "aa9fcdb15566d18f2ac9033c242b330f629e5d6210fe741230d922c1fb061437";
       libraryHaskellDepends = [
         alsa-core alsa-seq base containers data-accessor
         data-accessor-transformers event-list midi midi-alsa non-negative
         random transformers utility-ht
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/MIDI";
       description = "Programmatically edit MIDI event streams via ALSA";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "streaming" = callPackage
    ({ mkDerivation, base, bytestring, containers, exceptions, mmorph
     , mtl, resourcet, time, transformers, transformers-base
     }:
     mkDerivation {
       pname = "streaming";
       version = "0.1.4.0";
       sha256 = "063a14c2ce512b3265ae69d45f208d4c01ca6da9325fa9e471a1fd1acd968e3c";
       libraryHaskellDepends = [
         base bytestring containers exceptions mmorph mtl resourcet time
         transformers transformers-base
       ];
       homepage = "https://github.com/michaelt/streaming";
       description = "an elementary streaming prelude and general stream type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "streaming-bytestring" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, exceptions, mmorph, mtl
     , resourcet, streaming, transformers, transformers-base
     }:
     mkDerivation {
       pname = "streaming-bytestring";
       version = "0.1.4.0";
       sha256 = "121f5dbbac81fd7f74bc6c1b5f3a2ee2d99d6c38c5f772442baa44c5e29d737c";
       libraryHaskellDepends = [
         base bytestring deepseq exceptions mmorph mtl resourcet streaming
         transformers transformers-base
       ];
       homepage = "https://github.com/michaelt/streaming-bytestring";
       description = "effectful byte steams, or: bytestring io done right";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "streaming-commons_0_1_7_3" = callPackage
    ({ mkDerivation, array, async, base, blaze-builder, bytestring
     , deepseq, directory, hspec, network, process, QuickCheck, random
     , stm, text, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "streaming-commons";
       version = "0.1.7.3";
       sha256 = "ab7f9e481f0809c34dad20c791862ab558cdba8808a11284a7cf67095b2a558b";
       revision = "1";
       editedCabalFile = "fc48e51179bf49c32f93ae2fbff9366e7435d31f66d9247787b0da29df900973";
       libraryHaskellDepends = [
         array base blaze-builder bytestring directory network process
         random stm text transformers unix zlib
       ];
       testHaskellDepends = [
         array async base blaze-builder bytestring deepseq hspec network
         QuickCheck text unix zlib
       ];
       jailbreak = true;
       homepage = "https://github.com/fpco/streaming-commons";
       description = "Common lower-level functions needed by various streaming data libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "streaming-commons_0_1_8" = callPackage
    ({ mkDerivation, array, async, base, blaze-builder, bytestring
     , deepseq, directory, hspec, network, process, QuickCheck, random
     , stm, text, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "streaming-commons";
       version = "0.1.8";
       sha256 = "0f969599694ba4c168871dda1c70f7067e1a520344fb4ce1bd09a923a70d43e6";
       revision = "1";
       editedCabalFile = "e4c6964ab84d2bf6d48c604bc6941611bdf87dbb823725ef69f1e9d74031ad7d";
       libraryHaskellDepends = [
         array base blaze-builder bytestring directory network process
         random stm text transformers unix zlib
       ];
       testHaskellDepends = [
         array async base blaze-builder bytestring deepseq hspec network
         QuickCheck text unix zlib
       ];
       jailbreak = true;
       homepage = "https://github.com/fpco/streaming-commons";
       description = "Common lower-level functions needed by various streaming data libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "streaming-commons_0_1_8_1" = callPackage
    ({ mkDerivation, array, async, base, blaze-builder, bytestring
     , deepseq, directory, hspec, network, process, QuickCheck, random
     , stm, text, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "streaming-commons";
       version = "0.1.8.1";
       sha256 = "1151e4353530390f20fa973fa9224d18058c78bf9240a5264b0e08a75069c462";
       libraryHaskellDepends = [
         array base blaze-builder bytestring directory network process
         random stm text transformers unix zlib
       ];
       testHaskellDepends = [
         array async base blaze-builder bytestring deepseq hspec network
         QuickCheck text unix zlib
       ];
       jailbreak = true;
       homepage = "https://github.com/fpco/streaming-commons";
       description = "Common lower-level functions needed by various streaming data libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "streaming-commons_0_1_9_1" = callPackage
    ({ mkDerivation, array, async, base, blaze-builder, bytestring
     , deepseq, directory, hspec, network, process, QuickCheck, random
     , stm, text, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "streaming-commons";
       version = "0.1.9.1";
       sha256 = "579f94ceac64891d7fe6f98730389179581e081d4ad5c06d9fee3f16e3b1657e";
       libraryHaskellDepends = [
         array base blaze-builder bytestring directory network process
         random stm text transformers unix zlib
       ];
       testHaskellDepends = [
         array async base blaze-builder bytestring deepseq hspec network
         QuickCheck text unix zlib
       ];
       jailbreak = true;
       homepage = "https://github.com/fpco/streaming-commons";
       description = "Common lower-level functions needed by various streaming data libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "streaming-commons_0_1_10_0" = callPackage
    ({ mkDerivation, array, async, base, blaze-builder, bytestring
     , deepseq, directory, hspec, network, process, QuickCheck, random
     , stm, text, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "streaming-commons";
       version = "0.1.10.0";
       sha256 = "187187e7788c85c9492612a7534cc13ef877034b5abea9315b27f721f3957a95";
       libraryHaskellDepends = [
         array base blaze-builder bytestring directory network process
         random stm text transformers unix zlib
       ];
       testHaskellDepends = [
         array async base blaze-builder bytestring deepseq hspec network
         QuickCheck text unix zlib
       ];
       homepage = "https://github.com/fpco/streaming-commons";
       description = "Common lower-level functions needed by various streaming data libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "streaming-commons_0_1_11" = callPackage
    ({ mkDerivation, array, async, base, blaze-builder, bytestring
     , deepseq, directory, hspec, network, process, QuickCheck, random
     , stm, text, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "streaming-commons";
       version = "0.1.11";
       sha256 = "abe743597950017f0027de27958e9b7915b4b05de1854a6ac8dd248e2cdf0a06";
       libraryHaskellDepends = [
         array base blaze-builder bytestring directory network process
         random stm text transformers unix zlib
       ];
       testHaskellDepends = [
         array async base blaze-builder bytestring deepseq hspec network
         QuickCheck text unix zlib
       ];
       homepage = "https://github.com/fpco/streaming-commons";
       description = "Common lower-level functions needed by various streaming data libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "streaming-commons_0_1_12" = callPackage
    ({ mkDerivation, array, async, base, blaze-builder, bytestring
     , deepseq, directory, hspec, network, process, QuickCheck, random
     , stm, text, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "streaming-commons";
       version = "0.1.12";
       sha256 = "5e9f5e594f5bc15a26d3a5814a588b6120547ffdce22361102e1fe11ab5498e9";
       libraryHaskellDepends = [
         array base blaze-builder bytestring directory network process
         random stm text transformers unix zlib
       ];
       testHaskellDepends = [
         array async base blaze-builder bytestring deepseq hspec network
         QuickCheck text unix zlib
       ];
       homepage = "https://github.com/fpco/streaming-commons";
       description = "Common lower-level functions needed by various streaming data libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "streaming-commons_0_1_12_1" = callPackage
    ({ mkDerivation, array, async, base, blaze-builder, bytestring
     , deepseq, directory, hspec, network, process, QuickCheck, random
     , stm, text, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "streaming-commons";
       version = "0.1.12.1";
       sha256 = "d5bd8dd0b11a13d1d128d15dce31b3f2f4625c7f72d4420e749d85bf170a4fd7";
       libraryHaskellDepends = [
         array base blaze-builder bytestring directory network process
         random stm text transformers unix zlib
       ];
       testHaskellDepends = [
         array async base blaze-builder bytestring deepseq hspec network
         QuickCheck text unix zlib
       ];
       homepage = "https://github.com/fpco/streaming-commons";
       description = "Common lower-level functions needed by various streaming data libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "streaming-commons_0_1_13" = callPackage
    ({ mkDerivation, array, async, base, blaze-builder, bytestring
     , deepseq, directory, hspec, network, process, QuickCheck, random
     , stm, text, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "streaming-commons";
       version = "0.1.13";
       sha256 = "fca261aec4eae05785127e8eaf17a5872ab03547b225f1fca36af3bf82ca75a8";
       libraryHaskellDepends = [
         array base blaze-builder bytestring directory network process
         random stm text transformers unix zlib
       ];
       testHaskellDepends = [
         array async base blaze-builder bytestring deepseq hspec network
         QuickCheck text unix zlib
       ];
       homepage = "https://github.com/fpco/streaming-commons";
       description = "Common lower-level functions needed by various streaming data libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "streaming-commons_0_1_14_1" = callPackage
    ({ mkDerivation, array, async, base, blaze-builder, bytestring
     , deepseq, directory, hspec, network, process, QuickCheck, random
     , stm, text, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "streaming-commons";
       version = "0.1.14.1";
       sha256 = "b3494e9577bc66835bb0dd2669f0aa891ec013e253d742f92f971ed51ebdae9e";
       libraryHaskellDepends = [
         array base blaze-builder bytestring directory network process
         random stm text transformers unix zlib
       ];
       testHaskellDepends = [
         array async base blaze-builder bytestring deepseq hspec network
         QuickCheck text unix zlib
       ];
       homepage = "https://github.com/fpco/streaming-commons";
       description = "Common lower-level functions needed by various streaming data libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "streaming-commons_0_1_14_2" = callPackage
    ({ mkDerivation, array, async, base, blaze-builder, bytestring
     , deepseq, directory, hspec, network, process, QuickCheck, random
     , stm, text, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "streaming-commons";
       version = "0.1.14.2";
       sha256 = "1031548f0f9daf8b5678cc3a2ab1d16d28466738e3aefde652f91bbff94adc8a";
       libraryHaskellDepends = [
         array base blaze-builder bytestring directory network process
         random stm text transformers unix zlib
       ];
       testHaskellDepends = [
         array async base blaze-builder bytestring deepseq hspec network
         QuickCheck text unix zlib
       ];
       homepage = "https://github.com/fpco/streaming-commons";
       description = "Common lower-level functions needed by various streaming data libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "streaming-commons_0_1_15" = callPackage
    ({ mkDerivation, array, async, base, blaze-builder, bytestring
     , deepseq, directory, hspec, network, process, QuickCheck, random
     , stm, text, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "streaming-commons";
       version = "0.1.15";
       sha256 = "e507beac9ab68eaa8be4933bc1e9511610c581fdfc72621ba51faa913e5fce42";
       libraryHaskellDepends = [
         array base blaze-builder bytestring directory network process
         random stm text transformers unix zlib
       ];
       testHaskellDepends = [
         array async base blaze-builder bytestring deepseq hspec network
         QuickCheck text unix zlib
       ];
       homepage = "https://github.com/fpco/streaming-commons";
       description = "Common lower-level functions needed by various streaming data libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "streaming-commons" = callPackage
    ({ mkDerivation, array, async, base, blaze-builder, bytestring
     , deepseq, directory, hspec, network, process, QuickCheck, random
     , stm, text, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "streaming-commons";
       version = "0.1.15.1";
       sha256 = "af3b07d1022f263b1e0f95ba15697d87d55afc1cf0933c9b16fd37a687b8cacb";
       libraryHaskellDepends = [
         array async base blaze-builder bytestring directory network process
         random stm text transformers unix zlib
       ];
       testHaskellDepends = [
         array async base blaze-builder bytestring deepseq hspec network
         QuickCheck text unix zlib
       ];
       homepage = "https://github.com/fpco/streaming-commons";
       description = "Common lower-level functions needed by various streaming data libraries";
       license = stdenv.lib.licenses.mit;
     }) {};

  "streaming-histogram" = callPackage
    ({ mkDerivation, base, containers, criterion, tasty, tasty-hunit
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "streaming-histogram";
       version = "0.1.0.0";
       sha256 = "07f7c40aca77806a875ec3ceae0a9ad29a3609f9f988669e354b515a3a2ca0ea";
       libraryHaskellDepends = [ base containers criterion ];
       testHaskellDepends = [
         base containers tasty tasty-hunit tasty-quickcheck
       ];
       license = stdenv.lib.licenses.asl20;
     }) {};

  "streaming-png" = callPackage
    ({ mkDerivation, base, bytestring, cereal, exceptions, JuicyPixels
     , mmorph, mtl, resourcet, streaming, streaming-bytestring
     , streaming-commons, transformers, vector
     }:
     mkDerivation {
       pname = "streaming-png";
       version = "0.1.0.0";
       sha256 = "ecb3509c29481d7deb3b65c976cc08fb9a859cff9f52ad48c16402d9439420ca";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cereal exceptions JuicyPixels mmorph mtl resourcet
         streaming streaming-bytestring streaming-commons transformers
         vector
       ];
       homepage = "http://github.com/bch29/streaming-png#readme";
       description = "Perfectly streaming PNG image decoding";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "streaming-utils" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, http-client
     , http-client-tls, json-stream, mtl, pipes, resourcet, streaming
     , streaming-bytestring, transformers
     }:
     mkDerivation {
       pname = "streaming-utils";
       version = "0.1.4.2";
       sha256 = "7a672d1a52b424e0a2ef53e04ca8d0776f41fda6db223d6d989895f9357eaa61";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring http-client http-client-tls
         json-stream mtl pipes resourcet streaming streaming-bytestring
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/michaelt/streaming-utils";
       description = "http, attoparsec, pipes and conduit utilities for the streaming libraries";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "streaming-wai" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-builder, http-types
     , streaming, wai
     }:
     mkDerivation {
       pname = "streaming-wai";
       version = "0.1.1";
       sha256 = "35b4182386cc1d23731b3eac78dda79a1b7878c0b6bd78fd99907c776dbfaf30";
       libraryHaskellDepends = [
         base bytestring bytestring-builder http-types streaming wai
       ];
       homepage = "http://github.com/jb55/streaming-wai";
       description = "Streaming Wai utilities";
       license = stdenv.lib.licenses.mit;
     }) {};

  "streamproc" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "streamproc";
       version = "1.6.2";
       sha256 = "e76effaaff83e6a066df949415db109b405bda0aaeb95f0710906c65892584f2";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/peti/streamproc";
       description = "Stream Processer Arrow";
       license = stdenv.lib.licenses.bsd3;
       maintainers = with stdenv.lib.maintainers; [ simons ];
     }) {};

  "streams_3_2" = callPackage
    ({ mkDerivation, adjunctions, base, comonad, distributive
     , semigroupoids, semigroups
     }:
     mkDerivation {
       pname = "streams";
       version = "3.2";
       sha256 = "d13e8b0f3bfc426ba1f6ec32970f997cd5deaedecc1182b5ffd75e1d2327bade";
       revision = "1";
       editedCabalFile = "af489d487dc7cb4b1c778db5ffd29bd60fe97d222f25984fa56d9653dcd42d53";
       libraryHaskellDepends = [
         adjunctions base comonad distributive semigroupoids semigroups
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/streams/issues";
       description = "Various Haskell 2010 stream comonads";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "streams" = callPackage
    ({ mkDerivation, adjunctions, base, comonad, distributive
     , semigroupoids, semigroups
     }:
     mkDerivation {
       pname = "streams";
       version = "3.2.1";
       sha256 = "44edcc8bda54c0c356e606896756af5e61dab0070c021df31dfbbc56cad2d9f7";
       libraryHaskellDepends = [
         adjunctions base comonad distributive semigroupoids semigroups
       ];
       homepage = "http://github.com/ekmett/streams/issues";
       description = "Various Haskell 2010 stream comonads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "strict" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "strict";
       version = "0.3.2";
       sha256 = "2cd35a67938db635a87617d9576d5df0158b581e8e5694f07487c0f4b1549221";
       libraryHaskellDepends = [ array base ];
       homepage = "http://www.cse.unsw.edu.au/~rl/code/strict.html";
       description = "Strict data types and String IO";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "strict-base-types_0_4_0" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, binary, deepseq, ghc-prim
     , hashable, lens, QuickCheck, strict
     }:
     mkDerivation {
       pname = "strict-base-types";
       version = "0.4.0";
       sha256 = "5b9ac632f3128504b2619cc0e74ef6624e7b42a6a68f0a3758dd46937e172591";
       libraryHaskellDepends = [
         aeson base bifunctors binary deepseq ghc-prim hashable lens
         QuickCheck strict
       ];
       homepage = "https://github.com/meiersi/strict-base-types";
       description = "Strict variants of the types provided in base";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "strict-base-types" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, binary, deepseq, ghc-prim
     , hashable, lens, QuickCheck, strict
     }:
     mkDerivation {
       pname = "strict-base-types";
       version = "0.5.0";
       sha256 = "febcadf3d7f97f9c8c161a98e2537ba83a8adc4e4f6015e65430d7367104a1cb";
       libraryHaskellDepends = [
         aeson base bifunctors binary deepseq ghc-prim hashable lens
         QuickCheck strict
       ];
       homepage = "https://github.com/meiersi/strict-base-types";
       description = "Strict variants of the types provided in base";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "strict-concurrency" = callPackage
    ({ mkDerivation, base, deepseq }:
     mkDerivation {
       pname = "strict-concurrency";
       version = "0.2.4.1";
       sha256 = "0939212dd0cc3b9bd228dfbb233d9eccad22ca626752d9bad8026ceb0a5c1a89";
       revision = "2";
       editedCabalFile = "70e871fd6fd7dffa2dc373fda3a062e9b9efde6cbab873b250ff5731ca1a7850";
       libraryHaskellDepends = [ base deepseq ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~dons/code/strict-concurrency";
       description = "Strict concurrency abstractions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "strict-ghc-plugin" = callPackage
    ({ mkDerivation, base, ghc, syb }:
     mkDerivation {
       pname = "strict-ghc-plugin";
       version = "0.1.1";
       sha256 = "2b4b040927eda4d8016278551aa7ee3415ce5a747d243c78b98d5f9bd2fda143";
       libraryHaskellDepends = [ base ghc syb ];
       homepage = "http://thoughtpolice.github.com/strict-ghc-plugin";
       description = "Compiler plugin for making Haskell strict";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "strict-identity" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "strict-identity";
       version = "0.1.0.0";
       sha256 = "218e8746098c246a5cf497e96eac6b4305495de18dc5f281598d79b54e8decbb";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/cartazio/strict-identity";
       description = "Strict Identity Monad, handy for writing fast code!";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "strict-io" = callPackage
    ({ mkDerivation, base, deepseq, extensible-exceptions }:
     mkDerivation {
       pname = "strict-io";
       version = "0.2.1";
       sha256 = "ad265e5707c8badaea8b2a89457917d38ae3cf7c19ac46bac704a81ee5777700";
       libraryHaskellDepends = [ base deepseq extensible-exceptions ];
       jailbreak = true;
       description = "A library wrapping standard IO modules to provide strict IO";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "strictify" = callPackage
    ({ mkDerivation, base, directory, filepath, process, unix }:
     mkDerivation {
       pname = "strictify";
       version = "0.1";
       sha256 = "50d55fdc35308ab47b86cb660e6e61391305c8ad81b41ccb81fff5209e8b487c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath process unix
       ];
       description = "Find a local optimum of strictness annotations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "strictly" = callPackage
    ({ mkDerivation, base, deepseq }:
     mkDerivation {
       pname = "strictly";
       version = "1.0.0.0";
       sha256 = "6c742c9071b79f3fa669f0c514b0b95701d9f31c1ccbc9569d64e9995efe6aa8";
       libraryHaskellDepends = [ base deepseq ];
       jailbreak = true;
       homepage = "https://github.com/DanBurton/strictly#readme";
       description = "Combinators for strictifying functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "string" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "string";
       version = "0.4.0";
       sha256 = "dffcd3ede54ee2d4d023e353ba4dacb0bd606a680717c9ef6a42219918ba24d1";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "string-class" = callPackage
    ({ mkDerivation, base, bytestring, tagged, text }:
     mkDerivation {
       pname = "string-class";
       version = "0.1.6.5";
       sha256 = "821dc13ee0521e0bee335e689c88596efb193130835a6edc45f94dcc9f72237a";
       libraryHaskellDepends = [ base bytestring tagged text ];
       homepage = "https://github.com/bairyn/string-class";
       description = "String class library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "string-combinators" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "string-combinators";
       version = "0.6.0.5";
       sha256 = "94914abfbd7d17051edab4bc9927c191fd05a652d9ef3cf259b5d0e0ca177e1e";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/basvandijk/string-combinators";
       description = "Polymorphic functions to build and combine stringlike values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "string-conv" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "string-conv";
       version = "0.1";
       sha256 = "861a5402709202a1594f5e2ee2792c1ff31be73255619c967516c756e5a4557e";
       revision = "1";
       editedCabalFile = "e6fd8d1b56031e7c1ea24129ddb8bd2c6ab26a63d24b2e90ca40300f217602a9";
       libraryHaskellDepends = [ base bytestring text ];
       description = "Standardized conversion between string types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "string-conversions_0_3_0_3" = callPackage
    ({ mkDerivation, base, bytestring, text, utf8-string }:
     mkDerivation {
       pname = "string-conversions";
       version = "0.3.0.3";
       sha256 = "9720cd345ba23de3b67256dce8976118b5457b8134a1940b1875179b6a745158";
       libraryHaskellDepends = [ base bytestring text utf8-string ];
       description = "Simplifies dealing with different types for strings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "string-conversions" = callPackage
    ({ mkDerivation, base, bytestring, text, utf8-string }:
     mkDerivation {
       pname = "string-conversions";
       version = "0.4";
       sha256 = "1a64a6db3c7fe37c798aaa433ee4c951c0727fd46a9c096c002b6bf0adac24ae";
       libraryHaskellDepends = [ base bytestring text utf8-string ];
       description = "Simplifies dealing with different types for strings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "string-convert" = callPackage
    ({ mkDerivation, base, bytestring, text, utf8-string }:
     mkDerivation {
       pname = "string-convert";
       version = "2.0.1";
       sha256 = "088844c1f17f204a534c2f366fbe93777013df1460223f3372ebf3cf0e5ba953";
       libraryHaskellDepends = [ base bytestring text utf8-string ];
       homepage = "https://bitbucket.org/tdammers/string-convert";
       description = "Provide universal string conversions between any two string-like types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "string-qq" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "string-qq";
       version = "0.0.2";
       sha256 = "9757cad387856a313729caffe0639215a10be7d72b09c44bcab9e55ee2a8c218";
       libraryHaskellDepends = [ base template-haskell ];
       description = "QuasiQuoter for non-interpolated strings, texts and bytestrings";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "string-quote" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "string-quote";
       version = "0.0.1";
       sha256 = "6484e4fe361c0b5cb1ef1999529a5886d3aaf75dff78fa00a01bdec6e968d3dd";
       libraryHaskellDepends = [ base template-haskell ];
       description = "QuasiQuoter for non-interpolated strings, texts and bytestrings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "string-similarity" = callPackage
    ({ mkDerivation, base, bytestring, hspec, QuickCheck, suffixtree }:
     mkDerivation {
       pname = "string-similarity";
       version = "0.1.0.0";
       sha256 = "bb2e18741f084bef90531050a5b14712aca4e78d05de12d3ec6b803a5e9e034c";
       libraryHaskellDepends = [ base suffixtree ];
       testHaskellDepends = [ base bytestring hspec QuickCheck ];
       homepage = "http://github.com/mwotton/string-similarity";
       description = "longest common substring";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "string-typelits" = callPackage
    ({ mkDerivation, base, template-haskell, type-combinators
     , type-combinators-quote
     }:
     mkDerivation {
       pname = "string-typelits";
       version = "0.1.0.0";
       sha256 = "ff35b6eb25b8e7a18f3fd495c8c911acf3e866876cb521c44bae31ef2934abbb";
       libraryHaskellDepends = [
         base template-haskell type-combinators type-combinators-quote
       ];
       homepage = "https://github.com/kylcarte/string-typelits";
       description = "Type-level Chars and Strings, with decidable equality";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stringable" = callPackage
    ({ mkDerivation, base, bytestring, system-filepath, text }:
     mkDerivation {
       pname = "stringable";
       version = "0.1.3";
       sha256 = "e7af961e1eb52c89330aeb5434d7cfdebd3b712dd39812f68dcbd685e3da5a82";
       libraryHaskellDepends = [ base bytestring system-filepath text ];
       description = "A Stringable type class, in the spirit of Foldable and Traversable";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stringbuilder" = callPackage
    ({ mkDerivation, base, hspec, QuickCheck }:
     mkDerivation {
       pname = "stringbuilder";
       version = "0.5.0";
       sha256 = "8966882622fc06fd4e588da626a558b54daa313f2328c188d9305b0c6f2fe9aa";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec QuickCheck ];
       description = "A writer monad for multi-line string literals";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stringlike" = callPackage
    ({ mkDerivation, base, bytestring, QuickCheck, quickcheck-instances
     , test-framework, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "stringlike";
       version = "0.0.0";
       sha256 = "1eaa2307a330df6065c7ebcdb0ea48bfb9d360173f84b5bef2968ef38aaa3073";
       libraryHaskellDepends = [ base bytestring text ];
       testHaskellDepends = [
         base bytestring QuickCheck quickcheck-instances test-framework
         test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "https://github.com/selectel/stringlike";
       description = "Transformations to several string-like types";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stringprep" = callPackage
    ({ mkDerivation, base, containers, QuickCheck, tasty
     , tasty-quickcheck, tasty-th, text, text-icu
     }:
     mkDerivation {
       pname = "stringprep";
       version = "1.0.0";
       sha256 = "60015e858428f1af2f6e2e3e725a2738d8bcedd8258c043b09a5dddbfe664441";
       libraryHaskellDepends = [ base containers text text-icu ];
       testHaskellDepends = [
         base containers QuickCheck tasty tasty-quickcheck tasty-th text
         text-icu
       ];
       description = "Implements the \"StringPrep\" algorithm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "strings" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "strings";
       version = "1.1";
       sha256 = "9b3c3be8b04125cc2a6f26451616608649a15134bc251fcf847e045df8d8e9f7";
       libraryHaskellDepends = [ base bytestring text ];
       homepage = "http://hub.darcs.net/scravy/strings";
       description = "Functions for working with strings, including Text, ByteString, etc";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stringsearch_0_3_6_5" = callPackage
    ({ mkDerivation, array, base, bytestring, containers }:
     mkDerivation {
       pname = "stringsearch";
       version = "0.3.6.5";
       sha256 = "58d3409a551f71ccc55ded74be3f6f43b23614d74e12bc71d97d3a9271585bd6";
       revision = "1";
       editedCabalFile = "7a10da5ee4d6b4fbed31b2ac007e7cba3d9fe446736be03d49f62584641ef4c5";
       libraryHaskellDepends = [ array base bytestring containers ];
       jailbreak = true;
       homepage = "https://bitbucket.org/dafis/stringsearch";
       description = "Fast searching, splitting and replacing of ByteStrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stringsearch" = callPackage
    ({ mkDerivation, array, base, bytestring, containers }:
     mkDerivation {
       pname = "stringsearch";
       version = "0.3.6.6";
       sha256 = "295f1971920bc52263d8275d7054ad223a7e1aefe75533f9887735c9644ffe4a";
       libraryHaskellDepends = [ array base bytestring containers ];
       homepage = "https://bitbucket.org/dafis/stringsearch";
       description = "Fast searching, splitting and replacing of ByteStrings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stringtable-atom" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, syb }:
     mkDerivation {
       pname = "stringtable-atom";
       version = "0.0.7";
       sha256 = "5a72537ab158bda2a290fcce85e4bac48a23330bfaf80422673853b744e0e6f2";
       libraryHaskellDepends = [ base binary bytestring containers syb ];
       homepage = "http://github.com/audreyt/stringtable-atom/";
       description = "Memoize Strings as Atoms for fast comparison and sorting, with maps and sets";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "strio" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "strio";
       version = "0.0.0.0";
       sha256 = "14cbd9da8f3c97020aa6a414e059b41d57dbcb586153c8a328c835eec8ee32bd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       homepage = "https://github.com/yulii/strio";
       description = "Initial project template from stack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stripe" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-conduit, http-types
     , mtl, text, time, unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "stripe";
       version = "0.8.3";
       sha256 = "10abe90f5d3dd6897fb83fe6a552ed8acb69c36ba848e1342144c84d4d081fd3";
       libraryHaskellDepends = [
         aeson base bytestring http-conduit http-types mtl text time
         unordered-containers utf8-string
       ];
       jailbreak = true;
       homepage = "https://github.com/michaelschade/hs-stripe";
       description = "A Haskell implementation of the Stripe API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stripe-core" = callPackage
    ({ mkDerivation, aeson, base, bytestring, mtl, text, time
     , transformers, unordered-containers
     }:
     mkDerivation {
       pname = "stripe-core";
       version = "2.0.2";
       sha256 = "73ecdfae962260b4db665149c4836e5caec80dfa18be534e8d088df69cac0a94";
       libraryHaskellDepends = [
         aeson base bytestring mtl text time transformers
         unordered-containers
       ];
       homepage = "https://github.com/dmjio/stripe-haskell";
       description = "Stripe API for Haskell - Pure Core";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stripe-haskell" = callPackage
    ({ mkDerivation, base, stripe-core, stripe-http-streams }:
     mkDerivation {
       pname = "stripe-haskell";
       version = "2.0.2";
       sha256 = "7320b4650523b8c481543bd66c7e287c8e390722bc3a923cc2734384a39d7b50";
       libraryHaskellDepends = [ base stripe-core stripe-http-streams ];
       homepage = "https://github.com/dmjio/stripe";
       description = "Stripe API for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stripe-http-streams" = callPackage
    ({ mkDerivation, aeson, base, bytestring, HsOpenSSL, http-streams
     , io-streams, stripe-core, text
     }:
     mkDerivation {
       pname = "stripe-http-streams";
       version = "2.0.2";
       sha256 = "0de3899464bc77aec508c3f45335493795d97e1e0b12c8e867189853bd8bc717";
       libraryHaskellDepends = [
         aeson base bytestring HsOpenSSL http-streams io-streams stripe-core
         text
       ];
       doCheck = false;
       description = "Stripe API for Haskell - http-streams backend";
       license = stdenv.lib.licenses.mit;
     }) {};

  "strive" = callPackage
    ({ mkDerivation, aeson, base, bytestring, data-default, gpolyline
     , hlint, http-conduit, http-types, markdown-unlit, template-haskell
     , text, time, transformers
     }:
     mkDerivation {
       pname = "strive";
       version = "2.2.0";
       sha256 = "558042448e7694f893cba63b1191a8868b2d819fce3a1a54ac5309f6d9e0878a";
       libraryHaskellDepends = [
         aeson base bytestring data-default gpolyline http-conduit
         http-types template-haskell text time transformers
       ];
       testHaskellDepends = [ base bytestring hlint markdown-unlit time ];
       homepage = "http://taylor.fausak.me/strive/";
       description = "A Haskell client for the Strava V3 API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "strptime" = callPackage
    ({ mkDerivation, base, bytestring, text, time }:
     mkDerivation {
       pname = "strptime";
       version = "1.0.10";
       sha256 = "cd2508a07eec0197bd7cc67b7e5e2e7cf06a69ad4c4fe5a47722639788f382b8";
       libraryHaskellDepends = [ base bytestring text time ];
       description = "Efficient parsing of LocalTime using a binding to C's strptime, with some extra features (i.e. fractional seconds)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "structs" = callPackage
    ({ mkDerivation, base, deepseq, directory, doctest, filepath
     , ghc-prim, hlint, parallel, primitive
     }:
     mkDerivation {
       pname = "structs";
       version = "0";
       sha256 = "4ba635175f9db39b13d7ba7ecb2158c1c4228f33d0831e9dd48e5e247cda3970";
       libraryHaskellDepends = [ base deepseq ghc-prim primitive ];
       testHaskellDepends = [
         base directory doctest filepath hlint parallel
       ];
       homepage = "http://github.com/ekmett/structs/";
       description = "Strict GC'd imperative object-oriented programming with cheap pointers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "structural-induction" = callPackage
    ({ mkDerivation, base, containers, genifunctors, geniplate
     , language-haskell-extract, mtl, pretty, QuickCheck, safe
     , testing-feat
     }:
     mkDerivation {
       pname = "structural-induction";
       version = "0.3";
       sha256 = "5d7176d0536d407a0a96aa0602099c17f79a6bd7d637e1a712bf4a78c768d3f3";
       libraryHaskellDepends = [
         base containers genifunctors mtl pretty safe
       ];
       testHaskellDepends = [
         base geniplate language-haskell-extract mtl pretty QuickCheck safe
         testing-feat
       ];
       homepage = "http://www.github.com/danr/structural-induction";
       description = "Instantiate structural induction schemas for algebraic data types";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "structured-haskell-mode" = callPackage
    ({ mkDerivation, applicative-quoters, base, descriptive, ghc-prim
     , haskell-src-exts, text
     }:
     mkDerivation {
       pname = "structured-haskell-mode";
       version = "1.0.20";
       sha256 = "62b3673fba19d9b3eae87a0d4be6259a74fa41a8c4df34d0988796c4e2409edd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         applicative-quoters base descriptive ghc-prim haskell-src-exts text
       ];
       jailbreak = true;
       homepage = "https://github.com/chrisdone/structured-haskell-mode";
       description = "Structured editing Emacs mode for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "structured-mongoDB" = callPackage
    ({ mkDerivation, array, base, bson, bytestring, compact-string-fix
     , containers, monad-control, mongoDB, mtl, old-time
     , template-haskell, transformers, transformers-base
     }:
     mkDerivation {
       pname = "structured-mongoDB";
       version = "0.3";
       sha256 = "bdc9d9e0afc1cb2abaa9ad522562984e0095b3126a10372483721468e2279a38";
       libraryHaskellDepends = [
         array base bson bytestring compact-string-fix containers
         monad-control mongoDB mtl old-time template-haskell transformers
         transformers-base
       ];
       jailbreak = true;
       description = "Structured MongoDB interface";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "structures" = callPackage
    ({ mkDerivation, base, bytestring, containers, contravariant
     , deepseq, directory, doctest, filepath, free, ghc, ghc-prim
     , hashable, hlint, hybrid-vectors, lens, monad-st, parallel
     , primitive, QuickCheck, semigroups, tasty, tasty-quickcheck
     , tasty-th, transformers, unordered-containers, vector
     , vector-algorithms
     }:
     mkDerivation {
       pname = "structures";
       version = "0.2";
       sha256 = "48c72fd0c7cf9ddd957b471ac4140aac1068ca4aca9e88e1af56bb74978e1500";
       libraryHaskellDepends = [
         base containers contravariant deepseq free ghc ghc-prim hashable
         hybrid-vectors lens monad-st parallel primitive semigroups
         transformers vector vector-algorithms
       ];
       testHaskellDepends = [
         base bytestring containers deepseq directory doctest filepath hlint
         QuickCheck semigroups tasty tasty-quickcheck tasty-th
         unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/structures";
       description = "\"Advanced\" Data Structures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stunclient" = callPackage
    ({ mkDerivation, base, bytestring, cereal, crypto-api, cryptohash
     , cryptohash-cryptoapi, digest, network, QuickCheck, random
     , stringprep, test-framework, test-framework-quickcheck2, text
     , transformers, unbounded-delays
     }:
     mkDerivation {
       pname = "stunclient";
       version = "0.1.0.1";
       sha256 = "9d62319af1c8161b898562f51d20b6c586a66b18597627aedea399ce595c3a45";
       libraryHaskellDepends = [
         base bytestring cereal crypto-api cryptohash cryptohash-cryptoapi
         digest network random stringprep text transformers unbounded-delays
       ];
       testHaskellDepends = [
         base bytestring cereal digest network QuickCheck random
         test-framework test-framework-quickcheck2 text transformers
         unbounded-delays
       ];
       description = "RFC 5389: Session Traversal Utilities for NAT (STUN) client";
       license = stdenv.lib.licenses.mit;
     }) {};

  "stunts" = callPackage
    ({ mkDerivation, base, binary, bullet, bytestring, containers
     , directory, elerea, GLFW-b, lambdacube-bullet, lambdacube-engine
     , mtl, random, vector
     }:
     mkDerivation {
       pname = "stunts";
       version = "0.1.2";
       sha256 = "1cd1e7f4625c2b4a51418b593279c1084b02c9aa5992d2f9c408fd4c615bb91c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bullet bytestring containers directory elerea GLFW-b
         lambdacube-bullet lambdacube-engine mtl random vector
       ];
       homepage = "http://www.haskell.org/haskellwiki/LambdaCubeEngine";
       description = "A revival of the classic game Stunts (LambdaCube tech demo)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stylish-haskell_0_5_11_0" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cmdargs, containers
     , directory, filepath, haskell-src-exts, HUnit, mtl, strict, syb
     , test-framework, test-framework-hunit, yaml
     }:
     mkDerivation {
       pname = "stylish-haskell";
       version = "0.5.11.0";
       sha256 = "7f32ba6eee8100a3bc34bca93545593cee83a31fa98be5a913d458a18a7ee484";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers directory filepath
         haskell-src-exts mtl syb yaml
       ];
       executableHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts mtl strict syb yaml
       ];
       testHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts HUnit mtl syb test-framework test-framework-hunit
         yaml
       ];
       jailbreak = true;
       homepage = "https://github.com/jaspervdj/stylish-haskell";
       description = "Haskell code prettifier";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stylish-haskell_0_5_11_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cmdargs, containers
     , directory, filepath, haskell-src-exts, HUnit, mtl, strict, syb
     , test-framework, test-framework-hunit, yaml
     }:
     mkDerivation {
       pname = "stylish-haskell";
       version = "0.5.11.1";
       sha256 = "e1ed21c56582c5b5da75087bb20922cab25b54d63cc97f0fdc3e4bcd8b70a5a1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers directory filepath
         haskell-src-exts mtl syb yaml
       ];
       executableHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts mtl strict syb yaml
       ];
       testHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts HUnit mtl syb test-framework test-framework-hunit
         yaml
       ];
       jailbreak = true;
       homepage = "https://github.com/jaspervdj/stylish-haskell";
       description = "Haskell code prettifier";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stylish-haskell_0_5_11_2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cmdargs, containers
     , directory, filepath, haskell-src-exts, HUnit, mtl, strict, syb
     , test-framework, test-framework-hunit, yaml
     }:
     mkDerivation {
       pname = "stylish-haskell";
       version = "0.5.11.2";
       sha256 = "1d59818c32d64e5bad5f936631900818d88d700b6e609ca18c782f9ae70e79e5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers directory filepath
         haskell-src-exts mtl syb yaml
       ];
       executableHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts mtl strict syb yaml
       ];
       testHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts HUnit mtl syb test-framework test-framework-hunit
         yaml
       ];
       jailbreak = true;
       homepage = "https://github.com/jaspervdj/stylish-haskell";
       description = "Haskell code prettifier";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stylish-haskell_0_5_13_0" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cmdargs, containers
     , directory, filepath, haskell-src-exts, HUnit, mtl, strict, syb
     , test-framework, test-framework-hunit, yaml
     }:
     mkDerivation {
       pname = "stylish-haskell";
       version = "0.5.13.0";
       sha256 = "c884664613a28bd303c274c088cf21089d653cf54e9618c51c9b88691ee90489";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers directory filepath
         haskell-src-exts mtl syb yaml
       ];
       executableHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts mtl strict syb yaml
       ];
       testHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts HUnit mtl syb test-framework test-framework-hunit
         yaml
       ];
       jailbreak = true;
       homepage = "https://github.com/jaspervdj/stylish-haskell";
       description = "Haskell code prettifier";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stylish-haskell_0_5_14_0" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cmdargs, containers
     , directory, filepath, haskell-src-exts, HUnit, mtl, strict, syb
     , test-framework, test-framework-hunit, yaml
     }:
     mkDerivation {
       pname = "stylish-haskell";
       version = "0.5.14.0";
       sha256 = "c511e99c69e9ba27c257ee7442717fe93e7077ba84b912dc548db22182f20efd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers directory filepath
         haskell-src-exts mtl syb yaml
       ];
       executableHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts mtl strict syb yaml
       ];
       testHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts HUnit mtl syb test-framework test-framework-hunit
         yaml
       ];
       jailbreak = true;
       homepage = "https://github.com/jaspervdj/stylish-haskell";
       description = "Haskell code prettifier";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stylish-haskell_0_5_14_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cmdargs, containers
     , directory, filepath, haskell-src-exts, HUnit, mtl, strict, syb
     , test-framework, test-framework-hunit, yaml
     }:
     mkDerivation {
       pname = "stylish-haskell";
       version = "0.5.14.1";
       sha256 = "b2d0f8aa47c44309a427f5fb8cb2e125b8272f8eda0f2ffa0ca9a2121cdfb314";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers directory filepath
         haskell-src-exts mtl syb yaml
       ];
       executableHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts mtl strict syb yaml
       ];
       testHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts HUnit mtl syb test-framework test-framework-hunit
         yaml
       ];
       jailbreak = true;
       homepage = "https://github.com/jaspervdj/stylish-haskell";
       description = "Haskell code prettifier";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stylish-haskell_0_5_14_2" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cmdargs, containers
     , directory, filepath, haskell-src-exts, HUnit, mtl, strict, syb
     , test-framework, test-framework-hunit, yaml
     }:
     mkDerivation {
       pname = "stylish-haskell";
       version = "0.5.14.2";
       sha256 = "6f496aede4700d1a6ca343d3957d137a0a9c763436f155ca61a48474877eba30";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers directory filepath
         haskell-src-exts mtl syb yaml
       ];
       executableHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts mtl strict syb yaml
       ];
       testHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts HUnit mtl syb test-framework test-framework-hunit
         yaml
       ];
       jailbreak = true;
       homepage = "https://github.com/jaspervdj/stylish-haskell";
       description = "Haskell code prettifier";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stylish-haskell_0_5_14_3" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cmdargs, containers
     , directory, filepath, haskell-src-exts, HUnit, mtl, strict, syb
     , test-framework, test-framework-hunit, yaml
     }:
     mkDerivation {
       pname = "stylish-haskell";
       version = "0.5.14.3";
       sha256 = "a89d71b31c419f8b7b0befbcb766f0216cb58ce9a9761d916f5383f8c11b5eb1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers directory filepath
         haskell-src-exts mtl syb yaml
       ];
       executableHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts mtl strict syb yaml
       ];
       testHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts HUnit mtl syb test-framework test-framework-hunit
         yaml
       ];
       jailbreak = true;
       homepage = "https://github.com/jaspervdj/stylish-haskell";
       description = "Haskell code prettifier";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stylish-haskell_0_5_14_4" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cmdargs, containers
     , directory, filepath, haskell-src-exts, HUnit, mtl, strict, syb
     , test-framework, test-framework-hunit, yaml
     }:
     mkDerivation {
       pname = "stylish-haskell";
       version = "0.5.14.4";
       sha256 = "023da2a5911868e6f00344e45314c79b8593e29f1e4ed75a791953f4a1bf6676";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers directory filepath
         haskell-src-exts mtl syb yaml
       ];
       executableHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts mtl strict syb yaml
       ];
       testHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts HUnit mtl syb test-framework test-framework-hunit
         yaml
       ];
       homepage = "https://github.com/jaspervdj/stylish-haskell";
       description = "Haskell code prettifier";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "stylish-haskell" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cmdargs, containers
     , directory, filepath, haskell-src-exts, HUnit, mtl, strict, syb
     , test-framework, test-framework-hunit, yaml
     }:
     mkDerivation {
       pname = "stylish-haskell";
       version = "0.5.15.1";
       sha256 = "c7ff0fdf7a2e23b3c23dfd7b925ec29117a7d6d93fe1445f88d28b589802fee5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers directory filepath
         haskell-src-exts mtl syb yaml
       ];
       executableHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts mtl strict syb yaml
       ];
       testHaskellDepends = [
         aeson base bytestring cmdargs containers directory filepath
         haskell-src-exts HUnit mtl syb test-framework test-framework-hunit
         yaml
       ];
       homepage = "https://github.com/jaspervdj/stylish-haskell";
       description = "Haskell code prettifier";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "stylized" = callPackage
    ({ mkDerivation, ansi-terminal, base }:
     mkDerivation {
       pname = "stylized";
       version = "0.1.3";
       sha256 = "e41cce6f673123ca3b785d638d5e5563277ebdbc84642997d596ee812966ea25";
       libraryHaskellDepends = [ ansi-terminal base ];
       jailbreak = true;
       homepage = "http://patch-tag.com/r/lucid/Stylized";
       description = "Ways to output stylized text on ANSI consoles";
       license = "GPL";
     }) {};

  "sub-state" = callPackage
    ({ mkDerivation, base, mtl, QuickCheck, quickcheck-instances, sets
     , tasty, tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "sub-state";
       version = "0.0.0.1";
       sha256 = "970080595b22141e63563f4718515554bf3a59a0c7cfabe694285597468b6dde";
       libraryHaskellDepends = [ base mtl sets ];
       testHaskellDepends = [
         base QuickCheck quickcheck-instances tasty tasty-hunit
         tasty-quickcheck
       ];
       description = "Get the total, put a single element";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "subhask" = callPackage
    ({ mkDerivation, approximate, array, base, bloomfilter, bytes
     , bytestring, cassava, containers, deepseq, erf, gamma, ghc-prim
     , hmatrix, hyperloglog, lens, monad-primitive, MonadRandom, mtl
     , parallel, primitive, QuickCheck, semigroups, template-haskell
     , test-framework, test-framework-quickcheck2, vector
     }:
     mkDerivation {
       pname = "subhask";
       version = "0.1.1.0";
       sha256 = "c3e5a727ed988acb4c2a1083136be2faead19bef252345b12695d5050cddc791";
       libraryHaskellDepends = [
         approximate array base bloomfilter bytes bytestring cassava
         containers deepseq erf gamma ghc-prim hmatrix hyperloglog lens
         monad-primitive MonadRandom mtl parallel primitive QuickCheck
         semigroups template-haskell vector
       ];
       testHaskellDepends = [
         base test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://github.com/mikeizbicki/subhask";
       description = "Type safe interface for programming in subcategories of Hask";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "subleq-toolchain" = callPackage
    ({ mkDerivation, base, cmdargs, containers, lens, mtl, parsec
     , pretty, template-haskell
     }:
     mkDerivation {
       pname = "subleq-toolchain";
       version = "0.1.8.5";
       sha256 = "6a993ee41a0a4b55ee0f9bde633c092d656ee053c7e12fc97b82f42b2e1babc6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers lens mtl parsec pretty ];
       executableHaskellDepends = [
         base cmdargs containers lens mtl parsec pretty
       ];
       testHaskellDepends = [
         base containers lens mtl parsec pretty template-haskell
       ];
       jailbreak = true;
       description = "Toolchain of subleq computer";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "subnet" = callPackage
    ({ mkDerivation, base, split }:
     mkDerivation {
       pname = "subnet";
       version = "0.0.1.2";
       sha256 = "db262492bac9b1eeb81b8143f9f771ce77c9e2ebb7c83afa47bb43da1fd533a5";
       libraryHaskellDepends = [ base split ];
       homepage = "https://github.com/gcganley/subnet";
       description = "subnetting calculator";
       license = stdenv.lib.licenses.mit;
     }) {};

  "subtitleParser" = callPackage
    ({ mkDerivation, attoparsec, base, containers, text }:
     mkDerivation {
       pname = "subtitleParser";
       version = "0.5";
       sha256 = "78ec8a1af243b7465ed97c2be288c865ef81bbbf03732ab67de79c6dd73779ce";
       libraryHaskellDepends = [ attoparsec base containers text ];
       homepage = "https://patch-tag.com/r/rubenAst/subtitleParser/home";
       description = "A parser for .srt and .sub files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "subtitles" = callPackage
    ({ mkDerivation, base, split }:
     mkDerivation {
       pname = "subtitles";
       version = "0.0.1";
       sha256 = "94bd7635f99e70cd7aa5b0d344495c9609798497b60b0d72acb792683ee76c5f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base split ];
       description = "Modify SRT subtitle files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "success_0_2_4" = callPackage
    ({ mkDerivation, base, monad-control, mtl, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "success";
       version = "0.2.4";
       sha256 = "244ca46dd6b1a49ad765a36dcc1952c815ba12b33a2c3eb1c0c5e7ed1a2a3bf6";
       libraryHaskellDepends = [
         base monad-control mtl transformers transformers-base
       ];
       homepage = "https://github.com/nikita-volkov/success";
       description = "A version of Either specialised for encoding of success or failure";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "success_0_2_5" = callPackage
    ({ mkDerivation, base, monad-control, mtl, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "success";
       version = "0.2.5";
       sha256 = "d1548e0a685956ae0b568f89e9935af58ed6042fd5b850314b81e0a1efadabca";
       revision = "1";
       editedCabalFile = "0e3e195460c31e3cb90b992a36cfb7c39d5a7a5ac225cec3a45fb43aeb6a5580";
       libraryHaskellDepends = [
         base monad-control mtl transformers transformers-base
       ];
       homepage = "https://github.com/nikita-volkov/success";
       description = "A version of Either specialised for encoding of success or failure";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "success" = callPackage
    ({ mkDerivation, base, monad-control, mtl, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "success";
       version = "0.2.6";
       sha256 = "e995e77e8ae13bc4d543ea771f6a4d17853dea1ae46ef294131fc8c582f2dab6";
       libraryHaskellDepends = [
         base monad-control mtl transformers transformers-base
       ];
       homepage = "https://github.com/nikita-volkov/success";
       description = "A version of Either specialised for encoding of success or failure";
       license = stdenv.lib.licenses.mit;
     }) {};

  "suffixarray" = callPackage
    ({ mkDerivation, base, HUnit, vector }:
     mkDerivation {
       pname = "suffixarray";
       version = "0.0.3.1";
       sha256 = "174232b78466bb358a78f589a1946d54ee6c4438d4f7e16ac20d245fbef34271";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base vector ];
       executableHaskellDepends = [ base HUnit ];
       jailbreak = true;
       homepage = "https://github.com/VictorDenisov/suffixarray";
       description = "n log n implementation of suffix array";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "suffixtree" = callPackage
    ({ mkDerivation, base, bytestring, containers }:
     mkDerivation {
       pname = "suffixtree";
       version = "0.2.2.1";
       sha256 = "063b68cb37099294c57a933a212889ccce13c33e1be6f9d89789aa232e14b3b5";
       libraryHaskellDepends = [ base bytestring containers ];
       homepage = "https://github.com/bos/suffixtree";
       description = "Efficient, lazy suffix tree implementation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sugarhaskell" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "sugarhaskell";
       version = "0.1";
       sha256 = "b85e6ef0bcaa51e85d5360de717f9fc45ae9c87cc2f36ad381b10556ea649fc2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base process ];
       homepage = "http://sugarj.org";
       description = "Library-based syntactic extensibility for Haskell";
       license = "GPL";
     }) {};

  "suitable" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "suitable";
       version = "0.1.1";
       sha256 = "91bddb96f2e4996970c5b4e593f6904040af446a8f08e1e5131f64b7df3f7cdf";
       libraryHaskellDepends = [ base containers ];
       description = "Abstract over the constraints on the parameters to type constructors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sump" = callPackage
    ({ mkDerivation, base, bytestring, data-default, either, lens
     , serialport, transformers, vector
     }:
     mkDerivation {
       pname = "sump";
       version = "0.1.0.1";
       sha256 = "b7fa21630a6965fffd913280a7dd08a77a6e3f05b2bf04ad61c41ed601a0d1f7";
       libraryHaskellDepends = [
         base bytestring data-default either lens serialport transformers
         vector
       ];
       homepage = "http://github.com/bgamari/sump";
       description = "A Haskell interface to SUMP-compatible logic analyzers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sundown" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "sundown";
       version = "0.6";
       sha256 = "cb9b7e98138311375148ffe0fa4c4b04eb7a9f8ec2ae13a674d465e5d71db027";
       libraryHaskellDepends = [ base bytestring text ];
       homepage = "https://github.com/bitonic/sundown";
       description = "Bindings to the sundown markdown library";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "sunlight" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, directory, old-locale
     , process, random, time, tuple
     }:
     mkDerivation {
       pname = "sunlight";
       version = "0.6.0.0";
       sha256 = "bd94d7b2031e4c33218352f22184560142d3653736c46ee0b3e54b40767720e1";
       libraryHaskellDepends = [
         base bytestring Cabal directory old-locale process random time
         tuple
       ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/sunlight";
       description = "Test Cabalized package against multiple dependency versions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sunroof-compiler" = callPackage
    ({ mkDerivation, base, Boolean, containers, data-default
     , data-reify, mtl, operational, semigroups, tagged
     , template-haskell, transformers, vector-space
     }:
     mkDerivation {
       pname = "sunroof-compiler";
       version = "0.2";
       sha256 = "9f2162ac9a73cc395d8d0ddf0444dd7c44a540a4695830ddba76135d0a5703e4";
       libraryHaskellDepends = [
         base Boolean containers data-default data-reify mtl operational
         semigroups tagged template-haskell transformers vector-space
       ];
       jailbreak = true;
       homepage = "https://github.com/ku-fpg/sunroof-compiler";
       description = "Monadic Javascript Compiler";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sunroof-examples" = callPackage
    ({ mkDerivation, base, Boolean, containers, data-default, directory
     , filepath, parallel-io, process, QuickCheck, random, semigroups
     , shake, stm, sunroof-compiler, sunroof-server
     }:
     mkDerivation {
       pname = "sunroof-examples";
       version = "0.2.2";
       sha256 = "b3c839c832e29395fcb3761583b865f80fa244b140ce893b5b5305fc46549d2d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Boolean containers data-default directory filepath parallel-io
         process QuickCheck random semigroups shake stm sunroof-compiler
         sunroof-server
       ];
       jailbreak = true;
       homepage = "https://github.com/ku-fpg/sunroof-examples";
       description = "Tests for Sunroof";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sunroof-server" = callPackage
    ({ mkDerivation, aeson, base, containers, data-default, filepath
     , kansas-comet, scientific, scotty, semigroups, stm
     , sunroof-compiler, tagged, text, time, transformers
     , unordered-containers, vector, vector-space, wai-middleware-static
     , warp
     }:
     mkDerivation {
       pname = "sunroof-server";
       version = "0.2.1";
       sha256 = "a52132061d153266cef31ab128110516a724a0738a6ef6cd33ea7143d0f24c85";
       libraryHaskellDepends = [
         aeson base containers data-default filepath kansas-comet scientific
         scotty semigroups stm sunroof-compiler tagged text time
         transformers unordered-containers vector vector-space
         wai-middleware-static warp
       ];
       jailbreak = true;
       homepage = "https://github.com/ku-fpg/sunroof-server";
       description = "Monadic Javascript Compiler - Server Utilities";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "super-user-spark" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, binary, bytestring
     , directory, filepath, HTF, HUnit, mtl, optparse-applicative
     , parsec, process, shelly, text, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "super-user-spark";
       version = "0.2.0.3";
       sha256 = "0fa3189dcf517a50abab5b83eee5d706ea13cbaaa780e6d14fb38679d924beb7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson aeson-pretty base binary bytestring directory filepath HTF
         mtl optparse-applicative parsec process shelly text transformers
         unix zlib
       ];
       testHaskellDepends = [
         aeson aeson-pretty base binary bytestring directory filepath HTF
         HUnit mtl optparse-applicative parsec process shelly text
         transformers unix zlib
       ];
       jailbreak = true;
       description = "Configure your dotfile deployment with a DSL";
       license = stdenv.lib.licenses.mit;
     }) {};

  "supercollider-ht" = callPackage
    ({ mkDerivation, base, hosc, hsc3, opensoundcontrol-ht, process
     , random, transformers
     }:
     mkDerivation {
       pname = "supercollider-ht";
       version = "0.3";
       sha256 = "3cceb4e622bf1d6d7887cbefcd8d68e277c0d638de522276d4aa09db1cc316ed";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base hosc hsc3 opensoundcontrol-ht process random transformers
       ];
       homepage = "http://www.haskell.org/haskellwiki/SuperCollider";
       description = "Haskell SuperCollider utilities";
       license = "GPL";
     }) {};

  "supercollider-midi" = callPackage
    ({ mkDerivation, alsa-seq, array, base, containers, data-accessor
     , data-accessor-transformers, event-list, hosc, hsc3, midi
     , midi-alsa, non-negative, opensoundcontrol-ht, random
     , supercollider-ht, transformers, utility-ht
     }:
     mkDerivation {
       pname = "supercollider-midi";
       version = "0.2.1";
       sha256 = "13080add4d6df431da9856a4516a01799389aeb91e4ee256a390cb95483370d4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         alsa-seq array base containers data-accessor
         data-accessor-transformers event-list hosc hsc3 midi midi-alsa
         non-negative opensoundcontrol-ht random supercollider-ht
         transformers utility-ht
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/SuperCollider";
       description = "Demonstrate how to control SuperCollider via ALSA-MIDI";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "superdoc" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, filepath }:
     mkDerivation {
       pname = "superdoc";
       version = "0.1.2.2";
       sha256 = "ec9d79da2c20f55a426fcacac18563fe15762442a25bd460320ce01a2b6ce963";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers directory filepath
       ];
       executableHaskellDepends = [
         base Cabal containers directory filepath
       ];
       homepage = "http://www.mathstat.dal.ca/~selinger/superdoc/";
       description = "Additional documentation markup and Unicode support";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "supero" = callPackage
    ({ mkDerivation, base, containers, cpphs, directory, filepath
     , haskell-src-exts, mtl, process, time, uniplate
     }:
     mkDerivation {
       pname = "supero";
       version = "3.0";
       sha256 = "8ec38385db1d5cfd8e6aa716a3a80a5a013257dd1fd3a5a20c9f78a8f8b9d14a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers cpphs directory filepath haskell-src-exts mtl
         process time uniplate
       ];
       jailbreak = true;
       homepage = "http://community.haskell.org/~ndm/supero/";
       description = "A Supercompiler";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "supervisor" = callPackage
    ({ mkDerivation, base, containers, exceptions, monadloc, mtl }:
     mkDerivation {
       pname = "supervisor";
       version = "0.1.1.0";
       sha256 = "7da3d9453e1c5f4cf4560f07408249d462a8877f52a39f273443bc9850c5afbd";
       libraryHaskellDepends = [
         base containers exceptions monadloc mtl
       ];
       homepage = "http://github.com/agocorona/supervisor";
       description = "Control an internal monad execution for trace generation, backtrakcking, testing and other purposes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "suspend" = callPackage
    ({ mkDerivation, base, lifted-base, transformers-base }:
     mkDerivation {
       pname = "suspend";
       version = "0.2.0.0";
       sha256 = "2f4f5b64837e94859b75dd49b28cf77bc75d70d5ab4f9adacb46ada5da98f072";
       libraryHaskellDepends = [ base lifted-base transformers-base ];
       description = "Simple package that allows for long thread suspensions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "svg-builder" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, hashable, text
     , unordered-containers
     }:
     mkDerivation {
       pname = "svg-builder";
       version = "0.1.0.1";
       sha256 = "91c1a879e4b656355e9c843f29761a46dba6fd6c96c38a073dbb61b101923c9d";
       libraryHaskellDepends = [
         base blaze-builder bytestring hashable text unordered-containers
       ];
       homepage = "http://github.com/jeffreyrosenbluth/svg-builder.git";
       description = "DSL for building SVG";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "svg-tree_0_1_0_2" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , JuicyPixels, lens, linear, mtl, scientific, text, transformers
     , vector, xml
     }:
     mkDerivation {
       pname = "svg-tree";
       version = "0.1.0.2";
       sha256 = "454d9cf1ff7af6656e65a1186f86c68d2c7b62cae4b5247ae3894403ed05d8bb";
       libraryHaskellDepends = [
         attoparsec base bytestring containers JuicyPixels lens linear mtl
         scientific text transformers vector xml
       ];
       jailbreak = true;
       description = "SVG file loader and serializer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "svg-tree_0_1_1" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , JuicyPixels, lens, linear, mtl, scientific, text, transformers
     , vector, xml
     }:
     mkDerivation {
       pname = "svg-tree";
       version = "0.1.1";
       sha256 = "da19f16f0b5adfbec0ecaa68f4edc8963826200e8724b6cb1c80df2f013170a5";
       libraryHaskellDepends = [
         attoparsec base bytestring containers JuicyPixels lens linear mtl
         scientific text transformers vector xml
       ];
       jailbreak = true;
       description = "SVG file loader and serializer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "svg-tree_0_3_1" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , JuicyPixels, lens, linear, mtl, scientific, text, transformers
     , vector, xml
     }:
     mkDerivation {
       pname = "svg-tree";
       version = "0.3.1";
       sha256 = "8ca2837bc93bcd0bc538671cf23368fd3dad53fa8f98cb0da9e9126e453bd2ba";
       libraryHaskellDepends = [
         attoparsec base bytestring containers JuicyPixels lens linear mtl
         scientific text transformers vector xml
       ];
       description = "SVG file loader and serializer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "svg-tree_0_3_2" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , JuicyPixels, lens, linear, mtl, scientific, text, transformers
     , vector, xml
     }:
     mkDerivation {
       pname = "svg-tree";
       version = "0.3.2";
       sha256 = "b9fc42919351b5afd17cf8983e2cf8024edd3544efe92fe9ba26130d7d0d2d03";
       libraryHaskellDepends = [
         attoparsec base bytestring containers JuicyPixels lens linear mtl
         scientific text transformers vector xml
       ];
       description = "SVG file loader and serializer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "svg-tree" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , JuicyPixels, lens, linear, mtl, scientific, text, transformers
     , vector, xml
     }:
     mkDerivation {
       pname = "svg-tree";
       version = "0.4.1";
       sha256 = "eacdf66bad077c31d05979d82090dac7839a909d43e50876698d6c61eb0f7fe5";
       libraryHaskellDepends = [
         attoparsec base bytestring containers JuicyPixels lens linear mtl
         scientific text transformers vector xml
       ];
       description = "SVG file loader and serializer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "svg2q" = callPackage
    ({ mkDerivation, base, haskell98, language-c, pretty, svgutils, syb
     , xml
     }:
     mkDerivation {
       pname = "svg2q";
       version = "0.3.2";
       sha256 = "12ca1397fdcfdb6b9394513ec41b0b4a27ae61bb4b180dba7e745c4e6780702e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base haskell98 language-c pretty svgutils syb xml
       ];
       jailbreak = true;
       homepage = "http://www.informatik.uni-kiel.de/~jgr/svg2q";
       description = "Code generation tool for Quartz code from a SVG";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "svgcairo" = callPackage
    ({ mkDerivation, base, cairo, glib, gtk2hs-buildtools, librsvg, mtl
     , text
     }:
     mkDerivation {
       pname = "svgcairo";
       version = "0.13.0.4";
       sha256 = "a366bb2592d9bd398183eefc9407442cfeaddd5b39e9f898081c788c691126a6";
       libraryHaskellDepends = [ base cairo glib mtl text ];
       libraryPkgconfigDepends = [ librsvg ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the libsvg-cairo library";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) librsvg;};

  "svgutils" = callPackage
    ({ mkDerivation, base, filepath, xml }:
     mkDerivation {
       pname = "svgutils";
       version = "0.1";
       sha256 = "41bbc786e0b56de02d7fedb4dcb74a65c518f71a251c9fe1654d25c0028b358c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base xml ];
       executableHaskellDepends = [ base filepath xml ];
       jailbreak = true;
       homepage = "https://patch-tag.com/r/twistedsquare/svgutils/home";
       description = "Helper functions for dealing with SVG files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "svm" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "svm";
       version = "1.0.0.1";
       sha256 = "5fcfb822c620da4da5d9bf7c863c14acbf595f41ddc3e031ae1048743f0dd9a5";
       libraryHaskellDepends = [ array base ];
       homepage = "http://github.com/andrewdougherty/svm";
       description = "A support vector machine written in Haskell";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "svm-light-utils" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers }:
     mkDerivation {
       pname = "svm-light-utils";
       version = "0.1.3";
       sha256 = "fa5770c144c516485e409cc164cbc1e4f7dc5f1a32f41dd95356964c663e2e23";
       libraryHaskellDepends = [ attoparsec base bytestring containers ];
       homepage = "http://github.com/bgamari/svm-light-utils";
       description = "Parsers and formatters for the SVMlight input file format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "svm-simple" = callPackage
    ({ mkDerivation, base, binary, bindings-svm, bytestring, containers
     , deepseq, directory, monad-par, mwc-random, vector
     }:
     mkDerivation {
       pname = "svm-simple";
       version = "0.2.7.1";
       sha256 = "6da78972596a68d34fd67a51299f8a7f1159a2e6873647ee6026ab003cad491f";
       libraryHaskellDepends = [
         base binary bindings-svm bytestring containers deepseq directory
         monad-par mwc-random vector
       ];
       jailbreak = true;
       homepage = "http://github.com/aleator/Simple-SVM";
       description = "Medium level, simplified, bindings to libsvm";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "svndump" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , directory, doctest, filepath, old-locale, text, time, zlib
     }:
     mkDerivation {
       pname = "svndump";
       version = "0.4.5";
       sha256 = "974f585c26837e00f16c5d842002a23d956e41342ff0115c53baaa98937dca54";
       libraryHaskellDepends = [
         attoparsec base bytestring containers filepath old-locale text time
       ];
       testHaskellDepends = [
         attoparsec base bytestring directory doctest filepath zlib
       ];
       homepage = "http://github.com/jwiegley/svndump/";
       description = "Library for reading Subversion dump files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "swagger" = callPackage
    ({ mkDerivation, aeson, base, bytestring, tasty, tasty-hunit, text
     , time, transformers
     }:
     mkDerivation {
       pname = "swagger";
       version = "0.2.2";
       sha256 = "19ffcf443fd03a87258fb4b3225166315d0fd835a7539ea70d7992619329ecc2";
       libraryHaskellDepends = [
         aeson base bytestring text time transformers
       ];
       testHaskellDepends = [ aeson base bytestring tasty tasty-hunit ];
       description = "Implementation of swagger data model";
       license = "unknown";
     }) {};

  "swagger2_1_1_1" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, containers, doctest, Glob
     , hashable, hspec, http-media, HUnit, lens, mtl, network
     , QuickCheck, scientific, text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "swagger2";
       version = "1.1.1";
       sha256 = "bb441e8c160db9fe91ff62cc14b36ecfce683cd033a61aef7700acf763a526aa";
       revision = "1";
       editedCabalFile = "ac0b019958af896baba1453da3cf22b5437c0bfc23052a4ed8834180f01afcc8";
       libraryHaskellDepends = [
         aeson base containers hashable http-media lens mtl network
         scientific text time unordered-containers
       ];
       testHaskellDepends = [
         aeson aeson-qq base containers doctest Glob hspec HUnit lens
         QuickCheck text unordered-containers vector
       ];
       homepage = "https://github.com/GetShopTV/swagger2";
       description = "Swagger 2.0 data model";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "swagger2_1_2_1" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, containers, doctest, Glob
     , hashable, hspec, http-media, HUnit, lens, mtl, network
     , QuickCheck, scientific, text, time, unordered-containers, vector
     }:
     mkDerivation {
       pname = "swagger2";
       version = "1.2.1";
       sha256 = "4eba65057202562d1f57bb10dad930f4cf6e4521c414005afb83213b3901d6d9";
       revision = "1";
       editedCabalFile = "dbbae6a2ff27fd977d013d56cc36c4fef7f089cb8f88965b4c6c6ec22b50bebd";
       libraryHaskellDepends = [
         aeson base containers hashable http-media lens mtl network
         scientific text time unordered-containers
       ];
       testHaskellDepends = [
         aeson aeson-qq base containers doctest Glob hspec HUnit lens
         QuickCheck text unordered-containers vector
       ];
       homepage = "https://github.com/GetShopTV/swagger2";
       description = "Swagger 2.0 data model";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "swagger2" = callPackage
    ({ mkDerivation, aeson, aeson-qq, base, base-compat, containers
     , doctest, Glob, hashable, hspec, http-media, HUnit, lens, mtl
     , network, QuickCheck, scientific, template-haskell, text, time
     , transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "swagger2";
       version = "2.0.1";
       sha256 = "ff8c3a195ff7689ba027d7caecd9b20505529ecc4962ddb7503b5130aa815898";
       libraryHaskellDepends = [
         aeson base base-compat containers hashable http-media lens mtl
         network scientific template-haskell text time transformers
         unordered-containers vector
       ];
       testHaskellDepends = [
         aeson aeson-qq base base-compat containers doctest Glob hashable
         hspec HUnit lens mtl QuickCheck text time unordered-containers
         vector
       ];
       homepage = "https://github.com/GetShopTV/swagger2";
       description = "Swagger 2.0 data model";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "swapper" = callPackage
    ({ mkDerivation, base, binary, bytestring, deepseq, happstack-data
     , happstack-state, parallel, tokyocabinet
     }:
     mkDerivation {
       pname = "swapper";
       version = "0.1";
       sha256 = "d48008fa9c473dffcb6b18438216f4af019dc911ac87cf425096ef7b36332f29";
       libraryHaskellDepends = [
         base binary bytestring deepseq happstack-data happstack-state
         parallel
       ];
       librarySystemDepends = [ tokyocabinet ];
       homepage = "http://github.com/roman-smrz/swapper/";
       description = "Transparently swapping data from in-memory structures to disk";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) tokyocabinet;};

  "swearjure" = callPackage
    ({ mkDerivation, attoparsec, base, containers, fixplate, mtl
     , pretty, random, random-shuffle, readline, system-fileio
     , system-filepath, text
     }:
     mkDerivation {
       pname = "swearjure";
       version = "1.0.0";
       sha256 = "380abd5c62873cd1affe39ffa03d480c940e1b8fd6ec3d8fce664fbed4c07d3c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base containers fixplate mtl pretty random
         random-shuffle readline system-fileio system-filepath text
       ];
       jailbreak = true;
       homepage = "http://www.swearjure.com";
       description = "Clojure without alphanumerics";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "swf" = callPackage
    ({ mkDerivation, base, mtl, pretty }:
     mkDerivation {
       pname = "swf";
       version = "1.0.1";
       sha256 = "3487d73b39d2db481daf36a91443ac94762abac8a19effee27fca4350349a5cb";
       libraryHaskellDepends = [ base mtl pretty ];
       homepage = "http://www.n-heptane.com/nhlab";
       description = "A library for creating Shockwave Flash (SWF) files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "swift-lda" = callPackage
    ({ mkDerivation, array, base, containers, ghc-prim, mwc-random
     , primitive, vector
     }:
     mkDerivation {
       pname = "swift-lda";
       version = "0.7.0.0";
       sha256 = "3851b9693448750bdaf8307bf2dff9649989a67f1c1a1294d94bc989f6915b32";
       libraryHaskellDepends = [
         array base containers ghc-prim mwc-random primitive vector
       ];
       homepage = "https://bitbucket.org/gchrupala/colada";
       description = "Online sampler for Latent Dirichlet Allocation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "swish" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, hashable
     , HUnit, intern, mtl, network-uri, old-locale, polyparse
     , semigroups, test-framework, test-framework-hunit, text, time
     }:
     mkDerivation {
       pname = "swish";
       version = "0.9.1.7";
       sha256 = "f816c8e7e6b264043ac7d6d8572e74aedbf3c455907fc6ab6d077d2f47893b80";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory filepath hashable intern mtl network-uri
         old-locale polyparse semigroups text time
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base containers hashable HUnit network-uri old-locale semigroups
         test-framework test-framework-hunit text time
       ];
       homepage = "https://bitbucket.org/doug_burke/swish/wiki/Home";
       description = "A semantic web toolkit";
       license = "LGPL";
     }) {};

  "sws" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring
     , crypto-pubkey, crypto-random, directory, filepath, hourglass
     , http-types, network, pem, resourcet, transformers, wai, wai-extra
     , wai-middleware-static, warp, warp-tls, x509
     }:
     mkDerivation {
       pname = "sws";
       version = "0.3.1.2";
       sha256 = "e86be4df4f505f7f6eab69957ae3843455fbce9e13dd211ee65cff034449240c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         asn1-encoding asn1-types base bytestring crypto-pubkey
         crypto-random directory filepath hourglass http-types network pem
         resourcet transformers wai wai-extra wai-middleware-static warp
         warp-tls x509
       ];
       jailbreak = true;
       description = "A simple web server for serving directories, similar to weborf";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "syb_0_4_2" = callPackage
    ({ mkDerivation, base, containers, HUnit, mtl }:
     mkDerivation {
       pname = "syb";
       version = "0.4.2";
       sha256 = "142d71c9c655f9cd43d9e17f28232b95bccd1f36b1a77b39113732b69ee07ebf";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base containers HUnit mtl ];
       homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/SYB";
       description = "Scrap Your Boilerplate";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "syb_0_4_3" = callPackage
    ({ mkDerivation, base, containers, HUnit, mtl }:
     mkDerivation {
       pname = "syb";
       version = "0.4.3";
       sha256 = "749ff49197c75d3d182f9d5e6043c0ec2325476b7792245630f6578edf490e35";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base containers HUnit mtl ];
       homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/SYB";
       description = "Scrap Your Boilerplate";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "syb_0_4_4" = callPackage
    ({ mkDerivation, base, containers, HUnit, mtl }:
     mkDerivation {
       pname = "syb";
       version = "0.4.4";
       sha256 = "0610677803931a3355aae00fdd13145f80e26d7dee08e1ba5bc9b2edea4c4c87";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base containers HUnit mtl ];
       homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/SYB";
       description = "Scrap Your Boilerplate";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "syb_0_5_1" = callPackage
    ({ mkDerivation, base, containers, HUnit, mtl }:
     mkDerivation {
       pname = "syb";
       version = "0.5.1";
       sha256 = "81b05f0e78d03e1cabe9610a6045a5ae74d88eaed7e79464d436ccaa6af93846";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base containers HUnit mtl ];
       doCheck = false;
       homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/SYB";
       description = "Scrap Your Boilerplate";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "syb" = callPackage
    ({ mkDerivation, base, containers, HUnit, mtl }:
     mkDerivation {
       pname = "syb";
       version = "0.6";
       sha256 = "a38d1f7e6a40e2c990fec85215c45063a508bf73df98a4483ec78c5025b66cdc";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base containers HUnit mtl ];
       doCheck = false;
       homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/SYB";
       description = "Scrap Your Boilerplate";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "syb-extras" = callPackage
    ({ mkDerivation, base, eq, prelude-extras }:
     mkDerivation {
       pname = "syb-extras";
       version = "0.3";
       sha256 = "a90b1ccb9909a42568ac5cf002a757eb40854d281b8acbb62df6b8e0e61926d0";
       libraryHaskellDepends = [ base eq prelude-extras ];
       homepage = "http://github.com/ekmett/syb-extras/";
       description = "Higher order versions of the Scrap Your Boilerplate classes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "syb-with-class_0_6_1_5" = callPackage
    ({ mkDerivation, array, base, bytestring, containers
     , template-haskell
     }:
     mkDerivation {
       pname = "syb-with-class";
       version = "0.6.1.5";
       sha256 = "f617ee2dc6f2b0ad35e130c50500a2f67fe76b94df86b7ce5cfb2d2545bac4be";
       libraryHaskellDepends = [
         array base bytestring containers template-haskell
       ];
       jailbreak = true;
       description = "Scrap Your Boilerplate With Class";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "syb-with-class" = callPackage
    ({ mkDerivation, array, base, bytestring, containers
     , template-haskell
     }:
     mkDerivation {
       pname = "syb-with-class";
       version = "0.6.1.6";
       sha256 = "565c909dcf39c30c7fa2b5721e5d1049dbc9cdcd23e63645f69d8e245e84c1b0";
       revision = "1";
       editedCabalFile = "e894d322dfc9c36c33058bfcbecbe6d36e620556a9713108b008120f7981cd7c";
       libraryHaskellDepends = [
         array base bytestring containers template-haskell
       ];
       description = "Scrap Your Boilerplate With Class";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "syb-with-class-instances-text" = callPackage
    ({ mkDerivation, base, syb-with-class, text }:
     mkDerivation {
       pname = "syb-with-class-instances-text";
       version = "0.0.1";
       sha256 = "0e0aa90c02cbe76380274830be51e04cb3cc13d5ea5761ba5540779bd0c4d76e";
       libraryHaskellDepends = [ base syb-with-class text ];
       description = "Scrap Your Boilerplate With Class Text instance";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sylvia" = callPackage
    ({ mkDerivation, base, cairo, comonad-transformers, data-default
     , data-lens, data-lens-template, gtk, optparse-applicative, parsec
     , smallcheck, test-framework, test-framework-smallcheck
     , transformers, void
     }:
     mkDerivation {
       pname = "sylvia";
       version = "0.2.2";
       sha256 = "533c4c671432792d7d229fd9b9b51cceffc89e93d4ce79bfbd7308f3a6935bfa";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cairo comonad-transformers data-default data-lens
         data-lens-template gtk optparse-applicative parsec transformers
         void
       ];
       testHaskellDepends = [
         base parsec smallcheck test-framework test-framework-smallcheck
         void
       ];
       jailbreak = true;
       homepage = "https://github.com/lfairy/sylvia";
       description = "Lambda calculus visualization";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sym" = callPackage
    ({ mkDerivation, array, base, containers, hashable, QuickCheck }:
     mkDerivation {
       pname = "sym";
       version = "0.11.1";
       sha256 = "7255fa58097cd3d3a057760a8e922b5fabdd8ad2e4070a1d383b1c2f68f01c90";
       libraryHaskellDepends = [
         array base containers hashable QuickCheck
       ];
       homepage = "https://github.com/akc/sym";
       description = "Permutations, patterns, and statistics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sym-plot" = callPackage
    ({ mkDerivation, base, diagrams-cairo, diagrams-lib, sym }:
     mkDerivation {
       pname = "sym-plot";
       version = "0.2.0";
       sha256 = "e292042fe408db1ca1ca3775c5df05a1dec709120b4047d42d7afb3698890605";
       libraryHaskellDepends = [ base diagrams-cairo diagrams-lib sym ];
       jailbreak = true;
       homepage = "http://github.com/akc/sym-plot";
       description = "Plot permutations; an addition to the sym package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "symbol" = callPackage
    ({ mkDerivation, base, containers, deepseq }:
     mkDerivation {
       pname = "symbol";
       version = "0.2.4";
       sha256 = "d074a7741f6ce0f2a604e4467c1c46e1acc2b707db107b3458395e646a9b8831";
       revision = "1";
       editedCabalFile = "452caa71d01d9f17eb4f3e9c5ae94c9210ae67af1ff5f4b6e308290980394b05";
       libraryHaskellDepends = [ base containers deepseq ];
       homepage = "http://www.cs.drexel.edu/~mainland/";
       description = "A 'Symbol' type for fast symbol comparison";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "sync" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "sync";
       version = "0.1";
       sha256 = "932a9ffc30663f48f9a1fc068c4de6c61b0c7f337e8a7e789151d61f776c8281";
       libraryHaskellDepends = [ base stm ];
       description = "A fast implementation of synchronous channels with a CML-like API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sync-mht" = callPackage
    ({ mkDerivation, array, base, base16-bytestring, byteable, bytes
     , bytestring, cereal, containers, cryptohash, directory, exceptions
     , filepath, HUnit, io-streams, mtl, process, random, regex-compat
     , temporary, text, time, transformers, unix, zlib
     }:
     mkDerivation {
       pname = "sync-mht";
       version = "0.3.8.4";
       sha256 = "f276fac5a403f84dc4d1e75dfe257f3cc9b4c69f03803cd1c5654820a3035138";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base base16-bytestring byteable bytes bytestring cereal
         containers cryptohash directory exceptions filepath HUnit
         io-streams mtl process random regex-compat temporary text time
         transformers unix zlib
       ];
       executableHaskellDepends = [
         array base base16-bytestring byteable bytes bytestring cereal
         containers cryptohash directory exceptions filepath HUnit
         io-streams mtl process random regex-compat temporary text time
         transformers unix zlib
       ];
       testHaskellDepends = [
         array base base16-bytestring byteable bytes bytestring cereal
         containers cryptohash directory exceptions filepath HUnit
         io-streams mtl process random regex-compat temporary text time
         transformers unix zlib
       ];
       homepage = "https://github.com/ekarayel/sync-mht";
       description = "Fast incremental file transfer using Merkle-Hash-Trees";
       license = stdenv.lib.licenses.mit;
     }) {};

  "synchronous-channels" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "synchronous-channels";
       version = "0.2";
       sha256 = "6b3716eec9955a6da08354be583e5cdb921347ede69e3d4a890dd7010796f777";
       libraryHaskellDepends = [ base ];
       description = "Synchronous communication channels";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "syncthing-hs" = callPackage
    ({ mkDerivation, aeson, base, bytestring, connection, containers
     , data-default, derive, either, exceptions, http-client
     , http-client-tls, http-types, lens, quickcheck-instances
     , regex-posix, scientific, tasty, tasty-hunit, tasty-quickcheck
     , text, time, time-locale-compat, transformers
     , unordered-containers, vector, wreq
     }:
     mkDerivation {
       pname = "syncthing-hs";
       version = "0.3.0.0";
       sha256 = "19092366152c052b29e1de7acdd6b6494dbbca7efdebac996431d6e172635655";
       libraryHaskellDepends = [
         aeson base bytestring connection containers either exceptions
         http-client http-client-tls lens regex-posix text time
         time-locale-compat transformers unordered-containers vector wreq
       ];
       testHaskellDepends = [
         aeson base bytestring containers data-default derive either
         exceptions http-client http-types lens quickcheck-instances
         scientific tasty tasty-hunit tasty-quickcheck text transformers
         vector wreq
       ];
       homepage = "https://github.com/jetho/syncthing-hs";
       description = "Haskell bindings for the Syncthing REST API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "synt" = callPackage
    ({ mkDerivation, argparser, base, haskell-src-exts, hpc, hspec
     , regexpr, split, Synt
     }:
     mkDerivation {
       pname = "synt";
       version = "0.1.2";
       sha256 = "bb6c62669e1b2c83854989809375fb99761bf06262428e341195ed80168da989";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         argparser base haskell-src-exts regexpr split
       ];
       executableHaskellDepends = [
         argparser base haskell-src-exts regexpr split
       ];
       testHaskellDepends = [
         argparser base haskell-src-exts hpc hspec regexpr split Synt
       ];
       jailbreak = true;
       homepage = "http://github.com/brentlintner/synt";
       description = "Similar code analysis";
       license = "unknown";
       broken = true;
     }) {Synt = null;};

  "syntactic" = callPackage
    ({ mkDerivation, base, constraints, containers, data-hash, deepseq
     , mtl, QuickCheck, syb, tagged, tasty, tasty-golden
     , tasty-quickcheck, tasty-th, template-haskell, tree-view
     , utf8-string
     }:
     mkDerivation {
       pname = "syntactic";
       version = "3.4";
       sha256 = "93490ba1c33c4580187f6bf739ce43bae9dce3abee539deffc6d351769111a6e";
       libraryHaskellDepends = [
         base constraints containers data-hash deepseq mtl syb
         template-haskell tree-view
       ];
       testHaskellDepends = [
         base containers mtl QuickCheck tagged tasty tasty-golden
         tasty-quickcheck tasty-th utf8-string
       ];
       homepage = "https://github.com/emilaxelsson/syntactic";
       description = "Generic representation and manipulation of abstract syntax";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "syntactical" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "syntactical";
       version = "0.1";
       sha256 = "fc8d770e1afc1090841ac5e27f36412fd2d6e4b8eb2188848295d456b3aa16eb";
       libraryHaskellDepends = [ base ];
       description = "Distfix expression parsing library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "syntax" = callPackage
    ({ mkDerivation, base, lens, mono-traversable, scientific, semi-iso
     , text, vector
     }:
     mkDerivation {
       pname = "syntax";
       version = "1.0.0.0";
       sha256 = "fd548debb4f442bc23f24389c0d2d89f72fbe5fed061a62c94eed21fdcfa0bb6";
       revision = "2";
       editedCabalFile = "3959bcb0cea2f2e1d1bf643306962551f6888b0db888beb632477c7929e6966d";
       libraryHaskellDepends = [
         base lens mono-traversable scientific semi-iso text vector
       ];
       description = "Reversible parsing and pretty-printing";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "syntax-attoparsec" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, scientific, semi-iso
     , syntax, text, vector
     }:
     mkDerivation {
       pname = "syntax-attoparsec";
       version = "1.0.0.0";
       sha256 = "111239aded792af5e2a29e11e028645e862cda4f3985ef135cc7247dd89ff1f9";
       libraryHaskellDepends = [
         attoparsec base bytestring scientific semi-iso syntax text vector
       ];
       description = "Syntax instances for Attoparsec";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "syntax-example" = callPackage
    ({ mkDerivation, attoparsec, base, lens, scientific, semi-iso
     , syntax, syntax-attoparsec, syntax-printer, text
     }:
     mkDerivation {
       pname = "syntax-example";
       version = "1.0.0.0";
       sha256 = "59d213b6b2d2e1642ddbc3e87915145c8b720f4706937a234b213f46ed55eeeb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base lens scientific semi-iso syntax syntax-attoparsec
         syntax-printer text
       ];
       description = "Example application using syntax, a library for abstract syntax descriptions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "syntax-example-json" = callPackage
    ({ mkDerivation, attoparsec, base, containers, lens, scientific
     , semi-iso, syntax, syntax-attoparsec, syntax-printer, text
     }:
     mkDerivation {
       pname = "syntax-example-json";
       version = "1.0.0.0";
       sha256 = "35f206946d69149e36b55d931fff0bf48e9d42bda1113a9fc8b2cc7c9217fbad";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base containers lens scientific semi-iso syntax
         syntax-attoparsec syntax-printer text
       ];
       description = "Example JSON parser/pretty-printer";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "syntax-pretty" = callPackage
    ({ mkDerivation, base, pretty, scientific, semi-iso, syntax, text
     }:
     mkDerivation {
       pname = "syntax-pretty";
       version = "0.2.0.0";
       sha256 = "aefe3304aed29b756de90d43c4771eff7f156b4e1f16c063b37251945203dbb7";
       libraryHaskellDepends = [
         base pretty scientific semi-iso syntax text
       ];
       description = "Syntax instance for pretty, the pretty printing library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "syntax-printer" = callPackage
    ({ mkDerivation, base, bifunctors, bytestring, scientific, semi-iso
     , semigroupoids, syntax, text, vector
     }:
     mkDerivation {
       pname = "syntax-printer";
       version = "1.0.0.0";
       sha256 = "1f2f6dbe63402927a63054fe5cbd6950f883c85916112ad195353f9c649f2f14";
       libraryHaskellDepends = [
         base bifunctors bytestring scientific semi-iso semigroupoids syntax
         text vector
       ];
       jailbreak = true;
       description = "Text and ByteString printers for 'syntax'";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "syntax-trees" = callPackage
    ({ mkDerivation, base, haskell-src-exts, hint, mtl
     , template-haskell, uniplate
     }:
     mkDerivation {
       pname = "syntax-trees";
       version = "0.1.2";
       sha256 = "4ba73b48fc3c37fb25f1e6377346816c18ee72534701da10371bb54171548fa6";
       libraryHaskellDepends = [
         base haskell-src-exts hint mtl template-haskell uniplate
       ];
       description = "Convert between different Haskell syntax trees";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "syntax-trees-fork-bairyn" = callPackage
    ({ mkDerivation, base, haskell-src-exts, hint, mtl
     , template-haskell, uniplate
     }:
     mkDerivation {
       pname = "syntax-trees-fork-bairyn";
       version = "0.1.2.5";
       sha256 = "e6e1ed2c006d70f57fce70ff03bda431a9c5ba8c866803b3eff016fa494593d8";
       libraryHaskellDepends = [
         base haskell-src-exts hint mtl template-haskell uniplate
       ];
       description = "Convert between different Haskell syntax trees. Bairyn's fork.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "synthesizer" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, event-list, filepath, gnuplot, non-negative
     , numeric-prelude, numeric-quest, old-time, process, QuickCheck
     , random, sox, storable-record, storablevector, transformers
     , utility-ht
     }:
     mkDerivation {
       pname = "synthesizer";
       version = "0.2.0.1";
       sha256 = "6dfc0790c370fe8743052ee4ead7eb341d8ac44b126cc7911241a01e0c38b9d8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers event-list filepath gnuplot
         non-negative numeric-prelude numeric-quest process QuickCheck
         random sox storable-record storablevector transformers utility-ht
       ];
       executableHaskellDepends = [ directory old-time ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Synthesizer";
       description = "Audio signal processing coded in Haskell";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "synthesizer-alsa" = callPackage
    ({ mkDerivation, alsa-core, alsa-pcm, alsa-seq, base, event-list
     , midi, midi-alsa, non-negative, numeric-prelude, old-time, random
     , sox, storablevector, synthesizer-core, synthesizer-dimensional
     , synthesizer-midi, transformers, utility-ht
     }:
     mkDerivation {
       pname = "synthesizer-alsa";
       version = "0.5.0.2";
       sha256 = "c3db1a0d422a7348b4dbbae321faba688b564460b9901bd2f85de2dc28b4904c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         alsa-core alsa-pcm alsa-seq base event-list midi midi-alsa
         non-negative numeric-prelude old-time random sox storablevector
         synthesizer-core synthesizer-dimensional synthesizer-midi
         transformers utility-ht
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Synthesizer";
       description = "Control synthesizer effects via ALSA/MIDI";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "synthesizer-core" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , deepseq, event-list, explicit-exception, filepath, non-empty
     , non-negative, numeric-prelude, numeric-quest, process, QuickCheck
     , random, sample-frame-np, sox, storable-record, storable-tuple
     , storablevector, stream-fusion, transformers, utility-ht
     }:
     mkDerivation {
       pname = "synthesizer-core";
       version = "0.7.1";
       sha256 = "ee4f7d803ee743dc97c0d6abe61d4d75c702a2faa7edc1a9582d289824916d40";
       libraryHaskellDepends = [
         array base binary bytestring containers deepseq event-list
         explicit-exception filepath non-empty non-negative numeric-prelude
         numeric-quest process QuickCheck random sample-frame-np sox
         storable-record storable-tuple storablevector stream-fusion
         transformers utility-ht
       ];
       testHaskellDepends = [
         base containers event-list non-empty non-negative numeric-prelude
         QuickCheck random storable-tuple storablevector utility-ht
       ];
       homepage = "http://www.haskell.org/haskellwiki/Synthesizer";
       description = "Audio signal processing coded in Haskell: Low level part";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "synthesizer-dimensional" = callPackage
    ({ mkDerivation, base, bytestring, event-list, non-negative
     , numeric-prelude, random, sox, storable-record, storablevector
     , synthesizer-core, transformers, utility-ht
     }:
     mkDerivation {
       pname = "synthesizer-dimensional";
       version = "0.7.0.2";
       sha256 = "ebef455e1c0e188b55cbb15f5d88f933303b184ab1aae2b62016e8773fb572f8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring event-list non-negative numeric-prelude random sox
         storable-record storablevector synthesizer-core transformers
         utility-ht
       ];
       homepage = "http://www.haskell.org/haskellwiki/Synthesizer";
       description = "Audio signal processing with static physical dimensions";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "synthesizer-filter" = callPackage
    ({ mkDerivation, base, containers, numeric-prelude, numeric-quest
     , synthesizer-core, transformers, utility-ht
     }:
     mkDerivation {
       pname = "synthesizer-filter";
       version = "0.4.0.1";
       sha256 = "eed6f280d102a5d0e161796de9ba60198a6733441f6c2adee62829b76b43c161";
       libraryHaskellDepends = [
         base containers numeric-prelude numeric-quest synthesizer-core
         transformers utility-ht
       ];
       homepage = "http://www.haskell.org/haskellwiki/Synthesizer";
       description = "Audio signal processing coded in Haskell: Filter networks";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "synthesizer-inference" = callPackage
    ({ mkDerivation, base, event-list, non-negative, numeric-prelude
     , random, synthesizer-core, transformers, UniqueLogicNP, utility-ht
     }:
     mkDerivation {
       pname = "synthesizer-inference";
       version = "0.2";
       sha256 = "2ba794a3c1331a8f5c6e7927c6a4f06ea389d1692d1bac4cdf14e63d4e6b501e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base event-list non-negative numeric-prelude random
         synthesizer-core transformers UniqueLogicNP utility-ht
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Synthesizer";
       description = "Audio signal processing with dynamic physical dimensions";
       license = "GPL";
       broken = true;
     }) {UniqueLogicNP = null;};

  "synthesizer-llvm" = callPackage
    ({ mkDerivation, base, containers, event-list, filepath, llvm-extra
     , llvm-tf, midi, non-empty, non-negative, numeric-prelude
     , QuickCheck, random, sox, storable-record, storable-tuple
     , storablevector, synthesizer-core, synthesizer-midi, tfp
     , transformers, unsafe, utility-ht, vault
     }:
     mkDerivation {
       pname = "synthesizer-llvm";
       version = "0.7.0.1";
       sha256 = "626e02e30dcb6e197dc01265d3a7637057623af53e9f4d25b66158e478d3bf12";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers event-list filepath llvm-extra llvm-tf midi
         non-empty non-negative numeric-prelude random sox storable-record
         storable-tuple storablevector synthesizer-core synthesizer-midi tfp
         transformers unsafe utility-ht vault
       ];
       testHaskellDepends = [
         base llvm-extra llvm-tf numeric-prelude QuickCheck random
         storablevector synthesizer-core tfp utility-ht
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Synthesizer";
       description = "Efficient signal processing using runtime compilation";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "synthesizer-midi" = callPackage
    ({ mkDerivation, array, base, containers, data-accessor
     , data-accessor-transformers, deepseq, event-list, midi
     , non-negative, numeric-prelude, sox, storable-record
     , storablevector, synthesizer-core, synthesizer-dimensional
     , transformers, utility-ht
     }:
     mkDerivation {
       pname = "synthesizer-midi";
       version = "0.6.0.2";
       sha256 = "5dc040c8315bafb042e3efaec5caea4c10a97eef12527a61e6b75b81e0934e77";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers data-accessor data-accessor-transformers
         deepseq event-list midi non-negative numeric-prelude sox
         storable-record storablevector synthesizer-core
         synthesizer-dimensional transformers utility-ht
       ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Synthesizer";
       description = "Render audio signals from MIDI files or realtime messages";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "sys-auth-smbclient" = callPackage
    ({ mkDerivation, base, doctest, process, text }:
     mkDerivation {
       pname = "sys-auth-smbclient";
       version = "2.0.0.0";
       sha256 = "675571e74e9250d6331691b26fd5a7ecb375abaa29a70b36a8a859dd91d64102";
       libraryHaskellDepends = [ base process text ];
       testHaskellDepends = [ base doctest ];
       homepage = "https://github.com/kkazuo/sys-auth-smbclient";
       description = "Auth with smbclient command";
       license = stdenv.lib.licenses.mit;
     }) {};

  "sys-process" = callPackage
    ({ mkDerivation, base, bifunctors, directory, doctest, filepath
     , lens, mtl, notzero, process, QuickCheck, semigroupoids
     , semigroups, template-haskell, transformers
     }:
     mkDerivation {
       pname = "sys-process";
       version = "0.1.6";
       sha256 = "7838161f0acc22acdfcce3282e68be586c8833ec7c96e424471d07c3e6aac611";
       libraryHaskellDepends = [
         base bifunctors directory filepath lens mtl notzero process
         semigroupoids semigroups transformers
       ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck template-haskell
       ];
       homepage = "https://github.com/NICTA/sys-process";
       description = "A replacement for System.Exit and System.Process.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "system-argv0" = callPackage
    ({ mkDerivation, base, bytestring, system-filepath, text }:
     mkDerivation {
       pname = "system-argv0";
       version = "0.1.1";
       sha256 = "6d51da9d2157be14a83f8dca3e9d4196d420e667cd685effb8d7b39185cf4ec6";
       libraryHaskellDepends = [ base bytestring system-filepath text ];
       homepage = "https://john-millikin.com/software/haskell-filesystem/";
       description = "Get argv[0] as a FilePath";
       license = stdenv.lib.licenses.mit;
     }) {};

  "system-canonicalpath_0_2_0_0" = callPackage
    ({ mkDerivation, base, basic-prelude, directory, system-filepath
     , text
     }:
     mkDerivation {
       pname = "system-canonicalpath";
       version = "0.2.0.0";
       sha256 = "69faf8e9b3ee36cea8df48bdb9937516920a96a2919407b71192b2d121731f8c";
       libraryHaskellDepends = [
         base basic-prelude directory system-filepath text
       ];
       jailbreak = true;
       homepage = "https://github.com/d12frosted/CanonicalPath";
       description = "Abstract data type for canonical paths with pretty operations";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "system-canonicalpath_0_2_3_0" = callPackage
    ({ mkDerivation, base, basic-prelude, directory, system-filepath
     , text
     }:
     mkDerivation {
       pname = "system-canonicalpath";
       version = "0.2.3.0";
       sha256 = "9f79a12a4162df3857c92e1ec7359e2b724360a8655329f4bc40cdd4e4f2fb09";
       libraryHaskellDepends = [
         base basic-prelude directory system-filepath text
       ];
       homepage = "https://github.com/d12frosted/CanonicalPath";
       description = "Abstract data type for canonical paths with pretty operations";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "system-canonicalpath" = callPackage
    ({ mkDerivation, base, basic-prelude, chell, directory
     , system-filepath, text
     }:
     mkDerivation {
       pname = "system-canonicalpath";
       version = "0.3.2.0";
       sha256 = "5ec27fcfe64750e9bd5bbd8e2b211c2a282fcfd8c2bd99c77dadd3d78f2c350c";
       libraryHaskellDepends = [
         base basic-prelude directory system-filepath text
       ];
       testHaskellDepends = [ base basic-prelude chell system-filepath ];
       homepage = "https://github.com/d12frosted/CanonicalPath";
       description = "Abstract data type for canonical paths with some utilities";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "system-command" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, process
     , QuickCheck, transformers
     }:
     mkDerivation {
       pname = "system-command";
       version = "0.0.10";
       sha256 = "628558ab2af64fc3db4d4d86057e9ea10aaf2f50875d4204c1fbf652bbc98e86";
       libraryHaskellDepends = [
         base directory filepath process transformers
       ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck
       ];
       homepage = "https://github.com/tonymorris/system-command";
       description = "A replacement for System.Exit and System.Process";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "system-fileio_0_3_15" = callPackage
    ({ mkDerivation, base, bytestring, chell, system-filepath
     , temporary, text, time, transformers, unix
     }:
     mkDerivation {
       pname = "system-fileio";
       version = "0.3.15";
       sha256 = "11465809c097dbb003976f79dc1a89c5f7b29e54d8d9244a39ad23fee1c89619";
       revision = "1";
       editedCabalFile = "7937e8b6e14953958f4c2a7204d9df8004de905c6016a4b5c13716c09092aeac";
       libraryHaskellDepends = [
         base bytestring system-filepath text time unix
       ];
       testHaskellDepends = [
         base bytestring chell system-filepath temporary text time
         transformers unix
       ];
       homepage = "https://john-millikin.com/software/haskell-filesystem/";
       description = "Consistent filesystem interaction across GHC versions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "system-fileio_0_3_16" = callPackage
    ({ mkDerivation, base, bytestring, chell, system-filepath
     , temporary, text, time, transformers, unix
     }:
     mkDerivation {
       pname = "system-fileio";
       version = "0.3.16";
       sha256 = "13c5ef056a03f54becb4755274153b7ea3ab4cebc0d10774947019ada07328f4";
       revision = "1";
       editedCabalFile = "27687f6a2383c74296863a8593ee788f1310d0795a5a110f4bdf80bb74e6d23f";
       libraryHaskellDepends = [
         base bytestring system-filepath text time unix
       ];
       testHaskellDepends = [
         base bytestring chell system-filepath temporary text time
         transformers unix
       ];
       homepage = "https://github.com/fpco/haskell-filesystem";
       description = "Consistent filesystem interaction across GHC versions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "system-fileio_0_3_16_1" = callPackage
    ({ mkDerivation, base, bytestring, chell, system-filepath
     , temporary, text, time, transformers, unix
     }:
     mkDerivation {
       pname = "system-fileio";
       version = "0.3.16.1";
       sha256 = "734de7d75b05b747f9392cf19b0ff37386c2013816fa01311edcb2fa4a14f70c";
       libraryHaskellDepends = [
         base bytestring system-filepath text time unix
       ];
       testHaskellDepends = [
         base bytestring chell system-filepath temporary text time
         transformers unix
       ];
       homepage = "https://github.com/fpco/haskell-filesystem";
       description = "Consistent filesystem interaction across GHC versions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "system-fileio_0_3_16_2" = callPackage
    ({ mkDerivation, base, bytestring, chell, system-filepath
     , temporary, text, time, transformers, unix
     }:
     mkDerivation {
       pname = "system-fileio";
       version = "0.3.16.2";
       sha256 = "6dd62a829dfce740b58f05d336e7aaa226329b13ca3ceb686209e647330bb39e";
       libraryHaskellDepends = [
         base bytestring system-filepath text time unix
       ];
       testHaskellDepends = [
         base bytestring chell system-filepath temporary text time
         transformers unix
       ];
       homepage = "https://github.com/fpco/haskell-filesystem";
       description = "Consistent filesystem interaction across GHC versions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "system-fileio" = callPackage
    ({ mkDerivation, base, bytestring, chell, system-filepath
     , temporary, text, time, transformers, unix
     }:
     mkDerivation {
       pname = "system-fileio";
       version = "0.3.16.3";
       sha256 = "3175707cb322c65760fa2eb2ab17327f251c8294ad688efc6258e82328830491";
       libraryHaskellDepends = [
         base bytestring system-filepath text time unix
       ];
       testHaskellDepends = [
         base bytestring chell system-filepath temporary text time
         transformers unix
       ];
       homepage = "https://github.com/fpco/haskell-filesystem";
       description = "Consistent filesystem interaction across GHC versions (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "system-filepath_0_4_12" = callPackage
    ({ mkDerivation, base, bytestring, chell, chell-quickcheck, deepseq
     , QuickCheck, text
     }:
     mkDerivation {
       pname = "system-filepath";
       version = "0.4.12";
       sha256 = "a2714835ac25263b64c340a497e4d9409b8475181b885bb1836995f63855d969";
       revision = "1";
       editedCabalFile = "7b73c3633fa555173eff62cd7be8abe8ecdd7a633826df4014b90bfa4eed6d27";
       libraryHaskellDepends = [ base bytestring deepseq text ];
       testHaskellDepends = [
         base bytestring chell chell-quickcheck QuickCheck text
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://john-millikin.com/software/haskell-filesystem/";
       description = "High-level, byte-based file and directory path manipulations";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "system-filepath_0_4_13" = callPackage
    ({ mkDerivation, base, bytestring, chell, chell-quickcheck, deepseq
     , QuickCheck, text
     }:
     mkDerivation {
       pname = "system-filepath";
       version = "0.4.13";
       sha256 = "8ad97ffd780de5271c5302cc9c023fba70aba2324f63c4fc0e47ef545055343c";
       libraryHaskellDepends = [ base bytestring deepseq text ];
       testHaskellDepends = [
         base bytestring chell chell-quickcheck QuickCheck text
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/fpco/haskell-filesystem";
       description = "High-level, byte-based file and directory path manipulations";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "system-filepath_0_4_13_1" = callPackage
    ({ mkDerivation, base, bytestring, chell, chell-quickcheck, deepseq
     , QuickCheck, text
     }:
     mkDerivation {
       pname = "system-filepath";
       version = "0.4.13.1";
       sha256 = "a411b0d389ca403f4423190a0d709b6aca88e3268829f7b5697dc8a3c1fb302d";
       libraryHaskellDepends = [ base bytestring deepseq text ];
       testHaskellDepends = [
         base bytestring chell chell-quickcheck QuickCheck text
       ];
       doCheck = false;
       homepage = "https://github.com/fpco/haskell-filesystem";
       description = "High-level, byte-based file and directory path manipulations";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "system-filepath_0_4_13_2" = callPackage
    ({ mkDerivation, base, bytestring, chell, chell-quickcheck, deepseq
     , QuickCheck, text
     }:
     mkDerivation {
       pname = "system-filepath";
       version = "0.4.13.2";
       sha256 = "52b3a8adfb4ae9b2c268e1b580c7af1416584b86e2b2de0c96b19eb93c54bf5a";
       libraryHaskellDepends = [ base bytestring deepseq text ];
       testHaskellDepends = [
         base bytestring chell chell-quickcheck QuickCheck text
       ];
       doCheck = false;
       homepage = "https://github.com/fpco/haskell-filesystem";
       description = "High-level, byte-based file and directory path manipulations";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "system-filepath_0_4_13_3" = callPackage
    ({ mkDerivation, base, bytestring, chell, chell-quickcheck, deepseq
     , QuickCheck, text
     }:
     mkDerivation {
       pname = "system-filepath";
       version = "0.4.13.3";
       sha256 = "d2fba15fe9dee3c813a65b4ac3aae8305355c74f59f13f896d82653c5a98cec8";
       libraryHaskellDepends = [ base bytestring deepseq text ];
       testHaskellDepends = [
         base bytestring chell chell-quickcheck QuickCheck text
       ];
       doCheck = false;
       homepage = "https://github.com/fpco/haskell-filesystem";
       description = "High-level, byte-based file and directory path manipulations";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "system-filepath" = callPackage
    ({ mkDerivation, base, bytestring, chell, chell-quickcheck, deepseq
     , QuickCheck, text
     }:
     mkDerivation {
       pname = "system-filepath";
       version = "0.4.13.4";
       sha256 = "345d7dec968b74ab1b8c0e7bb78c2ef1e5be7be6b7bac455340fd658abfec5fb";
       libraryHaskellDepends = [ base bytestring deepseq text ];
       testHaskellDepends = [
         base bytestring chell chell-quickcheck QuickCheck text
       ];
       doCheck = false;
       homepage = "https://github.com/fpco/haskell-filesystem";
       description = "High-level, byte-based file and directory path manipulations (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "system-gpio" = callPackage
    ({ mkDerivation, array, base, ghc-prim }:
     mkDerivation {
       pname = "system-gpio";
       version = "0.0.2";
       sha256 = "24feb0b7cebd4fb7c0b943d69f4de3682084542e96f40073a24eef6ed244e1c4";
       libraryHaskellDepends = [ array base ghc-prim ];
       homepage = "https://github.com/luzhuomi/system-gpio/";
       description = "GPIO wrapper libary for Raspberry Pi";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "system-inotify" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "system-inotify";
       version = "0.1";
       sha256 = "8f92bd8a30ba57a2a7fe125046eaab34712217ac21d95d9635f7b8bdd926bc59";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://darcs.imperialviolet.org/system-inotify";
       description = "Binding to Linux's inotify interface";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "system-lifted" = callPackage
    ({ mkDerivation, base, directory, either, haskell-src-meta
     , template-haskell, text, time, transformers, unix
     }:
     mkDerivation {
       pname = "system-lifted";
       version = "0.2.0.1";
       sha256 = "dc45bc3f2948cc5acc48198bf61dde27ee83844f36dd69c031ad1d8348f047b0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory either haskell-src-meta template-haskell text time
         transformers unix
       ];
       executableHaskellDepends = [
         base directory either haskell-src-meta template-haskell text time
         transformers unix
       ];
       jailbreak = true;
       homepage = "https://github.com/jcristovao/system-lifted";
       description = "Lifted versions of System functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "system-posix-redirect" = callPackage
    ({ mkDerivation, base, bytestring, unix }:
     mkDerivation {
       pname = "system-posix-redirect";
       version = "1.1.0.1";
       sha256 = "53535011e64c1792052987bc1e8799222286c30c349dd36d3fc08c8612fa6ef2";
       libraryHaskellDepends = [ base bytestring unix ];
       description = "A toy module to temporarily redirect a program's stdout";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "system-random-effect" = callPackage
    ({ mkDerivation, base, bytestring, crypto-api, extensible-effects
     , HUnit, mersenne-random-pure64, primitive, QuickCheck, statistics
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , vector, vector-algorithms
     }:
     mkDerivation {
       pname = "system-random-effect";
       version = "0.4.1.3";
       sha256 = "ab36b9b3f622b37a2ce0c9698e125417264040538f5e1201cc6b9c7095f4dfbd";
       libraryHaskellDepends = [
         base bytestring crypto-api extensible-effects
         mersenne-random-pure64 primitive statistics vector
         vector-algorithms
       ];
       testHaskellDepends = [
         base extensible-effects HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 vector
       ];
       jailbreak = true;
       homepage = "https://github.com/wowus/system-random-effect";
       description = "Random number generation for extensible effects";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "system-time-monotonic" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "system-time-monotonic";
       version = "0.2";
       sha256 = "7b30d8786bd825434313a9888c1cfaf1902fb50df881d92a57cb896e20ccaf38";
       libraryHaskellDepends = [ base time ];
       homepage = "https://github.com/joeyadams/haskell-system-time-monotonic";
       description = "Simple library for using the system's monotonic clock";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "system-util" = callPackage
    ({ mkDerivation, base, directory, easy-data, either, filepath
     , hspec, quickcheck-instances, semigroups, system-lifted
     , template-haskell, transformers, unix
     }:
     mkDerivation {
       pname = "system-util";
       version = "0.2";
       sha256 = "137feedb2af1e105afbc7380aa4464af7210da0e7adff70ba1b6c66149d54f6a";
       libraryHaskellDepends = [
         base directory either filepath semigroups system-lifted
         template-haskell transformers unix
       ];
       testHaskellDepends = [
         base directory easy-data either filepath hspec quickcheck-instances
         semigroups system-lifted template-haskell transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/jcristovao/system-util";
       description = "Various system utils lifted to EitherT";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {easy-data = null;};

  "system-uuid" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, libossp_uuid
     , murmur-hash, parsec, template-haskell
     }:
     mkDerivation {
       pname = "system-uuid";
       version = "2.1.1";
       sha256 = "8b911863eab0109f0030282af3b94fa233988de78ef2050bd30ebbfeb02a8089";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers murmur-hash parsec
         template-haskell
       ];
       librarySystemDepends = [ libossp_uuid ];
       executableHaskellDepends = [
         base binary bytestring containers murmur-hash parsec
         template-haskell
       ];
       executableSystemDepends = [ libossp_uuid ];
       homepage = "http://github.com/solidsnack/system-uuid/";
       description = "Bindings to system UUID functions";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) libossp_uuid;};

  "systemd" = callPackage
    ({ mkDerivation, base, bytestring, network, transformers, unix }:
     mkDerivation {
       pname = "systemd";
       version = "1.0.2";
       sha256 = "5235db71cd2ed14a77003c2c659582dee64f504f4de1af9ceab72f00af4cc2aa";
       libraryHaskellDepends = [
         base bytestring network transformers unix
       ];
       testHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/erebe/systemd";
       description = "Systemd facilities (Socket activation, Notify)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "syz" = callPackage
    ({ mkDerivation, base, syb }:
     mkDerivation {
       pname = "syz";
       version = "0.2.0.0";
       sha256 = "3e85801a83fa2a7e57093a7d0aa52f21cba07a0bd6d1ba82d2ddfb335249a3d4";
       libraryHaskellDepends = [ base syb ];
       homepage = "http://www.cs.indiana.edu/~adamsmd/papers/scrap_your_zippers/";
       description = "Scrap Your Zippers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "t-regex" = callPackage
    ({ mkDerivation, base, containers, haskell-src-exts
     , haskell-src-meta, lens, mtl, QuickCheck, recursion-schemes
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "t-regex";
       version = "0.1.0.0";
       sha256 = "b4db068482f7ca6a5085864aea83f716205c9b6d3c0331306b9bd1c744da3a3c";
       libraryHaskellDepends = [
         base containers haskell-src-exts haskell-src-meta lens mtl
         QuickCheck recursion-schemes template-haskell transformers
       ];
       description = "Matchers and grammars using tree regular expressions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ta" = callPackage
    ({ mkDerivation, base, containers, ghc-prim, mtl, Takusen
     , template-haskell, time
     }:
     mkDerivation {
       pname = "ta";
       version = "0.1";
       sha256 = "bd43f3ff250afa8beb49fc018ee24025450dea38f7fde2ad7d80e5de1e192dc5";
       libraryHaskellDepends = [
         base containers ghc-prim mtl Takusen template-haskell time
       ];
       jailbreak = true;
       homepage = "not available";
       description = "Transito Abierto: convenience library when using Takusen and Oracle";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "table" = callPackage
    ({ mkDerivation, base, csv, optparse-applicative, process, split }:
     mkDerivation {
       pname = "table";
       version = "0.1.0.0";
       sha256 = "fc944368d2d19568355348f93eb0b957a6bfac689e33d92792257e5a774411ab";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base csv optparse-applicative process split
       ];
       jailbreak = true;
       homepage = "https://github.com/danchoi/table";
       description = "Simple tool to generate tables from DSV input";
       license = stdenv.lib.licenses.mit;
     }) {};

  "table-tennis" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "table-tennis";
       version = "0.1.0.3";
       sha256 = "339411608776228a77ac13218342d6bdc0fc804a89cc2eab26f55dbd9623afec";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "A table tennis game tracking engine";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tableaux" = callPackage
    ({ mkDerivation, base, cgi, containers, html, mtl, parsec
     , QuickCheck
     }:
     mkDerivation {
       pname = "tableaux";
       version = "0.2";
       sha256 = "0b5d292c51d18f819b15f4406532e589276faa5ad54e83c47212774e65c38135";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cgi containers html mtl parsec QuickCheck
       ];
       description = "An interactive theorem prover based on semantic tableaux";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tables" = callPackage
    ({ mkDerivation, base, binary, cereal, comonad, containers, deepseq
     , directory, doctest, filepath, hashable, lens, profunctors
     , safecopy, template-haskell, transformers, transformers-compat
     , unordered-containers
     }:
     mkDerivation {
       pname = "tables";
       version = "0.4.1.1";
       sha256 = "97184b4fb10c09e552325f4f5b9945ada56a206b5223f9417cd402bb400c65af";
       libraryHaskellDepends = [
         base binary cereal comonad containers deepseq hashable lens
         profunctors safecopy template-haskell transformers
         transformers-compat unordered-containers
       ];
       testHaskellDepends = [
         base containers directory doctest filepath lens transformers
         unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/tables/";
       description = "In-memory storage with multiple keys using lenses and traversals";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tablestorage" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, conduit
     , crypto-api, cryptohash, HTTP, http-conduit, http-types, mtl
     , network, old-locale, resourcet, SHA, time, transformers
     , utf8-string, xml
     }:
     mkDerivation {
       pname = "tablestorage";
       version = "0.2.1.0";
       sha256 = "287b11625780364ff5c0b8425b01672d6cbfd7575c8b73f88c3cc5823066480e";
       libraryHaskellDepends = [
         base base64-bytestring bytestring conduit crypto-api cryptohash
         HTTP http-conduit http-types mtl network old-locale resourcet SHA
         time transformers utf8-string xml
       ];
       homepage = "http://github.com/paf31/tablestorage";
       description = "Azure Table Storage REST API Wrapper";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tabloid" = callPackage
    ({ mkDerivation, base, bytestring, containers, gtk, hint, parallel
     , process, regex-base, regex-posix
     }:
     mkDerivation {
       pname = "tabloid";
       version = "0.47";
       sha256 = "0352d6c575e2bd8ddb1d03e79d00d50e3542f389f730b70d4c4c3cf34af08ae1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers gtk hint parallel process regex-base
         regex-posix
       ];
       description = "View the output of shell commands in a table";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tabular_0_2_2_5" = callPackage
    ({ mkDerivation, base, csv, html, mtl }:
     mkDerivation {
       pname = "tabular";
       version = "0.2.2.5";
       sha256 = "801cd563e2f3241d7c3562fd6896cb9b5d451c5a37811d3f186fcd933d72a101";
       revision = "1";
       editedCabalFile = "9e1a07443018009aa697caa2713231daafed4dfd734a275268831bfb5aebd05f";
       libraryHaskellDepends = [ base csv html mtl ];
       homepage = "http://hub.darcs.net/kowey/tabular";
       description = "Two-dimensional data tables with rendering functions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tabular" = callPackage
    ({ mkDerivation, base, csv, html, mtl }:
     mkDerivation {
       pname = "tabular";
       version = "0.2.2.7";
       sha256 = "13f8da12108dafcf3194eb6bf25febf0081c7e4734f66d2d4aeee899f3c14ffb";
       libraryHaskellDepends = [ base csv html mtl ];
       homepage = "http://hub.darcs.net/kowey/tabular";
       description = "Two-dimensional data tables with rendering functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "taffybar" = callPackage
    ({ mkDerivation, base, cairo, containers, dbus, dyre
     , enclosed-exceptions, filepath, gtk, gtk-traymanager, gtk2
     , HStringTemplate, HTTP, mtl, network, network-uri, old-locale
     , parsec, process, safe, split, stm, text, time, time-locale-compat
     , transformers, utf8-string, X11, xdg-basedir, xmonad
     , xmonad-contrib
     }:
     mkDerivation {
       pname = "taffybar";
       version = "0.4.6";
       sha256 = "620918469d79d33067808114bdf8d4d6f5a5ae6d77ff672a37ea04ecc5e0caf5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cairo containers dbus dyre enclosed-exceptions filepath gtk
         gtk-traymanager HStringTemplate HTTP mtl network network-uri
         old-locale parsec process safe split stm text time
         time-locale-compat transformers utf8-string X11 xdg-basedir xmonad
         xmonad-contrib
       ];
       libraryPkgconfigDepends = [ gtk2 ];
       executableHaskellDepends = [
         base dyre filepath gtk safe xdg-basedir
       ];
       executablePkgconfigDepends = [ gtk2 ];
       homepage = "http://github.com/travitch/taffybar";
       description = "A desktop bar similar to xmobar, but with more GUI";
       license = stdenv.lib.licenses.bsd3;
     }) {gtk2 = pkgs.gnome2.gtk;};

  "tag-bits" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "tag-bits";
       version = "0.1.1.2";
       sha256 = "c5c456b2917183bc0f32f329c152c2332198aadcf3825fca1afa24d8c60b3633";
       libraryHaskellDepends = [ base ghc-prim ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/tag-bits";
       description = "Provides access to the dynamic pointer tagging bits used by GHC";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tag-stream" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , enumerator
     }:
     mkDerivation {
       pname = "tag-stream";
       version = "0.2.1";
       sha256 = "b6ce1b1cf1ea2bd44426df51e0816feec22d872a1ba52021787ff8c1c3f51398";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring enumerator
       ];
       homepage = "http://github.com/yihuang/tag-stream";
       description = "streamlined html tag parser";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tagchup" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-accessor
     , explicit-exception, transformers, utility-ht, xml-basic
     }:
     mkDerivation {
       pname = "tagchup";
       version = "0.4.0.5";
       sha256 = "c0c12eeec562a7769deb165c7edae8a8dbc0087d5788655b72864df122a0fa35";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers data-accessor explicit-exception
         transformers utility-ht xml-basic
       ];
       executableHaskellDepends = [ base xml-basic ];
       testHaskellDepends = [ base xml-basic ];
       homepage = "http://code.haskell.org/~thielema/tagchup/";
       description = "alternative package for processing of tag soups";
       license = "GPL";
     }) {};

  "tagged_0_7_3" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "tagged";
       version = "0.7.3";
       sha256 = "eb544fc509fbb98100500f9c61617c0afee32854a6fc88bd873d017e34ffcb04";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/ekmett/tagged";
       description = "Haskell 98 phantom types to avoid unsafely passing dummy arguments";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tagged_0_8_1" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "tagged";
       version = "0.8.1";
       sha256 = "5bdd98389fcca3aa9c9902d1fb209fd431685ba6530f3051ebe1960fe1c782c1";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/ekmett/tagged";
       description = "Haskell 98 phantom types to avoid unsafely passing dummy arguments";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tagged_0_8_2" = callPackage
    ({ mkDerivation, base, deepseq, template-haskell }:
     mkDerivation {
       pname = "tagged";
       version = "0.8.2";
       sha256 = "e415d83329dba6c6b604cdf7ab331d321fa62d396f15e79439caa58279d6b77c";
       libraryHaskellDepends = [ base deepseq template-haskell ];
       homepage = "http://github.com/ekmett/tagged";
       description = "Haskell 98 phantom types to avoid unsafely passing dummy arguments";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tagged" = callPackage
    ({ mkDerivation, base, deepseq, template-haskell }:
     mkDerivation {
       pname = "tagged";
       version = "0.8.3";
       sha256 = "27aa7d3f17a01891fcd03ab7cbedc1fdd568475563cda7927ac3a3c2d3526893";
       libraryHaskellDepends = [ base deepseq template-haskell ];
       homepage = "http://github.com/ekmett/tagged";
       description = "Haskell 98 phantom types to avoid unsafely passing dummy arguments";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tagged-binary" = callPackage
    ({ mkDerivation, base, binary, bytestring, pureMD5 }:
     mkDerivation {
       pname = "tagged-binary";
       version = "0.2.0.0";
       sha256 = "35e30f2f9183a9890557be7a28e4f88b19c68b0cfd688e906d8491f72b247745";
       libraryHaskellDepends = [ base binary bytestring pureMD5 ];
       description = "Provides tools for serializing data tagged with type information";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tagged-exception-core" = callPackage
    ({ mkDerivation, base, exceptions, mmorph, mtl, transformers }:
     mkDerivation {
       pname = "tagged-exception-core";
       version = "2.2.0.0";
       sha256 = "b8e9ecabbf75c1733d0056a68349020d6104db6007cb466fa79e570464bd40c2";
       libraryHaskellDepends = [
         base exceptions mmorph mtl transformers
       ];
       homepage = "https://github.com/trskop/tagged-exception-core";
       description = "Reflect exceptions using phantom types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tagged-list" = callPackage
    ({ mkDerivation, AbortT-transformers, base, binary, natural-number
     , type-equality, type-level-natural-number
     , type-level-natural-number-induction
     , type-level-natural-number-operations
     }:
     mkDerivation {
       pname = "tagged-list";
       version = "1.1";
       sha256 = "ba0cdf1b64f033ee24ba0b8a0f01e1ae88bf41c052338e7cfa4530685ac2b3bd";
       libraryHaskellDepends = [
         AbortT-transformers base binary natural-number type-equality
         type-level-natural-number type-level-natural-number-induction
         type-level-natural-number-operations
       ];
       jailbreak = true;
       description = "Lists tagged with a type-level natural number representing their length";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tagged-th" = callPackage
    ({ mkDerivation, base, tagged, template-haskell, type-spine }:
     mkDerivation {
       pname = "tagged-th";
       version = "0.1";
       sha256 = "c9e830a0382ffb591ebc0ef068cdc48de7e2ab35ce7ab4f3c0a2cffc8bd51ee3";
       libraryHaskellDepends = [
         base tagged template-haskell type-spine
       ];
       jailbreak = true;
       description = "QuasiQuoter and Template Haskell splices for creating proxies at higher-kinds";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tagged-transformer" = callPackage
    ({ mkDerivation, base, comonad, contravariant, distributive
     , exceptions, mtl, reflection, semigroupoids, tagged
     }:
     mkDerivation {
       pname = "tagged-transformer";
       version = "0.8";
       sha256 = "c7fef845dfdec30c520d8c2e827c61850a8922ca086cadf17803aec77e765f8e";
       libraryHaskellDepends = [
         base comonad contravariant distributive exceptions mtl reflection
         semigroupoids tagged
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/tagged-transformer";
       description = "Provides newtype wrappers for phantom types to avoid unsafely passing dummy arguments";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tagging" = callPackage
    ({ mkDerivation, base, bytestring, pcre-light }:
     mkDerivation {
       pname = "tagging";
       version = "0.1";
       sha256 = "23f9cfbecd3dd24b93b3acbfb3479a2daace70543245418946432526ee625404";
       libraryHaskellDepends = [ base bytestring pcre-light ];
       homepage = "git://github.com/jre2/HaskellTagging.git";
       description = "Library for tagging data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "taggy" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-html, blaze-markup
     , directory, hspec, hspec-attoparsec, text, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "taggy";
       version = "0.2.0";
       sha256 = "c36b0bebb1e384afe9a11760183bc15a665fb2b352a5035d545321351c630207";
       revision = "1";
       editedCabalFile = "0343ad030ba4e9fd651b383e92c213c6c4a6560ec33f561cfcfa9c5493deb50b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base blaze-html blaze-markup text unordered-containers
         vector
       ];
       executableHaskellDepends = [ attoparsec base text ];
       testHaskellDepends = [
         attoparsec base blaze-html blaze-markup directory hspec
         hspec-attoparsec text unordered-containers vector
       ];
       homepage = "http://github.com/alpmestan/taggy";
       description = "Efficient and simple HTML/XML parsing library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "taggy-lens" = callPackage
    ({ mkDerivation, base, doctest, hspec, lens, taggy, text
     , unordered-containers
     }:
     mkDerivation {
       pname = "taggy-lens";
       version = "0.1.2";
       sha256 = "2bce7b9a008819f4a6ef5224136e0573bb0f2170b80d6bfe079efc0c7062a216";
       libraryHaskellDepends = [
         base lens taggy text unordered-containers
       ];
       testHaskellDepends = [
         base doctest hspec lens taggy text unordered-containers
       ];
       homepage = "http://github.com/alpmestan/taggy-lens";
       description = "Lenses for the taggy html/xml parser";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "taglib" = callPackage
    ({ mkDerivation, base, bytestring, taglib, utf8-string }:
     mkDerivation {
       pname = "taglib";
       version = "0.1.1";
       sha256 = "d77d93790ebf3718ba18b742c754498a8e562481006c2113064ba99e91771e9b";
       libraryHaskellDepends = [ base bytestring utf8-string ];
       librarySystemDepends = [ taglib ];
       libraryPkgconfigDepends = [ taglib ];
       description = "Binding to TagLib (ID3 tag library)";
       license = "LGPL";
     }) {inherit (pkgs) taglib;};

  "taglib-api" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, taglib, text
     , transformers
     }:
     mkDerivation {
       pname = "taglib-api";
       version = "0.1.1.3";
       sha256 = "b242f6f3d1b97fe6012d46b9041a61b456aab0525194edde5c2f4a8f44e40baa";
       libraryHaskellDepends = [
         base bytestring containers mtl text transformers
       ];
       libraryPkgconfigDepends = [ taglib ];
       jailbreak = true;
       description = "An FFI layer over TagLib's C bindings";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) taglib;};

  "tagset-positional" = callPackage
    ({ mkDerivation, base, binary, containers, parsec, text
     , text-binary
     }:
     mkDerivation {
       pname = "tagset-positional";
       version = "0.3.0";
       sha256 = "aef99f8efbe755694474513f19ec346a261c0f071278a8ff12414dc829e73574";
       libraryHaskellDepends = [
         base binary containers parsec text text-binary
       ];
       jailbreak = true;
       homepage = "https://github.com/kawu/tagset-positional";
       description = "Positional tags and tagsets";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tagshare" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "tagshare";
       version = "0.0";
       sha256 = "d2314bae2e6820700f2a61db9c9f7976e1b53547a49cdd3352bdf29ac3856ce0";
       libraryHaskellDepends = [ base containers mtl ];
       description = "TagShare - explicit sharing with tags";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tagsoup_0_13_3" = callPackage
    ({ mkDerivation, base, bytestring, containers, text }:
     mkDerivation {
       pname = "tagsoup";
       version = "0.13.3";
       sha256 = "32a862118d7836e9beb25fe4b317472fab6e1d41daefa86067231b328cff668d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring containers text ];
       homepage = "http://community.haskell.org/~ndm/tagsoup/";
       description = "Parsing and extracting information from (possibly malformed) HTML/XML documents";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tagsoup_0_13_5" = callPackage
    ({ mkDerivation, base, bytestring, containers, text }:
     mkDerivation {
       pname = "tagsoup";
       version = "0.13.5";
       sha256 = "9997aec735e54657ab03c34ac5ca95110703cb07eed6fa3989ad22832853bebe";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring containers text ];
       homepage = "http://community.haskell.org/~ndm/tagsoup/";
       description = "Parsing and extracting information from (possibly malformed) HTML/XML documents";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tagsoup_0_13_6" = callPackage
    ({ mkDerivation, base, bytestring, containers, text }:
     mkDerivation {
       pname = "tagsoup";
       version = "0.13.6";
       sha256 = "a8358c8c09b73912c4e832248d7543e4fddaf4ac9305f5f27d0854b9410d6ac8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring containers text ];
       homepage = "http://community.haskell.org/~ndm/tagsoup/";
       description = "Parsing and extracting information from (possibly malformed) HTML/XML documents";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tagsoup_0_13_7" = callPackage
    ({ mkDerivation, base, bytestring, containers, text }:
     mkDerivation {
       pname = "tagsoup";
       version = "0.13.7";
       sha256 = "6fd72e0d42e686f2af3bfcff30a1abe673530f86dfebf8cf2b02fd1667366d37";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring containers text ];
       homepage = "https://github.com/ndmitchell/tagsoup#readme";
       description = "Parsing and extracting information from (possibly malformed) HTML/XML documents";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tagsoup" = callPackage
    ({ mkDerivation, base, bytestring, containers, text }:
     mkDerivation {
       pname = "tagsoup";
       version = "0.13.8";
       sha256 = "cff171695c5c559565eff8296bd44442ffff6bc8972e81f3a6c27eb1f13e1c2e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring containers text ];
       homepage = "https://github.com/ndmitchell/tagsoup#readme";
       description = "Parsing and extracting information from (possibly malformed) HTML/XML documents";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tagsoup-ht" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-accessor
     , explicit-exception, old-time, tagsoup, transformers, utility-ht
     , xml-basic
     }:
     mkDerivation {
       pname = "tagsoup-ht";
       version = "0.3";
       sha256 = "75222a751f384bce22ef6c6794d76acf518a94df8b3d497ab71463af2a0dabfb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers data-accessor explicit-exception tagsoup
         transformers utility-ht xml-basic
       ];
       executableHaskellDepends = [
         base bytestring containers data-accessor explicit-exception
         old-time tagsoup transformers utility-ht xml-basic
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/tagsoup-ht/";
       description = "alternative parser for the tagsoup package";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tagsoup-parsec" = callPackage
    ({ mkDerivation, base, parsec, tagsoup }:
     mkDerivation {
       pname = "tagsoup-parsec";
       version = "0.0.8";
       sha256 = "f34fdbcd2fb7e13d61436f978a0deb345837c9567dffd5312f385ba4299ec240";
       libraryHaskellDepends = [ base parsec tagsoup ];
       homepage = "http://www.killersmurf.com";
       description = "Tokenizes Tag, so [ Tag ] can be used as parser input";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tagstream-conduit" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , case-insensitive, conduit, conduit-extra, data-default, hspec
     , HUnit, QuickCheck, resourcet, text, transformers, xml-conduit
     }:
     mkDerivation {
       pname = "tagstream-conduit";
       version = "0.5.5.3";
       sha256 = "b296e8f0ba18ae951b5bb3fc2d9d964954666df61ea9363d667f251af17134ab";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring case-insensitive conduit
         conduit-extra data-default resourcet text transformers xml-conduit
       ];
       testHaskellDepends = [
         base bytestring conduit hspec HUnit QuickCheck resourcet text
       ];
       homepage = "http://github.com/yihuang/tagstream-conduit";
       description = "streamlined html tag parser";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "takahashi" = callPackage
    ({ mkDerivation, base, lens, monad-skeleton, mtl }:
     mkDerivation {
       pname = "takahashi";
       version = "0.2.2.0";
       sha256 = "fa4dc21ff737de94e2254152217737f7b6545fe8792f6272d8ac4b1fea41993a";
       libraryHaskellDepends = [ base lens monad-skeleton mtl ];
       description = "create slide for presentation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "takusen-oracle" = callPackage
    ({ mkDerivation, base, clntsh, mtl, old-time, QuickCheck, random
     , sqlplus, time
     }:
     mkDerivation {
       pname = "takusen-oracle";
       version = "0.9.3";
       sha256 = "4d290f84c6f35cc447df478c6afddb38633ed2442c58f4b1e1a3254036fba7b4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl old-time time ];
       librarySystemDepends = [ clntsh ];
       libraryToolDepends = [ sqlplus ];
       executableHaskellDepends = [
         base mtl old-time QuickCheck random time
       ];
       homepage = "https://github.com/paulrzcz/takusen-oracle.git";
       description = "Database library with left-fold interface for Oracle";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {clntsh = null; sqlplus = null;};

  "tamarin-prover" = callPackage
    ({ mkDerivation, aeson, array, base, binary, blaze-builder
     , blaze-html, bytestring, cmdargs, conduit, containers, deepseq
     , derive, directory, dlist, fclabels, filepath, hamlet, http-types
     , HUnit, lifted-base, monad-control, mtl, old-locale, parallel
     , parsec, process, safe, shakespeare, syb, tamarin-prover-term
     , tamarin-prover-theory, tamarin-prover-utils, text, threads, time
     , transformers, uniplate, wai, warp, yesod-core, yesod-json
     , yesod-static
     }:
     mkDerivation {
       pname = "tamarin-prover";
       version = "0.8.6.3";
       sha256 = "62e4133bee08a3991cfc2aad22b4f55d2a85010c356f0b25904d6bcee91e4df4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson array base binary blaze-builder blaze-html bytestring cmdargs
         conduit containers deepseq derive directory dlist fclabels filepath
         hamlet http-types HUnit lifted-base monad-control mtl old-locale
         parallel parsec process safe shakespeare syb tamarin-prover-term
         tamarin-prover-theory tamarin-prover-utils text threads time
         transformers uniplate wai warp yesod-core yesod-json yesod-static
       ];
       jailbreak = true;
       homepage = "http://www.infsec.ethz.ch/research/software/tamarin";
       description = "The Tamarin prover for security protocol analysis";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tamarin-prover-term" = callPackage
    ({ mkDerivation, attoparsec, base, binary, bytestring, containers
     , deepseq, derive, directory, dlist, HUnit, mtl, parsec, process
     , safe, split, syb, tamarin-prover-utils
     }:
     mkDerivation {
       pname = "tamarin-prover-term";
       version = "0.8.5.1";
       sha256 = "45a9da283c76e9a778cabe4cdc380df89f140442687e294a2fbc3b7e3224989f";
       libraryHaskellDepends = [
         attoparsec base binary bytestring containers deepseq derive
         directory dlist HUnit mtl parsec process safe split syb
         tamarin-prover-utils
       ];
       jailbreak = true;
       homepage = "http://www.infsec.ethz.ch/research/software/tamarin";
       description = "Term manipulation library for the tamarin prover";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tamarin-prover-theory" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, cmdargs
     , containers, deepseq, derive, directory, dlist, fclabels, filepath
     , HUnit, mtl, parallel, parsec, process, safe, syb
     , tamarin-prover-term, tamarin-prover-utils, time, transformers
     , uniplate
     }:
     mkDerivation {
       pname = "tamarin-prover-theory";
       version = "0.8.6.0";
       sha256 = "838a82c2a0727db7ae41be2df835093c95211efd61f97369443b3cf7730d81f5";
       libraryHaskellDepends = [
         array base binary bytestring cmdargs containers deepseq derive
         directory dlist fclabels filepath HUnit mtl parallel parsec process
         safe syb tamarin-prover-term tamarin-prover-utils time transformers
         uniplate
       ];
       jailbreak = true;
       homepage = "http://www.infsec.ethz.ch/research/software/tamarin";
       description = "Term manipulation library for the tamarin prover";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tamarin-prover-utils" = callPackage
    ({ mkDerivation, base, base64-bytestring, binary, blaze-builder
     , bytestring, containers, deepseq, dlist, fclabels, mtl, parsec
     , pretty, SHA, syb, time, transformers
     }:
     mkDerivation {
       pname = "tamarin-prover-utils";
       version = "0.8.5.1";
       sha256 = "6c4811b8477929a4684a79566ff38888e61039f2549bf9cd0348a3e50ab0f086";
       libraryHaskellDepends = [
         base base64-bytestring binary blaze-builder bytestring containers
         deepseq dlist fclabels mtl parsec pretty SHA syb time transformers
       ];
       jailbreak = true;
       homepage = "http://www.infsec.ethz.ch/research/software/tamarin";
       description = "Utility library for the tamarin prover";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tamper" = callPackage
    ({ mkDerivation, base, containers, mtl, safe, text }:
     mkDerivation {
       pname = "tamper";
       version = "0.4.2.2";
       sha256 = "b4b124ab59761e3ff62bc9bf3461c94b1dee4f84b58fe3c75387b415a639fd4b";
       libraryHaskellDepends = [ base containers mtl safe text ];
       homepage = "https://bitbucket.org/tdammers/tamper/";
       description = "Blaze-style HTML templates as a Monad Transformer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tar_0_4_0_1" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, old-time
     , time
     }:
     mkDerivation {
       pname = "tar";
       version = "0.4.0.1";
       sha256 = "a408274d8325f4e3144c5aa154d72f1ee7b0a7342570fd6805e3be3fe0d97a6d";
       revision = "1";
       editedCabalFile = "1653792be4d9c7ea3181842ece695f0fee9bb52bc99694bca97e0b1f826775e4";
       libraryHaskellDepends = [
         base bytestring directory filepath old-time time
       ];
       jailbreak = true;
       description = "Reading, writing and manipulating \".tar\" archive files.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tar_0_4_1_0" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, time }:
     mkDerivation {
       pname = "tar";
       version = "0.4.1.0";
       sha256 = "7521310c34bb3b457e529a5f2037ac84f62420d6283f9ce8d22e685bd82d0715";
       libraryHaskellDepends = [
         base bytestring directory filepath time
       ];
       description = "Reading, writing and manipulating \".tar\" archive files.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tar_0_4_2_1" = callPackage
    ({ mkDerivation, array, base, bytestring, directory, filepath
     , old-time, QuickCheck, tasty, tasty-quickcheck, time
     }:
     mkDerivation {
       pname = "tar";
       version = "0.4.2.1";
       sha256 = "2fad0ae6c1d671f0fbd60f39b2d7df70c3f33890b92df177052d2d8733955080";
       revision = "1";
       editedCabalFile = "4b0749397f9f6aac3506e07c9043371ac8a2c5605dc4370501904f38c1a3c3b4";
       libraryHaskellDepends = [
         array base bytestring directory filepath old-time
       ];
       testHaskellDepends = [
         array base bytestring directory filepath old-time QuickCheck tasty
         tasty-quickcheck time
       ];
       jailbreak = true;
       description = "Reading, writing and manipulating \".tar\" archive files.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tar_0_4_2_2" = callPackage
    ({ mkDerivation, array, base, bytestring, bytestring-handle
     , directory, filepath, old-time, QuickCheck, tasty
     , tasty-quickcheck, time
     }:
     mkDerivation {
       pname = "tar";
       version = "0.4.2.2";
       sha256 = "4242573a8d0b4df721177ae36d277b4be68616ba7d8da645dab999d1e1464ced";
       revision = "1";
       editedCabalFile = "fcb87aaed6a22fef908468f008f39507fa1d22282c23dfb6ddb6837b794c2a30";
       libraryHaskellDepends = [
         array base bytestring directory filepath time
       ];
       testHaskellDepends = [
         array base bytestring bytestring-handle directory filepath old-time
         QuickCheck tasty tasty-quickcheck time
       ];
       doCheck = false;
       description = "Reading, writing and manipulating \".tar\" archive files.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tar" = callPackage
    ({ mkDerivation, array, base, bytestring, bytestring-handle
     , containers, deepseq, directory, filepath, QuickCheck, tasty
     , tasty-quickcheck, time
     }:
     mkDerivation {
       pname = "tar";
       version = "0.5.0.1";
       sha256 = "c465e21b9d70abaa610e94a3792c69b88bb4436fadc02a5fd72a933d46dc5818";
       libraryHaskellDepends = [
         array base bytestring containers deepseq directory filepath time
       ];
       testHaskellDepends = [
         array base bytestring bytestring-handle containers deepseq
         directory filepath QuickCheck tasty tasty-quickcheck time
       ];
       description = "Reading, writing and manipulating \".tar\" archive files.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tardis" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "tardis";
       version = "0.3.0.0";
       sha256 = "6622b9fd61a61a38998da4533ded7ee71b9b389f5d020f0c54619387cb42c895";
       libraryHaskellDepends = [ base mtl ];
       homepage = "https://github.com/DanBurton/tardis";
       description = "Bidirectional state monad transformer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "target" = callPackage
    ({ mkDerivation, array, base, containers, deepseq, directory
     , exceptions, filepath, ghc, ghc-paths, ghc-prim, hint
     , liquid-fixpoint, liquidhaskell, mtl, pretty, process, QuickCheck
     , syb, tagged, tasty, tasty-hunit, template-haskell, text
     , text-format, th-lift, transformers, unordered-containers, vector
     , z3
     }:
     mkDerivation {
       pname = "target";
       version = "0.2.0.1";
       sha256 = "a6366a2eddf278e368ec6b49c7aa483433fad6d473d5bc1751c0049ccd1a98cb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory exceptions filepath ghc ghc-paths
         liquid-fixpoint liquidhaskell mtl pretty process QuickCheck syb
         tagged template-haskell text text-format th-lift transformers
         unordered-containers vector
       ];
       executableHaskellDepends = [ base hint ];
       testHaskellDepends = [
         array base containers deepseq ghc ghc-prim liquid-fixpoint
         liquidhaskell mtl tagged tasty tasty-hunit template-haskell
         unordered-containers
       ];
       testSystemDepends = [ z3 ];
       description = "Generate test-suites from refinement types";
       license = stdenv.lib.licenses.mit;
       maintainers = with stdenv.lib.maintainers; [ gridaphobe ];
     }) {inherit (pkgs) z3;};

  "task" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, containers
     , csv-enumerator, directory, filepath, old-locale, random, text
     , time, unix
     }:
     mkDerivation {
       pname = "task";
       version = "0.0.1";
       sha256 = "16ff87b18a1baa8dad135969779c370bf6cf039a102f320233b41f2634248e7c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson attoparsec base bytestring containers csv-enumerator
         directory filepath old-locale random text time unix
       ];
       jailbreak = true;
       description = "A command line tool for keeping track of tasks you worked on";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "taskpool" = callPackage
    ({ mkDerivation, async, base, containers, fgl, hspec, stm
     , transformers
     }:
     mkDerivation {
       pname = "taskpool";
       version = "0.1.0";
       sha256 = "76b0a3b39223c0ad4bd9452cf16294aa18401c201b19a9fca8473a2d10f2270b";
       libraryHaskellDepends = [
         async base containers fgl stm transformers
       ];
       testHaskellDepends = [
         async base containers fgl hspec stm transformers
       ];
       description = "Manage pools of possibly interdependent tasks using STM and async";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tasty_0_10_1" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, containers, deepseq
     , mtl, optparse-applicative, regex-tdfa-rc, stm, tagged, time
     , unbounded-delays
     }:
     mkDerivation {
       pname = "tasty";
       version = "0.10.1";
       sha256 = "855699f3b1d7bc8aea5b10345eaa5550064f994b059aa23543753814c0810ad1";
       revision = "1";
       editedCabalFile = "5299d4b3a7175fa19834ad139198e934bca6285439fd3f4d2b91888b2b58ae42";
       libraryHaskellDepends = [
         ansi-terminal async base containers deepseq mtl
         optparse-applicative regex-tdfa-rc stm tagged time unbounded-delays
       ];
       homepage = "http://documentup.com/feuerbach/tasty";
       description = "Modern and extensible testing framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty_0_10_1_1" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, containers, deepseq
     , mtl, optparse-applicative, regex-tdfa-rc, stm, tagged, time
     , unbounded-delays
     }:
     mkDerivation {
       pname = "tasty";
       version = "0.10.1.1";
       sha256 = "360f64d2aa94a36279cebe485f7a7b38be0f9a649d11523f29fd844c0bad7dbd";
       revision = "1";
       editedCabalFile = "e506d7dd9e4d4897508b67e88af1ead3c795f1d8d8d2aa68e02c11e59507f78c";
       libraryHaskellDepends = [
         ansi-terminal async base containers deepseq mtl
         optparse-applicative regex-tdfa-rc stm tagged time unbounded-delays
       ];
       homepage = "http://documentup.com/feuerbach/tasty";
       description = "Modern and extensible testing framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty_0_10_1_2" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, containers, deepseq
     , mtl, optparse-applicative, regex-tdfa-rc, stm, tagged, time
     , unbounded-delays
     }:
     mkDerivation {
       pname = "tasty";
       version = "0.10.1.2";
       sha256 = "91e0b26ebe5263069747d92b6bdc3937d5513c2797c849b369f1282ca941b730";
       libraryHaskellDepends = [
         ansi-terminal async base containers deepseq mtl
         optparse-applicative regex-tdfa-rc stm tagged time unbounded-delays
       ];
       homepage = "http://documentup.com/feuerbach/tasty";
       description = "Modern and extensible testing framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, clock, containers
     , deepseq, mtl, optparse-applicative, regex-tdfa-rc, stm, tagged
     , unbounded-delays
     }:
     mkDerivation {
       pname = "tasty";
       version = "0.11.0.2";
       sha256 = "3d87f99a046bfda752dcf558f36931135c784af9a2911a61bc4673199f933c63";
       libraryHaskellDepends = [
         ansi-terminal async base clock containers deepseq mtl
         optparse-applicative regex-tdfa-rc stm tagged unbounded-delays
       ];
       homepage = "http://documentup.com/feuerbach/tasty";
       description = "Modern and extensible testing framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tasty-ant-xml_1_0_1" = callPackage
    ({ mkDerivation, base, containers, generic-deriving, ghc-prim, mtl
     , stm, tagged, tasty, transformers, xml
     }:
     mkDerivation {
       pname = "tasty-ant-xml";
       version = "1.0.1";
       sha256 = "4c572fd3ea41ae60de5344a00b8ef0ecfe54e0cfec5251597a86cc9553a569f1";
       libraryHaskellDepends = [
         base containers generic-deriving ghc-prim mtl stm tagged tasty
         transformers xml
       ];
       jailbreak = true;
       homepage = "http://github.com/ocharles/tasty-ant-xml";
       description = "Render tasty output to XML for Jenkins";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty-ant-xml" = callPackage
    ({ mkDerivation, base, containers, generic-deriving, ghc-prim, mtl
     , stm, tagged, tasty, transformers, xml
     }:
     mkDerivation {
       pname = "tasty-ant-xml";
       version = "1.0.2";
       sha256 = "bbc3cc6741597af6b158bb54345d7356c98b50eb8b493abd38178a471915ff5d";
       libraryHaskellDepends = [
         base containers generic-deriving ghc-prim mtl stm tagged tasty
         transformers xml
       ];
       homepage = "http://github.com/ocharles/tasty-ant-xml";
       description = "Render tasty output to XML for Jenkins";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tasty-dejafu" = callPackage
    ({ mkDerivation, base, dejafu, tasty }:
     mkDerivation {
       pname = "tasty-dejafu";
       version = "0.2.0.0";
       sha256 = "cba0315e6c6b2946ada0e48ea6f443f20bc8421810b0c334d1b095be0d1453ae";
       libraryHaskellDepends = [ base dejafu tasty ];
       homepage = "https://github.com/barrucadu/dejafu";
       description = "Deja Fu support for the Tasty test framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tasty-expected-failure" = callPackage
    ({ mkDerivation, base, tagged, tasty }:
     mkDerivation {
       pname = "tasty-expected-failure";
       version = "0.11.0.3";
       sha256 = "534b9bcbf945ec280c68c4776563c797ef03c3fdeb2703269d88f2c7fde22225";
       libraryHaskellDepends = [ base tagged tasty ];
       homepage = "http://github.com/nomeata/tasty-expected-failure";
       description = "Mark tasty tests as failure expected";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tasty-fail-fast" = callPackage
    ({ mkDerivation, base, containers, directory, stm, tagged, tasty
     , tasty-golden, tasty-hunit, tasty-tap
     }:
     mkDerivation {
       pname = "tasty-fail-fast";
       version = "0.0.2";
       sha256 = "28e463b3e85e356f1a0676a4accd7ecc002814dc0487323613f0c6aacc153ac6";
       libraryHaskellDepends = [ base containers stm tagged tasty ];
       testHaskellDepends = [
         base directory tasty tasty-golden tasty-hunit tasty-tap
       ];
       homepage = "http://github.com/MichaelXavier/tasty-fail-fast#readme";
       description = "Adds the ability to fail a tasty test suite on first test failure";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tasty-golden_2_2_2_4" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, deepseq
     , directory, filepath, mtl, optparse-applicative, process, tagged
     , tasty, tasty-hunit, temporary-rc
     }:
     mkDerivation {
       pname = "tasty-golden";
       version = "2.2.2.4";
       sha256 = "2cd0ac55b3edd218cf713842681aafa036db2aaf24558b303f9f64030624cc24";
       libraryHaskellDepends = [
         async base bytestring containers deepseq directory filepath mtl
         optparse-applicative process tagged tasty temporary-rc
       ];
       testHaskellDepends = [
         base directory filepath process tasty tasty-hunit temporary-rc
       ];
       homepage = "https://github.com/feuerbach/tasty-golden";
       description = "Golden tests support for tasty";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty-golden_2_3_0_1" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, deepseq
     , directory, filepath, mtl, optparse-applicative, process, tagged
     , tasty, tasty-hunit, temporary-rc
     }:
     mkDerivation {
       pname = "tasty-golden";
       version = "2.3.0.1";
       sha256 = "5146fc0121435d64ecb75c73ac71aad46a1159a1d169eeecd91adefc607754a6";
       libraryHaskellDepends = [
         async base bytestring containers deepseq directory filepath mtl
         optparse-applicative process tagged tasty temporary-rc
       ];
       testHaskellDepends = [
         base directory filepath process tasty tasty-hunit temporary-rc
       ];
       homepage = "https://github.com/feuerbach/tasty-golden";
       description = "Golden tests support for tasty";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty-golden_2_3_0_2" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, deepseq
     , directory, filepath, mtl, optparse-applicative, process, tagged
     , tasty, tasty-hunit, temporary, temporary-rc
     }:
     mkDerivation {
       pname = "tasty-golden";
       version = "2.3.0.2";
       sha256 = "b02bf439e0b8bb9182ace90791c00b5f02db7a96f641ee1c1db69cae03a5f658";
       libraryHaskellDepends = [
         async base bytestring containers deepseq directory filepath mtl
         optparse-applicative process tagged tasty temporary
       ];
       testHaskellDepends = [
         base directory filepath process tasty tasty-hunit temporary-rc
       ];
       homepage = "https://github.com/feuerbach/tasty-golden";
       description = "Golden tests support for tasty";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty-golden" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, deepseq
     , directory, filepath, mtl, optparse-applicative, process, tagged
     , tasty, tasty-hunit, temporary, temporary-rc
     }:
     mkDerivation {
       pname = "tasty-golden";
       version = "2.3.1";
       sha256 = "f292a57dc63afdd5607cca82bcc5ad606c5e1c59bb6fabc7fe48a26d816dcbf1";
       libraryHaskellDepends = [
         async base bytestring containers deepseq directory filepath mtl
         optparse-applicative process tagged tasty temporary
       ];
       testHaskellDepends = [
         base directory filepath process tasty tasty-hunit temporary-rc
       ];
       homepage = "https://github.com/feuerbach/tasty-golden";
       description = "Golden tests support for tasty";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tasty-hspec_1_1" = callPackage
    ({ mkDerivation, base, hspec, hspec-core, QuickCheck, random, tasty
     , tasty-quickcheck, tasty-smallcheck
     }:
     mkDerivation {
       pname = "tasty-hspec";
       version = "1.1";
       sha256 = "260ae081474e173e957fc268455520aba320536a0495656609acbd499c349e96";
       libraryHaskellDepends = [
         base hspec hspec-core QuickCheck random tasty tasty-quickcheck
         tasty-smallcheck
       ];
       homepage = "http://github.com/mitchellwrosen/tasty-hspec";
       description = "Hspec support for the Tasty test framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty-hspec" = callPackage
    ({ mkDerivation, base, hspec, hspec-core, QuickCheck, random
     , tagged, tasty, tasty-quickcheck, tasty-smallcheck
     }:
     mkDerivation {
       pname = "tasty-hspec";
       version = "1.1.2";
       sha256 = "69c5409e70694e8ba5791aaeb272e34af37cd28665c6d1c1f742cc7f053fab67";
       libraryHaskellDepends = [
         base hspec hspec-core QuickCheck random tagged tasty
         tasty-quickcheck tasty-smallcheck
       ];
       homepage = "https://github.com/mitchellwrosen/tasty-hspec";
       description = "Hspec support for the Tasty test framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tasty-html" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, containers, filepath
     , generic-deriving, mtl, stm, tagged, tasty, text, transformers
     }:
     mkDerivation {
       pname = "tasty-html";
       version = "0.4.1.1";
       sha256 = "0eea1c9fcf1ef3aeb94b811086e11d87ce59f90bb91afa8765152b943c591f1a";
       libraryHaskellDepends = [
         base blaze-html bytestring containers filepath generic-deriving mtl
         stm tagged tasty text transformers
       ];
       homepage = "http://github.com/feuerbach/tasty-html";
       description = "Render tasty output to HTML";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tasty-hunit_0_9_0_1" = callPackage
    ({ mkDerivation, base, tasty }:
     mkDerivation {
       pname = "tasty-hunit";
       version = "0.9.0.1";
       sha256 = "8bf14d5a37178d116a4f2fc430b22f3035f5d331aed6cdc89f8b4de5c8920d66";
       libraryHaskellDepends = [ base tasty ];
       homepage = "http://documentup.com/feuerbach/tasty";
       description = "HUnit support for the Tasty test framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty-hunit_0_9_1" = callPackage
    ({ mkDerivation, base, tasty }:
     mkDerivation {
       pname = "tasty-hunit";
       version = "0.9.1";
       sha256 = "47418ca61236611c9a8b0e497a1b469346ecdf176f76149f09b1b3296a51b0eb";
       libraryHaskellDepends = [ base tasty ];
       homepage = "http://documentup.com/feuerbach/tasty";
       description = "HUnit support for the Tasty test framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty-hunit" = callPackage
    ({ mkDerivation, base, tasty }:
     mkDerivation {
       pname = "tasty-hunit";
       version = "0.9.2";
       sha256 = "ae1efc2a750dfc09f9276d3a57e6a8f8b30f1a6932e81c53fcd67132b8ea1623";
       libraryHaskellDepends = [ base tasty ];
       homepage = "http://documentup.com/feuerbach/tasty";
       description = "HUnit support for the Tasty test framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tasty-hunit-adapter" = callPackage
    ({ mkDerivation, base, HUnit, tasty, tasty-hunit }:
     mkDerivation {
       pname = "tasty-hunit-adapter";
       version = "1.1";
       sha256 = "6ffb169f629e7c3a275561c227f2f3293ded413495c7621cf438b0676ce53e1b";
       libraryHaskellDepends = [ base HUnit tasty tasty-hunit ];
       homepage = "https://github.com/jstolarek/tasty-hunit-adapter";
       description = "Use existing HUnit tests with tasty";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tasty-integrate" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cmdargs, containers
     , deepseq, directory, either, haskell-src-exts
     , language-haskell-extract, lens, mtl, parsec, QuickCheck
     , quickcheck-property-comb, regex-posix, split, stm, stringbuilder
     , system-filepath, tasty, tasty-quickcheck, text, transformers
     , unix
     }:
     mkDerivation {
       pname = "tasty-integrate";
       version = "0.0.1";
       sha256 = "fddcf442462c6ee6ed800247265f2eaad1a5b68a345b69c3633ddbd2d5d14b7e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base bytestring cmdargs containers directory either
         haskell-src-exts language-haskell-extract lens mtl parsec
         regex-posix split system-filepath tasty tasty-quickcheck text
         transformers unix
       ];
       testHaskellDepends = [
         base bytestring containers deepseq directory haskell-src-exts lens
         mtl QuickCheck quickcheck-property-comb regex-posix split stm
         stringbuilder system-filepath tasty tasty-quickcheck text
         transformers
       ];
       jailbreak = true;
       description = "automated integration of QuickCheck properties into tasty suites";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty-kat_0_0_1" = callPackage
    ({ mkDerivation, base, bytestring, mtl, tasty, tasty-hunit
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "tasty-kat";
       version = "0.0.1";
       sha256 = "3442554518d9a46b78b5d6e5b00139c0aae702a3e8789e0da0f992f71add027c";
       libraryHaskellDepends = [ base bytestring tasty ];
       testHaskellDepends = [
         base bytestring mtl tasty tasty-hunit tasty-quickcheck
       ];
       doCheck = false;
       homepage = "https://github.com/vincenthz/tasty-kat";
       description = "Known Answer Tests (KAT) framework for tasty";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty-kat" = callPackage
    ({ mkDerivation, base, bytestring, mtl, tasty, tasty-hunit
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "tasty-kat";
       version = "0.0.3";
       sha256 = "a72501f0f77db372648566bbba1dd1d6d0d0c975b42238875d663313e9a5db93";
       libraryHaskellDepends = [ base bytestring tasty ];
       testHaskellDepends = [
         base bytestring mtl tasty tasty-hunit tasty-quickcheck
       ];
       doCheck = false;
       homepage = "https://github.com/vincenthz/tasty-kat";
       description = "Known Answer Tests (KAT) framework for tasty";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tasty-laws" = callPackage
    ({ mkDerivation, base, smallcheck, smallcheck-laws
     , smallcheck-series, tasty, tasty-smallcheck
     }:
     mkDerivation {
       pname = "tasty-laws";
       version = "0.3.1";
       sha256 = "dfe1308dc6e4a41ede3b56cef504dd0e1d210d2ea7cc3e2d296cf72928823226";
       libraryHaskellDepends = [
         base smallcheck smallcheck-laws smallcheck-series tasty
         tasty-smallcheck
       ];
       testHaskellDepends = [ base smallcheck smallcheck-laws tasty ];
       homepage = "https://github.com/jdnavarro/tasty-laws";
       description = "Test common laws";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tasty-lens" = callPackage
    ({ mkDerivation, base, lens, smallcheck, smallcheck-lens, tasty
     , tasty-smallcheck
     }:
     mkDerivation {
       pname = "tasty-lens";
       version = "0.3.1";
       sha256 = "06d947e738ef28ba74983fd611f76611483a384d4c637b126419ac61068ce90a";
       libraryHaskellDepends = [
         base lens smallcheck smallcheck-lens tasty tasty-smallcheck
       ];
       testHaskellDepends = [ base lens tasty ];
       homepage = "https://github.com/jdnavarro/tasty-lens";
       description = "Tasty TestTrees for Lens validation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tasty-program" = callPackage
    ({ mkDerivation, base, deepseq, directory, filepath, process, tasty
     }:
     mkDerivation {
       pname = "tasty-program";
       version = "1.0.3";
       sha256 = "1659e7651cd638cd1f7c80c0f5cd9be87358d2cc4a9c98f2f23240583e5a06a3";
       libraryHaskellDepends = [
         base deepseq directory filepath process tasty
       ];
       homepage = "https://github.com/jstolarek/tasty-program";
       description = "Use tasty framework to test whether a program executes correctly";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tasty-quickcheck_0_8_3_2" = callPackage
    ({ mkDerivation, base, pcre-light, QuickCheck, tagged, tasty
     , tasty-hunit
     }:
     mkDerivation {
       pname = "tasty-quickcheck";
       version = "0.8.3.2";
       sha256 = "3b50e0db4ebec3bc778aea7ee899a923a146f8d6552acba634b465a92b7c2ee0";
       libraryHaskellDepends = [ base QuickCheck tagged tasty ];
       testHaskellDepends = [ base pcre-light tasty tasty-hunit ];
       homepage = "http://documentup.com/feuerbach/tasty";
       description = "QuickCheck support for the Tasty test framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty-quickcheck" = callPackage
    ({ mkDerivation, base, pcre-light, QuickCheck, tagged, tasty
     , tasty-hunit
     }:
     mkDerivation {
       pname = "tasty-quickcheck";
       version = "0.8.4";
       sha256 = "365f4cb6db70cce36ebdc133a2f6388cab71df2ca11f223f0458565956ec3297";
       libraryHaskellDepends = [ base QuickCheck tagged tasty ];
       testHaskellDepends = [ base pcre-light tasty tasty-hunit ];
       homepage = "http://documentup.com/feuerbach/tasty";
       description = "QuickCheck support for the Tasty test framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tasty-rerun_1_1_4" = callPackage
    ({ mkDerivation, base, containers, mtl, optparse-applicative
     , reducers, split, stm, tagged, tasty, transformers
     }:
     mkDerivation {
       pname = "tasty-rerun";
       version = "1.1.4";
       sha256 = "1561eea5f795144b570859a65d602c931b56ab7da8795a59b84283f79c5c15b0";
       libraryHaskellDepends = [
         base containers mtl optparse-applicative reducers split stm tagged
         tasty transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/ocharles/tasty-rerun";
       description = "Run tests by filtering the test tree depending on the result of previous test runs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty-rerun" = callPackage
    ({ mkDerivation, base, containers, mtl, optparse-applicative
     , reducers, split, stm, tagged, tasty, transformers
     }:
     mkDerivation {
       pname = "tasty-rerun";
       version = "1.1.5";
       sha256 = "9877de7602a231fb9cf772c47f9a15ef6764e159ddd96a350a7c16b1a158403e";
       libraryHaskellDepends = [
         base containers mtl optparse-applicative reducers split stm tagged
         tasty transformers
       ];
       doHaddock = false;
       homepage = "http://github.com/ocharles/tasty-rerun";
       description = "Run tests by filtering the test tree depending on the result of previous test runs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tasty-silver_3_1_7" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
     , deepseq, directory, filepath, mtl, optparse-applicative, process
     , process-extras, regex-tdfa, stm, tagged, tasty, tasty-hunit
     , temporary, text, transformers
     }:
     mkDerivation {
       pname = "tasty-silver";
       version = "3.1.7";
       sha256 = "74b47940af2da96f0e6ebe7592fdda2633129855d20d2ef81c36e90bbd8ef4d6";
       libraryHaskellDepends = [
         ansi-terminal async base bytestring containers deepseq directory
         filepath mtl optparse-applicative process process-extras regex-tdfa
         stm tagged tasty temporary text
       ];
       testHaskellDepends = [
         base directory filepath process tasty tasty-hunit temporary
         transformers
       ];
       homepage = "https://github.com/phile314/tasty-silver";
       description = "A fancy test runner, including support for golden tests";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty-silver_3_1_8" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
     , deepseq, directory, filepath, mtl, optparse-applicative, process
     , process-extras, regex-tdfa, stm, tagged, tasty, tasty-hunit
     , temporary, text, transformers
     }:
     mkDerivation {
       pname = "tasty-silver";
       version = "3.1.8";
       sha256 = "044f65a91ef677545264d7fff0bf7a9ef5fa7ad49a6b3cb402c96f3b81aba430";
       libraryHaskellDepends = [
         ansi-terminal async base bytestring containers deepseq directory
         filepath mtl optparse-applicative process process-extras regex-tdfa
         stm tagged tasty temporary text
       ];
       testHaskellDepends = [
         base directory filepath process tasty tasty-hunit temporary
         transformers
       ];
       homepage = "https://github.com/phile314/tasty-silver";
       description = "A fancy test runner, including support for golden tests";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty-silver" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, bytestring, containers
     , deepseq, directory, filepath, mtl, optparse-applicative, process
     , process-extras, regex-tdfa, stm, tagged, tasty, tasty-hunit
     , temporary, text, transformers
     }:
     mkDerivation {
       pname = "tasty-silver";
       version = "3.1.8.1";
       sha256 = "0dc1bcced319abc9984aa8e61c4bb88c30279f1b87d4d4e0f368eade99525fb0";
       libraryHaskellDepends = [
         ansi-terminal async base bytestring containers deepseq directory
         filepath mtl optparse-applicative process process-extras regex-tdfa
         stm tagged tasty temporary text
       ];
       testHaskellDepends = [
         base directory filepath process tasty tasty-hunit temporary
         transformers
       ];
       homepage = "https://github.com/phile314/tasty-silver";
       description = "A fancy test runner, including support for golden tests";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tasty-smallcheck_0_8_0_1" = callPackage
    ({ mkDerivation, async, base, smallcheck, tagged, tasty }:
     mkDerivation {
       pname = "tasty-smallcheck";
       version = "0.8.0.1";
       sha256 = "55136f38f5ac6838c828cf8e4919b3cd8d06891a318424b8670c298bfe729379";
       libraryHaskellDepends = [ async base smallcheck tagged tasty ];
       homepage = "http://documentup.com/feuerbach/tasty";
       description = "SmallCheck support for the Tasty test framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty-smallcheck" = callPackage
    ({ mkDerivation, async, base, smallcheck, tagged, tasty }:
     mkDerivation {
       pname = "tasty-smallcheck";
       version = "0.8.1";
       sha256 = "314ba7acdb7793730e7677f553a72dd6a4a8f9a45ff3e931cd7d384affb3c6d8";
       libraryHaskellDepends = [ async base smallcheck tagged tasty ];
       homepage = "http://documentup.com/feuerbach/tasty";
       description = "SmallCheck support for the Tasty test framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tasty-tap" = callPackage
    ({ mkDerivation, base, containers, directory, stm, tasty
     , tasty-golden, tasty-hunit
     }:
     mkDerivation {
       pname = "tasty-tap";
       version = "0.0.3";
       sha256 = "b65cde7c662dd1d204a4e8efb84c1210c1ed0571def12ccf3c59f3036f0bc0fc";
       libraryHaskellDepends = [ base containers stm tasty ];
       testHaskellDepends = [
         base directory tasty tasty-golden tasty-hunit
       ];
       homepage = "https://github.com/michaelxavier/tasty-tap";
       description = "TAP (Test Anything Protocol) Version 13 formatter for tasty";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tasty-th_0_1_3" = callPackage
    ({ mkDerivation, base, language-haskell-extract, tasty
     , template-haskell
     }:
     mkDerivation {
       pname = "tasty-th";
       version = "0.1.3";
       sha256 = "a3ff8c151a29cf986173dc451978cfc7981a529e3492b2cfddb8ad549fba85ba";
       libraryHaskellDepends = [
         base language-haskell-extract tasty template-haskell
       ];
       homepage = "http://github.com/bennofs/tasty-th";
       description = "Automagically generate the HUnit- and Quickcheck-bulk-code using Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tasty-th" = callPackage
    ({ mkDerivation, base, tasty, template-haskell }:
     mkDerivation {
       pname = "tasty-th";
       version = "0.1.4";
       sha256 = "18a14d693e709046eba3bb1a4e9febfce09d04059342728f06178788a24ece35";
       libraryHaskellDepends = [ base tasty template-haskell ];
       homepage = "http://github.com/bennofs/tasty-th";
       description = "Automatic tasty test case discovery using TH";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tateti-tateti" = callPackage
    ({ mkDerivation, array, base, lens-simple, mtl, ncurses, random }:
     mkDerivation {
       pname = "tateti-tateti";
       version = "0.1.0.1";
       sha256 = "3cd5977a58eb22c2a17f524f918a01b101f0c42981167a7cb59b58e295bf0e58";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base lens-simple mtl ncurses random
       ];
       homepage = "http://github.com/alvare/tateti-tateti#readme";
       description = "Meta tic-tac-toe ncurses game";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tau" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "tau";
       version = "6.2831";
       sha256 = "5f6b8431a4c84f24147e41ed088c34245a091ab067c2aa845817d7b8871f7c83";
       libraryHaskellDepends = [ base ];
       description = "Tau, the ratio between any circle's circumference and radius";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tbox" = callPackage
    ({ mkDerivation, array, base, binary, cautious-file, containers
     , directory, filepath, IfElse, monad-loops, mtl, random
     , safe-failure, stm-io-hooks
     }:
     mkDerivation {
       pname = "tbox";
       version = "0.1.0";
       sha256 = "7e876bde1781d42bb008038a64ce7daa8bf4e3297dcbfff11d2efb1c5b254c63";
       libraryHaskellDepends = [
         array base binary cautious-file containers directory filepath
         IfElse monad-loops mtl random safe-failure stm-io-hooks
       ];
       jailbreak = true;
       homepage = "http://darcs.monoid.at/tbox";
       description = "Transactional variables and data structures with IO hooks";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tcache-AWS" = callPackage
    ({ mkDerivation, aws, base, bytestring, conduit, http-conduit
     , network, TCache, text
     }:
     mkDerivation {
       pname = "tcache-AWS";
       version = "0.0.1";
       sha256 = "9bdbaa9be02c9f8cb1e57b646b5add9cc4a5298621a175a1ecf784c0b64411a2";
       libraryHaskellDepends = [
         aws base bytestring conduit http-conduit network TCache text
       ];
       description = "tcache using Amazon Web Services as default persistence mechanism";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tccli" = callPackage
    ({ mkDerivation, base, bytestring, tokyocabinet-haskell
     , utf8-string
     }:
     mkDerivation {
       pname = "tccli";
       version = "0.0.1";
       sha256 = "a74a1e18c05833561b61f20da0e6b76f0c036461f1da5c0b109459bf5bb24e52";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring tokyocabinet-haskell utf8-string
       ];
       homepage = "http://bitcheese.net/wiki/code/tccli";
       description = "TokyoCabinet CLI interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tce-conf" = callPackage
    ({ mkDerivation, base, containers, HUnit }:
     mkDerivation {
       pname = "tce-conf";
       version = "1.1";
       sha256 = "d0dedf6185791d9808e57bf2f0a28f4164b1f285bde2f45c2b039da572ca7cb0";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [ base containers HUnit ];
       homepage = "http://hub.darcs.net/dino/tce-conf";
       description = "Very simple config file reading";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tconfig" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "tconfig";
       version = "0.5.2";
       sha256 = "79edeb5afa3fa30d1d9dea3517d54ec466debc39eb6854296f79b5d6f2a29615";
       libraryHaskellDepends = [ base containers ];
       description = "Simple text configuration file parser library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tcp" = callPackage
    ({ mkDerivation, base, containers, old-time }:
     mkDerivation {
       pname = "tcp";
       version = "0.0.2";
       sha256 = "9b4a45c0ee848a72b9bc56cee3d4c53e38254f7363e405a0512936d1a67513f3";
       libraryHaskellDepends = [ base containers old-time ];
       homepage = "http://www.cl.cam.ac.uk/~pes20/Netsem/";
       description = "A purely functional TCP implementation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tdd-util" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, lens
     , MonadCatchIO-transformers, parallel-io, process, QuickCheck
     , random, string-class, system-posix-redirect, tagged
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , time, transformers
     }:
     mkDerivation {
       pname = "tdd-util";
       version = "0.3.0.1";
       sha256 = "9e2285177390f8599db8d9ae43b5ce443979640189ed2bda532035216fdf2ab5";
       libraryHaskellDepends = [
         base bytestring HUnit lens MonadCatchIO-transformers parallel-io
         process QuickCheck random system-posix-redirect tagged
         test-framework test-framework-hunit test-framework-quickcheck2 time
         transformers
       ];
       testHaskellDepends = [
         base bytestring HUnit lens MonadCatchIO-transformers parallel-io
         process QuickCheck random string-class system-posix-redirect tagged
         test-framework test-framework-hunit test-framework-quickcheck2 time
         transformers
       ];
       description = "Test framework wrapper";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tdoc" = callPackage
    ({ mkDerivation, base, bytestring, template-haskell, transformers
     , xhtml
     }:
     mkDerivation {
       pname = "tdoc";
       version = "0.4.6";
       sha256 = "886ca4a6df39d265cb51f44192f6abeed53a8dfa193d490fe5025a3afe90543f";
       libraryHaskellDepends = [
         base bytestring template-haskell transformers xhtml
       ];
       homepage = "https://github.com/np/tdoc";
       description = "TDoc is a typed document builder with support for (X)HTML";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "teams" = callPackage
    ({ mkDerivation, base, containers, fgl, graphviz }:
     mkDerivation {
       pname = "teams";
       version = "0.0.2.3";
       sha256 = "ed25b9034a9f13245c6518413cc15d6004fb1a6272bea18e2a254f001b3e5812";
       libraryHaskellDepends = [ base containers fgl graphviz ];
       description = "Graphical modeling tools for sequential teams";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "teeth" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "teeth";
       version = "0.1.0.0";
       sha256 = "94f544c6bb663b37f7999ce59d24b67120d795e76f1107025cac374c4e89b1c3";
       revision = "1";
       editedCabalFile = "84bb818fc4cb06bf91450e31e9a023926449a6157ce1e5de60649cda931db416";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/expipiplus1/teeth";
       description = "Dental data types";
       license = stdenv.lib.licenses.mit;
     }) {};

  "telegram" = callPackage
    ({ mkDerivation, aeson, base, bytestring, data-default
     , http-conduit, url, utf8-string
     }:
     mkDerivation {
       pname = "telegram";
       version = "0.1.0.0";
       sha256 = "96c0fdd4c92f51fd45fd43fe1de090822752daac00caecd3d29195ee0c3026b2";
       libraryHaskellDepends = [
         aeson base bytestring data-default http-conduit url utf8-string
       ];
       description = "Telegram API client";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "telegram-api" = callPackage
    ({ mkDerivation, aeson, base, either, hspec, http-types, servant
     , servant-client, text
     }:
     mkDerivation {
       pname = "telegram-api";
       version = "0.2.1.0";
       sha256 = "02e564a45e095053f36e77772fc8dd9847b65f95087d47c6d50b96418f373a4f";
       libraryHaskellDepends = [
         aeson base either servant servant-client text
       ];
       testHaskellDepends = [
         base hspec http-types servant servant-client text
       ];
       homepage = "http://github.com/klappvisor/haskell-telegram-api#readme";
       description = "Telegram Bot API bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "teleport" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, base, bytestring
     , configurator, optparse-applicative, system-filepath, text, turtle
     }:
     mkDerivation {
       pname = "teleport";
       version = "0.0.0.10";
       sha256 = "cb39562f0e1fd428f072e2f2e2440f6ac6c2ff8077e767d2fced0e402f575f66";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [
         aeson ansi-terminal base bytestring configurator
         optparse-applicative system-filepath text turtle
       ];
       testHaskellDepends = [ base ];
       homepage = "https://github.com/bollu/teleport#readme";
       description = "A tool to quickly switch between directories";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tellbot_0_6_0_10" = callPackage
    ({ mkDerivation, base, bifunctors, bytestring, containers
     , http-conduit, mtl, network, regex-pcre, split, tagsoup, text
     , time, transformers
     }:
     mkDerivation {
       pname = "tellbot";
       version = "0.6.0.10";
       sha256 = "7b853263a4522ec8839a429c0d2be76ca2c7427f0693ce6a84b7a6067e979373";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bifunctors bytestring containers http-conduit mtl network
         regex-pcre split tagsoup text time transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/phaazon/tellbot";
       description = "IRC tellbot";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tellbot" = callPackage
    ({ mkDerivation, base, bifunctors, bytestring, containers
     , http-conduit, mtl, network, regex-pcre, split, tagsoup, text
     , time, transformers
     }:
     mkDerivation {
       pname = "tellbot";
       version = "0.6.0.11";
       sha256 = "0589e73acc704ef0b38e59b98caba0faba9aef9802672f50efc1fcb7c0287c9f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bifunctors bytestring containers http-conduit mtl network
         regex-pcre split tagsoup text time transformers
       ];
       homepage = "https://github.com/phaazon/tellbot";
       description = "IRC tellbot";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "template" = callPackage
    ({ mkDerivation, base, mtl, text }:
     mkDerivation {
       pname = "template";
       version = "0.2.0.10";
       sha256 = "8fd5a321b1c62f8ca5ed68c098e676917a5dac4d65809fceaed4b52c22b4ac82";
       libraryHaskellDepends = [ base mtl text ];
       description = "Simple string substitution";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "template-default" = callPackage
    ({ mkDerivation, base, data-default, template-haskell }:
     mkDerivation {
       pname = "template-default";
       version = "0.1.1";
       sha256 = "4dcb40cd1330d92dca50bdf6ecf5ca6c60a54e1567d7e114778708b04390681d";
       libraryHaskellDepends = [ base data-default template-haskell ];
       jailbreak = true;
       homepage = "https://github.com/haskell-pkg-janitors/template-default";
       description = "declaring Default instances just got even easier";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "template-haskell_2_10_0_0" = callPackage
    ({ mkDerivation, base, pretty }:
     mkDerivation {
       pname = "template-haskell";
       version = "2.10.0.0";
       sha256 = "358a3818d04fde27dd44f2c6d24b409031839ee5da2c9ec34b16257fd78c0df8";
       libraryHaskellDepends = [ base pretty ];
       description = "Support library for Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "template-haskell-util" = callPackage
    ({ mkDerivation, base, GenericPretty, ghc-prim, template-haskell }:
     mkDerivation {
       pname = "template-haskell-util";
       version = "0.1.1.0";
       sha256 = "8e9ca0323c52791fb5275d56e64cdefbeae3e364e124446044b4b477cd9a4f0c";
       libraryHaskellDepends = [
         base GenericPretty ghc-prim template-haskell
       ];
       homepage = "https://github.com/HaskellZhangSong/TemplateHaskellUtils";
       description = "Some utilities for template Haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "template-hsml" = callPackage
    ({ mkDerivation, base, blaze-markup, haskell-src-exts
     , haskell-src-meta, parsec, QuickCheck, template-haskell
     , test-framework, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "template-hsml";
       version = "0.2.0.3";
       sha256 = "2fa8ee2b181b38077bcfd6c8893820d48881526f423174c9b0df18d9610edcd2";
       libraryHaskellDepends = [
         base blaze-markup haskell-src-exts haskell-src-meta parsec
         template-haskell
       ];
       testHaskellDepends = [
         base parsec QuickCheck test-framework test-framework-quickcheck2
       ];
       jailbreak = true;
       description = "Haskell's Simple Markup Language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "template-yj" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "template-yj";
       version = "0.0.0.2";
       sha256 = "423e6a30ae66539a9f8935fd8c708eb8513f9f1ec30ffd67ff37daca9a2948ee";
       libraryHaskellDepends = [ base bytestring text ];
       jailbreak = true;
       homepage = "https://github.com/YoshikuniJujo/template/wiki";
       description = "Process template file";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "templatepg" = callPackage
    ({ mkDerivation, base, binary, bytestring, haskell-src-meta, mtl
     , network, parsec, regex-compat, regex-posix, template-haskell
     , time, utf8-string
     }:
     mkDerivation {
       pname = "templatepg";
       version = "0.2.8";
       sha256 = "bddd04dca12d48e9151b495b63a981540b2b6b6e7ba4857419abd2d3777410ac";
       libraryHaskellDepends = [
         base binary bytestring haskell-src-meta mtl network parsec
         regex-compat regex-posix template-haskell time utf8-string
       ];
       homepage = "https://github.com/jekor/templatepg";
       description = "A PostgreSQL access library with compile-time SQL type inference";
       license = stdenv.lib.licenses.mit;
     }) {};

  "templater" = callPackage
    ({ mkDerivation, attoparsec, base, hspec, hspec-attoparsec, HUnit
     , QuickCheck, text
     }:
     mkDerivation {
       pname = "templater";
       version = "0.0.3.0";
       sha256 = "e4c78dccf9bfae0a56c5594c22f6e20eb38fc0b3583e13884aadc812d25a0048";
       libraryHaskellDepends = [ attoparsec base text ];
       testHaskellDepends = [
         base hspec hspec-attoparsec HUnit QuickCheck text
       ];
       homepage = "https://github.com/geraud/templater";
       description = "Simple string templater";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tempodb" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, containers
     , HsOpenSSL, HTTP, http-streams, io-streams, mtl, old-locale, text
     , time
     }:
     mkDerivation {
       pname = "tempodb";
       version = "0.2.2.5";
       sha256 = "d49536e242b8ab53cbd3bbdd3773341403b1e02cbdcbbef349a4a9302814e003";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring containers HsOpenSSL HTTP
         http-streams io-streams mtl old-locale text time
       ];
       jailbreak = true;
       homepage = "https://github.com/ixmatus/hs-tempodb";
       description = "A small Haskell wrapper around the TempoDB api";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "temporal-csound" = callPackage
    ({ mkDerivation, base, csound-catalog, csound-expression
     , temporal-media, temporal-music-notation
     , temporal-music-notation-western
     }:
     mkDerivation {
       pname = "temporal-csound";
       version = "0.4.3.1";
       sha256 = "29c05b3019073882540ad420d0b05a49acf4f60ec6b585d40c386f3db48bedb0";
       libraryHaskellDepends = [
         base csound-catalog csound-expression temporal-media
         temporal-music-notation temporal-music-notation-western
       ];
       homepage = "https://github.com/anton-k/temporal-csound";
       description = "library to make electronic music, brings together temporal-music-notation and csound-expression packages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "temporal-media" = callPackage
    ({ mkDerivation, base, Boolean }:
     mkDerivation {
       pname = "temporal-media";
       version = "0.6.1";
       sha256 = "6c198d83654fd7fc341357393c6c6464c41f34b4b1a13b84aeb7b923488cb6ae";
       libraryHaskellDepends = [ base Boolean ];
       homepage = "https://github.com/anton-k/temporal-media";
       description = "data types for temporal media";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "temporal-music-notation" = callPackage
    ({ mkDerivation, base, data-default, temporal-media, vector }:
     mkDerivation {
       pname = "temporal-music-notation";
       version = "0.4.1";
       sha256 = "3b2ee2c5410ed623bb9f1ddfc2aaf74e908dc51984660dfef1be53f0dd32bd26";
       libraryHaskellDepends = [
         base data-default temporal-media vector
       ];
       homepage = "https://github.com/anton-k/temporal-music-notation";
       description = "music notation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "temporal-music-notation-demo" = callPackage
    ({ mkDerivation, base, binary, data-default, HCodecs
     , temporal-music-notation
     }:
     mkDerivation {
       pname = "temporal-music-notation-demo";
       version = "0.4.0";
       sha256 = "1f881bdc277b1ac67c7e6ae117d1a33d191641bbd372526fa5b527af52f3a9c9";
       libraryHaskellDepends = [
         base binary data-default HCodecs temporal-music-notation
       ];
       homepage = "https://github.com/anton-k/temporal-music-notation-demo";
       description = "generates midi from score notation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "temporal-music-notation-western" = callPackage
    ({ mkDerivation, base, temporal-music-notation }:
     mkDerivation {
       pname = "temporal-music-notation-western";
       version = "0.4.0";
       sha256 = "6cdebe9fc323e5718e712328328763474b172f0d10add3a2b7328e5c28d95704";
       libraryHaskellDepends = [ base temporal-music-notation ];
       homepage = "https://github.com/anton-k/temporal-music-notation-western";
       description = "western music notation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "temporary_1_2_0_3" = callPackage
    ({ mkDerivation, base, directory, exceptions, filepath
     , transformers, unix
     }:
     mkDerivation {
       pname = "temporary";
       version = "1.2.0.3";
       sha256 = "8a889c7e62a2bb144eb9e394fab51e5dbd843d473ac2eab9e16b55a9eb3a4647";
       libraryHaskellDepends = [
         base directory exceptions filepath transformers unix
       ];
       homepage = "http://www.github.com/batterseapower/temporary";
       description = "Portable temporary file and directory support for Windows and Unix, based on code from Cabal";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "temporary" = callPackage
    ({ mkDerivation, base, directory, exceptions, filepath
     , transformers, unix
     }:
     mkDerivation {
       pname = "temporary";
       version = "1.2.0.4";
       sha256 = "51e713804246404df8a728919a2e7d1994f8cfda42cfa7a74ea65d8b7d206762";
       libraryHaskellDepends = [
         base directory exceptions filepath transformers unix
       ];
       homepage = "http://www.github.com/feuerbach/temporary";
       description = "Portable temporary file and directory support for Windows and Unix, based on code from Cabal";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "temporary-rc" = callPackage
    ({ mkDerivation, base, directory, exceptions, filepath
     , transformers, unix
     }:
     mkDerivation {
       pname = "temporary-rc";
       version = "1.2.0.3";
       sha256 = "1a4f8dd65f7db92316a68ef64c3518873799115babce92ef9869103d318011db";
       libraryHaskellDepends = [
         base directory exceptions filepath transformers unix
       ];
       homepage = "http://www.github.com/feuerbach/temporary";
       description = "Portable temporary file and directory support for Windows and Unix, based on code from Cabal";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "temporary-resourcet" = callPackage
    ({ mkDerivation, base, directory, exceptions, filepath, resourcet
     , tasty, tasty-hunit, transformers, unix
     }:
     mkDerivation {
       pname = "temporary-resourcet";
       version = "0.1.0.0";
       sha256 = "30a01ce6ee41fb134ebf69fc21e38ce115ad6670a4f27b3828a2e9727744b4db";
       libraryHaskellDepends = [
         base directory exceptions filepath resourcet transformers unix
       ];
       testHaskellDepends = [
         base directory resourcet tasty tasty-hunit transformers
       ];
       jailbreak = true;
       homepage = "http://www.github.com/ttuegel/temporary-resourcet";
       description = "Portable temporary files and directories with automatic deletion";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tempus" = callPackage
    ({ mkDerivation, array, base, directory, executable-path, filepath
     , happy, haskeline, mtl, uniplate, utf8-string
     }:
     mkDerivation {
       pname = "tempus";
       version = "0.1.0";
       sha256 = "566fa9571b3717a46a79233cd8c818de0e50bab48bc4e7e4543f79ba13586543";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base directory executable-path filepath haskeline mtl
         uniplate utf8-string
       ];
       executableToolDepends = [ happy ];
       jailbreak = true;
       description = "Interpreter for the FRP language Tempus";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tempus-fugit" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "tempus-fugit";
       version = "0.1.0.1";
       sha256 = "d93b841938c4ae7e199a3135bbe1619bbf0e68919aee7fff72db903473644303";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/kadoban/tempus-fugit";
       description = "Programmers' time tracker";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "tensor" = callPackage
    ({ mkDerivation, base, ghc-prim, QuickCheck, random, vector }:
     mkDerivation {
       pname = "tensor";
       version = "0.3.0.1";
       sha256 = "ce06190f4ae042cd87bfb420342fa98fd18472ec218907d427e48ebebb08a60e";
       libraryHaskellDepends = [ base ghc-prim random vector ];
       testHaskellDepends = [ base QuickCheck random ];
       homepage = "http://noaxiom.org/tensor";
       description = "A completely type-safe library for linear algebra";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "term-rewriting" = callPackage
    ({ mkDerivation, ansi-wl-pprint, array, base, containers, HUnit
     , mtl, multiset, parsec, QuickCheck, union-find-array
     }:
     mkDerivation {
       pname = "term-rewriting";
       version = "0.2";
       sha256 = "2154905572f2b12c37d4a6ec3dd57d1bdd243057216aaf584432538af2635d1d";
       libraryHaskellDepends = [
         ansi-wl-pprint array base containers mtl multiset parsec
         union-find-array
       ];
       testHaskellDepends = [ base containers HUnit QuickCheck ];
       jailbreak = true;
       homepage = "http://cl-informatik.uibk.ac.at/software/haskell-rewriting/";
       description = "Term Rewriting Library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "termbox-bindings" = callPackage
    ({ mkDerivation, base, c2hs }:
     mkDerivation {
       pname = "termbox-bindings";
       version = "0.1.0.5";
       sha256 = "bb01fe054081a9affe0f5694ea4cf50f51825f2ad5b8e5a6cfca9a7ee7146743";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       libraryToolDepends = [ c2hs ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/luciferous/termbox-bindings";
       description = "Bindings to the Termbox library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "terminal-progress-bar" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, HUnit, stm, stm-chans
     , test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "terminal-progress-bar";
       version = "0.0.1.4";
       sha256 = "a36b3a305c58def80aa01fc2df46f4c15ea411a4531dd1723784e839448cbb51";
       libraryHaskellDepends = [
         base base-unicode-symbols stm stm-chans
       ];
       testHaskellDepends = [
         base base-unicode-symbols HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/roelvandijk/terminal-progress-bar";
       description = "A simple progress bar in the terminal";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "terminal-size_0_3_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "terminal-size";
       version = "0.3.0";
       sha256 = "7c9db8cd83b2cf2c49fce67ea0762315c87fc516fbd196a0d28e42201a021b3d";
       libraryHaskellDepends = [ base ];
       description = "Get terminal window height and width";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "terminal-size_0_3_2" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "terminal-size";
       version = "0.3.2";
       sha256 = "d737ed86e105fe1217416c4d59a6c10a2523ba86591ffb68001018596aeea66e";
       revision = "1";
       editedCabalFile = "9d18011d0c8779a7e928602d6750ca1f7cd069a7a1a08ca59224590bb250a955";
       libraryHaskellDepends = [ base ];
       description = "Get terminal window height and width";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "terminal-size" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "terminal-size";
       version = "0.3.2.1";
       sha256 = "b5c23e964756bc13914649a67d63233f59ad0a813abe7cadeb2fc9d586dc9658";
       libraryHaskellDepends = [ base ];
       description = "Get terminal window height and width";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "termination-combinators" = callPackage
    ({ mkDerivation, base, containers, contravariant }:
     mkDerivation {
       pname = "termination-combinators";
       version = "0.1";
       sha256 = "9027db33e370a409037f35c8fb4fd260429398f34cb78d2457daf6f977d162cc";
       libraryHaskellDepends = [ base containers contravariant ];
       jailbreak = true;
       homepage = "http://www.github.com/batterseapower/termination-combinators";
       description = "Termination combinators for forcing non-terminating algorithms to terminate";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "terminfo_0_4_0_1" = callPackage
    ({ mkDerivation, base, ncurses }:
     mkDerivation {
       pname = "terminfo";
       version = "0.4.0.1";
       sha256 = "a304011656f2f6fbc9a965fdcf6fc8592119b655c3ba138492c84c3cc3bb5ae3";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ ncurses ];
       homepage = "https://github.com/judah/terminfo";
       description = "Haskell bindings to the terminfo library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) ncurses;};

  "terminfo_0_4_0_2" = callPackage
    ({ mkDerivation, base, ncurses }:
     mkDerivation {
       pname = "terminfo";
       version = "0.4.0.2";
       sha256 = "fea88b28443f5efd316c7699685b3925c0a7613992305f11af03746139d8f856";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ ncurses ];
       homepage = "https://github.com/judah/terminfo";
       description = "Haskell bindings to the terminfo library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) ncurses;};

  "terminfo-hs" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , directory, errors, filepath, QuickCheck
     }:
     mkDerivation {
       pname = "terminfo-hs";
       version = "0.2.1";
       sha256 = "632fa74d6ae9fc0026022c6dd91577c8a05f95e973347b33b4d49cd9059a48ff";
       libraryHaskellDepends = [
         attoparsec base bytestring containers directory errors filepath
       ];
       testHaskellDepends = [ base directory errors filepath QuickCheck ];
       description = "A pure-Haskell (no FFI) module for accessing terminfo databases";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "termplot" = callPackage
    ({ mkDerivation, base, brick, data-default, optparse-applicative
     , process, split, time-units, transformers, unix, vty
     }:
     mkDerivation {
       pname = "termplot";
       version = "0.1.0.0";
       sha256 = "c84937853067147cfbd1dec0df3e488b63c6d9594c5e2a75e38ee786241a7364";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base brick data-default optparse-applicative process split
         time-units transformers unix vty
       ];
       jailbreak = true;
       homepage = "https://github.com/jimenezrick/termplot";
       description = "Plot time series in your terminal using commands stdout";
       license = stdenv.lib.licenses.mit;
     }) {};

  "terntup" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "terntup";
       version = "0.0.1";
       sha256 = "ffbb4c7dd4ccf56628360671a31745125a52f8131254fc98f2041e32bbe93ff7";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       description = "a ternary library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "terrahs" = callPackage
    ({ mkDerivation, base, haskell98, old-time, terralib4c, translib }:
     mkDerivation {
       pname = "terrahs";
       version = "0.9";
       sha256 = "0b52ac55ec87635def6462e0b0b23377141636f27cc3f829a3a11fbb2dfa913d";
       libraryHaskellDepends = [ base haskell98 old-time ];
       librarySystemDepends = [ terralib4c translib ];
       jailbreak = true;
       homepage = "http://lucc.ess.inpe.br/doku.php?id=terrahs";
       description = "A Haskell GIS Programming Environment";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {terralib4c = null; translib = null;};

  "tersmu" = callPackage
    ({ mkDerivation, base, containers, mtl, process, syb, transformers
     }:
     mkDerivation {
       pname = "tersmu";
       version = "0.2.1";
       sha256 = "96c068108cf92f6a4b9e24b64e3af8005b107e446ebd108d29fe5a68c7127881";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers mtl process syb transformers
       ];
       homepage = "http://mbays.freeshell.org/tersmu";
       description = "A semantic parser for lojban";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "test-framework_0_8_0_3" = callPackage
    ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, containers
     , hostname, old-locale, random, regex-posix, time, xml
     }:
     mkDerivation {
       pname = "test-framework";
       version = "0.8.0.3";
       sha256 = "5915bebf20a36f524241d1b85c45be2f767a9f9caeddc06d96e3ebab5ae1d68c";
       revision = "1";
       editedCabalFile = "b637576c9a1a313fa1274485a9af7745b21ff4ff7814feba6a2f4a0ab0b87f4a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal ansi-wl-pprint base containers hostname old-locale
         random regex-posix time xml
       ];
       jailbreak = true;
       homepage = "https://batterseapower.github.io/test-framework/";
       description = "Framework for running and organising tests, with HUnit and QuickCheck support";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "test-framework_0_8_1_0" = callPackage
    ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, containers
     , hostname, old-locale, random, regex-posix, time, xml
     }:
     mkDerivation {
       pname = "test-framework";
       version = "0.8.1.0";
       sha256 = "15ceb6f4ba48a45c4c8938d4eaa7cc431f41783dd00fc5a8bc3276c0db9247cb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal ansi-wl-pprint base containers hostname old-locale
         random regex-posix time xml
       ];
       homepage = "https://batterseapower.github.io/test-framework/";
       description = "Framework for running and organising tests, with HUnit and QuickCheck support";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "test-framework" = callPackage
    ({ mkDerivation, ansi-terminal, ansi-wl-pprint, base, containers
     , hostname, old-locale, random, regex-posix, time, xml
     }:
     mkDerivation {
       pname = "test-framework";
       version = "0.8.1.1";
       sha256 = "7883626a5aebb1df327bf26dbd382208946250a79f9cc3bf9a9eb0b0767bb273";
       revision = "1";
       editedCabalFile = "a6d9dbedbb574271e85c6e5ef9a9f935d87501a9b99b473bf306e3dcd36bdd9e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal ansi-wl-pprint base containers hostname old-locale
         random regex-posix time xml
       ];
       homepage = "https://batterseapower.github.io/test-framework/";
       description = "Framework for running and organising tests, with HUnit and QuickCheck support";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-framework-doctest" = callPackage
    ({ mkDerivation, base, doctest, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "test-framework-doctest";
       version = "0.2.1.2";
       sha256 = "185863eb3aea78ba85b8a3919d570aada59bad83f6fdc262563f10b6349b6006";
       libraryHaskellDepends = [
         base doctest test-framework test-framework-hunit
       ];
       testHaskellDepends = [ base test-framework ];
       jailbreak = true;
       description = "Test.Framework wrapper for DocTest";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "test-framework-golden" = callPackage
    ({ mkDerivation, base, bytestring, filepath, mtl, process
     , temporary, test-framework
     }:
     mkDerivation {
       pname = "test-framework-golden";
       version = "1.1.3.3";
       sha256 = "66700e5abe67ab8ab2418074f2fbca496cae2b4a62e870837c3c1efb43cacfe9";
       libraryHaskellDepends = [
         base bytestring filepath mtl process temporary test-framework
       ];
       homepage = "https://github.com/feuerbach/test-framework-golden";
       description = "Golden tests support for test-framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "test-framework-hunit_0_3_0_1" = callPackage
    ({ mkDerivation, base, extensible-exceptions, HUnit, test-framework
     }:
     mkDerivation {
       pname = "test-framework-hunit";
       version = "0.3.0.1";
       sha256 = "d3f9fd8e5e7251fa2f4727feb1397d80d9e979a4b086ee962dc239e3662910c0";
       revision = "1";
       editedCabalFile = "ef6155a767dc221d6f4dd2740fc79f5f4525b67e4cbb5c0ef3e5503d69594b29";
       libraryHaskellDepends = [
         base extensible-exceptions HUnit test-framework
       ];
       jailbreak = true;
       homepage = "https://batterseapower.github.io/test-framework/";
       description = "HUnit support for the test-framework package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "test-framework-hunit" = callPackage
    ({ mkDerivation, base, extensible-exceptions, HUnit, test-framework
     }:
     mkDerivation {
       pname = "test-framework-hunit";
       version = "0.3.0.2";
       sha256 = "95cb8ee02a850b164bfdabdf4dbc839d621361f3ac770ad21ea43a8bde360bf8";
       libraryHaskellDepends = [
         base extensible-exceptions HUnit test-framework
       ];
       homepage = "https://batterseapower.github.io/test-framework/";
       description = "HUnit support for the test-framework package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-framework-program" = callPackage
    ({ mkDerivation, base, directory, process, test-framework }:
     mkDerivation {
       pname = "test-framework-program";
       version = "1.1";
       sha256 = "7f6833a66bdafa9f237b90ec16d4c07df651213e73afc6c3c97e74b77aefe682";
       libraryHaskellDepends = [ base directory process test-framework ];
       description = "Test framework support for running simple test programs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-framework-quickcheck" = callPackage
    ({ mkDerivation, base, deepseq, extensible-exceptions, QuickCheck
     , random, test-framework
     }:
     mkDerivation {
       pname = "test-framework-quickcheck";
       version = "0.3.0";
       sha256 = "bba68b3276c63c65b40b19860b55fdf76786f86aeb31b6f500dac23afa801a3d";
       libraryHaskellDepends = [
         base deepseq extensible-exceptions QuickCheck random test-framework
       ];
       jailbreak = true;
       homepage = "http://batterseapower.github.com/test-framework/";
       description = "QuickCheck support for the test-framework package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "test-framework-quickcheck2" = callPackage
    ({ mkDerivation, base, extensible-exceptions, QuickCheck, random
     , test-framework
     }:
     mkDerivation {
       pname = "test-framework-quickcheck2";
       version = "0.3.0.3";
       sha256 = "cc96c6f30c29b16a3f7ec5c108f320a6c0f0d3ef71afff8a1cb98caf33ffe18a";
       revision = "1";
       editedCabalFile = "14fdf07c345e9460882b975851739afc2cf62f0c9930c38d0fee5b0943351638";
       libraryHaskellDepends = [
         base extensible-exceptions QuickCheck random test-framework
       ];
       homepage = "https://batterseapower.github.io/test-framework/";
       description = "QuickCheck2 support for the test-framework package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-framework-sandbox" = callPackage
    ({ mkDerivation, ansi-terminal, base, HUnit, lifted-base, mtl
     , temporary, test-framework, test-sandbox, test-sandbox-hunit
     , transformers
     }:
     mkDerivation {
       pname = "test-framework-sandbox";
       version = "0.1.0";
       sha256 = "fbd88b4e3e76f82a28bd8533ce7823cf403129c5acdb76631305b6840205d22d";
       libraryHaskellDepends = [
         ansi-terminal base lifted-base mtl temporary test-framework
         test-sandbox transformers
       ];
       testHaskellDepends = [
         base HUnit test-framework test-sandbox test-sandbox-hunit
       ];
       homepage = "http://gree.github.io/haskell-test-sandbox/";
       description = "test-sandbox support for the test-framework package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-framework-skip" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, smallcheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , test-framework-smallcheck
     }:
     mkDerivation {
       pname = "test-framework-skip";
       version = "1.0";
       sha256 = "c98e4bf8ca6245d6500263b5f8ec7d5c87462d1ec2011ff150862065a4197aab";
       libraryHaskellDepends = [ base test-framework ];
       testHaskellDepends = [
         base HUnit QuickCheck smallcheck test-framework
         test-framework-hunit test-framework-quickcheck2
         test-framework-smallcheck
       ];
       jailbreak = true;
       description = "Functions for conveniently marking some of the tests in a suite as being skipped";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-framework-smallcheck" = callPackage
    ({ mkDerivation, base, smallcheck, test-framework, transformers }:
     mkDerivation {
       pname = "test-framework-smallcheck";
       version = "0.2";
       sha256 = "6081c4f35967b0d0cb92ac09a915fa9e2da01c401266b20ce18793fbc2bceff6";
       libraryHaskellDepends = [
         base smallcheck test-framework transformers
       ];
       homepage = "https://github.com/feuerbach/smallcheck";
       description = "Support for SmallCheck tests in test-framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-framework-testing-feat" = callPackage
    ({ mkDerivation, base, test-framework, testing-feat }:
     mkDerivation {
       pname = "test-framework-testing-feat";
       version = "0.1.0.1";
       sha256 = "24a561741fd9bc1673709f268e2ba54be2d4e011a1629c3978301286f53dc05d";
       libraryHaskellDepends = [ base test-framework testing-feat ];
       testHaskellDepends = [ base test-framework testing-feat ];
       homepage = "http://github.com/jfischoff/test-framework-testing-feat";
       description = "A test framework provider for testing-feat";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-framework-th" = callPackage
    ({ mkDerivation, base, haskell-src-exts, language-haskell-extract
     , regex-posix, template-haskell, test-framework
     }:
     mkDerivation {
       pname = "test-framework-th";
       version = "0.2.4";
       sha256 = "8b780d9e3edd8d91e24f72d9fa1f80420e52959428ad7c22d0694901a43f9c8a";
       libraryHaskellDepends = [
         base haskell-src-exts language-haskell-extract regex-posix
         template-haskell test-framework
       ];
       homepage = "http://github.com/finnsson/test-generator";
       description = "Automagically generate the HUnit- and Quickcheck-bulk-code using Template Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-framework-th-prime" = callPackage
    ({ mkDerivation, base, cpphs, haskell-src-exts, template-haskell
     , test-framework
     }:
     mkDerivation {
       pname = "test-framework-th-prime";
       version = "0.0.8";
       sha256 = "193238b8854537f94903a99fc4b53b33777bf40c974c46a075a8e9dfdb5d673d";
       libraryHaskellDepends = [
         base cpphs haskell-src-exts template-haskell test-framework
       ];
       description = "Template Haskell for test framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-invariant" = callPackage
    ({ mkDerivation, base, QuickCheck, tasty, tasty-quickcheck }:
     mkDerivation {
       pname = "test-invariant";
       version = "0.4.5.0";
       sha256 = "306fbfcd1b7fea5a88b757ac90550ae6083f64e9dae7da5a3a26c87acf9c6332";
       libraryHaskellDepends = [ base QuickCheck ];
       testHaskellDepends = [ base QuickCheck tasty tasty-quickcheck ];
       homepage = "https://github.com/knupfer/test-invariant";
       description = "Provide common invariants to be checked with QuickCheck";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-pkg" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "test-pkg";
       version = "0.3.0.0";
       sha256 = "c88ac7972b8612c8630183cc511d80e93998518819064a5ab62b773ddaf2cc3a";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Just tests Hackage";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-sandbox" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, data-default
     , directory, filepath, hastache, heredoc, hspec
     , hspec-expectations-lifted, lifted-base, monad-control
     , monad-loops, mtl, network, process, QuickCheck, random
     , random-shuffle, regex-posix, template-haskell, temporary, text
     , transformers, transformers-base, transformers-compat, unix
     }:
     mkDerivation {
       pname = "test-sandbox";
       version = "0.1.5";
       sha256 = "5a02005aed04af0ed9d2781df0921ff0934e01c0ae6ac50cc1980bf7e9c276b2";
       libraryHaskellDepends = [
         base bytestring cereal containers data-default directory filepath
         lifted-base monad-control monad-loops mtl network process random
         random-shuffle regex-posix temporary transformers transformers-base
         transformers-compat unix
       ];
       testHaskellDepends = [
         base containers directory hastache heredoc hspec
         hspec-expectations-lifted mtl process QuickCheck regex-posix
         template-haskell text transformers transformers-compat unix
       ];
       jailbreak = true;
       homepage = "http://gree.github.io/haskell-test-sandbox/";
       description = "Sandbox for system tests";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-sandbox-compose" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cabal-test-bin
     , containers, directory, hastache, hspec, hspec-test-sandbox
     , http-conduit, lifted-base, network, optparse-applicative, process
     , shakespeare, shelly, test-sandbox, text, unix, wai, wai-extra
     , warp, yaml, yesod, yesod-core
     }:
     mkDerivation {
       pname = "test-sandbox-compose";
       version = "0.1.3";
       sha256 = "fd28485891def040e73e82c065c6bb5f26bbf6ac372422397098d7ffc62a10fb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers directory hastache http-conduit
         lifted-base network process shelly test-sandbox text unix wai
         wai-extra warp yaml yesod yesod-core
       ];
       executableHaskellDepends = [
         aeson base bytestring containers directory hastache http-conduit
         lifted-base network optparse-applicative process shelly
         test-sandbox text unix wai wai-extra warp yaml yesod yesod-core
       ];
       testHaskellDepends = [
         base bytestring cabal-test-bin hspec hspec-test-sandbox process
         shakespeare test-sandbox text unix
       ];
       description = "Lightweight development enviroments using test-sandbox";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-sandbox-hunit" = callPackage
    ({ mkDerivation, base, HUnit, lifted-base, test-sandbox }:
     mkDerivation {
       pname = "test-sandbox-hunit";
       version = "0.1.2";
       sha256 = "f3fea0e68663dab3c65a065990220373ba0688a898eec262f9041b62e573166d";
       libraryHaskellDepends = [ base HUnit lifted-base test-sandbox ];
       homepage = "http://gree.github.io/haskell-test-sandbox/";
       description = "HUnit convenience functions for use with test-sandbox";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-sandbox-quickcheck" = callPackage
    ({ mkDerivation, base, mtl, QuickCheck, random, test-sandbox
     , transformers
     }:
     mkDerivation {
       pname = "test-sandbox-quickcheck";
       version = "0.1.0";
       sha256 = "d1c7a7d787c1f7dd62a7527048e4e574e1d4cc72ce2200f7145852c6b1c1323e";
       libraryHaskellDepends = [
         base mtl QuickCheck random test-sandbox transformers
       ];
       homepage = "http://gree.github.io/haskell-test-sandbox/";
       description = "QuickCheck convenience functions for use with test-sandbox";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "test-shouldbe" = callPackage
    ({ mkDerivation, base, hspec, hspec-discover, HUnit, silently }:
     mkDerivation {
       pname = "test-shouldbe";
       version = "0.2.1.1";
       sha256 = "a43bd874f17192f622abc9f948531b77358689630d35da2fb755542f29744f71";
       libraryHaskellDepends = [ base HUnit ];
       testHaskellDepends = [ base hspec hspec-discover silently ];
       jailbreak = true;
       description = "Catchy combinators for HUnit";
       license = stdenv.lib.licenses.mit;
     }) {};

  "test-simple" = callPackage
    ({ mkDerivation, base, executable-path, mtl, process, QuickCheck
     , state-plus, template-haskell
     }:
     mkDerivation {
       pname = "test-simple";
       version = "0.1.8";
       sha256 = "8e8bacb6299e82d1f3f3643144e24ce574b99b2f052bd630930a4c2e62267895";
       libraryHaskellDepends = [
         base mtl QuickCheck state-plus template-haskell
       ];
       testHaskellDepends = [
         base executable-path mtl process QuickCheck
       ];
       description = "Simple Perl inspired testing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "testPkg" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "testPkg";
       version = "0.0";
       sha256 = "a03548f323235ea3c4ebf78c44a1e03fce506cccd8872614f219770ca0fff752";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       jailbreak = true;
       description = "Small test package";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "testing-feat" = callPackage
    ({ mkDerivation, base, mtl, QuickCheck, tagshare, template-haskell
     }:
     mkDerivation {
       pname = "testing-feat";
       version = "0.4.0.2";
       sha256 = "522c0f2d24e23861c95fb5a903a852c1a331508690cefc128c962a720f37f195";
       revision = "1";
       editedCabalFile = "0168dde1e9ac0e7a1f80a33c12a6c5d2b7c5e59e4dcd060ffb8d82f100c4dd3f";
       libraryHaskellDepends = [
         base mtl QuickCheck tagshare template-haskell
       ];
       description = "Functional Enumeration of Algebraic Types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "testing-type-modifiers" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "testing-type-modifiers";
       version = "0.1.0.1";
       sha256 = "050bdade2c6f0122b1a04a3833ab7eea2399ffda8258bca6d93ba6614bb202f2";
       libraryHaskellDepends = [ base ];
       description = "Data type modifiers for property based testing";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "testloop" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, fsnotify, hint
     , mtl, system-filepath, time, unix
     }:
     mkDerivation {
       pname = "testloop";
       version = "0.1.1.0";
       sha256 = "ffac18cca070139638a85d7b83a5d0237726b49e9f8ceba104c683665973cfaf";
       libraryHaskellDepends = [
         base Cabal directory filepath fsnotify hint mtl system-filepath
         time unix
       ];
       jailbreak = true;
       homepage = "http://github.com/roman/testloop";
       description = "Quick feedback loop for test suites";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "testpack" = callPackage
    ({ mkDerivation, base, containers, HUnit, mtl, QuickCheck, random
     }:
     mkDerivation {
       pname = "testpack";
       version = "2.1.3.0";
       sha256 = "97d82562edfb3fb4a7caf015ce62065efef86b27d9d5eed6bb6fc8d3886905e7";
       revision = "1";
       editedCabalFile = "c763bcd695cf8a5c02fb4ac9e73c08f66287d3649e81b9c2882af44700efaf39";
       libraryHaskellDepends = [
         base containers HUnit mtl QuickCheck random
       ];
       jailbreak = true;
       homepage = "https://github.com/jgoerzen/testpack";
       description = "Test Utililty Pack for HUnit and QuickCheck (unmaintained)";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "testpattern" = callPackage
    ({ mkDerivation, base, filepath, gtk }:
     mkDerivation {
       pname = "testpattern";
       version = "0.1";
       sha256 = "74c01d2240c59a3eea01a9065fad3b9bdf29ae0957e06666f3b27c434ae11328";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base filepath gtk ];
       homepage = "http://code.haskell.org/~dons/code/testpattern";
       description = "Display a monitor test pattern";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "testrunner" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, random, regex-compat, stm
     }:
     mkDerivation {
       pname = "testrunner";
       version = "0.9.1";
       sha256 = "5c4530d8e9622d7c848767ea94994f52f137ea07fbaf4d645fd4d662f97807a1";
       libraryHaskellDepends = [
         base HUnit QuickCheck random regex-compat stm
       ];
       description = "Easy unit test driver framework";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tetris" = callPackage
    ({ mkDerivation, base, GLUT, random }:
     mkDerivation {
       pname = "tetris";
       version = "0.27178";
       sha256 = "fcc91d4a6d39cec252a47528761b47f5a0cefabeaf53b42a9243a9995de09483";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base GLUT random ];
       homepage = "http://d.hatena.ne.jp/mokehehe/20080921/tetris";
       description = "A 2-D clone of Tetris";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tex2txt" = callPackage
    ({ mkDerivation, base, containers, deepseq, parsec }:
     mkDerivation {
       pname = "tex2txt";
       version = "0.1.0.0";
       sha256 = "1c5cb060e879309cf67198d51b877851c7becbdc9a6ecf195bb01f4ae19d81e0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers deepseq parsec ];
       executableHaskellDepends = [ base containers deepseq parsec ];
       jailbreak = true;
       homepage = "http://textmining.lt/tex2txt/";
       description = "LaTeX to plain-text conversion";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "texmath_0_8" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, pandoc-types, parsec, process, split, syb, temporary, text
     , utf8-string, xml
     }:
     mkDerivation {
       pname = "texmath";
       version = "0.8";
       sha256 = "eb9d558a67ac429055ebf70484b36a58ddbc9df1be59dfbf13146247524911c8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl pandoc-types parsec syb xml
       ];
       testHaskellDepends = [
         base bytestring directory filepath process split temporary text
         utf8-string xml
       ];
       homepage = "http://github.com/jgm/texmath";
       description = "Conversion between formats used to represent mathematics";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "texmath_0_8_0_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, network-uri, pandoc-types, parsec, process, split, syb
     , temporary, text, utf8-string, xml
     }:
     mkDerivation {
       pname = "texmath";
       version = "0.8.0.1";
       sha256 = "9625e7106c76199f1228777569a49900bf300e1f4880c69c22986358d5d5c8cc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl pandoc-types parsec syb xml
       ];
       executableHaskellDepends = [ network-uri ];
       testHaskellDepends = [
         base bytestring directory filepath process split temporary text
         utf8-string xml
       ];
       homepage = "http://github.com/jgm/texmath";
       description = "Conversion between formats used to represent mathematics";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "texmath_0_8_0_2" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, network-uri, pandoc-types, parsec, process, split, syb
     , temporary, text, utf8-string, xml
     }:
     mkDerivation {
       pname = "texmath";
       version = "0.8.0.2";
       sha256 = "47b9c3fdceed63c5d63987db7e511a38ea8ddf8591786ef56efea734a3c31f86";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl pandoc-types parsec syb xml
       ];
       executableHaskellDepends = [ network-uri ];
       testHaskellDepends = [
         base bytestring directory filepath process split temporary text
         utf8-string xml
       ];
       homepage = "http://github.com/jgm/texmath";
       description = "Conversion between formats used to represent mathematics";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "texmath_0_8_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, network-uri, pandoc-types, parsec, process, split, syb
     , temporary, text, utf8-string, xml
     }:
     mkDerivation {
       pname = "texmath";
       version = "0.8.1";
       sha256 = "d8e043a7d78e16f4775173d8642d8ce0e5735163b3f22b5f2a36dc452759604c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl pandoc-types parsec syb xml
       ];
       executableHaskellDepends = [ network-uri ];
       testHaskellDepends = [
         base bytestring directory filepath process split temporary text
         utf8-string xml
       ];
       jailbreak = true;
       homepage = "http://github.com/jgm/texmath";
       description = "Conversion between formats used to represent mathematics";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "texmath_0_8_2" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, network-uri, pandoc-types, parsec, process, split, syb
     , temporary, text, utf8-string, xml
     }:
     mkDerivation {
       pname = "texmath";
       version = "0.8.2";
       sha256 = "f9b7dd4ca3f8b1e868f0cd22db8432b85d26553464f20b60ccfb311215001db7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl pandoc-types parsec syb xml
       ];
       executableHaskellDepends = [ network-uri ];
       testHaskellDepends = [
         base bytestring directory filepath process split temporary text
         utf8-string xml
       ];
       jailbreak = true;
       homepage = "http://github.com/jgm/texmath";
       description = "Conversion between formats used to represent mathematics";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "texmath_0_8_2_2" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, network-uri, pandoc-types, parsec, process, split, syb
     , temporary, text, utf8-string, xml
     }:
     mkDerivation {
       pname = "texmath";
       version = "0.8.2.2";
       sha256 = "a1f492d8bfdd9a28f9bbb546fd335e285b7da15ab1e7ac0cc0c96a8e42cec2f3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl pandoc-types parsec syb xml
       ];
       executableHaskellDepends = [ network-uri ];
       testHaskellDepends = [
         base bytestring directory filepath process split temporary text
         utf8-string xml
       ];
       jailbreak = true;
       homepage = "http://github.com/jgm/texmath";
       description = "Conversion between formats used to represent mathematics";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "texmath_0_8_3" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, network-uri, pandoc-types, parsec, process, split, syb
     , temporary, text, utf8-string, xml
     }:
     mkDerivation {
       pname = "texmath";
       version = "0.8.3";
       sha256 = "553d4e8785caf97370aa8d1b626c0e310fe0a1dec15abf2b146dc2ee219e1d34";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl pandoc-types parsec syb xml
       ];
       executableHaskellDepends = [ network-uri ];
       testHaskellDepends = [
         base bytestring directory filepath process split temporary text
         utf8-string xml
       ];
       jailbreak = true;
       homepage = "http://github.com/jgm/texmath";
       description = "Conversion between formats used to represent mathematics";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "texmath_0_8_4" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, network-uri, pandoc-types, parsec, process, split, syb
     , temporary, text, utf8-string, xml
     }:
     mkDerivation {
       pname = "texmath";
       version = "0.8.4";
       sha256 = "318b8d640e6badd1ccc5b4cbb9c3c7186103959ee5d2a778267939629e0c0295";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl pandoc-types parsec syb xml
       ];
       executableHaskellDepends = [ network-uri ];
       testHaskellDepends = [
         base bytestring directory filepath process split temporary text
         utf8-string xml
       ];
       jailbreak = true;
       homepage = "http://github.com/jgm/texmath";
       description = "Conversion between formats used to represent mathematics";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "texmath_0_8_4_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, network-uri, pandoc-types, parsec, process, split, syb
     , temporary, text, utf8-string, xml
     }:
     mkDerivation {
       pname = "texmath";
       version = "0.8.4.1";
       sha256 = "45a9c779775e4e6effd7606bef5c179524b4fb88dca952c2decd3fa82e6c94f5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl pandoc-types parsec syb xml
       ];
       executableHaskellDepends = [ network-uri ];
       testHaskellDepends = [
         base bytestring directory filepath process split temporary text
         utf8-string xml
       ];
       homepage = "http://github.com/jgm/texmath";
       description = "Conversion between formats used to represent mathematics";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "texmath" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, network-uri, pandoc-types, parsec, process, split, syb
     , temporary, text, utf8-string, xml
     }:
     mkDerivation {
       pname = "texmath";
       version = "0.8.4.2";
       sha256 = "ee18da2835eba8ec388d15b4fa08cb72d789bb345be3abc4eac1713f0052b17d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl pandoc-types parsec syb xml
       ];
       executableHaskellDepends = [ network-uri ];
       testHaskellDepends = [
         base bytestring directory filepath process split temporary text
         utf8-string xml
       ];
       homepage = "http://github.com/jgm/texmath";
       description = "Conversion between formats used to represent mathematics";
       license = "GPL";
     }) {};

  "texrunner" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, directory, filepath
     , HUnit, io-streams, lens, mtl, process, temporary, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "texrunner";
       version = "0.0.1.0";
       sha256 = "9a410aae2b62fbfcdacab43de470002a65c1fa095775805365dc1467be4bf8dc";
       libraryHaskellDepends = [
         attoparsec base bytestring directory filepath io-streams mtl
         process temporary
       ];
       testHaskellDepends = [
         base bytestring HUnit lens test-framework test-framework-hunit
       ];
       description = "Functions for running Tex from Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "text_1_1_1_3" = callPackage
    ({ mkDerivation, array, base, bytestring, deepseq, directory
     , ghc-prim, HUnit, integer-gmp, QuickCheck, random, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "text";
       version = "1.1.1.3";
       sha256 = "0c7c94ee281deba5f58aa2a63c0f7a624227a570b5d5b49c807f2d9b08793ffb";
       revision = "1";
       editedCabalFile = "4384b331a195fbfb8b5cb4ad85dd2f65ae04f0b62a43bef622ff29a5d12612b8";
       libraryHaskellDepends = [
         array base bytestring deepseq ghc-prim integer-gmp
       ];
       testHaskellDepends = [
         array base bytestring deepseq directory ghc-prim HUnit integer-gmp
         QuickCheck random test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/bos/text";
       description = "An efficient packed Unicode text type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "text_1_2_0_3" = callPackage
    ({ mkDerivation, array, base, bytestring, deepseq, directory
     , ghc-prim, HUnit, integer-gmp, QuickCheck, quickcheck-unicode
     , random, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "text";
       version = "1.2.0.3";
       sha256 = "1d38bc0a8bf60c2f3581558a7870d6db7eefbe6da5df4d80a42c9b4837f8f986";
       revision = "1";
       editedCabalFile = "1ad163864f042122ba30e6707a3e4ffe8f2b7f69c2b24db365a478fbe1e3f119";
       libraryHaskellDepends = [
         array base bytestring deepseq ghc-prim integer-gmp
       ];
       testHaskellDepends = [
         array base bytestring deepseq directory ghc-prim HUnit integer-gmp
         QuickCheck quickcheck-unicode random test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "https://github.com/bos/text";
       description = "An efficient packed Unicode text type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "text_1_2_0_4" = callPackage
    ({ mkDerivation, array, base, bytestring, deepseq, directory
     , ghc-prim, HUnit, integer-gmp, QuickCheck, quickcheck-unicode
     , random, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "text";
       version = "1.2.0.4";
       sha256 = "865dbb8e824c197cdda6a15e8764c057335febe05573a764e54867460e0b9700";
       revision = "1";
       editedCabalFile = "ee605e146a984f0f9ea30b9e8d92a93a765f1bcc1fa6b6d23e0487fc3f210f0b";
       libraryHaskellDepends = [
         array base bytestring deepseq ghc-prim integer-gmp
       ];
       testHaskellDepends = [
         array base bytestring deepseq directory ghc-prim HUnit integer-gmp
         QuickCheck quickcheck-unicode random test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "https://github.com/bos/text";
       description = "An efficient packed Unicode text type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "text_1_2_0_6" = callPackage
    ({ mkDerivation, array, base, bytestring, deepseq, directory
     , ghc-prim, HUnit, integer-gmp, QuickCheck, quickcheck-unicode
     , random, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "text";
       version = "1.2.0.6";
       sha256 = "d8fd82e876b4d1f2f4c25605adde2092308524a246fb4b3f4f665d73aaf56f73";
       revision = "1";
       editedCabalFile = "1d5d0c706835f1ca74925cd3b0aa025bf4ee0fd795581b6038c13cd030fddb47";
       libraryHaskellDepends = [
         array base bytestring deepseq ghc-prim integer-gmp
       ];
       testHaskellDepends = [
         array base bytestring deepseq directory ghc-prim HUnit integer-gmp
         QuickCheck quickcheck-unicode random test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "https://github.com/bos/text";
       description = "An efficient packed Unicode text type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "text_1_2_1_3" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, deepseq
     , directory, ghc-prim, HUnit, integer-gmp, QuickCheck
     , quickcheck-unicode, random, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "text";
       version = "1.2.1.3";
       sha256 = "98364c94f259ec95e380e44bde90b37708ec6f0d45eb9efe821ab67959e9f83f";
       revision = "1";
       editedCabalFile = "0f5b6a2f9204089b6cc58071b92e9f2fc3e6d773e3aa486b4a66bf25e124712a";
       libraryHaskellDepends = [
         array base binary bytestring deepseq ghc-prim integer-gmp
       ];
       testHaskellDepends = [
         array base binary bytestring deepseq directory ghc-prim HUnit
         integer-gmp QuickCheck quickcheck-unicode random test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "https://github.com/bos/text";
       description = "An efficient packed Unicode text type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "text" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, deepseq
     , directory, ghc-prim, HUnit, integer-gmp, QuickCheck
     , quickcheck-unicode, random, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "text";
       version = "1.2.2.0";
       sha256 = "3fb3921488b4c10f1a389f4ad1a1ae44cf1a6d1ce4305a55d1d7c745cff50088";
       libraryHaskellDepends = [
         array base binary bytestring deepseq ghc-prim integer-gmp
       ];
       testHaskellDepends = [
         array base binary bytestring deepseq directory ghc-prim HUnit
         integer-gmp QuickCheck quickcheck-unicode random test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       doCheck = false;
       homepage = "https://github.com/bos/text";
       description = "An efficient packed Unicode text type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "text-and-plots" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, containers, markdown
     , text, unordered-containers
     }:
     mkDerivation {
       pname = "text-and-plots";
       version = "0.2.1.0";
       sha256 = "e8a72fa6a54230ff2e390512e949a3f800ac29735795133dfd0eaf6b72935c3a";
       libraryHaskellDepends = [
         base blaze-html bytestring containers markdown text
         unordered-containers
       ];
       homepage = "https://github.com/andersjel/haskell-text-and-plots";
       description = "EDSL to create HTML documents with plots based on the C3.js library.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "text-binary_0_1_0" = callPackage
    ({ mkDerivation, base, binary, text }:
     mkDerivation {
       pname = "text-binary";
       version = "0.1.0";
       sha256 = "dfcccc976b60f7b9882e2b742ce824ecf1e050581e86461cb457638864008571";
       revision = "2";
       editedCabalFile = "3524207f26b3df55c76ecb6c4b50e761dd1a9bec605aa9d696c706d989785119";
       libraryHaskellDepends = [ base binary text ];
       jailbreak = true;
       homepage = "https://github.com/kawu/text-binary";
       description = "Binary instances for text types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "text-binary" = callPackage
    ({ mkDerivation, base, binary, text }:
     mkDerivation {
       pname = "text-binary";
       version = "0.2.1";
       sha256 = "df22f237ebfe8c813be289d40e86ce3590ccc9c33c41053f4234b5672dc7ea02";
       libraryHaskellDepends = [ base binary text ];
       homepage = "https://github.com/kawu/text-binary";
       description = "Binary instances for text types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "text-format" = callPackage
    ({ mkDerivation, array, base, double-conversion, ghc-prim
     , integer-gmp, old-locale, text, time, transformers
     }:
     mkDerivation {
       pname = "text-format";
       version = "0.3.1.1";
       sha256 = "6de112764446a65370204f35a5fc4b1831106049f90918545d5dcd2ddd7fee0b";
       libraryHaskellDepends = [
         array base double-conversion ghc-prim integer-gmp old-locale text
         time transformers
       ];
       homepage = "https://github.com/bos/text-format";
       description = "Text formatting";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "text-format-simple" = callPackage
    ({ mkDerivation, base, MissingH }:
     mkDerivation {
       pname = "text-format-simple";
       version = "1.1.0";
       sha256 = "13e2af87e67ddd359702213c60445d1a6f973f6ef8ca73e96732c739c01e1a47";
       libraryHaskellDepends = [ base MissingH ];
       description = "Simple text formatting library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "text-icu_0_7_0_0" = callPackage
    ({ mkDerivation, array, base, bytestring, deepseq, directory
     , ghc-prim, HUnit, icu, QuickCheck, random, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "text-icu";
       version = "0.7.0.0";
       sha256 = "3edbfe54e35ab0547d66d2e1ab1cd7390ac5f906a4a52ab61087ef99223678bb";
       revision = "2";
       editedCabalFile = "19434ecaff8ca937793656a4d0cadbe33c44debe36d05ccc06f5fc692382b81d";
       libraryHaskellDepends = [ base bytestring deepseq text ];
       librarySystemDepends = [ icu ];
       testHaskellDepends = [
         array base bytestring deepseq directory ghc-prim HUnit QuickCheck
         random test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "https://github.com/bos/text-icu";
       description = "Bindings to the ICU library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) icu;};

  "text-icu" = callPackage
    ({ mkDerivation, array, base, bytestring, deepseq, directory
     , ghc-prim, HUnit, icu, QuickCheck, random, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "text-icu";
       version = "0.7.0.1";
       sha256 = "e2764c2749033706eed5b9fb3cda11177ad15cdf11912028f551eca39a2c7f78";
       libraryHaskellDepends = [ base bytestring deepseq text ];
       librarySystemDepends = [ icu ];
       testHaskellDepends = [
         array base bytestring deepseq directory ghc-prim HUnit QuickCheck
         random test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       homepage = "https://github.com/bos/text-icu";
       description = "Bindings to the ICU library";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) icu;};

  "text-icu-translit" = callPackage
    ({ mkDerivation, base, icu, QuickCheck, test-framework
     , test-framework-quickcheck2, text, text-icu
     }:
     mkDerivation {
       pname = "text-icu-translit";
       version = "0.1.0.7";
       sha256 = "028026a5a73e3bf5373de8895f66409e2841b0353468b7a99d4162af9a9fd5e1";
       libraryHaskellDepends = [ base text ];
       librarySystemDepends = [ icu ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2 text
         text-icu
       ];
       description = "ICU transliteration";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) icu;};

  "text-json-qq" = callPackage
    ({ mkDerivation, base, haskell-src-meta, json, json-qq, parsec
     , template-haskell
     }:
     mkDerivation {
       pname = "text-json-qq";
       version = "0.4.1";
       sha256 = "0f368864ff18f048d2c5ea80632cb936c4a7e54c2ec47aa434f495ef472af58c";
       libraryHaskellDepends = [
         base haskell-src-meta json json-qq parsec template-haskell
       ];
       homepage = "http://github.com/finnsson/text-json-qq";
       description = "Json Quasiquatation for Haskell";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "text-latin1" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, data-checked
     , hashable, text
     }:
     mkDerivation {
       pname = "text-latin1";
       version = "0.3";
       sha256 = "892bbccaed95502faf33dfda612358f24fcaaee521ffa926b34b5236394e40b3";
       libraryHaskellDepends = [
         base bytestring case-insensitive data-checked hashable text
       ];
       homepage = "https://github.com/mvv/text-latin1";
       description = "Latin-1 (including ASCII) utility functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "text-ldap" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, bytestring
     , containers, dlist, QuickCheck, quickcheck-simple, random
     , semigroups, transformers
     }:
     mkDerivation {
       pname = "text-ldap";
       version = "0.1.1.6";
       sha256 = "b88abdaf75171463fdb74507ad7a1688113f600b82eb808d54cae181245b208b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base base64-bytestring bytestring containers dlist
         semigroups transformers
       ];
       executableHaskellDepends = [ base bytestring ];
       testHaskellDepends = [
         base bytestring QuickCheck quickcheck-simple random semigroups
       ];
       description = "Parser and Printer for LDAP text data stream";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "text-locale-encoding" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-handle, text }:
     mkDerivation {
       pname = "text-locale-encoding";
       version = "0.1.0.2";
       sha256 = "cfa52bca5eb69f8a08b78a5bc585c79f41b8faf6f9858998aa35735c880e44d3";
       libraryHaskellDepends = [ base bytestring bytestring-handle text ];
       homepage = "https://github.com/exbb2/text-locale-encoding";
       description = "Encode and decode Text to/from ByteString using TextEncoding";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "text-manipulate_0_1_3_1" = callPackage
    ({ mkDerivation, base, tasty, tasty-hunit, text, text-format }:
     mkDerivation {
       pname = "text-manipulate";
       version = "0.1.3.1";
       sha256 = "4c3ec73db9c3870fecf5cb987d29acfecbb4d3a40c3fb73472d123666e82f54c";
       libraryHaskellDepends = [ base text text-format ];
       testHaskellDepends = [ base tasty tasty-hunit text ];
       homepage = "https://github.com/brendanhay/text-manipulate";
       description = "Case conversion, word boundary manipulation, and textual subjugation";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "text-manipulate" = callPackage
    ({ mkDerivation, base, tasty, tasty-hunit, text }:
     mkDerivation {
       pname = "text-manipulate";
       version = "0.2.0.1";
       sha256 = "e0e9c71d9b1cfb7d3bca3d0a500d939b3efc6684515c0d7bd685503aa4f49d2f";
       libraryHaskellDepends = [ base text ];
       testHaskellDepends = [ base tasty tasty-hunit text ];
       homepage = "https://github.com/brendanhay/text-manipulate";
       description = "Case conversion, word boundary manipulation, and textual subjugation";
       license = "unknown";
     }) {};

  "text-normal" = callPackage
    ({ mkDerivation, base, deepseq, hspec, QuickCheck
     , quickcheck-instances, text, text-icu
     }:
     mkDerivation {
       pname = "text-normal";
       version = "0.2.1.0";
       sha256 = "3b06f6436e828994d6d1d8ef363adf73462f3a10551c4fbb6c4e605088dd9d81";
       libraryHaskellDepends = [ base deepseq text text-icu ];
       testHaskellDepends = [
         base hspec QuickCheck quickcheck-instances
       ];
       homepage = "https://github.com/joelteon/text-normal.git";
       description = "Unicode-normalized text";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "text-position" = callPackage
    ({ mkDerivation, base, QuickCheck, regex-applicative }:
     mkDerivation {
       pname = "text-position";
       version = "0.1.0.0";
       sha256 = "e8055a2d125d84eb861b3e3c9de5339552284957dcbef96053f56f7ef92cb131";
       revision = "2";
       editedCabalFile = "47ad75275f3f8f705336ebac8adc9af40682a530668e2e56655a243aa516c8e3";
       libraryHaskellDepends = [ base regex-applicative ];
       testHaskellDepends = [ base QuickCheck regex-applicative ];
       jailbreak = true;
       homepage = "http://rel4tion.org/projects/text-position/";
       description = "Handling positions in text and position-tagging it";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "text-postgresql" = callPackage
    ({ mkDerivation, base, dlist, QuickCheck, quickcheck-simple
     , transformers
     }:
     mkDerivation {
       pname = "text-postgresql";
       version = "0.0.2.0";
       sha256 = "abd84b2f205694f58be46ca9f8a2a98f1d407e74da27092aebaba1e26d48dc54";
       libraryHaskellDepends = [ base dlist transformers ];
       testHaskellDepends = [ base QuickCheck quickcheck-simple ];
       homepage = "http://khibino.github.io/haskell-relational-record/";
       description = "Parser and Printer of PostgreSQL extended types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "text-printer" = callPackage
    ({ mkDerivation, base, bytestring, pretty, QuickCheck, semigroups
     , test-framework, test-framework-quickcheck2, text, text-latin1
     }:
     mkDerivation {
       pname = "text-printer";
       version = "0.4";
       sha256 = "b878db9dfb786368324c35cb3e1070264eaa6b1d0f1459bf1581114bfbeb9149";
       libraryHaskellDepends = [
         base bytestring pretty semigroups text text-latin1
       ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       homepage = "https://github.com/mvv/text-printer";
       description = "Abstract interface for text builders/printers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "text-regex-replace" = callPackage
    ({ mkDerivation, attoparsec, base, hspec, QuickCheck, smallcheck
     , text, text-icu
     }:
     mkDerivation {
       pname = "text-regex-replace";
       version = "0.1.1.1";
       sha256 = "2f27c43d4e59cfb1be632fe3445e0164cc7e10f3b39f1ed21a1e36d6f0981258";
       libraryHaskellDepends = [ attoparsec base text text-icu ];
       testHaskellDepends = [
         base hspec QuickCheck smallcheck text text-icu
       ];
       description = "Easy replacement when using text-icu regexes";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "text-region" = callPackage
    ({ mkDerivation, aeson, base, base-unicode-symbols, bytestring
     , containers, groups, hspec, lens, mtl, text
     }:
     mkDerivation {
       pname = "text-region";
       version = "0.1.0.0";
       sha256 = "bf65047a5608e62b55a6a10067068b5ef63675df1b41148ad198f464e8f80673";
       libraryHaskellDepends = [
         aeson base base-unicode-symbols bytestring containers groups lens
         mtl text
       ];
       testHaskellDepends = [
         base base-unicode-symbols containers hspec lens mtl text
       ];
       homepage = "https://github.com/mvoidex/text-region";
       description = "Provides functions to update text region positions according to text edit actions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "text-register-machine" = callPackage
    ({ mkDerivation, base, containers, mtl, vector }:
     mkDerivation {
       pname = "text-register-machine";
       version = "0.4.0";
       sha256 = "f02e71da264754dc095b6bbc39811b33d0a137e1529e9ccc7472171b1d8c113c";
       libraryHaskellDepends = [ base containers mtl vector ];
       jailbreak = true;
       homepage = "https://github.com/acfoltzer/text-register-machine";
       description = "A Haskell implementation of the 1# Text Register Machine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "text-render" = callPackage
    ({ mkDerivation, base, classy-prelude, mtl, parsec, text }:
     mkDerivation {
       pname = "text-render";
       version = "0.1.0.2";
       sha256 = "978bc340cba883bfad3300eff67a7fa6689ead23d873ba0d4dd031725bb3cf9d";
       libraryHaskellDepends = [ base classy-prelude mtl parsec text ];
       homepage = "http://github.com/thinkpad20/text-render";
       description = "A type class for rendering objects as text, pretty-printing, etc";
       license = stdenv.lib.licenses.mit;
     }) {};

  "text-show_2" = callPackage
    ({ mkDerivation, array, base, base-compat, base-orphans, bytestring
     , bytestring-builder, containers, generic-deriving, ghc-prim, hspec
     , integer-gmp, nats, QuickCheck, quickcheck-instances, semigroups
     , tagged, template-haskell, text, transformers, transformers-compat
     , void
     }:
     mkDerivation {
       pname = "text-show";
       version = "2";
       sha256 = "5f64a35d1121c31a9166fd3910c865ad8f23e50edfc4b3733e63d4f415635694";
       revision = "2";
       editedCabalFile = "26d3d47cd81cdf00d2d529569aec498a095fe424a4469405527b40ef489c3cc4";
       libraryHaskellDepends = [
         array base base-compat bytestring bytestring-builder containers
         generic-deriving ghc-prim integer-gmp nats semigroups tagged
         template-haskell text transformers void
       ];
       testHaskellDepends = [
         array base base-compat base-orphans bytestring bytestring-builder
         generic-deriving ghc-prim hspec nats QuickCheck
         quickcheck-instances tagged text transformers transformers-compat
         void
       ];
       jailbreak = true;
       homepage = "https://github.com/RyanGlScott/text-show";
       description = "Efficient conversion of values into Text";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "text-show_2_1_2" = callPackage
    ({ mkDerivation, array, base, base-compat, base-orphans, bifunctors
     , bytestring, bytestring-builder, containers, generic-deriving
     , ghc-prim, hspec, integer-gmp, nats, QuickCheck
     , quickcheck-instances, semigroups, tagged, template-haskell, text
     , transformers, transformers-compat, void
     }:
     mkDerivation {
       pname = "text-show";
       version = "2.1.2";
       sha256 = "76c1ce631c6932816dc241b290400e7200d7c79fd50ec03f51964e244fae320d";
       revision = "2";
       editedCabalFile = "b3b37a10589923b91729f07291795acf58f98efd5df1f32de99ab27fa1d3eda3";
       libraryHaskellDepends = [
         array base base-compat bytestring bytestring-builder containers
         generic-deriving ghc-prim integer-gmp nats semigroups tagged
         template-haskell text transformers void
       ];
       testHaskellDepends = [
         array base base-compat base-orphans bifunctors bytestring
         bytestring-builder generic-deriving ghc-prim hspec nats QuickCheck
         quickcheck-instances tagged text transformers transformers-compat
         void
       ];
       jailbreak = true;
       homepage = "https://github.com/RyanGlScott/text-show";
       description = "Efficient conversion of values into Text";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "text-show" = callPackage
    ({ mkDerivation, array, base, base-compat, base-orphans, bifunctors
     , bytestring, bytestring-builder, containers, generic-deriving
     , ghc-prim, hspec, integer-gmp, nats, QuickCheck
     , quickcheck-instances, semigroups, tagged, template-haskell, text
     , th-lift, transformers, transformers-compat, void
     }:
     mkDerivation {
       pname = "text-show";
       version = "3.0.1";
       sha256 = "39806d6d3098f099ede1a740f6fb55e84144a34442496145063b408262b899ca";
       libraryHaskellDepends = [
         array base base-compat bifunctors bytestring bytestring-builder
         containers generic-deriving ghc-prim integer-gmp nats semigroups
         tagged template-haskell text th-lift transformers
         transformers-compat void
       ];
       testHaskellDepends = [
         array base base-compat base-orphans bifunctors bytestring
         bytestring-builder containers generic-deriving ghc-prim hspec
         integer-gmp nats QuickCheck quickcheck-instances semigroups tagged
         template-haskell text th-lift transformers transformers-compat void
       ];
       homepage = "https://github.com/RyanGlScott/text-show";
       description = "Efficient conversion of values into Text";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "text-show-instances" = callPackage
    ({ mkDerivation, base, base-compat, bifunctors, binary, bytestring
     , containers, directory, generic-deriving, ghc-prim, haskeline
     , hoopl, hpc, hspec, old-locale, old-time, pretty, QuickCheck
     , quickcheck-instances, random, semigroups, tagged
     , template-haskell, terminfo, text, text-show, th-orphans, time
     , transformers, transformers-compat, unix, unordered-containers
     , vector, xhtml
     }:
     mkDerivation {
       pname = "text-show-instances";
       version = "3.0.1";
       sha256 = "9164fd2e5ad017923d9e5cdafae6d895a4014009e982346e1a13b3ef8ecb1045";
       libraryHaskellDepends = [
         base base-compat bifunctors binary bytestring containers directory
         haskeline hoopl hpc old-locale old-time pretty random semigroups
         tagged template-haskell terminfo text text-show time transformers
         transformers-compat unix unordered-containers vector xhtml
       ];
       testHaskellDepends = [
         base base-compat bifunctors binary bytestring containers directory
         generic-deriving ghc-prim haskeline hoopl hpc hspec old-locale
         old-time pretty QuickCheck quickcheck-instances random semigroups
         tagged template-haskell terminfo text text-show th-orphans time
         transformers transformers-compat unix unordered-containers vector
         xhtml
       ];
       homepage = "https://github.com/RyanGlScott/text-show-instances";
       description = "Additional instances for text-show";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "text-stream-decode" = callPackage
    ({ mkDerivation, base, bytestring, deepseq, hspec, text }:
     mkDerivation {
       pname = "text-stream-decode";
       version = "0.1.0.5";
       sha256 = "fede45dc702b29ca3e25591df7f43244aa1a6ef99bb8bbc2e33aa35934b354e8";
       revision = "1";
       editedCabalFile = "d4ea8ff401a3ccbd8a6ce2918385bac4859150047ce9b7f752ff5575db71e9fd";
       libraryHaskellDepends = [ base bytestring text ];
       testHaskellDepends = [ base bytestring deepseq hspec text ];
       homepage = "http://github.com/fpco/text-stream-decode";
       description = "Streaming decoding functions for UTF encodings. (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "text-utf7" = callPackage
    ({ mkDerivation, base, bytestring, quickcheck-instances, tasty
     , tasty-hunit, tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "text-utf7";
       version = "0.1.0.0";
       sha256 = "9b4634419f0d072a0457f402662dc568c447ef2b0f54102e619b57b45ee28b4d";
       libraryHaskellDepends = [ base bytestring text ];
       testHaskellDepends = [
         base bytestring quickcheck-instances tasty tasty-hunit
         tasty-quickcheck text
       ];
       homepage = "https://github.com/dpwright/text-utf7";
       description = "UTF-7 encoding/decoding for Data.Text";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "text-xml-generic" = callPackage
    ({ mkDerivation, base, bytestring, containers, haskell98, mtl
     , not-in-base, split, syb, template-haskell, xml
     }:
     mkDerivation {
       pname = "text-xml-generic";
       version = "0.1.1";
       sha256 = "300c3a55cae3e97438d8799daf79870a75d56dd746070d713832484fd2c66ff0";
       libraryHaskellDepends = [
         base bytestring containers haskell98 mtl not-in-base split syb
         template-haskell xml
       ];
       homepage = "http://github.com/finnsson/Text.XML.Generic";
       description = "Serialize Data to XML (strings)";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "text-xml-qq" = callPackage
    ({ mkDerivation, base, parsec, template-haskell, xml }:
     mkDerivation {
       pname = "text-xml-qq";
       version = "0.1";
       sha256 = "a56515d6c2ea2e94ef3f0ee4cdf6f387d0b5367d3879f25c982b213b888d210c";
       libraryHaskellDepends = [ base parsec template-haskell xml ];
       homepage = "http://www.github.com/finnsson/text-xml-qq";
       description = "Quasiquoter for xml. XML DSL in Haskell.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "text-zipper" = callPackage
    ({ mkDerivation, base, text, vector }:
     mkDerivation {
       pname = "text-zipper";
       version = "0.3.1";
       sha256 = "b407d9e898b1aa8550bbf7372623185f11b574e4497cf76cbc81ea4c849744b0";
       libraryHaskellDepends = [ base text vector ];
       description = "A text editor zipper library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "text1" = callPackage
    ({ mkDerivation, base, binary, directory, doctest, filepath, lens
     , QuickCheck, semigroups, template-haskell, text
     }:
     mkDerivation {
       pname = "text1";
       version = "0.0.3";
       sha256 = "4ca7215f67aa347fbc26b266c1b8455d0e4eae8533523acc8a8ef7b221827d50";
       libraryHaskellDepends = [ base binary lens semigroups text ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck template-haskell
       ];
       homepage = "https://github.com/NICTA/text1";
       description = "Non-empty values of `Data.Text`.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "textPlot" = callPackage
    ({ mkDerivation, array, base }:
     mkDerivation {
       pname = "textPlot";
       version = "1.0";
       sha256 = "6d73fe98a29e33507200f27bbd0fb49c7dfcd7a6c8942a543e1988693764b012";
       libraryHaskellDepends = [ array base ];
       description = "Plot functions in text";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "textmatetags" = callPackage
    ({ mkDerivation, base, haskell98, process }:
     mkDerivation {
       pname = "textmatetags";
       version = "0.0.1.2";
       sha256 = "f381d68b96ecd63ed9bd92c49b6676e7071c1ffdd12ffc480d22be683ed287e0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskell98 process ];
       homepage = "https://github.com/spockz/Haskell-Code-Completion-for-TextMate";
       description = "A simple Haskell program to provide tags for Haskell code completion in TextMate";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "textocat-api" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, http-conduit
     , http-types, resourcet, tasty, tasty-hunit, text, transformers
     }:
     mkDerivation {
       pname = "textocat-api";
       version = "0.1.0.0";
       sha256 = "a9cfba0cdc4e60dbef46ecee44f4c1756e57158fe4dceb5cdf0df711f4f09232";
       libraryHaskellDepends = [
         aeson base bytestring conduit http-conduit http-types resourcet
         text transformers
       ];
       testHaskellDepends = [
         aeson base bytestring conduit http-conduit http-types resourcet
         tasty tasty-hunit text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/gltronred/textocat-api-haskell";
       description = "Unofficial Haskell SDK for Textocat API -- http://textocat.com";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "texts" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "texts";
       version = "0.4.0";
       sha256 = "3069c41bc635b2152987caaa65b490b590f24a7b7b516c28d510666c5aa62397";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "textual" = callPackage
    ({ mkDerivation, base, bytestring, text, utf8-string }:
     mkDerivation {
       pname = "textual";
       version = "0.2.0.0";
       sha256 = "de00ec44e43d3ed188c13c186d0326cde86fac9b8d0f42e9f937a1038f6c4c39";
       libraryHaskellDepends = [ base bytestring text utf8-string ];
       jailbreak = true;
       homepage = "https://sealgram.com/git/haskell/text-like/";
       description = "Textual type class for data that represent text";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tf-random" = callPackage
    ({ mkDerivation, base, primitive, random, time }:
     mkDerivation {
       pname = "tf-random";
       version = "0.5";
       sha256 = "2e30cec027b313c9e1794d326635d8fc5f79b6bf6e7580ab4b00186dadc88510";
       libraryHaskellDepends = [ base primitive random time ];
       description = "High-quality splittable pseudorandom number generator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tfp" = callPackage
    ({ mkDerivation, base, QuickCheck, utility-ht }:
     mkDerivation {
       pname = "tfp";
       version = "1.0.0.2";
       sha256 = "9a817090cb91f78424affc3bfb6a7ea65b520087b779c9fd501fc9779e654cda";
       libraryHaskellDepends = [ base utility-ht ];
       testHaskellDepends = [ base QuickCheck ];
       homepage = "http://www.haskell.org/haskellwiki/Type_arithmetic";
       description = "Type-level integers, booleans, lists using type families";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tfp-th" = callPackage
    ({ mkDerivation, base, template-haskell, tfp }:
     mkDerivation {
       pname = "tfp-th";
       version = "0.8";
       sha256 = "f5cfed02c2a63ace2a517dd5d0333622d81e6895ad851307bdcea31937672d8d";
       libraryHaskellDepends = [ base template-haskell tfp ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/Type_arithmetic";
       description = "Template-Haskell code for tfp";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tftp" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , hslogger, mtl, network, QuickCheck, transformers
     }:
     mkDerivation {
       pname = "tftp";
       version = "0.2";
       sha256 = "96eb4db7b255f161bf3708e703f3cbf7fd70f453ecda018b31f1835f3eb42535";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers directory hslogger mtl network
         transformers
       ];
       executableHaskellDepends = [
         base binary bytestring directory hslogger mtl network transformers
       ];
       testHaskellDepends = [
         base hslogger mtl network QuickCheck transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/sheyll/tftp";
       description = "A library for building tftp servers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "tga" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "tga";
       version = "0.2";
       sha256 = "0ecae6ee98298b52e07cc1971a2d3663b9d970c9760ace07c0ecf872ca2fec52";
       libraryHaskellDepends = [ base bytestring ];
       jailbreak = true;
       description = "Reading and writing of tga image files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "th-alpha" = callPackage
    ({ mkDerivation, base, containers, derive, mmorph, mtl, tasty
     , tasty-hunit, tasty-quickcheck, template-haskell, th-desugar
     , transformers
     }:
     mkDerivation {
       pname = "th-alpha";
       version = "0.2.0.2";
       sha256 = "f3690f2fe6ee2a47f165f761eea10c617455e84fa833690c139273120a12d7eb";
       libraryHaskellDepends = [
         base containers mmorph mtl template-haskell th-desugar transformers
       ];
       testHaskellDepends = [
         base derive tasty tasty-hunit tasty-quickcheck template-haskell
       ];
       homepage = "https://github.com/jkarni/th-alpha";
       description = "Alpha equivalence for TH Exp";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "th-build" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "th-build";
       version = "0.4.0.0";
       sha256 = "e6a7fd93ad038826f781ab3e55b137a97eae4d718045df6da913e23af9632638";
       libraryHaskellDepends = [ base template-haskell ];
       jailbreak = true;
       homepage = "https://github.com/DanielSchuessler/th-build";
       description = "More convenient construction of TH ASTs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "th-cas" = callPackage
    ({ mkDerivation, base, hspec, template-haskell }:
     mkDerivation {
       pname = "th-cas";
       version = "0.1.0";
       sha256 = "6caab40db7a8aba41760c1b4ef884f52de0905ff8865dd7f6ab7ca5446b9653f";
       libraryHaskellDepends = [ base template-haskell ];
       testHaskellDepends = [ base hspec template-haskell ];
       homepage = "https://github/junjihashimoto/th-cas";
       description = "Compile-time CAS(Computer Algebra System)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "th-context" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, data-default
     , deepseq, ghc-prim, haskell-src-exts, hspec, hspec-core, lens, mtl
     , mtl-unleashed, syb, template-haskell, text, th-desugar
     , th-orphans, th-reify-many, th-typegraph
     }:
     mkDerivation {
       pname = "th-context";
       version = "0.23";
       sha256 = "54b65f7692f211426c7f3fc1751d938d756fee64f2970ebe6db30476f95c219f";
       libraryHaskellDepends = [
         base containers data-default haskell-src-exts lens mtl
         mtl-unleashed syb template-haskell th-desugar th-orphans
         th-typegraph
       ];
       testHaskellDepends = [
         array base bytestring containers deepseq ghc-prim hspec hspec-core
         lens mtl mtl-unleashed syb template-haskell text th-desugar
         th-orphans th-reify-many th-typegraph
       ];
       homepage = "https://github.com/seereason/th-context";
       description = "Test instance context";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-desugar_1_4_2" = callPackage
    ({ mkDerivation, base, containers, hspec, HUnit, mtl, syb
     , template-haskell
     }:
     mkDerivation {
       pname = "th-desugar";
       version = "1.4.2";
       sha256 = "69a10e29337f68af0a97776cf7a7ecb0a49a8a79d5dcab53b5f772d1259c809a";
       revision = "1";
       editedCabalFile = "1ec55cb7234a4e2b229484198407fc76df4b40512df6097b07ae252a0c522b32";
       libraryHaskellDepends = [
         base containers mtl syb template-haskell
       ];
       testHaskellDepends = [
         base containers hspec HUnit mtl syb template-haskell
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.cis.upenn.edu/~eir/packages/th-desugar";
       description = "Functions to desugar Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-desugar_1_4_2_1" = callPackage
    ({ mkDerivation, base, containers, hspec, HUnit, mtl, syb
     , template-haskell
     }:
     mkDerivation {
       pname = "th-desugar";
       version = "1.4.2.1";
       sha256 = "59f27b6a076f71f02bb1688bd0dd078e093cb83463dc9cd1ba83eabd619047fb";
       revision = "1";
       editedCabalFile = "c7e3641a1eeafc122866550771d0e1802079d394aadfd9b52ec4eba4cce42bd5";
       libraryHaskellDepends = [
         base containers mtl syb template-haskell
       ];
       testHaskellDepends = [
         base containers hspec HUnit mtl syb template-haskell
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.cis.upenn.edu/~eir/packages/th-desugar";
       description = "Functions to desugar Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-desugar_1_5_3" = callPackage
    ({ mkDerivation, base, containers, hspec, HUnit, mtl, syb
     , template-haskell, th-lift, th-orphans
     }:
     mkDerivation {
       pname = "th-desugar";
       version = "1.5.3";
       sha256 = "209e979a0daee1e0264245754161531c3d1b198b3960c9062682db765de9cbae";
       libraryHaskellDepends = [
         base containers mtl syb template-haskell th-lift th-orphans
       ];
       testHaskellDepends = [
         base containers hspec HUnit mtl syb template-haskell th-lift
         th-orphans
       ];
       homepage = "http://www.cis.upenn.edu/~eir/packages/th-desugar";
       description = "Functions to desugar Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-desugar_1_5_4" = callPackage
    ({ mkDerivation, base, containers, hspec, HUnit, mtl, syb
     , template-haskell, th-lift, th-orphans
     }:
     mkDerivation {
       pname = "th-desugar";
       version = "1.5.4";
       sha256 = "c83013c92f136fb8d94c4d1893cbcb6748cba19d63382536588b20eddf3997b7";
       libraryHaskellDepends = [
         base containers mtl syb template-haskell th-lift th-orphans
       ];
       testHaskellDepends = [
         base containers hspec HUnit mtl syb template-haskell th-lift
         th-orphans
       ];
       homepage = "http://www.cis.upenn.edu/~eir/packages/th-desugar";
       description = "Functions to desugar Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-desugar_1_5_4_1" = callPackage
    ({ mkDerivation, base, containers, hspec, HUnit, mtl, syb
     , template-haskell, th-lift, th-orphans
     }:
     mkDerivation {
       pname = "th-desugar";
       version = "1.5.4.1";
       sha256 = "d32902a53c31b557eab3c2f2e6723a56b3b038f8655cee26b9d700e2737fef0a";
       libraryHaskellDepends = [
         base containers mtl syb template-haskell th-lift th-orphans
       ];
       testHaskellDepends = [
         base containers hspec HUnit mtl syb template-haskell th-lift
         th-orphans
       ];
       homepage = "http://www.cis.upenn.edu/~eir/packages/th-desugar";
       description = "Functions to desugar Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-desugar" = callPackage
    ({ mkDerivation, base, containers, hspec, HUnit, mtl, syb
     , template-haskell, th-lift, th-orphans
     }:
     mkDerivation {
       pname = "th-desugar";
       version = "1.5.5";
       sha256 = "db8cfe15c2b1c5b5e6c2105a0a16f409c9eb9b359c2f2c18e440d5562c5d38a3";
       libraryHaskellDepends = [
         base containers mtl syb template-haskell th-lift th-orphans
       ];
       testHaskellDepends = [
         base containers hspec HUnit mtl syb template-haskell th-lift
         th-orphans
       ];
       homepage = "http://www.cis.upenn.edu/~eir/packages/th-desugar";
       description = "Functions to desugar Template Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "th-expand-syns_0_3_0_4" = callPackage
    ({ mkDerivation, base, containers, syb, template-haskell }:
     mkDerivation {
       pname = "th-expand-syns";
       version = "0.3.0.4";
       sha256 = "d82360ff04ae814bc9fb118c7cfc45ad40768c6ead6d16114102e07faa720f17";
       revision = "1";
       editedCabalFile = "a067fbdc4c4a7943e1931e127514ff94cccbcb730e152a73a3e281ba13900b18";
       libraryHaskellDepends = [ base containers syb template-haskell ];
       jailbreak = true;
       description = "Expands type synonyms in Template Haskell ASTs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-expand-syns_0_3_0_5" = callPackage
    ({ mkDerivation, base, containers, syb, template-haskell }:
     mkDerivation {
       pname = "th-expand-syns";
       version = "0.3.0.5";
       sha256 = "30933dcd5b92c3daa6317adb0688cb7cb0eed193a6a2af9bda142d6dd95f39f6";
       revision = "1";
       editedCabalFile = "f0c7ebf50e7282f73c160d7b6821e3b9da2f42c4f076655416925788eb968eb3";
       libraryHaskellDepends = [ base containers syb template-haskell ];
       testHaskellDepends = [ base template-haskell ];
       jailbreak = true;
       description = "Expands type synonyms in Template Haskell ASTs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-expand-syns" = callPackage
    ({ mkDerivation, base, containers, syb, template-haskell }:
     mkDerivation {
       pname = "th-expand-syns";
       version = "0.3.0.6";
       sha256 = "d2f4ea032b5cc79591f516cf607a99acb9557f054edb9906a50a4decef481b0f";
       libraryHaskellDepends = [ base containers syb template-haskell ];
       testHaskellDepends = [ base template-haskell ];
       description = "Expands type synonyms in Template Haskell ASTs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "th-extras" = callPackage
    ({ mkDerivation, base, syb, template-haskell }:
     mkDerivation {
       pname = "th-extras";
       version = "0.0.0.2";
       sha256 = "94212defd4d76bf27eddfb85c1a49c1ef3a73d980ea00b11d69a612ba5705897";
       revision = "1";
       editedCabalFile = "d9dfbdaeda88312758fd97e43f54d2d83d49039ee1bcfa94e38d87b215dedf67";
       libraryHaskellDepends = [ base syb template-haskell ];
       homepage = "https://github.com/mokus0/th-extras";
       description = "A grab bag of functions for use with Template Haskell";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "th-fold" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "th-fold";
       version = "0.0.0.1";
       sha256 = "5fb88f2e441ac24f86db3024de624a9f75e9cd8eb01d8282feafc44e0e57c182";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://code.haskell.org/~mokus/th-fold";
       description = "TH fold generator";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "th-inline-io-action" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "th-inline-io-action";
       version = "0.1.0.0";
       sha256 = "8f7fa350547913e30a26930cad3560044be1f440ad0159ff19d9291bec887dfb";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "https://github.com/tolysz/inline-io-action";
       description = "Simple inline IO action into compiled code using TH";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "th-instance-reification" = callPackage
    ({ mkDerivation, base, containers, HTF, list-extras, loch-th
     , placeholders, template-haskell, th-expand-syns
     }:
     mkDerivation {
       pname = "th-instance-reification";
       version = "0.1.4";
       sha256 = "71da68020f4275002741f9d064dffd93a70e67c64ea31d5351a8b08b3b3ed832";
       libraryHaskellDepends = [
         base containers list-extras loch-th placeholders template-haskell
         th-expand-syns
       ];
       testHaskellDepends = [
         base containers HTF list-extras loch-th placeholders
         template-haskell th-expand-syns
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/th-instance-reification";
       description = "Fixed versions of instances reification functions";
       license = stdenv.lib.licenses.mit;
     }) {};

  "th-instances" = callPackage
    ({ mkDerivation, base, checkers, DebugTraceHelpers, derive, HUnit
     , mtl, QuickCheck, template-haskell, test-framework
     , test-framework-hunit, test-framework-quickcheck2, th-kinds
     , th-lift
     }:
     mkDerivation {
       pname = "th-instances";
       version = "0.1.0.14";
       sha256 = "1b78f6f5444a92e875ffeb293d9aaf6b1155590d721e6dffce5efe2005abeac7";
       libraryHaskellDepends = [
         base checkers derive mtl QuickCheck template-haskell th-kinds
         th-lift
       ];
       testHaskellDepends = [
         base checkers DebugTraceHelpers derive HUnit mtl QuickCheck
         template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2 th-kinds th-lift
       ];
       description = "A place to collect orphan instances for Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-kinds" = callPackage
    ({ mkDerivation, base, containers, mtl, template-haskell }:
     mkDerivation {
       pname = "th-kinds";
       version = "0.1.1";
       sha256 = "ab388f37f83e533d01bfd0d5cd256b231f218043819c3c214ed1b7e72d071635";
       libraryHaskellDepends = [ base containers mtl template-haskell ];
       jailbreak = true;
       description = "Automated kind inference in Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-kinds-fork" = callPackage
    ({ mkDerivation, base, containers, mtl, template-haskell
     , th-orphans
     }:
     mkDerivation {
       pname = "th-kinds-fork";
       version = "0.2";
       sha256 = "fce4c9c8f8ca4c00acd2674319901fd2a21f2742644cdbb919cfb23a87122131";
       libraryHaskellDepends = [
         base containers mtl template-haskell th-orphans
       ];
       description = "Automated kind inference in Template Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "th-lift_0_7" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "th-lift";
       version = "0.7";
       sha256 = "ea5f6c6ad93347b4dd31386c6cc7f2679c674bc16cde4cb79275b0eaa29905d6";
       revision = "2";
       editedCabalFile = "8c27e18de29621de1588e4c0e6dd5c72c6e1e088fd998d5475458062f607aed5";
       libraryHaskellDepends = [ base template-haskell ];
       testHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/mboes/th-lift";
       description = "Derive Template Haskell's Lift class for datatypes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-lift_0_7_2" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "th-lift";
       version = "0.7.2";
       sha256 = "755c2477d4f1c77d9da73ef5a824b34b1c382aa98833b64ad7d9255813e8824a";
       libraryHaskellDepends = [ base template-haskell ];
       testHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/mboes/th-lift";
       description = "Derive Template Haskell's Lift class for datatypes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-lift_0_7_5" = callPackage
    ({ mkDerivation, base, ghc-prim, template-haskell }:
     mkDerivation {
       pname = "th-lift";
       version = "0.7.5";
       sha256 = "f3d483f1f85556e0be70b3c4f6570bb2828cda68a83b9d0a70f035c8c29cad8f";
       revision = "1";
       editedCabalFile = "89d1cfba7e4a65b09078476bbbd2a0d0e843922ca8d17885fd63d9ace06c25cc";
       libraryHaskellDepends = [ base ghc-prim template-haskell ];
       testHaskellDepends = [ base ghc-prim template-haskell ];
       homepage = "http://github.com/mboes/th-lift";
       description = "Derive Template Haskell's Lift class for datatypes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-lift" = callPackage
    ({ mkDerivation, base, ghc-prim, template-haskell }:
     mkDerivation {
       pname = "th-lift";
       version = "0.7.6";
       sha256 = "326a2c9dac32506d5b7e5d9f3234c0e7a33a612256e4745bfb8de5a32803ecd1";
       libraryHaskellDepends = [ base ghc-prim template-haskell ];
       testHaskellDepends = [ base ghc-prim template-haskell ];
       homepage = "http://github.com/mboes/th-lift";
       description = "Derive Template Haskell's Lift class for datatypes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "th-lift-instances" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, doctest
     , filepath, QuickCheck, template-haskell, text, th-lift, vector
     }:
     mkDerivation {
       pname = "th-lift-instances";
       version = "0.1.6";
       sha256 = "537ebabc98a9026292813ad2f48a3ca68601cb0fcdf559f579405da385ca40e5";
       libraryHaskellDepends = [
         base bytestring containers template-haskell text th-lift vector
       ];
       testHaskellDepends = [
         base bytestring containers directory doctest filepath QuickCheck
         template-haskell text vector
       ];
       homepage = "http://github.com/bennofs/th-lift-instances/";
       description = "Lift instances for template-haskell for common data types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "th-orphans_0_8_2" = callPackage
    ({ mkDerivation, base, template-haskell, th-lift, th-reify-many }:
     mkDerivation {
       pname = "th-orphans";
       version = "0.8.2";
       sha256 = "de8db3117fae31e33e3125f66fbcb9cea514771da0a4c4922db6767a85a6a4a5";
       revision = "1";
       editedCabalFile = "9a990b97359930791aec671a44eed2cc91ff31793cbfb1e2e65e4db5ce8c0415";
       libraryHaskellDepends = [
         base template-haskell th-lift th-reify-many
       ];
       jailbreak = true;
       description = "Orphan instances for TH datatypes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-orphans_0_8_3" = callPackage
    ({ mkDerivation, base, template-haskell, th-lift, th-reify-many }:
     mkDerivation {
       pname = "th-orphans";
       version = "0.8.3";
       sha256 = "dd424a0a2313b3dc02748cad9f400f35e201594544b069d0a30f24e8ccc346c5";
       libraryHaskellDepends = [
         base template-haskell th-lift th-reify-many
       ];
       description = "Orphan instances for TH datatypes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-orphans_0_11_1" = callPackage
    ({ mkDerivation, base, hspec, mtl, nats, template-haskell, th-lift
     , th-reify-many
     }:
     mkDerivation {
       pname = "th-orphans";
       version = "0.11.1";
       sha256 = "be0b88c2f83fb8a373498f95044ff9f9b68480cdc74e6bb11a256516f79e2c84";
       revision = "1";
       editedCabalFile = "49eccfaa4ed12b68d724c75f02b10ba104295366fd1c17d69ee7151d5d5042b8";
       libraryHaskellDepends = [
         base mtl nats template-haskell th-lift th-reify-many
       ];
       testHaskellDepends = [ base hspec template-haskell ];
       jailbreak = true;
       description = "Orphan instances for TH datatypes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-orphans_0_12_2" = callPackage
    ({ mkDerivation, base, hspec, mtl, nats, template-haskell, th-lift
     , th-reify-many
     }:
     mkDerivation {
       pname = "th-orphans";
       version = "0.12.2";
       sha256 = "ab3509388cc34b7ec22e8eb8ebd78f98414184f3319b7b15b926ebbf81a06510";
       revision = "1";
       editedCabalFile = "625878feb629523b71d80ad65c4bddde91b33f52c37575536ea268fe86cb04f1";
       libraryHaskellDepends = [
         base mtl nats template-haskell th-lift th-reify-many
       ];
       testHaskellDepends = [ base hspec template-haskell ];
       jailbreak = true;
       description = "Orphan instances for TH datatypes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-orphans" = callPackage
    ({ mkDerivation, base, hspec, mtl, template-haskell, th-lift
     , th-reify-many
     }:
     mkDerivation {
       pname = "th-orphans";
       version = "0.13.0";
       sha256 = "bdaeee2a3588e0622f2036481974dfe1bd135a3d71004393c94201d8d700be80";
       libraryHaskellDepends = [
         base mtl template-haskell th-lift th-reify-many
       ];
       testHaskellDepends = [ base hspec template-haskell ];
       description = "Orphan instances for TH datatypes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "th-printf" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, hspec, HUnit
     , QuickCheck, template-haskell, text, transformers
     }:
     mkDerivation {
       pname = "th-printf";
       version = "0.3.1";
       sha256 = "ea3cccf9abc8633aa5d347aef20822f0869e1e6f3929951f481befad2ecd2f21";
       libraryHaskellDepends = [
         attoparsec base bytestring template-haskell text transformers
       ];
       testHaskellDepends = [
         base bytestring hspec HUnit QuickCheck template-haskell text
       ];
       homepage = "https://github.com/joelteon/th-printf";
       description = "Compile-time printf";
       license = stdenv.lib.licenses.mit;
     }) {};

  "th-reify-many_0_1_2" = callPackage
    ({ mkDerivation, base, containers, mtl, safe, template-haskell
     , th-expand-syns
     }:
     mkDerivation {
       pname = "th-reify-many";
       version = "0.1.2";
       sha256 = "e96f4452f86fd01a59e18e9673ea6b2332132d4b88466c3283b98ab88955f9e4";
       revision = "1";
       editedCabalFile = "fe6403c094644e2e0c987dcf2846fc068ccfe32e5291099fb4abb2073e5baf31";
       libraryHaskellDepends = [
         base containers mtl safe template-haskell th-expand-syns
       ];
       homepage = "http://github.com/mgsloan/th-reify-many";
       description = "Recurseively reify template haskell datatype info";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-reify-many_0_1_3" = callPackage
    ({ mkDerivation, base, containers, mtl, safe, template-haskell
     , th-expand-syns
     }:
     mkDerivation {
       pname = "th-reify-many";
       version = "0.1.3";
       sha256 = "dd51e8aafe834e7a39ad6777d90c71a7a029577355a91d36e36410cd24f51902";
       libraryHaskellDepends = [
         base containers mtl safe template-haskell th-expand-syns
       ];
       testHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/mgsloan/th-reify-many";
       description = "Recurseively reify template haskell datatype info";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "th-reify-many" = callPackage
    ({ mkDerivation, base, containers, mtl, safe, template-haskell
     , th-expand-syns
     }:
     mkDerivation {
       pname = "th-reify-many";
       version = "0.1.4";
       sha256 = "6de5daac837af9d845bb2bbd302db35109b5d20ae298c5ee35eb3c7889850c42";
       libraryHaskellDepends = [
         base containers mtl safe template-haskell th-expand-syns
       ];
       testHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/mgsloan/th-reify-many";
       description = "Recurseively reify template haskell datatype info";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "th-sccs" = callPackage
    ({ mkDerivation, base, containers, template-haskell }:
     mkDerivation {
       pname = "th-sccs";
       version = "0.0.0.20110723";
       sha256 = "86feb152939b648d5b53e83cc5934035ec45f5bafe1458f11422892d1bc7326f";
       libraryHaskellDepends = [ base containers template-haskell ];
       description = "Binding group analysis in Template Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "th-traced" = callPackage
    ({ mkDerivation, base, containers, mtl, template-haskell }:
     mkDerivation {
       pname = "th-traced";
       version = "0.0.1.0";
       sha256 = "e267a20fa11bd42a4c4018cc428051089225514f11e38ad1821842f03abbb0c2";
       libraryHaskellDepends = [ base containers mtl template-haskell ];
       homepage = "https://github.com/konn/th-traced";
       description = "Tracing Q monad computation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "th-typegraph" = callPackage
    ({ mkDerivation, array, base, base-compat, bytestring, containers
     , data-default, deepseq, ghc-prim, haskell-src-exts, hspec
     , hspec-core, lens, mtl, mtl-unleashed, set-extra, syb
     , template-haskell, text, th-desugar, th-orphans, th-reify-many
     }:
     mkDerivation {
       pname = "th-typegraph";
       version = "0.32";
       sha256 = "a01b758d99f95fa012c8266bb3c083a77c022a95fc86bdfcde493888e4bea3c5";
       libraryHaskellDepends = [
         base base-compat containers data-default haskell-src-exts lens mtl
         mtl-unleashed set-extra syb template-haskell th-desugar th-orphans
       ];
       testHaskellDepends = [
         array base bytestring containers data-default deepseq ghc-prim
         hspec hspec-core lens mtl mtl-unleashed syb template-haskell text
         th-desugar th-orphans th-reify-many
       ];
       homepage = "https://github.com/seereason/th-typegraph";
       description = "Graph of the subtype relation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "themoviedb" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, either
     , http-client, http-client-tls, http-types, mtl, tasty, tasty-hunit
     , text, text-binary, time, time-locale-compat, transformers
     }:
     mkDerivation {
       pname = "themoviedb";
       version = "1.1.1.0";
       sha256 = "a8999895fdf594720cdce1661cc093c978d72cf4377fbc26eae756fbe182a9a0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base binary bytestring either http-client http-client-tls
         http-types mtl text text-binary time time-locale-compat
         transformers
       ];
       executableHaskellDepends = [
         base text time time-locale-compat transformers
       ];
       testHaskellDepends = [
         base bytestring tasty tasty-hunit text time
       ];
       jailbreak = true;
       homepage = "http://github.com/pjones/themoviedb";
       description = "Haskell API bindings for http://themoviedb.org";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "themplate" = callPackage
    ({ mkDerivation, base, configurator, directory, either, errors
     , filepath, optparse-applicative, text, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "themplate";
       version = "1.2";
       sha256 = "2352212b0d13744e926a70eb93a6ab273f01e8919102ce9a1c4989469c71cf46";
       revision = "1";
       editedCabalFile = "9562873914a204ed7daf91844f70592385a93b6c348798dc8772b439436ca109";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base configurator directory either errors filepath
         optparse-applicative text transformers transformers-compat
       ];
       homepage = "http://github.com/bennofs/themplate/";
       description = "Project templating tool";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "theoremquest" = callPackage
    ({ mkDerivation, base, HTTP, json, utf8-string }:
     mkDerivation {
       pname = "theoremquest";
       version = "0.0.0";
       sha256 = "c160e75e395e54b0fa6442c4639f4bbd6d74fb113a62013dcde0f025ef95e017";
       libraryHaskellDepends = [ base HTTP json utf8-string ];
       jailbreak = true;
       description = "A common library for TheoremQuest, a theorem proving game";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "theoremquest-client" = callPackage
    ({ mkDerivation, base, HTTP, network, theoremquest }:
     mkDerivation {
       pname = "theoremquest-client";
       version = "0.0.0";
       sha256 = "6af80811d79eaba39f7894e51e97ba3b8068bd8582916f7ff2ec09a5cb5fae4d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base HTTP network theoremquest ];
       jailbreak = true;
       description = "A simple client for the TheoremQuest theorem proving game";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "these_0_6_2_0" = callPackage
    ({ mkDerivation, base, bifunctors, containers, data-default-class
     , hashable, mtl, profunctors, QuickCheck, quickcheck-instances
     , semigroupoids, semigroups, tasty, tasty-quickcheck, transformers
     , transformers-compat, unordered-containers, vector
     }:
     mkDerivation {
       pname = "these";
       version = "0.6.2.0";
       sha256 = "9802c398812396525789156b39e23dcb03fe3d218d588f33700386897993bee7";
       revision = "1";
       editedCabalFile = "3eb49900e4884ffe0296f8fb963b2cbf078f2ee368509c8e51a7304a7bdb5681";
       libraryHaskellDepends = [
         base bifunctors containers data-default-class hashable mtl
         profunctors semigroupoids semigroups transformers
         transformers-compat unordered-containers vector
       ];
       testHaskellDepends = [
         base bifunctors containers hashable QuickCheck quickcheck-instances
         tasty tasty-quickcheck transformers unordered-containers vector
       ];
       homepage = "https://github.com/isomorphism/these";
       description = "An either-or-both data type & a generalized 'zip with padding' typeclass";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "these" = callPackage
    ({ mkDerivation, base, bifunctors, containers, data-default-class
     , hashable, mtl, profunctors, QuickCheck, quickcheck-instances
     , semigroupoids, semigroups, tasty, tasty-quickcheck, transformers
     , transformers-compat, unordered-containers, vector
     }:
     mkDerivation {
       pname = "these";
       version = "0.6.2.1";
       sha256 = "41dd6403ec489deef66632fcae4cd058f636badb162aedff7c8b4930affb99bb";
       libraryHaskellDepends = [
         base bifunctors containers data-default-class hashable mtl
         profunctors semigroupoids semigroups transformers
         transformers-compat unordered-containers vector
       ];
       testHaskellDepends = [
         base bifunctors containers hashable QuickCheck quickcheck-instances
         tasty tasty-quickcheck transformers unordered-containers vector
       ];
       homepage = "https://github.com/isomorphism/these";
       description = "An either-or-both data type & a generalized 'zip with padding' typeclass";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "thespian" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "thespian";
       version = "0.999";
       sha256 = "d6b2856d7c8bce362a06f48d7400d583f03434fb5a063ddef92077e398c46c7c";
       libraryHaskellDepends = [ base containers mtl ];
       homepage = "http://bitbucket.org/alinabi/thespian";
       description = "Lightweight Erlang-style actors for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "theta-functions" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "theta-functions";
       version = "1.0.1";
       sha256 = "0e7d531700c7c08b80d63f27e1ff0cd01126f1d21f3779f036aa2859ce0a3355";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/hijarian/theta-functions";
       description = "Theta-functions implemented as trigonometric series";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "thih" = callPackage
    ({ mkDerivation, base, pretty }:
     mkDerivation {
       pname = "thih";
       version = "1.0";
       sha256 = "15684654a6d533b957729ec1699e12e8ee33cd08b480650be6b2bb41d5f92847";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base pretty ];
       homepage = "http://web.cecs.pdx.edu/~mpj/thih/";
       description = "Typing Haskell In Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "thimk" = callPackage
    ({ mkDerivation, base, edit-distance, parseargs, phonetic-code
     , sqlite
     }:
     mkDerivation {
       pname = "thimk";
       version = "0.3.1";
       sha256 = "20fe22aec4a5c27c6a4d6e0b54fe49e16dc101d95ab943eeeb9486ba6c365fde";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base edit-distance parseargs phonetic-code sqlite
       ];
       homepage = "http://wiki.cs.pdx.edu/bartforge/thimk";
       description = "Command-line spelling word suggestion tool";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "thorn" = callPackage
    ({ mkDerivation, base, bifunctors, containers, contravariant, mtl
     , profunctors, random, template-haskell
     }:
     mkDerivation {
       pname = "thorn";
       version = "0.2";
       sha256 = "304092862e88464550e3f600fd48ef802c1b382554c369ce733132229f763dcf";
       revision = "1";
       editedCabalFile = "d19e959e95f55075f6f4f0013cbc980e2c351c871e3d9d5bbe2febafb7711b9a";
       libraryHaskellDepends = [
         base bifunctors containers contravariant mtl profunctors random
         template-haskell
       ];
       jailbreak = true;
       homepage = "https://github.com/Kinokkory/Thorn";
       description = "Datatype Manipulation with Template Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "thread-local-storage" = callPackage
    ({ mkDerivation, atomic-primops, base, containers }:
     mkDerivation {
       pname = "thread-local-storage";
       version = "0.1.0.3";
       sha256 = "74ccc31b79a3a0b087b654185ddafc42ac4609846213c670495f70fd7bee464d";
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [ atomic-primops base containers ];
       description = "Several options for thread-local-storage (TLS) in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "threadPool" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "threadPool";
       version = "0.3.1";
       sha256 = "915fc3b528fa75cce8419a7364c56e26e6aa44b25601ee8bde7335aad344f9a3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base process ];
       homepage = "http://bjaress.blogspot.com/";
       description = "Runs other programs in the manner of a thread pool";
       license = "GPL";
     }) {};

  "threadmanager" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "threadmanager";
       version = "0.1.7";
       sha256 = "2e81795ca3b066138e4f1b703df2b7a306e423bf61b7d1124379d1a82834429f";
       libraryHaskellDepends = [ base containers ];
       description = "(deprecated in favor of 'threads') Simple thread management";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "threads_0_5_1_2" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, concurrent-extra
     , HUnit, stm, test-framework, test-framework-hunit
     }:
     mkDerivation {
       pname = "threads";
       version = "0.5.1.2";
       sha256 = "49a4d776b9c8c8d11467a95bab500cca8a3921251db977dffca42a6dd45702af";
       libraryHaskellDepends = [ base base-unicode-symbols stm ];
       testHaskellDepends = [
         base base-unicode-symbols concurrent-extra HUnit stm test-framework
         test-framework-hunit
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/basvandijk/threads";
       description = "Fork threads and wait for their result";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "threads" = callPackage
    ({ mkDerivation, base, concurrent-extra, HUnit, stm, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "threads";
       version = "0.5.1.3";
       sha256 = "02bd4c7597f77d0d5064db4031547cd7b4989f453c77d520223ba2b1b9846411";
       libraryHaskellDepends = [ base stm ];
       testHaskellDepends = [
         base concurrent-extra HUnit stm test-framework test-framework-hunit
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/basvandijk/threads";
       description = "Fork threads and wait for their result";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "threads-pool" = callPackage
    ({ mkDerivation, base, containers, mtl, stm }:
     mkDerivation {
       pname = "threads-pool";
       version = "0.1";
       sha256 = "7f7621a065b0cd825968e036bc8292931c0975aa16df8899001939a5ba533ef4";
       libraryHaskellDepends = [ base containers mtl stm ];
       description = "A library to operate with pool of haskell's IO threads";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "threads-supervisor" = callPackage
    ({ mkDerivation, base, bytestring, QuickCheck, retry, stm, tasty
     , tasty-hunit, tasty-quickcheck, time, transformers
     , unordered-containers
     }:
     mkDerivation {
       pname = "threads-supervisor";
       version = "1.0.4.1";
       sha256 = "d58d14711cabfb9e594d5e930e09a831aeb5ef4a428b2ebf09edc24d88d46cda";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base retry stm time unordered-containers
       ];
       executableHaskellDepends = [ base stm time unordered-containers ];
       testHaskellDepends = [
         base bytestring QuickCheck retry stm tasty tasty-hunit
         tasty-quickcheck time transformers
       ];
       description = "Simple, IO-based library for Erlang-style thread supervision";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "threadscope" = callPackage
    ({ mkDerivation, array, base, binary, cairo, containers, deepseq
     , filepath, ghc-events, glib, gtk, mtl, pango, text, time, unix
     }:
     mkDerivation {
       pname = "threadscope";
       version = "0.2.7";
       sha256 = "cc5653831252d55b3ba7506ea648e770b2c4489cdf4d78828f07dc24ea7ffdb6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base binary cairo containers deepseq filepath ghc-events glib
         gtk mtl pango text time unix
       ];
       homepage = "http://www.haskell.org/haskellwiki/ThreadScope";
       description = "A graphical tool for profiling parallel Haskell programs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "threefish" = callPackage
    ({ mkDerivation, array, base, bytestring, cereal, crypto-api
     , data-default, entropy, random, tagged
     }:
     mkDerivation {
       pname = "threefish";
       version = "0.2.6";
       sha256 = "21b9eae06fb2355dcb4a04cb93fdf1557202aa59c5e99ce0fc959fe545ed9bec";
       libraryHaskellDepends = [
         array base bytestring cereal crypto-api data-default entropy random
         tagged
       ];
       homepage = "http://github.com/valderman/threefish";
       description = "The Threefish block cipher and the Skein hash function for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "threepenny-gui" = callPackage
    ({ mkDerivation, aeson, async, base, bytestring, containers
     , data-default, deepseq, filepath, hashable, network-uri, safe
     , snap-core, snap-server, stm, template-haskell, text, transformers
     , unordered-containers, vault, vector, websockets, websockets-snap
     }:
     mkDerivation {
       pname = "threepenny-gui";
       version = "0.6.0.6";
       sha256 = "f275e22d52d419f97feacbc0dbd4a99b32992910bf6427a0a1798b6146a2f94d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson async base bytestring containers data-default deepseq
         filepath hashable network-uri safe snap-core snap-server stm
         template-haskell text transformers unordered-containers vault
         vector websockets websockets-snap
       ];
       homepage = "http://wiki.haskell.org/Threepenny-gui";
       description = "GUI framework that uses the web browser as a display";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "thrift" = callPackage
    ({ mkDerivation, attoparsec, base, binary, bytestring, containers
     , ghc-prim, hashable, HTTP, network, network-uri, QuickCheck, split
     , text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "thrift";
       version = "0.9.3";
       sha256 = "dd2cfeec5f6a7142407ccc5d361afc6c45e5c50813e4246ed91137efc5cfbe9f";
       libraryHaskellDepends = [
         attoparsec base binary bytestring containers ghc-prim hashable HTTP
         network network-uri QuickCheck split text unordered-containers
         vector
       ];
       homepage = "http://thrift.apache.org";
       description = "Haskell bindings for the Apache Thrift RPC system";
       license = "unknown";
     }) {};

  "thrist" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "thrist";
       version = "0.3.0.2";
       sha256 = "175b2b306825d3a4c536e8a5aace903eb71466928064870ef2a09d796bd1c407";
       libraryHaskellDepends = [ base ];
       homepage = "http://heisenbug.blogspot.com/search/label/thrist";
       description = "Type-threaded list";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "throttle" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "throttle";
       version = "3.0.0";
       sha256 = "8ce272ffbcd4a5b1414b331436c60810b9cf2fc30d802703670b2942c4c1b5fb";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "through-text" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, text }:
     mkDerivation {
       pname = "through-text";
       version = "0.1.0.0";
       sha256 = "933225da128906e61865ccd1da73463781b890d742cbb38f52524d94ac19b4cd";
       libraryHaskellDepends = [ base bytestring case-insensitive text ];
       homepage = "https://www.github.com/bergmark/through-text";
       description = "Convert textual types through Text without needing O(n^2) instances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "thumbnail" = callPackage
    ({ mkDerivation, base, bytestring, gd }:
     mkDerivation {
       pname = "thumbnail";
       version = "0.8.0";
       sha256 = "6d22a6491362c6831712d1f3c4dc91c50255f8968782a5cdbef3664af8bf47d7";
       libraryHaskellDepends = [ base bytestring gd ];
       homepage = "https://github.com/cutsea110/thumbnail";
       description = "generate thumbnail image";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "thumbnail-plus" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , data-default, directory, either, gd, hspec, imagesize-conduit
     , resourcet, temporary, transformers
     }:
     mkDerivation {
       pname = "thumbnail-plus";
       version = "1.0.5";
       sha256 = "81907f62a172f044dbc5c17feb18adee3512eb39c0fd54fb3af42b6d9ff3400c";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra data-default directory either
         gd imagesize-conduit resourcet temporary transformers
       ];
       testHaskellDepends = [
         base conduit conduit-extra data-default directory hspec resourcet
         transformers
       ];
       homepage = "https://github.com/prowdsponsor/thumbnail-plus";
       description = "Generate thumbnails easily and safely";
       license = stdenv.lib.licenses.mit;
     }) {};

  "thyme" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, Cabal
     , containers, cpphs, deepseq, directory, filepath, mtl, old-locale
     , profunctors, QuickCheck, random, system-posix-redirect, text
     , time, vector, vector-space, vector-th-unbox
     }:
     mkDerivation {
       pname = "thyme";
       version = "0.3.5.5";
       sha256 = "84c6701fb7b40841d22582202382c362fd9e0d6e5f1c959b7e0f2f91a85c796c";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring containers deepseq mtl old-locale
         profunctors QuickCheck random text time vector vector-space
         vector-th-unbox
       ];
       libraryToolDepends = [ cpphs ];
       testHaskellDepends = [
         attoparsec base bytestring Cabal containers directory filepath mtl
         old-locale profunctors QuickCheck random system-posix-redirect text
         time vector-space
       ];
       doHaddock = false;
       doCheck = false;
       homepage = "https://github.com/liyang/thyme";
       description = "A faster time library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tianbar" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, containers
     , dbus, directory, gtk, gtk-traymanager, gtk2, happstack-server
     , network, network-uri, process, random, split, text, transformers
     , utf8-string, webkit, xdg-basedir, xmonad, xmonad-contrib
     }:
     mkDerivation {
       pname = "tianbar";
       version = "0.4.8.0";
       sha256 = "5ed0ad66ed6bfeb5b7145ce1e05d578963f8f7fec43c5474ca9a9023acb3cb16";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html blaze-markup dbus utf8-string xmonad xmonad-contrib
       ];
       executableHaskellDepends = [
         aeson base containers dbus directory gtk gtk-traymanager
         happstack-server network network-uri process random split text
         transformers webkit xdg-basedir
       ];
       executablePkgconfigDepends = [ gtk2 ];
       homepage = "https://github.com/koterpillar/tianbar";
       description = "A desktop bar based on WebKit";
       license = stdenv.lib.licenses.mit;
     }) {gtk2 = pkgs.gnome2.gtk;};

  "tic-tac-toe" = callPackage
    ({ mkDerivation, base, glade, gtk, haskell98 }:
     mkDerivation {
       pname = "tic-tac-toe";
       version = "0.1";
       sha256 = "0148047de472a013841c02a90c328e771957a19a6b9b5f706f3f20f1bbd0b42d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base glade gtk haskell98 ];
       homepage = "http://ecks.homeunix.net";
       description = "Useful if reading \"Why FP matters\" by John Hughes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tickle" = callPackage
    ({ mkDerivation, base, bifunctors, bytestring, directory, doctest
     , filepath, lens, mtl, QuickCheck, semigroupoids, semigroups
     , template-haskell, transformers, validation
     }:
     mkDerivation {
       pname = "tickle";
       version = "0.0.6";
       sha256 = "a5701be4825537d2426f1d84366847b50876087319bdf8df96028b8f874ebba7";
       libraryHaskellDepends = [
         base bifunctors bytestring filepath lens mtl semigroupoids
         semigroups transformers validation
       ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck template-haskell
       ];
       homepage = "https://github.com/NICTA/tickle";
       description = "A port of @Data.Binary@";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tictactoe3d" = callPackage
    ({ mkDerivation, base, tuples-homogenous-h98, vector }:
     mkDerivation {
       pname = "tictactoe3d";
       version = "0.1.0.3";
       sha256 = "e162cfdc30aac18f0ddb98ee3d3de72c584523937a88250742d75e0a9762ee76";
       libraryHaskellDepends = [ base tuples-homogenous-h98 vector ];
       jailbreak = true;
       homepage = "https://github.com/ryo0ka/tictactoe3d";
       description = "3D Tic-Tac-Toe game";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "tidal" = callPackage
    ({ mkDerivation, base, binary, bytestring, colour, containers
     , hashable, hmt, hosc, mersenne-random-pure64, mtl, parsec
     , PortMidi, process, serialport, text, time, transformers
     , websockets
     }:
     mkDerivation {
       pname = "tidal";
       version = "0.7";
       sha256 = "740fed95c4eacdf2abea0965d81f2d6e747a303868adf0d9472b7413952a5aa1";
       libraryHaskellDepends = [
         base binary bytestring colour containers hashable hmt hosc
         mersenne-random-pure64 mtl parsec PortMidi process serialport text
         time transformers websockets
       ];
       homepage = "http://tidal.lurk.org/";
       description = "Pattern language for improvised music";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "tidal-midi" = callPackage
    ({ mkDerivation, base, bytestring, containers, hashable, hosc
     , PortMidi, process, tidal, time
     }:
     mkDerivation {
       pname = "tidal-midi";
       version = "0.1";
       sha256 = "0c84459f67334b94ba0b95c142ca37cae7969436344661b01482e753b2eba511";
       libraryHaskellDepends = [
         base bytestring containers hashable hosc PortMidi process tidal
         time
       ];
       homepage = "http://tidal.lurk.org/";
       description = "MIDI support for tidal";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "tidal-vis" = callPackage
    ({ mkDerivation, base, cairo, colour, tidal }:
     mkDerivation {
       pname = "tidal-vis";
       version = "0.1.8";
       sha256 = "3cb3fab058e0a2891d33d02adac326ada6558892c0f58467625c44b99f262ac9";
       libraryHaskellDepends = [ base cairo colour tidal ];
       homepage = "http://yaxu.org/tidal/";
       description = "Visual rendering for Tidal patterns";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "tie-knot" = callPackage
    ({ mkDerivation, base, containers, mtl, recursion-schemes }:
     mkDerivation {
       pname = "tie-knot";
       version = "0.2";
       sha256 = "e47108f0062c9cc0460c7134934c6070931df3d46ab9323e42d47b6660c97ac6";
       libraryHaskellDepends = [ base containers mtl recursion-schemes ];
       jailbreak = true;
       homepage = "https://github.com/ppetr/tie-knot";
       description = "\"Ties the knot\" on a given set of structures that reference each other by keys";
       license = "LGPL";
     }) {};

  "tiempo" = callPackage
    ({ mkDerivation, base, deepseq, time }:
     mkDerivation {
       pname = "tiempo";
       version = "0.0.1.1";
       sha256 = "a8b04eef8e1eca0a496410eb82289345c2060be8726b09f5f4b0242d9ffe4a8e";
       libraryHaskellDepends = [ base deepseq time ];
       homepage = "http://github.com/HaskVan/tiempo";
       description = "Specify time intervals in different units (secs, mins, hours, etc.)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tiger" = callPackage
    ({ mkDerivation, array, base, containers, uuagc, uuagc-cabal, uulib
     }:
     mkDerivation {
       pname = "tiger";
       version = "1.1.1";
       sha256 = "019332f021a738bc18109e02286f0d74b2d9534d6e445fe8394f93cfd48f95d2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers uuagc uuagc-cabal uulib
       ];
       homepage = "http://www.cs.uu.nl/wiki/HUT/WebHome";
       description = "Tiger Compiler of Universiteit Utrecht";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tight-apply" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "tight-apply";
       version = "0.1.0.0";
       sha256 = "8419d1dcaab2a942603584e04bf36369d4d7e4f6560f53ea7a968942a1e62f19";
       libraryHaskellDepends = [ base ];
       description = "Tightly binding infix function application";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "tightrope" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, http-types
     , lens, mtl, text, wai, wai-extra, wreq
     }:
     mkDerivation {
       pname = "tightrope";
       version = "0.2.0.0";
       sha256 = "c0d8c4a6fee99342c4ccbd3c679c09a2454ab7fa391c3c3d78101b13a8767fef";
       libraryHaskellDepends = [
         aeson base bytestring containers http-types lens mtl text wai
         wai-extra wreq
       ];
       jailbreak = true;
       description = "Nice API for a Slackbot";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tighttp" = callPackage
    ({ mkDerivation, base, bytestring, handle-like, monads-tf
     , old-locale, papillon, simple-pipe, time
     }:
     mkDerivation {
       pname = "tighttp";
       version = "0.0.0.9";
       sha256 = "8b73c5ae1f631621b3e67f9665e5b1dc886c60b16f608f3f929653c21dae1b96";
       libraryHaskellDepends = [
         base bytestring handle-like monads-tf old-locale papillon
         simple-pipe time
       ];
       jailbreak = true;
       homepage = "https://github.com/YoshikuniJujo/tighttp/wiki";
       description = "Tiny and Incrementally-Growing HTTP library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tilings" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "tilings";
       version = "0.1";
       sha256 = "dacb3b51d7b670ce96aa2fa94487607ac89be0913d97d31a6063b9f5095b490d";
       libraryHaskellDepends = [ base ];
       homepage = "https://gitorious.org/tilings";
       description = "substitution tilings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "timberc" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, bzlib, filepath
     , happy, haskell98, mtl, pretty
     }:
     mkDerivation {
       pname = "timberc";
       version = "1.0.3";
       sha256 = "32a4f09fc6d520e1f02274592c9d25a4c35c8aa7b317434988b1bcf44e615e74";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base binary bytestring bzlib filepath haskell98 mtl pretty
       ];
       executableToolDepends = [ happy ];
       homepage = "http://www.timber-lang.org";
       description = "The Timber Compiler";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "time_1_6" = callPackage
    ({ mkDerivation, base, deepseq, QuickCheck, test-framework
     , test-framework-quickcheck2, unix
     }:
     mkDerivation {
       pname = "time";
       version = "1.6";
       sha256 = "2b4ff69434fd920353ab9948b8e36b71a76227661b06cad1bb0ef99a2e91a29f";
       revision = "1";
       editedCabalFile = "aa5ff661ec586e3c082485d21abe107332ba29355d1a2c8c2966ba518d1309f2";
       libraryHaskellDepends = [ base deepseq ];
       testHaskellDepends = [
         base deepseq QuickCheck test-framework test-framework-quickcheck2
         unix
       ];
       jailbreak = true;
       homepage = "https://github.com/haskell/time";
       description = "A time library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "time-compat" = callPackage
    ({ mkDerivation, base, old-time, time }:
     mkDerivation {
       pname = "time-compat";
       version = "0.1.0.3";
       sha256 = "590711214510c0d2d09780c7fe3b21748bc4802e9053f78ccd6658e951fe0f7f";
       libraryHaskellDepends = [ base old-time time ];
       homepage = "http://hub.darcs.net/dag/time-compat";
       description = "Compatibility with old-time for the time package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "time-extras" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "time-extras";
       version = "1.1.4";
       sha256 = "74dc327986d7ef6d65bc4ee4c855995dd8e05ae92f3a34fd0b835021526d2acd";
       libraryHaskellDepends = [ base time ];
       jailbreak = true;
       homepage = "http://semantic.org/TimeLib/";
       description = "Data instances for the time package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "time-exts" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bindings-DSL, containers
     , convertible, data-default, deepseq, fclabels, mtl, old-locale
     , QuickCheck, random, text, time, timezone-olson
     }:
     mkDerivation {
       pname = "time-exts";
       version = "2.1.0";
       sha256 = "7519345408bd1f856af169e3185d69f7a3a0be045b91084a40909a4a7357e378";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bindings-DSL containers convertible
         data-default deepseq fclabels mtl old-locale QuickCheck random text
         time timezone-olson
       ];
       executableHaskellDepends = [
         aeson attoparsec base bindings-DSL containers convertible
         data-default deepseq fclabels mtl old-locale QuickCheck random text
         time timezone-olson
       ];
       homepage = "https://github.com/enzoh/time-exts";
       description = "Efficient Timestamps";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "time-http" = callPackage
    ({ mkDerivation, ascii, attempt, attoparsec, base
     , base-unicode-symbols, blaze-builder, blaze-textual, bytestring
     , convertible-text, data-default, failure, QuickCheck, tagged, time
     }:
     mkDerivation {
       pname = "time-http";
       version = "0.5";
       sha256 = "4dd2ceee6967d3ea2fb5b885fc140d18d626fd446395bc3b7b0c5d1222577149";
       libraryHaskellDepends = [
         ascii attempt attoparsec base base-unicode-symbols blaze-builder
         blaze-textual bytestring convertible-text data-default failure
         tagged time
       ];
       testHaskellDepends = [
         ascii attempt attoparsec base base-unicode-symbols blaze-builder
         blaze-textual bytestring convertible-text data-default failure
         QuickCheck tagged time
       ];
       jailbreak = true;
       homepage = "http://cielonegro.org/HTTPDateTime.html";
       description = "Parse and format HTTP/1.1 Date and Time strings";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "time-interval" = callPackage
    ({ mkDerivation, base, time-units }:
     mkDerivation {
       pname = "time-interval";
       version = "0.1.0.0";
       sha256 = "6cfb53e61d573d649273ced38f19e9f84279ed826197b47cfab0587aeb85598d";
       revision = "3";
       editedCabalFile = "bb8d2204c5dcdf0a749985524cd52debe95511ad8ed785c6ab6e19e877de46ae";
       libraryHaskellDepends = [ base time-units ];
       homepage = "http://rel4tion.org/projects/time-interval/";
       description = "Use a time unit class, but hold a concrete time type";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "time-io-access" = callPackage
    ({ mkDerivation, base, base-io-access, time }:
     mkDerivation {
       pname = "time-io-access";
       version = "0.1.0.0";
       sha256 = "2be786989fcb0ad6d5d768aa0a7a5234543f24d8c762e1391dd9b1fb0da70558";
       libraryHaskellDepends = [ base base-io-access time ];
       jailbreak = true;
       description = "IO Access for time";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "time-lens" = callPackage
    ({ mkDerivation, base, data-lens-light, time }:
     mkDerivation {
       pname = "time-lens";
       version = "0.4.0.1";
       sha256 = "9f53888424e7f68be8966ac25c8e36dae03cf576f120c76248588d6495c32624";
       libraryHaskellDepends = [ base data-lens-light time ];
       description = "Lens-based interface to Data.Time data structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "time-locale-compat_0_1_0_1" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "time-locale-compat";
       version = "0.1.0.1";
       sha256 = "ac24cdf39f86a6520bc942cdf437bed8e21e31b6ca8d433285c7b3cdc808ad60";
       libraryHaskellDepends = [ base time ];
       homepage = "http://twitter.com/khibino/";
       description = "Compatibility of TimeLocale between old-locale and time-1.5";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "time-locale-compat_0_1_1_0" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "time-locale-compat";
       version = "0.1.1.0";
       sha256 = "25a04d0099482c2f367fb80e557ab59ba09c99aec6061c2b52733178420cb455";
       libraryHaskellDepends = [ base time ];
       homepage = "http://twitter.com/khibino/";
       description = "Compatibility of TimeLocale between old-locale and time-1.5";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "time-locale-compat" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "time-locale-compat";
       version = "0.1.1.1";
       sha256 = "ced6a61e81671f266cc3daf7eee798e5355df8d82163e7e44dc0a51a47c50670";
       libraryHaskellDepends = [ base time ];
       homepage = "https://github.com/khibino/haskell-time-locale-compat";
       description = "Compatibility of TimeLocale between old-locale and time-1.5";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "time-parsers" = callPackage
    ({ mkDerivation, attoparsec, base, bifunctors, parsec, parsers
     , tasty, tasty-hunit, template-haskell, text, time
     }:
     mkDerivation {
       pname = "time-parsers";
       version = "0.1.0.0";
       sha256 = "e4eb246c3d97e69785a26ecd91381b4cf80e4d1d4313381ad68861b7e72ccff8";
       revision = "1";
       editedCabalFile = "57e4187d557fd911e5578d0daf7ccc5734bb968820e211c1a3c64c291b423132";
       libraryHaskellDepends = [ base parsers template-haskell time ];
       testHaskellDepends = [
         attoparsec base bifunctors parsec parsers tasty tasty-hunit
         template-haskell text time
       ];
       homepage = "https://github.com/phadej/time-parsers#readme";
       description = "Parsers for types in `time`";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "time-patterns" = callPackage
    ({ mkDerivation, base, intervals, lens, thyme, vector-space }:
     mkDerivation {
       pname = "time-patterns";
       version = "0.1.3.1";
       sha256 = "56a0ac5f1a6a264f779d3de15ac09a204eda5a2fb04122e398fa9bb6848dee9d";
       libraryHaskellDepends = [ base intervals lens thyme vector-space ];
       jailbreak = true;
       homepage = "https://bitbucket.org/jfmueller/time-patterns";
       description = "Patterns for recurring events";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "time-qq" = callPackage
    ({ mkDerivation, base, hspec, template-haskell, time
     , time-locale-compat
     }:
     mkDerivation {
       pname = "time-qq";
       version = "0.0.0.2";
       sha256 = "e7abb7307b01793c7283f8669985d8029501fd756890275b998e60597bd1ef7e";
       libraryHaskellDepends = [
         base template-haskell time time-locale-compat
       ];
       testHaskellDepends = [ base hspec ];
       homepage = "https://github.com/christian-marie/time-qq";
       description = "Quasi-quoter for UTCTime times";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "time-recurrence" = callPackage
    ({ mkDerivation, base, data-ordlist, HUnit, mtl, old-locale
     , test-framework, test-framework-hunit, time
     }:
     mkDerivation {
       pname = "time-recurrence";
       version = "0.9.2";
       sha256 = "f5e73d98da00b48422719bc8243809314d1ad92adf6174e0aa91ebfad4ac38ab";
       revision = "1";
       editedCabalFile = "7f1fe44ec61160e3fba86a04942d056ac91faa0002817e107e3d8399b71fe427";
       libraryHaskellDepends = [ base data-ordlist mtl time ];
       testHaskellDepends = [
         base data-ordlist HUnit mtl old-locale test-framework
         test-framework-hunit time
       ];
       jailbreak = true;
       homepage = "http://github.com/hellertime/time-recurrence";
       description = "Generate recurring dates";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "time-series" = callPackage
    ({ mkDerivation, array, base, containers, mtl }:
     mkDerivation {
       pname = "time-series";
       version = "0.1.0.0";
       sha256 = "250195f9d422c92145ad4eeae5c61cc13648b962f8cf32f2bb4a925888cbddc8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base containers mtl ];
       executableHaskellDepends = [ base ];
       description = "Time series analysis";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "time-units" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "time-units";
       version = "1.0.0";
       sha256 = "e181997dd05321f09b21c5e0bf38524ccab51ecc588a6017253cc96db289e099";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/acw/time-units";
       description = "A basic library for defining units of time as types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "time-w3c" = callPackage
    ({ mkDerivation, base, convertible, parsec, time }:
     mkDerivation {
       pname = "time-w3c";
       version = "0.1.0.1";
       sha256 = "6fb9bd6dcaf5d95093d7d24b6d37edfae71c22dab8158b650b7ba2b019dc168a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base convertible parsec time ];
       jailbreak = true;
       homepage = "http://cielonegro.org/W3CDateTime.html";
       description = "Parse, format and convert W3C Date and Time";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "timecalc" = callPackage
    ({ mkDerivation, base, haskeline, uu-parsinglib }:
     mkDerivation {
       pname = "timecalc";
       version = "0.1.1";
       sha256 = "3aedb0fbad5691985057d94fccf9eab14d340495c55ddbaa93d526fb9b77df16";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base haskeline uu-parsinglib ];
       homepage = "https://github.com/chriseidhof/TimeCalc";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "timeconsole" = callPackage
    ({ mkDerivation, base, process, time }:
     mkDerivation {
       pname = "timeconsole";
       version = "0.1.0.0";
       sha256 = "807921c815ca23a86691ae47c445fa9ea2c5cae6aa3ad748debd4314b3f6b97e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base process time ];
       jailbreak = true;
       description = "Time commands by lines of STDOUT";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "timeit" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "timeit";
       version = "1.0.0.0";
       sha256 = "bd48d90bf96802580d0fa4e9c99150ef3c32cdf97bf345bf40e83633cc5d7236";
       libraryHaskellDepends = [ base ];
       description = "Time a computation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "timeless" = callPackage
    ({ mkDerivation, ansi-terminal, base, linear, time, transformers }:
     mkDerivation {
       pname = "timeless";
       version = "0.9.0.1";
       sha256 = "2dd43e752b92715d96e71dd82b65cfd6d9f89c808cb2bb70442d8b133cc01443";
       libraryHaskellDepends = [
         ansi-terminal base linear time transformers
       ];
       homepage = "https://github.com/carldong/timeless";
       description = "An Arrow based Functional Reactive Programming library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "timelike" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "timelike";
       version = "0.1.0";
       sha256 = "6588260531b2821ab33fb92b6587d971c68334f1b07daba56ebf7418641d6036";
       libraryHaskellDepends = [ base transformers ];
       homepage = "http://hub.darcs.net/esz/timelike";
       description = "Type classes for types representing time";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "timelike-time" = callPackage
    ({ mkDerivation, base, time, timelike, transformers }:
     mkDerivation {
       pname = "timelike-time";
       version = "0.1.0";
       sha256 = "25c4b9ed4eb5ab0121973a2b54c19ec451c1ac9e0e54ce62f211814732ccca16";
       libraryHaskellDepends = [ base time timelike transformers ];
       homepage = "http://hub.darcs.net/esz/timelike-time";
       description = "Timelike interface for the time library";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "timemap" = callPackage
    ({ mkDerivation, base, containers, focus, hashable, list-t
     , QuickCheck, quickcheck-instances, stm, stm-containers, tasty
     , tasty-hunit, tasty-quickcheck, time, unordered-containers
     }:
     mkDerivation {
       pname = "timemap";
       version = "0.0.2";
       sha256 = "089ec15bb8c6a4da17ef7619fa1b42dc4288ce630a261270f2ac6752a8387be4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers focus hashable list-t stm stm-containers time
         unordered-containers
       ];
       executableHaskellDepends = [
         base containers focus hashable list-t stm stm-containers time
         unordered-containers
       ];
       testHaskellDepends = [
         base containers focus hashable list-t QuickCheck
         quickcheck-instances stm stm-containers tasty tasty-hunit
         tasty-quickcheck time unordered-containers
       ];
       description = "A mutable hashmap, implicitly indexed by UTCTime";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "timeout" = callPackage
    ({ mkDerivation, base, exceptions, mtl, QuickCheck, tasty
     , tasty-quickcheck, time
     }:
     mkDerivation {
       pname = "timeout";
       version = "0.1.1";
       sha256 = "56bec547e5fcb6a6bd6eb2621e0e432e1ef3e8fef3529b11d41eb5c1ea9cadc9";
       libraryHaskellDepends = [ base exceptions mtl time ];
       testHaskellDepends = [
         base exceptions mtl QuickCheck tasty tasty-quickcheck time
       ];
       homepage = "https://github.com/lambda-llama/timeout";
       description = "Generalized sleep and timeout functions";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "timeout-control" = callPackage
    ({ mkDerivation, base, ghc-prim, lifted-base, monad-control, mtl
     , transformers-base
     }:
     mkDerivation {
       pname = "timeout-control";
       version = "0.2";
       sha256 = "741854f07709ee30c9e31db04745fefc8a42d00023a494e65d17ae40b41679e6";
       libraryHaskellDepends = [
         base ghc-prim lifted-base monad-control mtl transformers-base
       ];
       homepage = "http://github.com/alphaHeavy/timeout-control";
       description = "Updatable timeouts as a Monad transformer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "timeout-with-results" = callPackage
    ({ mkDerivation, base, deepseq, mtl, parallel }:
     mkDerivation {
       pname = "timeout-with-results";
       version = "0.2";
       sha256 = "a0d932c6b488d21cbb492376cf42fde01deb18390cf35a6f4f9741c55560b5f8";
       libraryHaskellDepends = [ base deepseq mtl parallel ];
       homepage = "https://github.com/ppetr/timeout-with-results";
       description = "Runs a time-limited computation alowing it to return intermediate results";
       license = "LGPL";
     }) {};

  "timeparsers" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , convertible, mtl, time
     }:
     mkDerivation {
       pname = "timeparsers";
       version = "0.3.2";
       sha256 = "0706cc3c91bb35fab2aa422ddab234531da9c8bed2515b5f2eb62ae150b92cb6";
       libraryHaskellDepends = [
         attoparsec base bytestring containers convertible mtl time
       ];
       jailbreak = true;
       description = "Attoparsec parsers for various Date/Time formats";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "timeplot" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-lexing, cairo, Chart
     , Chart-cairo, colour, containers, data-default, lens, regex-tdfa
     , strptime, template-haskell, time, transformers, vcs-revision
     }:
     mkDerivation {
       pname = "timeplot";
       version = "1.0.31";
       sha256 = "8dc8e4901b4b2f84c654d34f6721762bb662697b89dcfad969180a00820254b2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring bytestring-lexing cairo Chart Chart-cairo colour
         containers data-default lens regex-tdfa strptime template-haskell
         time transformers vcs-revision
       ];
       homepage = "http://haskell.org/haskellwiki/Timeplot";
       description = "A tool for visualizing time series from log files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "timerep" = callPackage
    ({ mkDerivation, attoparsec, base, monoid-subclasses, QuickCheck
     , tasty, tasty-hunit, tasty-quickcheck, text, time
     }:
     mkDerivation {
       pname = "timerep";
       version = "2.0.0.1";
       sha256 = "68912c451b641a7561c1a57c3d78b45482686dbd2f4891f639b7abd3f9d66366";
       libraryHaskellDepends = [
         attoparsec base monoid-subclasses text time
       ];
       testHaskellDepends = [
         base QuickCheck tasty tasty-hunit tasty-quickcheck text time
       ];
       homepage = "https://github.com/HugoDaniel/timerep";
       description = "Parse and display time according to some RFCs (RFC3339, RFC2822, RFC822)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "timers" = callPackage
    ({ mkDerivation, base, lifted-base, monad-control, suspend
     , transformers-base
     }:
     mkDerivation {
       pname = "timers";
       version = "0.2.0.3";
       sha256 = "4552851a116a6f430754b711e06039e23903ac7b9424da58a3b138d864209c60";
       libraryHaskellDepends = [
         base lifted-base monad-control suspend transformers-base
       ];
       description = "Simple package that implements timers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "timers-updatable" = callPackage
    ({ mkDerivation, base, stm }:
     mkDerivation {
       pname = "timers-updatable";
       version = "0.2.0.2";
       sha256 = "bc927e9716dad072d93529d1974afc8e38d9c9b3ff6d8813f90fbab57b2a5cd9";
       libraryHaskellDepends = [ base stm ];
       homepage = "http://github.com/paolino/timers-updatable";
       description = "timers which are updatable in the remaining time";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "timestamp-subprocess-lines" = callPackage
    ({ mkDerivation, base, bytestring, old-locale, process, split, time
     , transformers
     }:
     mkDerivation {
       pname = "timestamp-subprocess-lines";
       version = "0.1.0.3";
       sha256 = "35aae25c87e8849d9eb9efe581aa94340da27c16f6f72c7ee5ea40b7d621c9ee";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring old-locale process split time transformers
       ];
       homepage = "https://github.com/Peaker/timestamp-subprocess-lines";
       description = "Run a command and timestamp its stdout/stderr lines";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "timestamper" = callPackage
    ({ mkDerivation, base, old-locale, time }:
     mkDerivation {
       pname = "timestamper";
       version = "1.0.3";
       sha256 = "da639240cce6ab43d372c1fb5894e610a340944b7bc7984ba7c0cf43c098ffe2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base old-locale time ];
       homepage = "https://github.com/kisom/timestamper";
       description = "Read standard input and prepend each line with a timestamp";
       license = stdenv.lib.licenses.mit;
     }) {};

  "timezone-olson_0_1_6" = callPackage
    ({ mkDerivation, base, binary, bytestring, extensible-exceptions
     , time, timezone-series
     }:
     mkDerivation {
       pname = "timezone-olson";
       version = "0.1.6";
       sha256 = "1f2c2d53e393ca40c1460877847e0b9473f00d3e4628631222add4591076e13d";
       libraryHaskellDepends = [
         base binary bytestring extensible-exceptions time timezone-series
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/time-ng/";
       description = "A pure Haskell parser and renderer for binary Olson timezone files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "timezone-olson" = callPackage
    ({ mkDerivation, base, binary, bytestring, extensible-exceptions
     , time, timezone-series
     }:
     mkDerivation {
       pname = "timezone-olson";
       version = "0.1.7";
       sha256 = "232f55b670531dced3b4f86b97b8f597073da6540e2b4e085936f73f30dea6aa";
       revision = "1";
       editedCabalFile = "cdd67661d2460ceb1720bcbb194726a57c21b113b9383cd1f1dca91e8e71d652";
       libraryHaskellDepends = [
         base binary bytestring extensible-exceptions time timezone-series
       ];
       homepage = "http://projects.haskell.org/time-ng/";
       description = "A pure Haskell parser and renderer for binary Olson timezone files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "timezone-olson-th" = callPackage
    ({ mkDerivation, base, template-haskell, time, timezone-olson
     , timezone-series
     }:
     mkDerivation {
       pname = "timezone-olson-th";
       version = "0.1.0.1";
       sha256 = "61eb1559bea5a5d5548a5ac0a915d741e6336eae0c3634b7f503583ed7221ef7";
       libraryHaskellDepends = [
         base template-haskell time timezone-olson timezone-series
       ];
       homepage = "http://github.com/jonpetterbergman/timezone-olson-th";
       description = "Load TimeZoneSeries from an Olson file at compile time";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "timezone-series_0_1_4" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "timezone-series";
       version = "0.1.4";
       sha256 = "8038d73de99d7d2c3a06dca9bd441489503afe84933f0082ca95c31a1bd8e51a";
       libraryHaskellDepends = [ base time ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/time-ng/";
       description = "Enhanced timezone handling for Data.Time";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "timezone-series" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "timezone-series";
       version = "0.1.5.1";
       sha256 = "d244dda23a90f019884e6684a6bd7ec43f77875edf382861890ef1c68b2e7a56";
       libraryHaskellDepends = [ base time ];
       homepage = "http://projects.haskell.org/time-ng/";
       description = "Enhanced timezone handling for Data.Time";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "timing-convenience" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "timing-convenience";
       version = "0.1";
       sha256 = "72200ea2c942bfb4ac4c5ae53222353ac3af0c40058f4a9179c99df5ff33171d";
       libraryHaskellDepends = [ base time ];
       description = "Convenient functions for getting times";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tinyMesh" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, hex, serialport
     , unix
     }:
     mkDerivation {
       pname = "tinyMesh";
       version = "0.1.0.0";
       sha256 = "a3527673647b3396363d013e8ea79aad20f06f8c1e626bc8ab205678a6e557a6";
       libraryHaskellDepends = [
         attoparsec base bytestring hex serialport unix
       ];
       jailbreak = true;
       homepage = "http://github.com/mgajda/tinyMesh";
       description = "TinyMesh - communicating with auto-meshing sensor network";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "tinylog" = callPackage
    ({ mkDerivation, auto-update, base, bytestring, containers
     , double-conversion, fast-logger, text, transformers, unix-time
     }:
     mkDerivation {
       pname = "tinylog";
       version = "0.12.1";
       sha256 = "094b52eb6b622f8f17efedd6baa2ad632da3071a3d2eaf72192d8386d00107c2";
       revision = "1";
       editedCabalFile = "b0e1cd3e83f3745355d1183935660d4b02ed152083da7af0ea4f386e155db04d";
       libraryHaskellDepends = [
         auto-update base bytestring containers double-conversion
         fast-logger text transformers unix-time
       ];
       homepage = "https://github.com/twittner/tinylog/";
       description = "Simplistic logging using fast-logger";
       license = "unknown";
     }) {};

  "tinytemplate" = callPackage
    ({ mkDerivation, base, QuickCheck, text }:
     mkDerivation {
       pname = "tinytemplate";
       version = "0.1.2.0";
       sha256 = "30c73964f575bd139ccb214b1123caa99bc330d1904c4d3a5e31e33c31d17d0a";
       libraryHaskellDepends = [ base text ];
       testHaskellDepends = [ base QuickCheck text ];
       homepage = "http://github.com/dicomgrid/tinytemplate";
       description = "A tiny text templating library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tip-haskell-frontend" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , geniplate-mirror, ghc, ghc-paths, ghc-simple, mtl
     , optparse-applicative, pretty, pretty-show, QuickCheck, split
     , tip-lib
     }:
     mkDerivation {
       pname = "tip-haskell-frontend";
       version = "0.2";
       sha256 = "9e39b0c1a59e1a71f2a054811289fd8c2025ec990bc4a876c614d77be7a3a040";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers directory filepath geniplate-mirror ghc
         ghc-paths ghc-simple mtl optparse-applicative pretty QuickCheck
         split tip-lib
       ];
       executableHaskellDepends = [
         base optparse-applicative pretty pretty-show tip-lib
       ];
       jailbreak = true;
       homepage = "http://tip-org.github.io";
       description = "Convert from Haskell to Tip";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tip-lib" = callPackage
    ({ mkDerivation, alex, array, base, containers, filepath
     , genifunctors, geniplate-mirror, happy, mtl, optparse-applicative
     , pretty, split, structural-induction
     }:
     mkDerivation {
       pname = "tip-lib";
       version = "0.2.2";
       sha256 = "66698d1000e582542f3ef838960edc66ae3874eb6b21f169ed8497fd2c2cc12b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers genifunctors geniplate-mirror mtl
         optparse-applicative pretty split structural-induction
       ];
       libraryToolDepends = [ alex happy ];
       executableHaskellDepends = [
         base filepath optparse-applicative pretty
       ];
       homepage = "http://tip-org.github.io";
       description = "tons of inductive problems - support library and tools";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tiphys" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, errors, hspec, text
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "tiphys";
       version = "0.1.1.0";
       sha256 = "6e120092e002d76903e47ce70871ba6aa7b8f194a2ea1319344693178acb9cdf";
       libraryHaskellDepends = [
         aeson attoparsec base errors text unordered-containers vector
       ];
       testHaskellDepends = [ aeson base hspec vector ];
       jailbreak = true;
       homepage = "https://github.com/llhotka/tiphys";
       description = "Navigating and editing JSON data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "titlecase" = callPackage
    ({ mkDerivation, base, blaze-markup, semigroups, tasty, tasty-hunit
     , tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "titlecase";
       version = "0.1.0.2";
       sha256 = "4860625a5233a9cc923224e0d86f113200b6636a79bef209acf40f1dcb631ce1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base blaze-markup semigroups text ];
       executableHaskellDepends = [ base blaze-markup text ];
       testHaskellDepends = [
         base semigroups tasty tasty-hunit tasty-quickcheck text
       ];
       homepage = "https://github.com/nkaretnikov/titlecase";
       description = "Convert English words to title case";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tkhs" = callPackage
    ({ mkDerivation, base, HUnit, mtl, parsec, pretty, test-framework
     , test-framework-hunit, utf8-string, vty
     }:
     mkDerivation {
       pname = "tkhs";
       version = "0.3.0";
       sha256 = "f7392627a6c715e59936c16c92e04dc955275baf988fce7e5ab53015966c7aeb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base mtl parsec pretty utf8-string vty
       ];
       testHaskellDepends = [ HUnit test-framework test-framework-hunit ];
       homepage = "http://patch-tag.com/r/nonowarn/tkhs/snapshot/current/content/pretty/README";
       description = "Simple Presentation Utility";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tkyprof" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, bytestring
     , cmdargs, conduit, conduit-extra, containers, data-default
     , directory, exceptions, filepath, http-types, mtl, resourcet
     , rosezipper, shakespeare, stm, template-haskell, text, time
     , transformers, unordered-containers, vector, wai, wai-extra, warp
     , web-routes, yesod, yesod-core, yesod-form, yesod-static
     }:
     mkDerivation {
       pname = "tkyprof";
       version = "0.2.2.2";
       sha256 = "ea40c354d37843757b76152cbde1d9612000593fae4a515ad2d2cbf5940adef7";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [
         aeson attoparsec base blaze-builder bytestring cmdargs conduit
         conduit-extra containers data-default directory exceptions filepath
         http-types mtl resourcet rosezipper shakespeare stm
         template-haskell text time transformers unordered-containers vector
         wai wai-extra warp web-routes yesod yesod-core yesod-form
         yesod-static
       ];
       jailbreak = true;
       homepage = "https://github.com/maoe/tkyprof";
       description = "A web-based visualizer for GHC Profiling Reports";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tld" = callPackage
    ({ mkDerivation, base, containers, HUnit, network-uri, text }:
     mkDerivation {
       pname = "tld";
       version = "0.3.0.0";
       sha256 = "feb269cd135796d7a378a01150ca89fdea380e4e7fa67b031b299fcd16acac5e";
       libraryHaskellDepends = [ base containers network-uri text ];
       testHaskellDepends = [ base HUnit network-uri text ];
       description = "This project separates subdomains, domains, and top-level-domains from URLs";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tls_1_2_13" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, async, base, byteable
     , bytestring, cereal, cipher-aes, cipher-des, cipher-rc4, cprng-aes
     , crypto-cipher-types, crypto-numbers, crypto-pubkey
     , crypto-pubkey-types, crypto-random, cryptohash
     , data-default-class, hourglass, mtl, network, QuickCheck, tasty
     , tasty-quickcheck, transformers, x509, x509-store, x509-validation
     }:
     mkDerivation {
       pname = "tls";
       version = "1.2.13";
       sha256 = "83b50db00e15dca66507634a4ff3105ea86ec5a70ce4f03fb58c0feb2bd352b6";
       libraryHaskellDepends = [
         asn1-encoding asn1-types async base byteable bytestring cereal
         cipher-aes cipher-des cipher-rc4 crypto-cipher-types crypto-numbers
         crypto-pubkey crypto-pubkey-types crypto-random cryptohash
         data-default-class mtl network transformers x509 x509-store
         x509-validation
       ];
       testHaskellDepends = [
         base bytestring cereal cprng-aes crypto-pubkey crypto-random
         data-default-class hourglass mtl QuickCheck tasty tasty-quickcheck
         x509 x509-validation
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-tls";
       description = "TLS/SSL protocol native implementation (Server and Client)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tls_1_2_15" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, async, base, byteable
     , bytestring, cereal, cipher-aes, cipher-des, cipher-rc4, cprng-aes
     , crypto-cipher-types, crypto-numbers, crypto-pubkey
     , crypto-pubkey-types, crypto-random, cryptohash
     , data-default-class, hourglass, mtl, network, QuickCheck, tasty
     , tasty-quickcheck, transformers, x509, x509-store, x509-validation
     }:
     mkDerivation {
       pname = "tls";
       version = "1.2.15";
       sha256 = "a126ff9e941f9aab3b63ceb0348b4fd139e6c6888fa0f0471c016d50e83fb408";
       libraryHaskellDepends = [
         asn1-encoding asn1-types async base byteable bytestring cereal
         cipher-aes cipher-des cipher-rc4 crypto-cipher-types crypto-numbers
         crypto-pubkey crypto-pubkey-types crypto-random cryptohash
         data-default-class mtl network transformers x509 x509-store
         x509-validation
       ];
       testHaskellDepends = [
         base bytestring cereal cprng-aes crypto-pubkey crypto-random
         data-default-class hourglass mtl QuickCheck tasty tasty-quickcheck
         x509 x509-validation
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-tls";
       description = "TLS/SSL protocol native implementation (Server and Client)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tls_1_2_16" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, async, base, byteable
     , bytestring, cereal, cipher-aes, cipher-des, cipher-rc4, cprng-aes
     , crypto-cipher-types, crypto-numbers, crypto-pubkey
     , crypto-pubkey-types, crypto-random, cryptohash
     , data-default-class, hourglass, mtl, network, QuickCheck, tasty
     , tasty-quickcheck, transformers, x509, x509-store, x509-validation
     }:
     mkDerivation {
       pname = "tls";
       version = "1.2.16";
       sha256 = "405086ac53cce81c5886534281ff44c04aa647c4b315e14f28273365e442bc7c";
       libraryHaskellDepends = [
         asn1-encoding asn1-types async base byteable bytestring cereal
         cipher-aes cipher-des cipher-rc4 crypto-cipher-types crypto-numbers
         crypto-pubkey crypto-pubkey-types crypto-random cryptohash
         data-default-class mtl network transformers x509 x509-store
         x509-validation
       ];
       testHaskellDepends = [
         base bytestring cereal cprng-aes crypto-pubkey crypto-random
         data-default-class hourglass mtl QuickCheck tasty tasty-quickcheck
         x509 x509-validation
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-tls";
       description = "TLS/SSL protocol native implementation (Server and Client)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tls_1_2_17" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, async, base, byteable
     , bytestring, cereal, cipher-aes, cipher-des, cipher-rc4, cprng-aes
     , crypto-cipher-types, crypto-numbers, crypto-pubkey
     , crypto-pubkey-types, crypto-random, cryptohash
     , data-default-class, hourglass, mtl, network, QuickCheck, tasty
     , tasty-quickcheck, transformers, x509, x509-store, x509-validation
     }:
     mkDerivation {
       pname = "tls";
       version = "1.2.17";
       sha256 = "c6fe7c428237246034958e3258bda4a1eda2d9cd202ba9730397f9cbbf090a48";
       libraryHaskellDepends = [
         asn1-encoding asn1-types async base byteable bytestring cereal
         cipher-aes cipher-des cipher-rc4 crypto-cipher-types crypto-numbers
         crypto-pubkey crypto-pubkey-types crypto-random cryptohash
         data-default-class mtl network transformers x509 x509-store
         x509-validation
       ];
       testHaskellDepends = [
         base bytestring cereal cprng-aes crypto-pubkey crypto-random
         data-default-class hourglass mtl QuickCheck tasty tasty-quickcheck
         x509 x509-validation
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-tls";
       description = "TLS/SSL protocol native implementation (Server and Client)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tls_1_2_18" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, async, base, byteable
     , bytestring, cereal, cipher-aes, cipher-des, cipher-rc4, cprng-aes
     , crypto-cipher-types, crypto-numbers, crypto-pubkey
     , crypto-pubkey-types, crypto-random, cryptohash
     , data-default-class, hourglass, mtl, network, QuickCheck, tasty
     , tasty-quickcheck, transformers, x509, x509-store, x509-validation
     }:
     mkDerivation {
       pname = "tls";
       version = "1.2.18";
       sha256 = "019249ef687ce4f0961adcfe24553340a1bf98eb15485918112f804993b9ae01";
       libraryHaskellDepends = [
         asn1-encoding asn1-types async base byteable bytestring cereal
         cipher-aes cipher-des cipher-rc4 crypto-cipher-types crypto-numbers
         crypto-pubkey crypto-pubkey-types crypto-random cryptohash
         data-default-class mtl network transformers x509 x509-store
         x509-validation
       ];
       testHaskellDepends = [
         base bytestring cereal cprng-aes crypto-pubkey crypto-random
         data-default-class hourglass mtl QuickCheck tasty tasty-quickcheck
         x509 x509-validation
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-tls";
       description = "TLS/SSL protocol native implementation (Server and Client)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tls_1_3_1" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, async, base, byteable
     , bytestring, cereal, cryptonite, data-default-class, hourglass
     , memory, mtl, network, QuickCheck, tasty, tasty-quickcheck
     , transformers, x509, x509-store, x509-validation
     }:
     mkDerivation {
       pname = "tls";
       version = "1.3.1";
       sha256 = "747f840677115d077ef548b4da54acb479253ce3cb58ad3a03275fe2b452d5d0";
       revision = "1";
       editedCabalFile = "2b613b97c0a4ac9fd196e985f85e67de684e0cc41d699df8e1715ad72131cc8b";
       libraryHaskellDepends = [
         asn1-encoding asn1-types async base byteable bytestring cereal
         cryptonite data-default-class memory mtl network transformers x509
         x509-store x509-validation
       ];
       testHaskellDepends = [
         base bytestring cereal cryptonite data-default-class hourglass mtl
         QuickCheck tasty tasty-quickcheck x509 x509-validation
       ];
       homepage = "http://github.com/vincenthz/hs-tls";
       description = "TLS/SSL protocol native implementation (Server and Client)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tls_1_3_2" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, async, base, bytestring
     , cereal, cryptonite, data-default-class, hourglass, memory, mtl
     , network, QuickCheck, tasty, tasty-quickcheck, transformers, x509
     , x509-store, x509-validation
     }:
     mkDerivation {
       pname = "tls";
       version = "1.3.2";
       sha256 = "e9f2d3685b4731cb865a1d9ea9a2ddd5dce5393c49d8fd89dd9e00e8b0e06ce4";
       revision = "1";
       editedCabalFile = "14e3ed2c0cd4707c4ca3b727001eb7ca498239c33af8e935745359c07dbe4ba8";
       libraryHaskellDepends = [
         asn1-encoding asn1-types async base bytestring cereal cryptonite
         data-default-class memory mtl network transformers x509 x509-store
         x509-validation
       ];
       testHaskellDepends = [
         base bytestring cereal cryptonite data-default-class hourglass mtl
         QuickCheck tasty tasty-quickcheck x509 x509-validation
       ];
       homepage = "http://github.com/vincenthz/hs-tls";
       description = "TLS/SSL protocol native implementation (Server and Client)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tls" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, async, base, bytestring
     , cereal, cryptonite, data-default-class, hourglass, memory, mtl
     , network, QuickCheck, tasty, tasty-quickcheck, transformers, x509
     , x509-store, x509-validation
     }:
     mkDerivation {
       pname = "tls";
       version = "1.3.4";
       sha256 = "49fff2bd6b420bb57f7cc78445f9a17547a5ff4a72e29135695c9cc2d91e19c1";
       revision = "1";
       editedCabalFile = "52c52c0c7a3816c50437b9bbec9cff59dbdea6330fa64475c1bd51da0dbf6fe9";
       libraryHaskellDepends = [
         asn1-encoding asn1-types async base bytestring cereal cryptonite
         data-default-class memory mtl network transformers x509 x509-store
         x509-validation
       ];
       testHaskellDepends = [
         base bytestring cereal cryptonite data-default-class hourglass mtl
         QuickCheck tasty tasty-quickcheck x509 x509-validation
       ];
       homepage = "http://github.com/vincenthz/hs-tls";
       description = "TLS/SSL protocol native implementation (Server and Client)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tls-debug_0_3_4" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, crypto-pubkey
     , data-default-class, network, pem, time, tls, x509, x509-system
     , x509-validation
     }:
     mkDerivation {
       pname = "tls-debug";
       version = "0.3.4";
       sha256 = "23ada2d22a27e708c53302115decb56fd3071248a949e5fae8ee004701657d21";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cprng-aes crypto-pubkey data-default-class network
         pem time tls x509 x509-system x509-validation
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-tls";
       description = "Set of programs for TLS testing and debugging";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tls-debug_0_4_0" = callPackage
    ({ mkDerivation, base, bytestring, cryptonite, data-default-class
     , network, pem, time, tls, x509, x509-system, x509-validation
     }:
     mkDerivation {
       pname = "tls-debug";
       version = "0.4.0";
       sha256 = "32d6f128bd29048f6adcb736770910b930ec3dc736932b38bd9fd8849eb71b1a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cryptonite data-default-class network pem time tls
         x509 x509-system x509-validation
       ];
       homepage = "http://github.com/vincenthz/hs-tls";
       description = "Set of programs for TLS testing and debugging";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tls-debug" = callPackage
    ({ mkDerivation, base, bytestring, cryptonite, data-default-class
     , network, pem, time, tls, x509, x509-store, x509-system
     , x509-validation
     }:
     mkDerivation {
       pname = "tls-debug";
       version = "0.4.1";
       sha256 = "0051e7f978cde5825317d0ff9220f15dd4ed13512eec30246ec1ff268d00f42c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cryptonite data-default-class network pem time tls
         x509 x509-store x509-system x509-validation
       ];
       homepage = "http://github.com/vincenthz/hs-tls";
       description = "Set of programs for TLS testing and debugging";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tls-extra" = callPackage
    ({ mkDerivation, base, bytestring, certificate, cipher-aes
     , cipher-rc4, crypto-pubkey, crypto-random, cryptohash, mtl
     , network, pem, time, tls, vector
     }:
     mkDerivation {
       pname = "tls-extra";
       version = "0.6.6";
       sha256 = "dbf782edbb82321b6484105518fe8e2ff6d51992b20a545a5d3bd380ed901a4c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring certificate cipher-aes cipher-rc4 crypto-pubkey
         crypto-random cryptohash mtl network pem time tls vector
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-tls";
       description = "TLS extra default values and helpers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tmpl" = callPackage
    ({ mkDerivation, base, bytestring, directory, template, text }:
     mkDerivation {
       pname = "tmpl";
       version = "0.0.0.1";
       sha256 = "6f6769f470570ea3fc8c2b7fa8c30fcfe148d084a9890596100755158a233880";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory template text
       ];
       homepage = "https://www.github.com/michelk/tmpl";
       description = "simple executable for templating";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "tn" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, process
     , safe, text, time, yaml
     }:
     mkDerivation {
       pname = "tn";
       version = "1.0.2.1";
       sha256 = "be665fab37226ff6bfe94cce7ab2c195d4a91bea2536923a58098eb1d05b501e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers directory process safe text time yaml
       ];
       jailbreak = true;
       description = "A simple daily journal program";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "tnet" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, utf8-string }:
     mkDerivation {
       pname = "tnet";
       version = "0.0.1";
       sha256 = "89eb275e56f3f385a7fd2492fe2bec12264a5c405b6d167514072fef2452b3c3";
       libraryHaskellDepends = [ attoparsec base bytestring utf8-string ];
       description = "Library for encoding/decoding TNET strings for PGI";
       license = "unknown";
     }) {};

  "to-haskell" = callPackage
    ({ mkDerivation, base, containers, haskell-src-exts, transformers
     }:
     mkDerivation {
       pname = "to-haskell";
       version = "0.3.0";
       sha256 = "1393c215a3188fc28de6ba8f8c3797f7e77a86c209aff0ae58eabe94413d8e3e";
       libraryHaskellDepends = [
         base containers haskell-src-exts transformers
       ];
       homepage = "https://github.com/conal/to-haskell";
       description = "A type class and some utilities for generating Haskell code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "to-string-class" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "to-string-class";
       version = "0.1.2";
       sha256 = "aeebad6f4d2f4a0d8b6168d71ced245fb836ffc3ddd855ea69b001b618905050";
       libraryHaskellDepends = [ base ];
       description = "Converting string-like types to Strings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "to-string-instances" = callPackage
    ({ mkDerivation, to-string-class }:
     mkDerivation {
       pname = "to-string-instances";
       version = "0.2";
       sha256 = "89f68da09117a2c88428ada452650b1bcf9c45dc542f8d6480ef3f05f5c0aac0";
       libraryHaskellDepends = [ to-string-class ];
       description = "Instances for the ToString class";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "todos" = callPackage
    ({ mkDerivation, ansi-terminal, base, base-unicode-symbols
     , containers, data-hash, dates, directory, dyre, filepath, Glob
     , mtl, parsec, process, regex-pcre, syb, time, utf8-string
     }:
     mkDerivation {
       pname = "todos";
       version = "0.5.3.2";
       sha256 = "291cbabd72022696ba71cebf2e1fe6cc7d693f46c4ebae1caa32363bd3ebf6f1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal base base-unicode-symbols containers data-hash dates
         directory dyre filepath Glob mtl parsec process regex-pcre syb time
         utf8-string
       ];
       executableHaskellDepends = [
         ansi-terminal base base-unicode-symbols containers data-hash dates
         directory dyre filepath Glob mtl parsec process regex-pcre syb time
         utf8-string
       ];
       homepage = "http://gitorious.org/todos";
       description = "Easy-to-use TODOs manager";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tofromxml" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, filepath
     , hexpat, hexpat-pickle
     }:
     mkDerivation {
       pname = "tofromxml";
       version = "0.1.0.2";
       sha256 = "100ff3946757095dcfd6f55b15366b061fe0fc899b1d7300fe6dc9e84cee0d73";
       libraryHaskellDepends = [
         array base bytestring containers hexpat hexpat-pickle
       ];
       testHaskellDepends = [
         array base bytestring containers filepath hexpat hexpat-pickle
       ];
       description = "Reading and writing Haskell data from and to XML";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "toilet" = callPackage
    ({ mkDerivation, base, containers, old-locale, strict, time
     , transformers, utility-ht
     }:
     mkDerivation {
       pname = "toilet";
       version = "0.0.1";
       sha256 = "7d983fa1c8c55b7544e36a825ddbca3e8aa02d657fc13f8438289ac533814626";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers old-locale strict time transformers utility-ht
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/toilet/";
       description = "Manage the toilet queue at the IMO";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "token-bucket" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "token-bucket";
       version = "0.1.0.1";
       sha256 = "312609c0037271b1091f23c2edf467e9449edca5bbed0cfb45c2c93c1bee6ad0";
       revision = "1";
       editedCabalFile = "41232cfabd4ba8e217d2b78f0f897d5a245756cf525c9a84c5ba2c695b533576";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base time ];
       homepage = "https://github.com/hvr/token-bucket";
       description = "Rate limiter using lazy bucket algorithm";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "tokenify" = callPackage
    ({ mkDerivation, base, containers, text }:
     mkDerivation {
       pname = "tokenify";
       version = "0.1.2.0";
       sha256 = "90655271f5cc70dfdc571815407fbc64973318a5f02f0f0f8f70b590aa0fcebb";
       libraryHaskellDepends = [ base containers text ];
       homepage = "https://github.com/AKST/tokenify";
       description = "A regex lexer";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tokenize" = callPackage
    ({ mkDerivation, base, split, text }:
     mkDerivation {
       pname = "tokenize";
       version = "0.3.0";
       sha256 = "0e88490f06efb45c17138ebbc9bec206b87b98361c2c949ca16546e3f9ab91b5";
       libraryHaskellDepends = [ base split text ];
       homepage = "https://bitbucket.org/gchrupala/lingo/overview";
       description = "Simple tokenizer for English text";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "toktok" = callPackage
    ({ mkDerivation, base, bytestring, containers, criterion, filepath
     , gf, haskell98, HUnit, iconv, progression, QuickCheck
     }:
     mkDerivation {
       pname = "toktok";
       version = "0.5";
       sha256 = "1ba56b91114ac27b155a7072a9cc7e1e4fcb4b666d0e2e4407bc936b1f329a78";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers haskell98 ];
       executableHaskellDepends = [
         base bytestring criterion filepath gf HUnit iconv progression
         QuickCheck
       ];
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tokyocabinet-haskell" = callPackage
    ({ mkDerivation, base, bytestring, mtl, tokyocabinet }:
     mkDerivation {
       pname = "tokyocabinet-haskell";
       version = "0.0.5";
       sha256 = "af6575357b7c26c721b17025db23815119de414cffeafb1e60961985701adaec";
       libraryHaskellDepends = [ base bytestring mtl ];
       librarySystemDepends = [ tokyocabinet ];
       homepage = "http://tom-lpsd.github.com/tokyocabinet-haskell/";
       description = "Haskell binding of Tokyo Cabinet";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) tokyocabinet;};

  "tokyotyrant-haskell" = callPackage
    ({ mkDerivation, base, bytestring, mtl, tokyocabinet, tokyotyrant
     }:
     mkDerivation {
       pname = "tokyotyrant-haskell";
       version = "1.0.1";
       sha256 = "f086ef51dc07d0798d1329fc4fd51521f4e2fc905843c4f8522dc3f9e0b0e8f7";
       libraryHaskellDepends = [ base bytestring mtl ];
       librarySystemDepends = [ tokyocabinet tokyotyrant ];
       homepage = "http://www.polarmobile.com/";
       description = "FFI bindings to libtokyotyrant";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) tokyocabinet; inherit (pkgs) tokyotyrant;};

  "tomato-rubato-openal" = callPackage
    ({ mkDerivation, base, OpenAL, stm, vector }:
     mkDerivation {
       pname = "tomato-rubato-openal";
       version = "0.1.0.4";
       sha256 = "a1f762ee2229ecba58debf2cce2ef4498f101ff1a0177d70c332bc293b60ce75";
       libraryHaskellDepends = [ base OpenAL stm vector ];
       homepage = "http://www.haskell.org/haskellwiki/tomato-rubato";
       description = "Easy to use library for audio programming";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "toml" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , old-locale, time
     }:
     mkDerivation {
       pname = "toml";
       version = "0.1.3";
       sha256 = "c29946c58656443d0dbf18aad0582707311c691ab624a63c8f9614a4950c7e71";
       libraryHaskellDepends = [
         attoparsec base bytestring containers old-locale time
       ];
       jailbreak = true;
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "toolshed" = callPackage
    ({ mkDerivation, array, base, containers, deepseq, directory
     , filepath, QuickCheck, random
     }:
     mkDerivation {
       pname = "toolshed";
       version = "0.16.0.0";
       sha256 = "bf19c993d987d9024aced25f3aeab1732ffe935c76daf276e147668f1c8fa244";
       libraryHaskellDepends = [
         array base containers deepseq directory filepath QuickCheck random
       ];
       testHaskellDepends = [ base containers QuickCheck random ];
       homepage = "http://functionalley.eu";
       description = "Ill-defined library";
       license = "GPL";
     }) {};

  "topkata" = callPackage
    ({ mkDerivation, ALUT, array, base, filepath, GLFW-b, OpenAL
     , OpenGL, parseargs, random
     }:
     mkDerivation {
       pname = "topkata";
       version = "0.2.4";
       sha256 = "b13b54ed389d87a26d48f247a65b7f181ac732a74324d098244c9821221a6919";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ALUT array base filepath GLFW-b OpenAL OpenGL parseargs random
       ];
       homepage = "http://home.arcor.de/chr_bauer/topkata.html";
       description = "OpenGL Arcade Game";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "torch" = callPackage
    ({ mkDerivation, base, mtl, parallel, QuickCheck }:
     mkDerivation {
       pname = "torch";
       version = "0.1";
       sha256 = "ec3f0b1c1dad776ae2c55e17fe4ab693405fc0cabb9d617fa2dd6dd1fa0e51ad";
       libraryHaskellDepends = [ base mtl parallel QuickCheck ];
       homepage = "http://patch-tag.com/repo/torch/home";
       description = "Simple unit test library (or framework)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "torrent" = callPackage
    ({ mkDerivation, base, bencode, binary, bytestring, containers
     , filepath, syb
     }:
     mkDerivation {
       pname = "torrent";
       version = "10000.0.0";
       sha256 = "5914bc8b4c32c10dc82bfe373ba73745e1e785424a052b0ede5352802aa1140c";
       libraryHaskellDepends = [
         base bencode binary bytestring containers filepath syb
       ];
       description = "BitTorrent file parser and generater";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tostring_0_2_1" = callPackage
    ({ mkDerivation, base, case-insensitive, text, utf8-string }:
     mkDerivation {
       pname = "tostring";
       version = "0.2.1";
       sha256 = "9c7aeb18c65aa42a98df329d9147d9616d137bb07fc808d96a161a1cb4dc6e53";
       libraryHaskellDepends = [ base case-insensitive text utf8-string ];
       jailbreak = true;
       description = "The ToString class";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tostring" = callPackage
    ({ mkDerivation, base, case-insensitive, text, utf8-string }:
     mkDerivation {
       pname = "tostring";
       version = "0.2.1.1";
       sha256 = "efa700d44aec57c82be60c0eabd610f62f2df0d9b06cf41b5fc35a2b77502531";
       libraryHaskellDepends = [ base case-insensitive text utf8-string ];
       description = "The ToString class";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "total" = callPackage
    ({ mkDerivation, base, void }:
     mkDerivation {
       pname = "total";
       version = "1.0.4";
       sha256 = "eadd2440d593a5df926f8ed77c6455c235e25948240d235a0ae7bd6bff15807e";
       libraryHaskellDepends = [ base void ];
       description = "Exhaustive pattern matching using lenses, traversals, and prisms";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "total-map" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "total-map";
       version = "0.0.4";
       sha256 = "282de643c4b34e1a5eabc89a0c1c4b1c62637626a1f9b4ea567fd40e71dc5cbe";
       libraryHaskellDepends = [ base containers ];
       homepage = "http://github.com/conal/total-map/";
       description = "Finitely represented /total/ maps";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "total-maps" = callPackage
    ({ mkDerivation, adjunctions, base, base-compat, bytes, containers
     , distributive, keys, linear, reflection, semigroups, vector
     }:
     mkDerivation {
       pname = "total-maps";
       version = "1.0.0.3";
       sha256 = "6b2d338e1253854550216147ea6a274c0b8a5ab3cc49eb0a1d5c95c5cc69e931";
       libraryHaskellDepends = [
         adjunctions base base-compat bytes containers distributive keys
         linear reflection semigroups vector
       ];
       description = "Dense and sparse total maps";
       license = stdenv.lib.licenses.mit;
     }) {};

  "touched" = callPackage
    ({ mkDerivation, base, cmdargs, directory, process, time }:
     mkDerivation {
       pname = "touched";
       version = "0.2.0.1";
       sha256 = "f1f565427a69e3f91303ae5ca5c8c4d813efb4148ab6454c635c5a8fe9133352";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory process time ];
       executableHaskellDepends = [ base cmdargs ];
       description = "Library (and cli) to execute a procedure on file change";
       license = stdenv.lib.licenses.mit;
     }) {};

  "toysolver" = callPackage
    ({ mkDerivation, array, base, bytestring, bytestring-builder
     , containers, data-default-class, data-interval, deepseq
     , exceptions, extended-reals, filepath, finite-field, ghc-prim
     , hashable, haskeline, heaps, intern, loop, mtl, multiset
     , mwc-random, OptDir, parse-dimacs, parsec, prettyclass, primes
     , process, pseudo-boolean, queue, QuickCheck, semigroups, sign
     , split, stm, tasty, tasty-hunit, tasty-quickcheck, tasty-th
     , template-haskell, temporary, time, transformers
     , transformers-compat, type-level-numbers, unbounded-delays
     , unordered-containers, vector, vector-space
     }:
     mkDerivation {
       pname = "toysolver";
       version = "0.4.0";
       sha256 = "e9633a7854e6b67d947da02128098f7a29100e9a185be1a5d267e1d4fbf8e3bf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base bytestring bytestring-builder containers
         data-default-class data-interval deepseq exceptions extended-reals
         filepath finite-field ghc-prim hashable heaps intern loop mtl
         multiset mwc-random OptDir parse-dimacs parsec prettyclass primes
         process pseudo-boolean queue semigroups sign stm template-haskell
         temporary time transformers transformers-compat type-level-numbers
         unordered-containers vector vector-space
       ];
       executableHaskellDepends = [
         array base bytestring containers data-default-class filepath
         haskeline mtl mwc-random OptDir parse-dimacs parsec process
         pseudo-boolean split time transformers transformers-compat
         unbounded-delays vector vector-space
       ];
       testHaskellDepends = [
         array base containers data-default-class data-interval deepseq
         finite-field mtl mwc-random OptDir parsec prettyclass QuickCheck
         tasty tasty-hunit tasty-quickcheck tasty-th transformers
         transformers-compat vector vector-space
       ];
       description = "Assorted decision procedures for SAT, Max-SAT, PB, MIP, etc";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tpdb" = callPackage
    ({ mkDerivation, base, bytestring, containers, filepath, hashable
     , HaXml, hxt, mtl, parsec, pretty, text, time, wl-pprint-text
     }:
     mkDerivation {
       pname = "tpdb";
       version = "1.2.0";
       sha256 = "60553cf6424b839b79331516056b5ea3cc61f6fc22e2d1c2c1035889ae51848a";
       libraryHaskellDepends = [
         base containers filepath hashable HaXml hxt mtl parsec text time
         wl-pprint-text
       ];
       testHaskellDepends = [ base bytestring HaXml pretty ];
       homepage = "https://github.com/jwaldmann/haskell-tpdb";
       description = "Data Type for Rewriting Systems";
       license = "GPL";
     }) {};

  "trace" = callPackage
    ({ mkDerivation, base, containers, deepseq, monad-control, mtl
     , transformers, transformers-base
     }:
     mkDerivation {
       pname = "trace";
       version = "0.2.0.0";
       sha256 = "81fcd5593b6e1a5e4b23bf695e704576e6cb53547cefa9797021b2274c6b7f92";
       libraryHaskellDepends = [
         base containers deepseq monad-control mtl transformers
         transformers-base
       ];
       description = "A monad transformer for tracing provenience of errors";
       license = stdenv.lib.licenses.mit;
     }) {};

  "trace-call" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "trace-call";
       version = "0.1";
       sha256 = "5c993e37bf00d321afd93f3485a399edadb74751907b868cb26832d2d20e3fba";
       libraryHaskellDepends = [ base containers mtl ];
       jailbreak = true;
       description = "functions for logging the arguments and results of function calls";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "trace-function-call" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "trace-function-call";
       version = "0.1";
       sha256 = "be8fe1743d07d6d64d53dade44a14544793949da2167b6fd6c35a7d213d6b630";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Easy lightweight tracing of function arguments and results for ad hoc debugging";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "traced" = callPackage
    ({ mkDerivation, base, containers, mtl, pretty }:
     mkDerivation {
       pname = "traced";
       version = "3000";
       sha256 = "2942100c3c48b8b8171cb941a5a98219e5c0ba46dad74630dd122ebff452d1de";
       libraryHaskellDepends = [ base containers mtl pretty ];
       description = "Simple evaluation trace";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tracer" = callPackage
    ({ mkDerivation, base, mtl, transformers }:
     mkDerivation {
       pname = "tracer";
       version = "0.1";
       sha256 = "5516cd56d87063601525d9abefe7c4f1b826e902e0ecbe6dfe49f8fc85a6f6e5";
       libraryHaskellDepends = [ base mtl transformers ];
       testHaskellDepends = [ base mtl transformers ];
       homepage = "https://github.com/knz/hs-tracer";
       description = "Tracing utilities for Functor/Applicative/Monad types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tracker" = callPackage
    ({ mkDerivation, base, containers, glib }:
     mkDerivation {
       pname = "tracker";
       version = "0.1";
       sha256 = "42ffbe3f790327c516613e3f4b64bc3e028f98f85b78f39cdb138ef7e7e46cca";
       libraryHaskellDepends = [ base containers glib ];
       description = "Client library for Tracker metadata database, indexer and search tool";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tracy" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "tracy";
       version = "0.1.2.0";
       sha256 = "29e1a75da8bcf1029d6e918f6b681ba401fe41e01d3bace52852d7d35759b431";
       libraryHaskellDepends = [ base ];
       description = "Convenience wrappers for non-intrusive debug tracing";
       license = stdenv.lib.licenses.mit;
     }) {};

  "trajectory" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, cmdargs
     , containers, http-enumerator, http-types, regexpr, text
     , unordered-containers, uri
     }:
     mkDerivation {
       pname = "trajectory";
       version = "0.1.0.0";
       sha256 = "f06831a87b172c0a95c329bb61ee695e9de60b917d75e75917cf973b40a2fbd8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring http-enumerator http-types uri
       ];
       executableHaskellDepends = [
         aeson attoparsec base bytestring cmdargs containers http-enumerator
         http-types regexpr text unordered-containers uri
       ];
       jailbreak = true;
       homepage = "https://github.com/mike-burns/trajectory";
       description = "Tools and a library for working with Trajectory";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "transactional-events" = callPackage
    ({ mkDerivation, base, ListZipper, MonadPrompt, stm }:
     mkDerivation {
       pname = "transactional-events";
       version = "0.1.0.0";
       sha256 = "b47e21951c88ec3243c6f977b2d59e2688c536e3f182e3d7e80700bb88636349";
       libraryHaskellDepends = [ base ListZipper MonadPrompt stm ];
       description = "Transactional events, based on Concurrent ML semantics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "transf" = callPackage
    ({ mkDerivation, async, base, containers, data-default, filepath
     , hashable, hint, monadplus, mtl, process, semigroups
     }:
     mkDerivation {
       pname = "transf";
       version = "0.13.1";
       sha256 = "34f2d3352d73eb3684dc64a55a887c4754c9f73c20ec5c2b1bc59aa48ece36dd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base containers data-default filepath hashable hint monadplus
         mtl process semigroups
       ];
       description = "Text transformer and interpreter";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "transformations" = callPackage
    ({ mkDerivation, base, containers, criterion, mtl, multirec, parsec
     , QuickCheck, regular, template-haskell
     }:
     mkDerivation {
       pname = "transformations";
       version = "0.2.0.0";
       sha256 = "55d1035545a623d77823d68408d9c1ba22561497abfae7f0733d068051d3bf5a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers mtl multirec regular template-haskell
       ];
       executableHaskellDepends = [
         base containers criterion mtl multirec parsec QuickCheck
       ];
       description = "Generic representation of tree transformations";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "transformers_0_4_3_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "transformers";
       version = "0.4.3.0";
       sha256 = "b3d0a797e815ca50d411e20c02f781efe7751308007d880af7f0b5c4365c3a9d";
       revision = "1";
       editedCabalFile = "60dafcffe8c4fe6f3760426fc35a325c8e6419877596518c76f46657280207a9";
       libraryHaskellDepends = [ base ];
       description = "Concrete functor and monad transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "transformers_0_5_2_0" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "transformers";
       version = "0.5.2.0";
       sha256 = "6c408713a8ba7dd7a6573a4644e0c17fe11747f5bf259eab958421a7358a70e2";
       libraryHaskellDepends = [ base ];
       description = "Concrete functor and monad transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "transformers-abort" = callPackage
    ({ mkDerivation, base, data-default-class, monad-control, pointed
     , semigroupoids, transformers, transformers-base
     }:
     mkDerivation {
       pname = "transformers-abort";
       version = "0.5.0.1";
       sha256 = "f525bd66622ceb6dcdf38d7f96cc3fbcf5e9cc8bc1f5f126e2fbc011a3dc1b68";
       libraryHaskellDepends = [
         base data-default-class monad-control pointed semigroupoids
         transformers transformers-base
       ];
       homepage = "https://github.com/mvv/transformers-abort";
       description = "A better error monad transformer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "transformers-base_0_4_3" = callPackage
    ({ mkDerivation, base, stm, transformers }:
     mkDerivation {
       pname = "transformers-base";
       version = "0.4.3";
       sha256 = "9e38d66cf9fb5eaccbfcd03451d0fc302ddfae30a2632b5382f6c618efc9742e";
       revision = "1";
       editedCabalFile = "48e267c7ce3e0cbc1493d5d7dc3fd7301ae42d229857fd21240a3b915665545e";
       libraryHaskellDepends = [ base stm transformers ];
       homepage = "https://github.com/mvv/transformers-base";
       description = "Lift computations from the bottom of a transformer stack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "transformers-base" = callPackage
    ({ mkDerivation, base, stm, transformers, transformers-compat }:
     mkDerivation {
       pname = "transformers-base";
       version = "0.4.4";
       sha256 = "6aa3494fc70659342fbbb163035d5827ecfd8079e3c929e2372adf771fd52387";
       revision = "1";
       editedCabalFile = "fb1a305f29cbf6ac182af7e67efaae9fcb9664d8d9606bb8a7f3414ad4c8d7a4";
       libraryHaskellDepends = [
         base stm transformers transformers-compat
       ];
       homepage = "https://github.com/mvv/transformers-base";
       description = "Lift computations from the bottom of a transformer stack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "transformers-compat_0_3_3_3" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "transformers-compat";
       version = "0.3.3.3";
       sha256 = "a74b7b26d58856e3d6d81dd49cd2d444a2ea36e4dc3a6a719227b1071c7c98a1";
       libraryHaskellDepends = [ base transformers ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/ekmett/transformers-compat/";
       description = "A small compatibility shim exposing the new types from transformers 0.3 and 0.4 to older Haskell platforms.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "transformers-compat_0_4_0_3" = callPackage
    ({ mkDerivation, base, mtl, transformers }:
     mkDerivation {
       pname = "transformers-compat";
       version = "0.4.0.3";
       sha256 = "4eca78f0190df3f6f5655901817d51e848ca60ef162e906b98a6d9ac0d33fe24";
       libraryHaskellDepends = [ base mtl transformers ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/transformers-compat/";
       description = "A small compatibility shim exposing the new types from transformers 0.3 and 0.4 to older Haskell platforms.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "transformers-compat_0_4_0_4" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "transformers-compat";
       version = "0.4.0.4";
       sha256 = "d5231bc9929ed234032411038c0baae5a3d82939163c2a36582fbe657c46af52";
       libraryHaskellDepends = [ base transformers ];
       doHaddock = false;
       homepage = "http://github.com/ekmett/transformers-compat/";
       description = "A small compatibility shim exposing the new types from transformers 0.3 and 0.4 to older Haskell platforms.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "transformers-compat" = callPackage
    ({ mkDerivation, base, ghc-prim, transformers }:
     mkDerivation {
       pname = "transformers-compat";
       version = "0.5.1.4";
       sha256 = "d881ef4ec164b631591b222efe7ff555af6d5397c9d86475b309ba9402a8ca9f";
       libraryHaskellDepends = [ base ghc-prim transformers ];
       homepage = "http://github.com/ekmett/transformers-compat/";
       description = "A small compatibility shim exposing the new types from transformers 0.3 and 0.4 to older Haskell platforms.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "transformers-compose" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "transformers-compose";
       version = "0.1";
       sha256 = "cddca7ec49334b951418dac5014aa0c4bf2ad38a841906d330d1681974a1704f";
       libraryHaskellDepends = [ base transformers ];
       jailbreak = true;
       homepage = "http://github.com/aristidb/transformers-compose";
       description = "Arrow-like / category-like composition for transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "transformers-convert" = callPackage
    ({ mkDerivation, base, data-easy, directory, either, errors
     , haskell-src-exts, hlint, hspec, HUnit, QuickCheck, text
     , transformers, unix
     }:
     mkDerivation {
       pname = "transformers-convert";
       version = "0.2.0.0";
       sha256 = "679c9f0ce00853e836d4acc9698341c92982fe4ceb2d1dd6a6b2bcf5bc4ca95b";
       libraryHaskellDepends = [ base data-easy either transformers ];
       testHaskellDepends = [
         base data-easy directory either errors haskell-src-exts hlint hspec
         HUnit QuickCheck text transformers unix
       ];
       jailbreak = true;
       homepage = "https://github.com/jcristovao/transformers-convert";
       description = "Sensible conversions between some of the monad transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "transformers-free" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "transformers-free";
       version = "1.0.1";
       sha256 = "e08b197351a03537b57f561d133e7266f4baf916638c88397a166f174f9e7f39";
       libraryHaskellDepends = [ base transformers ];
       description = "Free monad transformers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "transformers-lift" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "transformers-lift";
       version = "0.1.0.0";
       sha256 = "52830bb81f2cf400f4f47990196c1db535a95653607946b6313de4a2d036ad3a";
       libraryHaskellDepends = [ base transformers ];
       description = "Ad-hoc type classes for lifting";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "transformers-runnable" = callPackage
    ({ mkDerivation, base, transformers }:
     mkDerivation {
       pname = "transformers-runnable";
       version = "0.1.0.0";
       sha256 = "3ac45eb89a407fca2d9872309f4f065934c9b8751abe5c6aaf3518135ddb3b54";
       libraryHaskellDepends = [ base transformers ];
       jailbreak = true;
       homepage = "https://github.com/JanBessai/transformers-runnable";
       description = "A unified interface for the run operation of monad transformers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "transformers-supply" = callPackage
    ({ mkDerivation, base, mtl, transformers }:
     mkDerivation {
       pname = "transformers-supply";
       version = "0.1.0";
       sha256 = "b8c60e6ad35c53a77c4e72b255562b0aebb6a1f26c33ed51ab528fd8d9b0c925";
       libraryHaskellDepends = [ base mtl transformers ];
       description = "Supply applicative, monad, applicative transformer and monad transformer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "transient" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , HTTP, mtl, network, network-info, process, random, SHA, stm
     , TCache, time, transformers
     }:
     mkDerivation {
       pname = "transient";
       version = "0.1.1";
       sha256 = "edd779a4ef2c7762ddd097427a16dc96eddc6d1d0fbf714f85b7304c290819ed";
       revision = "2";
       editedCabalFile = "ed7129095502ad5fc1ca8aa9dbfe7526110681f7d1ffb6ff8249b359d52d3b40";
       libraryHaskellDepends = [
         base bytestring containers directory filepath HTTP mtl network
         network-info process random SHA stm TCache time transformers
       ];
       homepage = "http://www.fpcomplete.com/user/agocorona";
       description = "Making composable programs with multithreading, events and distributed computing";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "translatable-intset" = callPackage
    ({ mkDerivation, base, fingertree }:
     mkDerivation {
       pname = "translatable-intset";
       version = "0.1";
       sha256 = "7556dd009fa229c94ad47dfc7ef86b1e5e5bf76feee8db9b704419820b0d685f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base fingertree ];
       jailbreak = true;
       description = "Integer sets with a constant time translate operation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "translate" = callPackage
    ({ mkDerivation, base, curl, json, network, utf8-string }:
     mkDerivation {
       pname = "translate";
       version = "2010.1.24";
       sha256 = "ee5780019a3af853ce9a3c0ba0ea9ea0e896c5e965ccfda247cb26763ae0986d";
       libraryHaskellDepends = [ base curl json network utf8-string ];
       homepage = "http://github.com/nfjinjing/translate";
       description = "Haskell binding to Google's AJAX Language API for Translation and Detection";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "traverse-with-class" = callPackage
    ({ mkDerivation, base, template-haskell, transformers }:
     mkDerivation {
       pname = "traverse-with-class";
       version = "0.2.0.3";
       sha256 = "cfe4dd30867108f04aec32c36b2636cca224eee5331257798836d9c153d0d56a";
       libraryHaskellDepends = [ base template-haskell transformers ];
       description = "Generic applicative traversals";
       license = stdenv.lib.licenses.mit;
     }) {};

  "travis" = callPackage
    ({ mkDerivation, aeson, base, bytestring, http-conduit
     , transformers
     }:
     mkDerivation {
       pname = "travis";
       version = "0.1.0.1";
       sha256 = "eed3dc277851940c32df93f6d3f1343f7a0f0d35998fdcc73f0ffdc8da5ecdd6";
       libraryHaskellDepends = [
         aeson base bytestring http-conduit transformers
       ];
       homepage = "http://github.com/tomtau/travis#readme";
       description = "A simple client implementation using Travis CI API";
       license = stdenv.lib.licenses.mit;
     }) {};

  "travis-meta-yaml" = callPackage
    ({ mkDerivation, aeson, base, bytestring, extra, file-embed, lens
     , lens-aeson, optparse-applicative, regex-applicative, tasty
     , tasty-quickcheck, text, unordered-containers, yaml
     }:
     mkDerivation {
       pname = "travis-meta-yaml";
       version = "0.1.0.0";
       sha256 = "d5d9e8fe5c2e49fdd0beac1535d5d7567a6ab3e29d13bcc0c610e1865de09b94";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring file-embed lens lens-aeson regex-applicative
         text unordered-containers yaml
       ];
       executableHaskellDepends = [
         aeson base bytestring file-embed lens lens-aeson
         optparse-applicative regex-applicative text unordered-containers
         yaml
       ];
       testHaskellDepends = [
         aeson base bytestring extra file-embed lens lens-aeson
         regex-applicative tasty tasty-quickcheck text unordered-containers
         yaml
       ];
       homepage = "https://github.com/phadej/travis-meta-yaml#readme";
       description = ".travis.yml preprocessor";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "trawl" = callPackage
    ({ mkDerivation, base, Cabal, directory, filepath, MissingH
     , optparse-applicative, process, split
     }:
     mkDerivation {
       pname = "trawl";
       version = "0.1.0.0";
       sha256 = "699d373ca97b04aedee973d466a8afbe81faa2e2e20e3e87d8261fe4f685a42e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base Cabal directory filepath MissingH optparse-applicative process
         split
       ];
       jailbreak = true;
       homepage = "https://github.com/bmjames/trawl";
       description = "A tool for finding haddocks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "traypoweroff" = callPackage
    ({ mkDerivation, base, gtk, process }:
     mkDerivation {
       pname = "traypoweroff";
       version = "1.0.0";
       sha256 = "95b035d1ac8dbb5bf69153c901b46253cbc2a6f253b16fde7a12953ea40cfd3c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base gtk process ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/traypoweroff";
       description = "Tray Icon application to PowerOff / Reboot computer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tree-fun" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "tree-fun";
       version = "0.8.1.0";
       sha256 = "2ae925f198e9700dedbf809c2b77086fef32f58b4a4adb6c398dca49f4d56f1f";
       libraryHaskellDepends = [ base containers mtl ];
       description = "Library for functions pertaining to tree exploration and manipulation";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "tree-monad" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "tree-monad";
       version = "0.3";
       sha256 = "95ea6fbd0af4d360b7a66aa1fc89e04afc240ae51fd654dbf1a02190eec341ff";
       libraryHaskellDepends = [ base ];
       homepage = "http://sebfisch.github.com/tree-monad";
       description = "Non-Determinism Monad for Tree Search";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tree-view" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "tree-view";
       version = "0.4";
       sha256 = "f64de6b9461d125fa4755fc98b6921a7a53cb4f096f88692fe86dd68cde5fe57";
       libraryHaskellDepends = [ base containers mtl ];
       description = "Render trees as foldable HTML and Unicode art";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "treemap-html" = callPackage
    ({ mkDerivation, base, Cabal, containers, filepath, ghc, html
     , parsec, regex-posix
     }:
     mkDerivation {
       pname = "treemap-html";
       version = "0.1";
       sha256 = "058d1a3093dffedd393d6244d5f05736b4af280222d60b19271f89f2c7e3124b";
       libraryHaskellDepends = [
         base Cabal containers filepath ghc html parsec regex-posix
       ];
       jailbreak = true;
       homepage = "http://rampa.sk/static/treemap-html.html";
       description = "Generates HTML for Data.Tree as TreeMap";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "treemap-html-tools" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, filepath, ghc
     , parsec, regex-posix, split, treemap-html, xml
     }:
     mkDerivation {
       pname = "treemap-html-tools";
       version = "0.2";
       sha256 = "6e19cf868c27e2eebe7fb695009470443edaa00cf9b196e2edf4a21036aaf128";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers directory filepath ghc parsec regex-posix
         split treemap-html xml
       ];
       doHaddock = false;
       jailbreak = true;
       homepage = "http://rampa.sk/static/treemap-html.html";
       description = "Treemap related commands for producing foldable TreeMap HTML";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "treersec" = callPackage
    ({ mkDerivation, base, haste-compiler, sneathlane-haste }:
     mkDerivation {
       pname = "treersec";
       version = "1";
       sha256 = "220e4863d0ca51e1d5372e7bb1c97528ff0262d8083413183fb56068fe2cc32a";
       libraryHaskellDepends = [ base haste-compiler sneathlane-haste ];
       homepage = "http://sneathlane.com/treersec";
       description = "Structure Editing Combinators";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "treeviz" = callPackage
    ({ mkDerivation, base, containers, mtl, QuickCheck, random }:
     mkDerivation {
       pname = "treeviz";
       version = "2.0.3";
       sha256 = "dab7dd9935cde4259dab1604b732292a0076e1e8a277476abf822ea2819f26a9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers mtl QuickCheck random ];
       executableHaskellDepends = [
         base containers mtl QuickCheck random
       ];
       testHaskellDepends = [ base containers mtl QuickCheck random ];
       homepage = "http://www.haskell.org/haskellwiki/Treeviz";
       description = "Visualization of computation decomposition trees";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tremulous-query" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers, deepseq
     , mtl, network
     }:
     mkDerivation {
       pname = "tremulous-query";
       version = "1.0.7";
       sha256 = "7d9d3c6fa0c8987d456dd190f016d8d5c154c4c50b31853170e2d9740174c66d";
       libraryHaskellDepends = [
         attoparsec base bytestring containers deepseq mtl network
       ];
       description = "Library for polling Tremulous servers";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "trhsx" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "trhsx";
       version = "0.2.2";
       sha256 = "631601c5345599e08535221df4415c7676e3e307bfa6a13d32e3c46d9c145d86";
       description = "Deprecated";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "triangulation" = callPackage
    ({ mkDerivation, array, base, collada-types, haskell98, tuple
     , vector, vector-algorithms
     }:
     mkDerivation {
       pname = "triangulation";
       version = "0.3";
       sha256 = "ae3d076ad06c73170ab534fec7720e8bc383ae5880ff66fe707d5c6349f1a953";
       libraryHaskellDepends = [
         array base collada-types haskell98 tuple vector vector-algorithms
       ];
       homepage = "http://www.dinkla.net/";
       description = "triangulation of polygons";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tries" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-trie, composition
     , composition-extra, containers, deepseq, hashable, keys, mtl
     , QuickCheck, quickcheck-instances, rose-trees, semigroups, sets
     , tasty, tasty-quickcheck, unordered-containers
     }:
     mkDerivation {
       pname = "tries";
       version = "0.0.4";
       sha256 = "6be9638a03b35effe69c9bbfc33b00fe92156211945b83dee871e70cf266f94a";
       libraryHaskellDepends = [
         base bytestring bytestring-trie composition composition-extra
         containers deepseq hashable keys QuickCheck quickcheck-instances
         rose-trees semigroups sets unordered-containers
       ];
       testHaskellDepends = [
         base bytestring bytestring-trie composition composition-extra
         containers deepseq hashable keys mtl QuickCheck
         quickcheck-instances rose-trees semigroups sets tasty
         tasty-quickcheck unordered-containers
       ];
       description = "Various trie implementations in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "trifecta_1_5_1_3" = callPackage
    ({ mkDerivation, ansi-terminal, ansi-wl-pprint, array, base
     , blaze-builder, blaze-html, blaze-markup, bytestring, charset
     , comonad, containers, deepseq, directory, doctest, filepath
     , fingertree, ghc-prim, hashable, lens, mtl, parsers, QuickCheck
     , reducers, semigroups, transformers, unordered-containers
     , utf8-string
     }:
     mkDerivation {
       pname = "trifecta";
       version = "1.5.1.3";
       sha256 = "bc5377d7faf3724a94b02bf19e8458117267b523081426dc9c0cd906dd2aa5f9";
       revision = "2";
       editedCabalFile = "a2557eb713724d9a22c282e0d1f971628838a4281eb3d3be9c44eed424bb3d20";
       libraryHaskellDepends = [
         ansi-terminal ansi-wl-pprint array base blaze-builder blaze-html
         blaze-markup bytestring charset comonad containers deepseq
         fingertree ghc-prim hashable lens mtl parsers reducers semigroups
         transformers unordered-containers utf8-string
       ];
       testHaskellDepends = [
         base directory doctest filepath parsers QuickCheck
       ];
       homepage = "http://github.com/ekmett/trifecta/";
       description = "A modern parser combinator library with convenient diagnostics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "trifecta" = callPackage
    ({ mkDerivation, ansi-terminal, ansi-wl-pprint, array, base
     , blaze-builder, blaze-html, blaze-markup, bytestring, charset
     , comonad, containers, deepseq, directory, doctest, filepath
     , fingertree, ghc-prim, hashable, lens, mtl, parsers, profunctors
     , QuickCheck, reducers, semigroups, transformers
     , unordered-containers, utf8-string
     }:
     mkDerivation {
       pname = "trifecta";
       version = "1.5.2";
       sha256 = "ebc23319d2cfd39c87b2cf688f3db45528e371de9a417fc9e07e50a796b6503a";
       libraryHaskellDepends = [
         ansi-terminal ansi-wl-pprint array base blaze-builder blaze-html
         blaze-markup bytestring charset comonad containers deepseq
         fingertree ghc-prim hashable lens mtl parsers profunctors reducers
         semigroups transformers unordered-containers utf8-string
       ];
       testHaskellDepends = [
         base directory doctest filepath parsers QuickCheck
       ];
       homepage = "http://github.com/ekmett/trifecta/";
       description = "A modern parser combinator library with convenient diagnostics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "trimpolya" = callPackage
    ({ mkDerivation, base, bio, bytestring, simpleargs }:
     mkDerivation {
       pname = "trimpolya";
       version = "0";
       sha256 = "314504ac9c9c4681e8cb5b4c0dde13e7a7824a358c08810cc9f45f700b4ea5f8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bio bytestring simpleargs ];
       jailbreak = true;
       description = "Search for, annotate and trim poly-A tail";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tripLL" = callPackage
    ({ mkDerivation, base, bytestring, cereal, filepath
     , leveldb-haskell
     }:
     mkDerivation {
       pname = "tripLL";
       version = "0.1.0.0";
       sha256 = "228b6112c915aa6fd70605bca9c76f0468a13afe6956e3755d48efc0efaec3ab";
       libraryHaskellDepends = [
         base bytestring cereal filepath leveldb-haskell
       ];
       homepage = "https://github.com/aphorisme/tripLL";
       description = "A very simple triple store";
       license = stdenv.lib.licenses.mit;
     }) {};

  "trivia" = callPackage
    ({ mkDerivation, base, comonad, distributive }:
     mkDerivation {
       pname = "trivia";
       version = "0.0";
       sha256 = "e8c4f180becea2005c61c0f97ac1e460755dbd31c0e055ab148998c9b1fcb50f";
       libraryHaskellDepends = [ base comonad distributive ];
       homepage = "https://github.com/fumieval/trivia";
       description = "The trivial monad and comonad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "trivial-constraint" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "trivial-constraint";
       version = "0.4.0.0";
       sha256 = "17fc46892beaa08c5badd544e71f690784f683efcfc50f482f5f8bc19fdc86c1";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/leftaroundabout/trivial-constraint";
       description = "Constraints that any type, resp. no type fulfills";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "tropical" = callPackage
    ({ mkDerivation, base, semiring-simple }:
     mkDerivation {
       pname = "tropical";
       version = "0.0.0.2";
       sha256 = "6282fbe2f86bb261a2f4189154125865b12754f6028181e6229ae3f59d94c9c6";
       libraryHaskellDepends = [ base semiring-simple ];
       jailbreak = true;
       description = "A library for tropical mathematics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "true-name_0_0_0_2" = callPackage
    ({ mkDerivation, base, containers, template-haskell, time }:
     mkDerivation {
       pname = "true-name";
       version = "0.0.0.2";
       sha256 = "55e3785f6072bd0b5ed030ae3894bb92c5684681217833ddc4f112b0d32f9c3e";
       libraryHaskellDepends = [ base template-haskell ];
       testHaskellDepends = [ base containers template-haskell time ];
       homepage = "https://github.com/liyang/true-name";
       description = "Template Haskell hack to violate another module's abstractions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "true-name" = callPackage
    ({ mkDerivation, base, containers, template-haskell, time }:
     mkDerivation {
       pname = "true-name";
       version = "0.1.0.0";
       sha256 = "1423602dc6e9325e68da0763c7946b85ce0b6548de7a6600a58351ddc6de3f25";
       libraryHaskellDepends = [ base template-haskell ];
       testHaskellDepends = [ base containers template-haskell time ];
       homepage = "https://github.com/liyang/true-name";
       description = "Template Haskell hack to violate another module's abstractions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "truelevel" = callPackage
    ({ mkDerivation, base, containers, parseargs, WAVE }:
     mkDerivation {
       pname = "truelevel";
       version = "0.1.3.1";
       sha256 = "324ae37a43574ccce1ff7ddca01bdcdccd7ccf54124113d66c907369f58eac60";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers parseargs WAVE ];
       homepage = "http://github.com/BartMassey/truelevel";
       description = "Audio file compressor-limiter";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "trurl" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, filemanip
     , filepath, hastache, hastache-aeson, http-conduit, MissingH, safe
     , split, tar, tasty, tasty-hunit, text, unordered-containers
     }:
     mkDerivation {
       pname = "trurl";
       version = "0.4.1.0";
       sha256 = "9399cf354e434c631bcd4275951480c19b3217daa7d18ecebfbc6c3a4bd61e26";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring directory filemanip filepath hastache
         hastache-aeson http-conduit MissingH safe split tar text
         unordered-containers
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base hastache tasty tasty-hunit ];
       homepage = "http://github.com/dbushenko/trurl";
       description = "Haskell template code generator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "truthful" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "truthful";
       version = "0.1.0.2";
       sha256 = "e47eee33d83123c7c7d2498befc1911081465143cb25329c3bdd7de38f0d1f5d";
       libraryHaskellDepends = [ base ];
       description = "Typeclass for truthfulness of values";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "tsession" = callPackage
    ({ mkDerivation, base, containers, mtl, time, transformers }:
     mkDerivation {
       pname = "tsession";
       version = "0.1";
       sha256 = "331b5a38f9ec5ad66c3c8f6c47f7b0c5c4cbaa36f8a22e9931501cd1fc0e41e6";
       revision = "2";
       editedCabalFile = "afd89984a633388a2db5ad107968c92693527eb6f746318c4752993633705e57";
       libraryHaskellDepends = [ base containers mtl time transformers ];
       description = "A Transaction Framework for Web Applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tsession-happstack" = callPackage
    ({ mkDerivation, base, happstack-server, transformers, tsession }:
     mkDerivation {
       pname = "tsession-happstack";
       version = "0.1";
       sha256 = "dfbb1cc4e741084f3836ec1b90e380e2daf9913f60346b5e49fd6f9a711466eb";
       libraryHaskellDepends = [
         base happstack-server transformers tsession
       ];
       description = "A Transaction Framework for Happstack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tskiplist" = callPackage
    ({ mkDerivation, array, base, containers, random, stm }:
     mkDerivation {
       pname = "tskiplist";
       version = "1.0.0";
       sha256 = "aa20f823c787122858513b38207bc74e9eb032435ac7e6624569f1411d825e2d";
       libraryHaskellDepends = [ array base containers random stm ];
       homepage = "https://github.com/thaldyron/tskiplist";
       description = "A Skip List Implementation in Software Transactional Memory (STM)";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tslogger" = callPackage
    ({ mkDerivation, async, base, containers, random }:
     mkDerivation {
       pname = "tslogger";
       version = "0.1.0.0";
       sha256 = "b41d3612219cc49b7e61531587ca33e582ec11f76e24254154f44fd515a5cbf7";
       libraryHaskellDepends = [ async base containers random ];
       jailbreak = true;
       description = "Thread-safe logging";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tsp-viz" = callPackage
    ({ mkDerivation, base, gloss, stm, vector }:
     mkDerivation {
       pname = "tsp-viz";
       version = "0.1.0.0";
       sha256 = "53aefc7be6a180a062e141e06e3c91db78e7b00d2cc8a20aaa5509dd76bd3673";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base gloss stm vector ];
       jailbreak = true;
       homepage = "https://github.com/davnils/tsp-viz";
       description = "Real time TSP tour visualization";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tsparse" = callPackage
    ({ mkDerivation, base, Decimal, parsec, pretty, process, random
     , split, time
     }:
     mkDerivation {
       pname = "tsparse";
       version = "0.4.0.0";
       sha256 = "511b4bca012747f7fc97a78f620ea3d9dca4e1a6d7a0b2fb17d8f010f7a5bb68";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Decimal parsec pretty process split time
       ];
       executableHaskellDepends = [
         base Decimal parsec pretty process random split time
       ];
       jailbreak = true;
       homepage = "http://www.github.com/massysett/tsparse";
       description = "Parses U.S. federal Thrift Savings Plan PDF quarterly statements";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tst" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "tst";
       version = "0.1.1";
       sha256 = "1d6e11d80383d2bf28c01ea75391b68dc6991b90a9613404cafc0a502fa121ef";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/bitonic/language-spelling";
       description = "BK-tree implementation";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "tsvsql" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , optparse-applicative, string-qq, text, unordered-containers
     }:
     mkDerivation {
       pname = "tsvsql";
       version = "0.2.0.0";
       sha256 = "ebbdba194d7bdb248631e96de0635d773b0fac6adb979722dbb257848b367382";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base bytestring containers optparse-applicative
         string-qq text unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/danchoi/tsvsql";
       description = "Template tsv into SQL";
       license = stdenv.lib.licenses.mit;
     }) {};

  "ttrie" = callPackage
    ({ mkDerivation, atomic-primops, base, containers, hashable
     , primitive, QuickCheck, stm, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "ttrie";
       version = "0.1.2.1";
       sha256 = "50444fe989559a0b16120df72765321ffd9de2fd97c943104513d894f21f4a68";
       libraryHaskellDepends = [
         atomic-primops base hashable primitive stm
       ];
       testHaskellDepends = [
         base containers hashable QuickCheck stm test-framework
         test-framework-quickcheck2
       ];
       homepage = "http://github.com/mcschroeder/ttrie";
       description = "Contention-free STM hash map";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tttool_1_3" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, containers
     , directory, filepath, ghc-prim, hashable, JuicyPixels, mtl, parsec
     , process, template-haskell, text, time, unordered-containers
     , vector, yaml
     }:
     mkDerivation {
       pname = "tttool";
       version = "1.3";
       sha256 = "ded22a2938730b8f0611ec1869696a4b8de268cb280a283e20ddcc4f543e8b0f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base binary bytestring containers directory filepath ghc-prim
         hashable JuicyPixels mtl parsec process template-haskell text time
         unordered-containers vector yaml
       ];
       jailbreak = true;
       homepage = "https://github.com/entropia/tip-toi-reveng";
       description = "Working with files for the Tiptoi® pen";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tttool_1_4_0_3" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, containers
     , directory, executable-path, filepath, hashable, haskeline
     , JuicyPixels, mtl, parsec, process, random, template-haskell, time
     , vector, yaml
     }:
     mkDerivation {
       pname = "tttool";
       version = "1.4.0.3";
       sha256 = "2de9817bfeee47ea168194862a2fa27c86bff3c7f5063537394c38851f7ed757";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base binary bytestring containers directory executable-path
         filepath hashable haskeline JuicyPixels mtl parsec process random
         template-haskell time vector yaml
       ];
       homepage = "https://github.com/entropia/tip-toi-reveng";
       description = "Working with files for the Tiptoi® pen";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tttool_1_4_0_4" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, containers
     , directory, executable-path, filepath, hashable, haskeline
     , JuicyPixels, mtl, parsec, process, random, template-haskell, time
     , vector, yaml
     }:
     mkDerivation {
       pname = "tttool";
       version = "1.4.0.4";
       sha256 = "b3e15148fa1090cdffaa91094aadedb6f80ad70ebcf9740e27d2c5256147a260";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base binary bytestring containers directory executable-path
         filepath hashable haskeline JuicyPixels mtl parsec process random
         template-haskell time vector yaml
       ];
       homepage = "https://github.com/entropia/tip-toi-reveng";
       description = "Working with files for the Tiptoi® pen";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tttool_1_4_0_5" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, containers
     , directory, executable-path, filepath, hashable, haskeline
     , JuicyPixels, mtl, parsec, process, random, template-haskell, time
     , vector, yaml
     }:
     mkDerivation {
       pname = "tttool";
       version = "1.4.0.5";
       sha256 = "7adde3a207387ae2cb1d44f30344a0b053703a204c2fdea670ab7409e5ad3764";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base binary bytestring containers directory executable-path
         filepath hashable haskeline JuicyPixels mtl parsec process random
         template-haskell time vector yaml
       ];
       homepage = "https://github.com/entropia/tip-toi-reveng";
       description = "Working with files for the Tiptoi® pen";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tttool_1_5_1" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, containers
     , directory, executable-path, filepath, hashable, haskeline
     , JuicyPixels, mtl, parsec, process, random, template-haskell, time
     , vector, yaml
     }:
     mkDerivation {
       pname = "tttool";
       version = "1.5.1";
       sha256 = "acfae333308f70fbf8511141ef4cb19505f4b10012bfcf3a686c299a8ac6ec60";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base binary bytestring containers directory executable-path
         filepath hashable haskeline JuicyPixels mtl parsec process random
         template-haskell time vector yaml
       ];
       homepage = "https://github.com/entropia/tip-toi-reveng";
       description = "Working with files for the Tiptoi® pen";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tttool" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, containers
     , directory, executable-path, filepath, hashable, haskeline, HPDF
     , JuicyPixels, mtl, optparse-applicative, parsec, process, random
     , split, spool, template-haskell, time, vector, yaml, zlib
     }:
     mkDerivation {
       pname = "tttool";
       version = "1.6.0.1";
       sha256 = "52d9d4e28ce1e1a81e81ff2b8fe9a2a21d0b1b74ba172777c654d0c1e608a23f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base binary bytestring containers directory executable-path
         filepath hashable haskeline HPDF JuicyPixels mtl
         optparse-applicative parsec process random split spool
         template-haskell time vector yaml zlib
       ];
       homepage = "https://github.com/entropia/tip-toi-reveng";
       description = "Working with files for the Tiptoi® pen";
       license = stdenv.lib.licenses.mit;
     }) {};

  "tubes" = callPackage
    ({ mkDerivation, base, comonad, free, mtl, transformers }:
     mkDerivation {
       pname = "tubes";
       version = "1.1.0.0";
       sha256 = "c1b6623455b98cb956ec37f290a51e61c6f372aeb5ecffa12c5c182f713fb86d";
       libraryHaskellDepends = [ base comonad free mtl transformers ];
       homepage = "https://github.com/gatlin/tubes";
       description = "Effectful, iteratee-inspired stream processing based on a free monad";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "tuntap" = callPackage
    ({ mkDerivation, base, bytestring, unix }:
     mkDerivation {
       pname = "tuntap";
       version = "0.0.2";
       sha256 = "8154773e5f58768307cb2554a5b9f3af70ad1916f6769768c869b5261917cf60";
       libraryHaskellDepends = [ base bytestring unix ];
       jailbreak = true;
       description = "Interface to TUN/TAP drivers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tup-functor" = callPackage
    ({ mkDerivation, base, cpphs, haskell-src-exts, parsec2 }:
     mkDerivation {
       pname = "tup-functor";
       version = "0.3.0.0";
       sha256 = "3d26284d1f13df507d02d9c73198fa1741f552a03ae6c5ec6d86d4f4ca4346ce";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base cpphs ];
       executableHaskellDepends = [ base haskell-src-exts parsec2 ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "Homogeneous tuples";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tuple" = callPackage
    ({ mkDerivation, base, OneTuple }:
     mkDerivation {
       pname = "tuple";
       version = "0.3.0.2";
       sha256 = "2fcb068ffafbe64170e02094a363f83d1725f44f8af963d9dad943a592e89624";
       libraryHaskellDepends = [ base OneTuple ];
       description = "Various functions on tuples";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tuple-gen" = callPackage
    ({ mkDerivation, base, combinat }:
     mkDerivation {
       pname = "tuple-gen";
       version = "2.0";
       sha256 = "a76d663380cc6b4b9d12307f42cce8ed30f25406bb29be203407668e70d7fc2d";
       libraryHaskellDepends = [ base combinat ];
       jailbreak = true;
       description = "Enum instances for tuples where the digits increase with the same speed";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tuple-generic" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "tuple-generic";
       version = "0.6.0.0";
       sha256 = "b5bda11535fb03d224f79a7d6b8372ca356e3f35e8ec7c7b4bb4793d79fb9e0c";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/aelve/tuple-generic";
       description = "Generic operations on tuples";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "tuple-hlist" = callPackage
    ({ mkDerivation, base, HList, OneTuple }:
     mkDerivation {
       pname = "tuple-hlist";
       version = "0.2.0.1";
       sha256 = "886472d2043cc29e7eba49277ccabc731e7f46763f3ec77a77a4f9208a15729b";
       libraryHaskellDepends = [ base HList OneTuple ];
       homepage = "http://github.com/dudebout/tuple-hlist";
       description = "Functions to convert between tuples and HLists";
       license = "unknown";
     }) {};

  "tuple-lenses" = callPackage
    ({ mkDerivation, base, lens, template-haskell }:
     mkDerivation {
       pname = "tuple-lenses";
       version = "0.1.0.2";
       sha256 = "fc3002223e70b7714b40c384fc42532acf1f0108b24e7b53e620908414d501e3";
       libraryHaskellDepends = [ base lens template-haskell ];
       jailbreak = true;
       homepage = "http://github.com/jfischoff/tuple-lenses";
       description = "Stock FieldN combos and generators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tuple-morph" = callPackage
    ({ mkDerivation, base, HList, template-haskell }:
     mkDerivation {
       pname = "tuple-morph";
       version = "0.1.0.0";
       sha256 = "244de7dfb5296875d954e96e6b7b3c3d07ef3e13b5ed0b60f952fcf303b426fe";
       revision = "4";
       editedCabalFile = "835c4661ff3b962ec5fa6f1899c6cb0d241362f06636478935fd5475c684eada";
       libraryHaskellDepends = [ base HList template-haskell ];
       description = "Morph between tuples, or convert them from and to HLists";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tuple-th" = callPackage
    ({ mkDerivation, base, containers, template-haskell }:
     mkDerivation {
       pname = "tuple-th";
       version = "0.2.5";
       sha256 = "56ea37dcede07b5cf5385108540ae626db163f9df0387583d3c7afdaf72634d7";
       libraryHaskellDepends = [ base containers template-haskell ];
       description = "Generate (non-recursive) utility functions for tuples of statically known size";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tupleinstances" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "tupleinstances";
       version = "0.0.1";
       sha256 = "237a1c4efce728055817cf2aef8a064f7b85324cd998f3eebf54ebeec263954d";
       libraryHaskellDepends = [ base template-haskell ];
       jailbreak = true;
       homepage = "http://github.com/diegoeche/tupleinstances";
       description = "Functor, Applicative and Monad for n-ary tuples";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tuples-homogenous-h98" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "tuples-homogenous-h98";
       version = "0.1.1.0";
       sha256 = "025afc8f0fe9c92fb43cebedfa6a764f744d3dc3a3d52935d0a01bc80d111f3a";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/ppetr/tuples-homogenous-h98";
       description = "Wrappers for n-ary tuples with Traversable and Applicative/Monad instances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "turing" = callPackage
    ({ mkDerivation, base, doctest, hspec, QuickCheck }:
     mkDerivation {
       pname = "turing";
       version = "0.1.1";
       sha256 = "f3c60dd8bfead96b5e0836116d25fa14869ef62eb8feecc0b53c9c5f02cb60ae";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base doctest hspec QuickCheck ];
       homepage = "http://github.com/sebastianpoeplau/turing#readme";
       description = "A simple simulator for Turing machines";
       license = "GPL";
     }) {};

  "turing-music" = callPackage
    ({ mkDerivation, ALUT, base }:
     mkDerivation {
       pname = "turing-music";
       version = "0.1.1";
       sha256 = "c3cfcf66e1fbf3a75488d1ce35bead220f70921eed0dc6b3a846f728f77b6e98";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ ALUT base ];
       description = "Plays music generated by Turing machines with 5 states and 2 symbols";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "turkish-deasciifier" = callPackage
    ({ mkDerivation, base, containers, HUnit, vector }:
     mkDerivation {
       pname = "turkish-deasciifier";
       version = "0.1.0.0";
       sha256 = "23418d85dadd046b7dc04999b38853e2473feb2167252b8fd927766e671b6636";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers vector ];
       executableHaskellDepends = [ base containers vector ];
       testHaskellDepends = [ base HUnit ];
       homepage = "http://github.com/joom/turkish-deasciifier.hs";
       description = "Haskell port of Deniz Yuret's Turkish deasciifier";
       license = stdenv.lib.licenses.mit;
     }) {};

  "turni" = callPackage
    ({ mkDerivation, base, containers, MonadRandom, random }:
     mkDerivation {
       pname = "turni";
       version = "2011.1.15";
       sha256 = "d4f2d684299f116425d0f005898323f5dfc73d9c6c81159b6436745037eca204";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base containers MonadRandom random ];
       homepage = "http://wiki.github.com/paolino/turni";
       description = "shifts scheduling tool";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "turtle_1_0_2" = callPackage
    ({ mkDerivation, async, base, clock, directory, doctest, foldl
     , managed, process, system-fileio, system-filepath, temporary, text
     , time, transformers, unix
     }:
     mkDerivation {
       pname = "turtle";
       version = "1.0.2";
       sha256 = "c8862d1bed3da0370b6fd75279997ddfb29072084c25e82f6a0315431a46cee1";
       libraryHaskellDepends = [
         async base clock directory foldl managed process system-fileio
         system-filepath temporary text time transformers unix
       ];
       testHaskellDepends = [ base doctest ];
       jailbreak = true;
       description = "Shell programming, Haskell-style";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "turtle_1_2_1" = callPackage
    ({ mkDerivation, async, base, clock, directory, doctest, foldl
     , hostname, managed, optional-args, optparse-applicative, process
     , system-fileio, system-filepath, temporary, text, time
     , transformers, unix
     }:
     mkDerivation {
       pname = "turtle";
       version = "1.2.1";
       sha256 = "9c5886fcfc2397da2d2861ad85992d952b0f749ef07b60f93c717b5ca87d8406";
       libraryHaskellDepends = [
         async base clock directory foldl hostname managed optional-args
         optparse-applicative process system-fileio system-filepath
         temporary text time transformers unix
       ];
       testHaskellDepends = [ base doctest ];
       jailbreak = true;
       description = "Shell programming, Haskell-style";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "turtle_1_2_2" = callPackage
    ({ mkDerivation, async, base, clock, directory, doctest, foldl
     , hostname, managed, optional-args, optparse-applicative, process
     , stm, system-fileio, system-filepath, temporary, text, time
     , transformers, unix
     }:
     mkDerivation {
       pname = "turtle";
       version = "1.2.2";
       sha256 = "b2676e0222829b8951fe127676f891e212d1dad95d8db92dc7ffdbd099e60ec6";
       libraryHaskellDepends = [
         async base clock directory foldl hostname managed optional-args
         optparse-applicative process stm system-fileio system-filepath
         temporary text time transformers unix
       ];
       testHaskellDepends = [ base doctest ];
       jailbreak = true;
       description = "Shell programming, Haskell-style";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "turtle_1_2_3" = callPackage
    ({ mkDerivation, async, base, clock, directory, doctest, foldl
     , hostname, managed, optional-args, optparse-applicative, process
     , stm, system-fileio, system-filepath, temporary, text, time
     , transformers, unix
     }:
     mkDerivation {
       pname = "turtle";
       version = "1.2.3";
       sha256 = "3669a203887b58621ba20a4192defb3bdbfdf17ac13de80747143f739127d36d";
       libraryHaskellDepends = [
         async base clock directory foldl hostname managed optional-args
         optparse-applicative process stm system-fileio system-filepath
         temporary text time transformers unix
       ];
       testHaskellDepends = [ base doctest ];
       jailbreak = true;
       description = "Shell programming, Haskell-style";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "turtle_1_2_4" = callPackage
    ({ mkDerivation, async, base, clock, directory, doctest, foldl
     , hostname, managed, optional-args, optparse-applicative, process
     , stm, system-fileio, system-filepath, temporary, text, time
     , transformers, unix
     }:
     mkDerivation {
       pname = "turtle";
       version = "1.2.4";
       sha256 = "c42148d062098913a4519af92c0bc6b139edad18c22f6c01aea8697386851de4";
       libraryHaskellDepends = [
         async base clock directory foldl hostname managed optional-args
         optparse-applicative process stm system-fileio system-filepath
         temporary text time transformers unix
       ];
       testHaskellDepends = [ base doctest ];
       jailbreak = true;
       description = "Shell programming, Haskell-style";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "turtle" = callPackage
    ({ mkDerivation, async, base, clock, directory, doctest, foldl
     , hostname, managed, optional-args, optparse-applicative, process
     , stm, system-fileio, system-filepath, temporary, text, time
     , transformers, unix
     }:
     mkDerivation {
       pname = "turtle";
       version = "1.2.5";
       sha256 = "006566b6d1060c576ad10db068381ff433598bffac0e49847c6aff522ad9c5c7";
       libraryHaskellDepends = [
         async base clock directory foldl hostname managed optional-args
         optparse-applicative process stm system-fileio system-filepath
         temporary text time transformers unix
       ];
       testHaskellDepends = [ base doctest ];
       description = "Shell programming, Haskell-style";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "tweak" = callPackage
    ({ mkDerivation, base, containers, lens, stm, transformers }:
     mkDerivation {
       pname = "tweak";
       version = "0.1.0.1";
       sha256 = "3cbe6fd74e2ef0bf5eb5fad2ba81a0880db3f005c170631f2f4527a61e49bed0";
       libraryHaskellDepends = [ base containers lens stm transformers ];
       jailbreak = true;
       homepage = "http://github.com/jfischoff/tweak";
       description = "A library for incremental computing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "twentefp" = callPackage
    ({ mkDerivation, base, gloss, parsec, time }:
     mkDerivation {
       pname = "twentefp";
       version = "0.4.2";
       sha256 = "b447850b13c77fcc761b25138b926839eb008e590390873874d43c130f48aece";
       libraryHaskellDepends = [ base gloss parsec time ];
       description = "Lab Assignments Environment at Univeriteit Twente";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "twentefp-eventloop-graphics" = callPackage
    ({ mkDerivation, base, network, text, twentefp-number
     , twentefp-websockets
     }:
     mkDerivation {
       pname = "twentefp-eventloop-graphics";
       version = "0.1.0.4";
       sha256 = "9592b9a1101d6779723b032f8108718a3322eee792a85bbeaef3b04410e8db20";
       revision = "1";
       editedCabalFile = "2a887ef5e938d11f5944ea59ced4cf4bd22930b452f6e6b884f58031761cf817";
       libraryHaskellDepends = [
         base network text twentefp-number twentefp-websockets
       ];
       jailbreak = true;
       description = "Used as Lab Assignments Environment at the University of Twente";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "twentefp-eventloop-trees" = callPackage
    ({ mkDerivation, base, eventloop }:
     mkDerivation {
       pname = "twentefp-eventloop-trees";
       version = "0.1.2.2";
       sha256 = "5fc63b1739a64e5316fa3c1d91f9d47a34d1f2e494e91658bd0b719c18a2257d";
       libraryHaskellDepends = [ base eventloop ];
       description = "Tree type and show functions for lab assignment of University of Twente. Contains RoseTree and RedBlackTree";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twentefp-graphs" = callPackage
    ({ mkDerivation, base, twentefp-eventloop-graphics }:
     mkDerivation {
       pname = "twentefp-graphs";
       version = "0.1.0.4";
       sha256 = "396e7c12d4f194f00c58b46e30474f51b98daaf457a809e54d317db218f2173c";
       libraryHaskellDepends = [ base twentefp-eventloop-graphics ];
       description = "Lab Assignments Environment at Univeriteit Twente";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "twentefp-number" = callPackage
    ({ mkDerivation, base, parsec }:
     mkDerivation {
       pname = "twentefp-number";
       version = "0.1.0.2";
       sha256 = "ae1b183a28e89bd43f63ee424d57d8214546046386b7c89f47a97b4da05100ce";
       libraryHaskellDepends = [ base parsec ];
       description = "Lab Assignments Environment at Univeriteit Twente";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "twentefp-rosetree" = callPackage
    ({ mkDerivation, base, twentefp-eventloop-graphics, twentefp-number
     }:
     mkDerivation {
       pname = "twentefp-rosetree";
       version = "0.1.0.1";
       sha256 = "a7ad92cb98e41e7d68f24976a2487ef7cc088deb2ecde6a6f8f4a9c87885c4b7";
       libraryHaskellDepends = [
         base twentefp-eventloop-graphics twentefp-number
       ];
       jailbreak = true;
       description = "RoseTree type and show functions for lab assignment of University of Twente";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twentefp-trees" = callPackage
    ({ mkDerivation, base, twentefp-eventloop-graphics }:
     mkDerivation {
       pname = "twentefp-trees";
       version = "0.1.0.2";
       sha256 = "0facb114d7805e24a3719c050ccaa8067227d38a378d493d23f54bbcba49b256";
       libraryHaskellDepends = [ base twentefp-eventloop-graphics ];
       description = "Tree type and show functions for lab assignment of University of Twente. Contains RoseTree and ParseTree";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "twentefp-websockets" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, binary
     , blaze-builder, bytestring, case-insensitive, concurrent-extra
     , containers, entropy, io-streams, mtl, network, random, SHA, text
     }:
     mkDerivation {
       pname = "twentefp-websockets";
       version = "0.1.0.1";
       sha256 = "0422dfeb9df01fc01cf9582ad56f5ceeb6e144dfd1e37f6c006f6f4fe13d4220";
       libraryHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive concurrent-extra containers entropy io-streams mtl
         network random SHA text
       ];
       jailbreak = true;
       description = "A fork of the popular websockets package. It is used for the practical assignments of the University of Twente. A sensible and clean way to write WebSocket-capable servers in Haskell.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "twhs" = callPackage
    ({ mkDerivation, ansi-terminal, authenticate-oauth, base
     , bytestring, case-insensitive, conduit, containers, data-default
     , hspec, http-conduit, lens, monad-control, monad-logger, network
     , QuickCheck, resourcet, text, transformers, transformers-base
     , twitter-conduit
     }:
     mkDerivation {
       pname = "twhs";
       version = "0.1.0.3";
       sha256 = "810a07dfc3dd28428f33e37290ddee0c2f84b62141c03088da246f6ac45e0634";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         ansi-terminal authenticate-oauth base bytestring case-insensitive
         conduit containers data-default http-conduit lens monad-control
         monad-logger network resourcet text transformers transformers-base
         twitter-conduit
       ];
       executableHaskellDepends = [
         ansi-terminal authenticate-oauth base bytestring case-insensitive
         conduit containers data-default http-conduit lens monad-control
         monad-logger network resourcet text transformers transformers-base
         twitter-conduit
       ];
       testHaskellDepends = [ base hspec QuickCheck ];
       jailbreak = true;
       homepage = "https://github.com/suzuki-shin/twhs";
       description = "CLI twitter client";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twidge" = callPackage
    ({ mkDerivation, aeson, base, binary, bytestring, ConfigFile, curl
     , directory, hoauth, HSH, hslogger, MissingH, mtl, network
     , old-locale, parsec, regex-posix, text, time, unix, utf8-string
     }:
     mkDerivation {
       pname = "twidge";
       version = "1.1.2";
       sha256 = "612117e78856c32e9db419fa2f6d185b1cf4433907a7d1b4f238a8f1092f5698";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base binary bytestring ConfigFile curl directory hoauth HSH
         hslogger MissingH mtl network old-locale parsec regex-posix text
         time unix utf8-string
       ];
       jailbreak = true;
       homepage = "http://software.complete.org/twidge";
       description = "Unix Command-Line Twitter and Identica Client";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twilight-stm" = callPackage
    ({ mkDerivation, base, containers, haskell98, mtl }:
     mkDerivation {
       pname = "twilight-stm";
       version = "1.2";
       sha256 = "b9b16274960b8c78d4b687f8f194102f553b7abdadba67a20cd04baddcace9c2";
       libraryHaskellDepends = [ base containers haskell98 mtl ];
       homepage = "http://proglang.informatik.uni-freiburg.de/projects/twilight/";
       description = "STM library with safe irrevocable I/O and inconsistency repair";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twilio" = callPackage
    ({ mkDerivation, aeson, base, bifunctors, bytestring, Cabal
     , containers, errors, exceptions, free, http-client
     , http-client-tls, http-types, mtl, network-uri, old-locale
     , scientific, text, time, transformers, unordered-containers
     }:
     mkDerivation {
       pname = "twilio";
       version = "0.1.3.0";
       sha256 = "e3a25a6896c83d84c347510e7112b597d398e4e04b5254c5732e2b2b4354b4e1";
       libraryHaskellDepends = [
         aeson base bifunctors bytestring containers errors exceptions free
         http-client http-client-tls http-types mtl network-uri old-locale
         scientific text time transformers unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring Cabal http-client http-client-tls network-uri
         text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/markandrus/twilio-haskell";
       description = "Twilio REST API library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twill" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base16-bytestring
     , base64-bytestring, bytestring, cryptohash, data-default, datetime
     , errors, old-locale, QuickCheck, text, time
     }:
     mkDerivation {
       pname = "twill";
       version = "0.1.0.3";
       sha256 = "a6f3a59ffa6db8840168f4de1f4aedca2c34b1ec57a3c7a138df95769dec6c72";
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring base64-bytestring
         bytestring cryptohash data-default datetime errors old-locale
         QuickCheck text time
       ];
       jailbreak = true;
       description = "Twilio API interaction";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twiml" = callPackage
    ({ mkDerivation, base, Cabal, data-default, deepseq, Diff, HUnit
     , lens, network-uri, parsec, should-not-typecheck, template-haskell
     , text, void, xml
     }:
     mkDerivation {
       pname = "twiml";
       version = "0.2.0.0";
       sha256 = "25e2f9f25cc8b228b2bcb97d069f23fd534a93fd32b465597bb9dd2c00db6a8b";
       libraryHaskellDepends = [
         base data-default deepseq lens network-uri parsec template-haskell
         text void xml
       ];
       testHaskellDepends = [
         base Cabal data-default deepseq Diff HUnit lens
         should-not-typecheck void
       ];
       jailbreak = true;
       homepage = "https://github.com/markandrus/twiml-haskell";
       description = "TwiML library for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twine" = callPackage
    ({ mkDerivation, base, bytestring, containers, convertible
     , filepath, mtl, parsec
     }:
     mkDerivation {
       pname = "twine";
       version = "0.1.2";
       sha256 = "6171fe5eb172b8d2ba64006efbad98ed53b9bdc2191cd075b331f0d00dd48d60";
       libraryHaskellDepends = [
         base bytestring containers convertible filepath mtl parsec
       ];
       homepage = "http://twine.james-sanders.com";
       description = "very simple template language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twisty" = callPackage
    ({ mkDerivation, array, base, containers, data-memocombinators
     , MonadRandom, parallel
     }:
     mkDerivation {
       pname = "twisty";
       version = "0.1.0";
       sha256 = "d24b2d9b707b20d1647802cbc584e267c7615ef3c2e83280e4a93e538739880b";
       libraryHaskellDepends = [
         array base containers data-memocombinators MonadRandom parallel
       ];
       jailbreak = true;
       description = "Simulator of twisty puzzles à la Rubik's Cube";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twitch" = callPackage
    ({ mkDerivation, base, data-default, directory, filepath, fsnotify
     , Glob, hspec, optparse-applicative, time, transformers
     }:
     mkDerivation {
       pname = "twitch";
       version = "0.1.7.0";
       sha256 = "45579aee9ce53f729477a378320bc37755e9daf146df8297db0ed8cbf056fb36";
       libraryHaskellDepends = [
         base data-default directory filepath fsnotify Glob
         optparse-applicative time transformers
       ];
       testHaskellDepends = [
         base data-default directory filepath fsnotify Glob hspec
         optparse-applicative time transformers
       ];
       homepage = "https://github.com/jfischoff/twitch";
       description = "A high level file watcher DSL";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twitter" = callPackage
    ({ mkDerivation, base, curl, directory, filepath, json, mtl
     , old-locale, readline, time, xml
     }:
     mkDerivation {
       pname = "twitter";
       version = "0.1.1";
       sha256 = "fda52d989532777817134f168096eb919b683c87d8185ce513f067eb78e2058b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base curl directory filepath json mtl old-locale readline time xml
       ];
       description = "A Haskell-based CLI Twitter client";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twitter-conduit" = callPackage
    ({ mkDerivation, aeson, attoparsec, authenticate-oauth, base
     , bytestring, case-insensitive, conduit, conduit-extra, containers
     , data-default, doctest, hlint, hspec, http-client, http-conduit
     , http-types, lens, lens-aeson, monad-control, network-uri
     , resourcet, template-haskell, text, time, transformers
     , transformers-base, twitter-types, twitter-types-lens
     }:
     mkDerivation {
       pname = "twitter-conduit";
       version = "0.1.1.1";
       sha256 = "904b9413e8f729c52f16f6251c5edd641a938f5740392cc0e7a53ab24ce0e593";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec authenticate-oauth base bytestring conduit
         conduit-extra containers data-default http-client http-conduit
         http-types lens lens-aeson resourcet template-haskell text time
         transformers twitter-types twitter-types-lens
       ];
       executableHaskellDepends = [ network-uri ];
       testHaskellDepends = [
         aeson attoparsec authenticate-oauth base bytestring
         case-insensitive conduit conduit-extra containers data-default
         doctest hlint hspec http-client http-conduit http-types lens
         lens-aeson monad-control network-uri resourcet template-haskell
         text time transformers transformers-base twitter-types
         twitter-types-lens
       ];
       homepage = "https://github.com/himura/twitter-conduit";
       description = "Twitter API package with conduit interface and Streaming API support";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twitter-enumerator" = callPackage
    ({ mkDerivation, aeson, attoparsec, attoparsec-enumerator
     , authenticate, base, bytestring, containers, enumerator
     , http-enumerator, http-types, text, tls-extra, transformers
     }:
     mkDerivation {
       pname = "twitter-enumerator";
       version = "0.0.3";
       sha256 = "041b5533caf549013f9d0379f3ed30497866303a0c4175fac1969e0ef03c1eb1";
       libraryHaskellDepends = [
         aeson attoparsec attoparsec-enumerator authenticate base bytestring
         containers enumerator http-enumerator http-types text tls-extra
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/himura/twitter-enumerator";
       description = "Twitter API package with enumerator interface and Streaming API support";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twitter-feed_0_2_0_2" = callPackage
    ({ mkDerivation, aeson, authenticate-oauth, base, bytestring
     , containers, http-conduit, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "twitter-feed";
       version = "0.2.0.2";
       sha256 = "d38d683310aff56dcade64e55d5dfaa747007802ecbb0d9987def2bdc0847ca6";
       libraryHaskellDepends = [
         aeson authenticate-oauth base bytestring http-conduit
       ];
       testHaskellDepends = [
         base containers HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "https://github.com/stackbuilders/twitter-feed";
       description = "Client for fetching Twitter timeline via Oauth";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twitter-feed_0_2_0_3" = callPackage
    ({ mkDerivation, aeson, authenticate-oauth, base, bytestring
     , containers, http-conduit, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "twitter-feed";
       version = "0.2.0.3";
       sha256 = "d68038b73093485318e4f85fce0fe2fad8be90c52c9d76249b5512a93b077a1d";
       libraryHaskellDepends = [
         aeson authenticate-oauth base bytestring http-conduit
       ];
       testHaskellDepends = [
         base containers HUnit test-framework test-framework-hunit
       ];
       homepage = "https://github.com/stackbuilders/twitter-feed";
       description = "Client for fetching Twitter timeline via Oauth";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twitter-feed_0_2_0_4" = callPackage
    ({ mkDerivation, aeson, authenticate-oauth, base, bytestring
     , containers, http-conduit, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "twitter-feed";
       version = "0.2.0.4";
       sha256 = "fd6a8fbf316f855182d0b9371e890eba77d09821ca4fc1238ec22469e6910bd9";
       libraryHaskellDepends = [
         aeson authenticate-oauth base bytestring http-conduit
       ];
       testHaskellDepends = [
         base containers HUnit test-framework test-framework-hunit
       ];
       homepage = "https://github.com/stackbuilders/twitter-feed";
       description = "Client for fetching Twitter timeline via Oauth";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twitter-feed" = callPackage
    ({ mkDerivation, aeson, authenticate-oauth, base, bytestring
     , containers, http-conduit, HUnit, test-framework
     , test-framework-hunit
     }:
     mkDerivation {
       pname = "twitter-feed";
       version = "0.2.0.5";
       sha256 = "faf8a79a0c423d2aef9a88fab34084c0264f19efcebe721c71786e8fcd971773";
       libraryHaskellDepends = [
         aeson authenticate-oauth base bytestring http-conduit
       ];
       testHaskellDepends = [
         base containers HUnit test-framework test-framework-hunit
       ];
       homepage = "https://github.com/stackbuilders/twitter-feed";
       description = "Client for fetching Twitter timeline via Oauth";
       license = stdenv.lib.licenses.mit;
     }) {};

  "twitter-types" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, derive
     , directory, filepath, HUnit, old-locale, QuickCheck
     , template-haskell, test-framework, test-framework-hunit
     , test-framework-quickcheck2, test-framework-th-prime, text, time
     , unordered-containers
     }:
     mkDerivation {
       pname = "twitter-types";
       version = "0.7.1.1";
       sha256 = "677b4273c13540602e7dd6c75736693092287da251d8e4658128666bc148ddf5";
       libraryHaskellDepends = [
         aeson base text time unordered-containers
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring derive directory filepath HUnit
         old-locale QuickCheck template-haskell test-framework
         test-framework-hunit test-framework-quickcheck2
         test-framework-th-prime text time unordered-containers
       ];
       homepage = "https://github.com/himura/twitter-types";
       description = "Twitter JSON parser and types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "twitter-types-lens" = callPackage
    ({ mkDerivation, base, lens, template-haskell, text, time
     , twitter-types
     }:
     mkDerivation {
       pname = "twitter-types-lens";
       version = "0.7.1";
       sha256 = "d162b38100cfbcff1128d45dbe9c455816990f26a0711c06517fd0c274d1d286";
       libraryHaskellDepends = [
         base lens template-haskell text time twitter-types
       ];
       homepage = "https://github.com/himura/twitter-types-lens";
       description = "Twitter JSON types (lens powered)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tx" = callPackage
    ({ mkDerivation, base, bytestring, cereal, safecopy, stm
     , transformers
     }:
     mkDerivation {
       pname = "tx";
       version = "0.1.0.0";
       sha256 = "5e5395c664b32989f9fcb5ede51e9e05d24f982569363c78df233d11f39dd7a1";
       libraryHaskellDepends = [
         base bytestring cereal safecopy stm transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/mcschroeder/tx";
       description = "Persistent transactions on top of STM";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "txt-sushi" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, directory
     , parsec, regex-posix
     }:
     mkDerivation {
       pname = "txt-sushi";
       version = "0.6.0";
       sha256 = "46074c0cb01bcbbd9b13164128f72b1fc9d027f5332362cda76ae6c830c2e50c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers directory parsec regex-posix
       ];
       homepage = "http://keithsheppard.name/txt-sushi";
       description = "The SQL link in your *NIX chain";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "txt2rtf" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "txt2rtf";
       version = "1.0.1";
       sha256 = "44a7b049f1f3f3f928986cf7ccae50cd22e012a5c240e4924dd1b5caee0dc06e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       homepage = "http://github.com/jgoerzen/txt2rtf";
       description = "Filter to convert plain text files to RTF";
       license = "GPL";
     }) {};

  "txtblk" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "txtblk";
       version = "0.2.0.1";
       sha256 = "6b095e72de6a004432a81c85098d82f438edd021e6aacc3f7171ae16966f1723";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "Deprecated in favor of eros";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ty" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "ty";
       version = "0.1.6";
       sha256 = "1e4a77501ba2d11491de3c705f0f2e1bc3667f369dfc921f3ebf193792602844";
       libraryHaskellDepends = [ base ghc-prim ];
       homepage = "https://github.com/conal/ty";
       description = "Typed type representations and equality proofs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "typalyze" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, ghc
     , process
     }:
     mkDerivation {
       pname = "typalyze";
       version = "0.1.1";
       sha256 = "b52020ca6f8029e5d6e691c435475ca3c9d63a242632ab85e68be5a0eff981f1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory filepath ghc process
       ];
       homepage = "http://www.decidable.org/haskell/typalyze";
       description = "Analyzes Haskell source files for easy reference";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-aligned" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "type-aligned";
       version = "0.9.6";
       sha256 = "1b877271cbfc365563f2dc779dc2ee4820be144e1708318882a3cd11786ade55";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/atzeus/type-aligned";
       description = "Various type-aligned sequence data structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-booleans" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "type-booleans";
       version = "0.1";
       sha256 = "d0f9133f1883f6aea6dd561d4249566dc50b8423b15d6b73e46d52b697b36b86";
       libraryHaskellDepends = [ base ];
       description = "Type-level booleans via type-families";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-cache" = callPackage
    ({ mkDerivation, base, containers, lens, lens-utils
     , template-haskell
     }:
     mkDerivation {
       pname = "type-cache";
       version = "1.0";
       sha256 = "ce75db1e0a87af31a6e2589ca74d7c5987c1541c70579e186c377045e6e070df";
       libraryHaskellDepends = [
         base containers lens lens-utils template-haskell
       ];
       homepage = "https://github.com/wdanilo/type-cache";
       description = "Utilities for caching type families results. Sometimes complex type families take long time to compile, so it is proficient to cache them and use the final result without the need of re-computation.";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "type-cereal" = callPackage
    ({ mkDerivation, base, bytestring, cereal, data-hash
     , template-haskell, type-digits, type-spine
     }:
     mkDerivation {
       pname = "type-cereal";
       version = "0.3";
       sha256 = "9b6d3d445108797d726f15c066ffaf006e056d686bc1e712e3bf60e10e0b3af0";
       libraryHaskellDepends = [
         base bytestring cereal data-hash template-haskell type-digits
         type-spine
       ];
       description = "Type-level serialization of type constructors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-combinators" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "type-combinators";
       version = "0.2.2.1";
       sha256 = "96e3c4954236120f46fa515c75f33a8b641d5263bc3b4b7dd2055858dfeee966";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/kylcarte/type-combinators";
       description = "A collection of data types for type-level programming";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-combinators-quote" = callPackage
    ({ mkDerivation, base, haskell-src-meta, template-haskell
     , type-combinators
     }:
     mkDerivation {
       pname = "type-combinators-quote";
       version = "0.1.0.1";
       sha256 = "808b305a08443e27e46bbf2c7604eb312d1a44df6bd140f917b485e6eb35f6a7";
       libraryHaskellDepends = [
         base haskell-src-meta template-haskell type-combinators
       ];
       homepage = "https://github.com/kylcarte/type-combinators-quote";
       description = "Quasiquoters for the 'type-combinators' package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-digits" = callPackage
    ({ mkDerivation, base, template-haskell, type-spine }:
     mkDerivation {
       pname = "type-digits";
       version = "0.3";
       sha256 = "a844a8c5d4dd491550b282462bf5b52f792af2dc1d7c675f02d85fcff8f0b866";
       libraryHaskellDepends = [ base template-haskell type-spine ];
       description = "Arbitrary-base type-level digits";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-eq_0_4_2" = callPackage
    ({ mkDerivation, base, cpphs }:
     mkDerivation {
       pname = "type-eq";
       version = "0.4.2";
       sha256 = "5979f5ee0b187ebace5f3ea449b94ca361fa9ab0b4047307059fdafc301ddd5b";
       libraryHaskellDepends = [ base ];
       libraryToolDepends = [ cpphs ];
       jailbreak = true;
       homepage = "http://github.com/glaebhoerl/type-eq";
       description = "Type equality evidence you can carry around";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-eq" = callPackage
    ({ mkDerivation, base, cpphs }:
     mkDerivation {
       pname = "type-eq";
       version = "0.5";
       sha256 = "9fcf4c4f1734b113625f0fd38a239a9637366e176736a4183f22f60e2ccdfa00";
       libraryHaskellDepends = [ base ];
       libraryToolDepends = [ cpphs ];
       homepage = "http://github.com/glaebhoerl/type-eq";
       description = "Type equality evidence you can carry around";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-equality" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "type-equality";
       version = "0.1.2";
       sha256 = "9977801ac1b082b57497fb7aed1a335a7d08487deb7f6967d9546dbfe7c54c19";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/hesselink/type-equality/";
       description = "Type equality, coercion/cast and other operations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-equality-check" = callPackage
    ({ mkDerivation, base, type-level }:
     mkDerivation {
       pname = "type-equality-check";
       version = "0.0.0.3";
       sha256 = "c7f8bcc8bfc2b87f7ce4e48ce422c3a8cfe2d4807c4edacca638c2a55715523b";
       libraryHaskellDepends = [ base type-level ];
       homepage = "http://darcs.wolfgang.jeltsch.info/haskell/type-equality-check";
       description = "Type equality check";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-fun" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "type-fun";
       version = "0.0.1";
       sha256 = "bc21ad690809ffad66ebaf9df7af07e5609b026fbd257b813228d1b3ea141a1f";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       homepage = "https://github.com/s9gf4ult/type-fun";
       description = "Collection of widely reimplemented type families";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-functions" = callPackage
    ({ mkDerivation, base, kinds }:
     mkDerivation {
       pname = "type-functions";
       version = "0.2.0.3";
       sha256 = "55ed9016a713a74f40c9b6c148b6d12cb749a5b3cbfcd55dd0e3fef1c3e446ef";
       libraryHaskellDepends = [ base kinds ];
       homepage = "http://darcs.wolfgang.jeltsch.info/haskell/type-functions";
       description = "Emulation of type-level functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-hint" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "type-hint";
       version = "0.1";
       sha256 = "1161cdbf4b4b43c2953ee60438e948737604193e1bfe2c880ff178538faa99b9";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/mvv/type-hint";
       description = "Guide type inference with proxy values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-int" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "type-int";
       version = "0.5.0.2";
       sha256 = "5c18c3ee2232d07873917864a1a658a7270b42b1517d708a1223c6b92be153d1";
       libraryHaskellDepends = [ base template-haskell ];
       homepage = "http://github.com/ekmett/type-int";
       description = "Type Level 2s- and 16s- Complement Integers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-iso" = callPackage
    ({ mkDerivation, base, data-default, nats, numericpeano, text }:
     mkDerivation {
       pname = "type-iso";
       version = "0.1.0.0";
       sha256 = "5d4eed78d7f91358101e9a58091b7a1019b7a38235e7306f974201a9b3431a0f";
       libraryHaskellDepends = [
         base data-default nats numericpeano text
       ];
       homepage = "https://github.com/ombocomp/type-iso";
       description = "Typeclasses for injective relations and isomorphisms between types";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "type-level" = callPackage
    ({ mkDerivation, base, syb, template-haskell }:
     mkDerivation {
       pname = "type-level";
       version = "0.2.4";
       sha256 = "3bbdca0507187b72675dc182bb05da68d7e080693fa1ffe9fb961f693c81f7b1";
       libraryHaskellDepends = [ base syb template-haskell ];
       homepage = "http://code.haskell.org/type-level";
       description = "Type-level programming library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-level-bst" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "type-level-bst";
       version = "0.1";
       sha256 = "13164f8ec945b7c1166463aac5d1c067c4602585053269e48cad11e49bb9a130";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/Kinokkory/type-level-bst";
       description = "type-level binary search trees in haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-level-natural-number" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "type-level-natural-number";
       version = "2.0";
       sha256 = "d36754ece101d23e2666a3fb7d8dbf88b05153fc6bfccf7a9fc1fca07da9ef9f";
       libraryHaskellDepends = [ base ];
       description = "Simple type level natural numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-level-natural-number-induction" = callPackage
    ({ mkDerivation, base, transformers, type-level-natural-number }:
     mkDerivation {
       pname = "type-level-natural-number-induction";
       version = "1.0.0.1";
       sha256 = "596c2589e33bffb8f9bd652103b1530629d87f01db33e2fed4dce295cbd796d7";
       libraryHaskellDepends = [
         base transformers type-level-natural-number
       ];
       jailbreak = true;
       description = "High-level combinators for performing inductive operations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-level-natural-number-operations" = callPackage
    ({ mkDerivation, base, type-level-natural-number }:
     mkDerivation {
       pname = "type-level-natural-number-operations";
       version = "1.0";
       sha256 = "7ce40401be031506c6d1b0fa9c48f8ba61af48ec6061ccc1e6152ef80b2e146f";
       libraryHaskellDepends = [ base type-level-natural-number ];
       jailbreak = true;
       description = "Basic operations on type-level natural numbers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-level-numbers" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "type-level-numbers";
       version = "0.1.1.1";
       sha256 = "5b56ef5f6e0b6476b9aba46055c3919e67823cbc1b87ed8e6ed70113b1f2318a";
       libraryHaskellDepends = [ base template-haskell ];
       testHaskellDepends = [ base template-haskell ];
       description = "Type level numbers implemented using type families";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-level-sets" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "type-level-sets";
       version = "0.6.1";
       sha256 = "08bb523150e2ad8fb3028303ac354f2329da220f4b214e7a18ba7731adbbf926";
       libraryHaskellDepends = [ base ghc-prim ];
       description = "Type-level sets and finite maps (with value-level counterparts)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-level-tf" = callPackage
    ({ mkDerivation, base, syb, template-haskell }:
     mkDerivation {
       pname = "type-level-tf";
       version = "0.2.1";
       sha256 = "55bc212e4ff404e9d51bf234bae9ecfa3bd13704e7d2c8ddcdc76d9f8248061f";
       libraryHaskellDepends = [ base syb template-haskell ];
       homepage = "https://github.com/coreyoconnor/type-level-tf";
       description = "Type-level programming library (type families)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-list_0_0_0_0" = callPackage
    ({ mkDerivation, base, singletons }:
     mkDerivation {
       pname = "type-list";
       version = "0.0.0.0";
       sha256 = "651600a0111b79f90c55b637639518d2754fba48b3412dd8efa3e39984d1ffd4";
       libraryHaskellDepends = [ base singletons ];
       jailbreak = true;
       description = "Operations on type-level lists and tuples";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-list_0_0_0_1" = callPackage
    ({ mkDerivation, base, singletons }:
     mkDerivation {
       pname = "type-list";
       version = "0.0.0.1";
       sha256 = "a28123d3eb2c9513bb4b010cc5e4e3fd94b07113d06036ea74c1b11c6ce46fd5";
       libraryHaskellDepends = [ base singletons ];
       description = "Operations on type-level lists and tuples";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-list_0_2_0_0" = callPackage
    ({ mkDerivation, base, singletons }:
     mkDerivation {
       pname = "type-list";
       version = "0.2.0.0";
       sha256 = "03b0cf523f9b56e835462ba7747f81fb101a9b773711eeb5ebecc960656553a5";
       libraryHaskellDepends = [ base singletons ];
       jailbreak = true;
       description = "Operations on type-level lists and tuples";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-list" = callPackage
    ({ mkDerivation, base, singletons }:
     mkDerivation {
       pname = "type-list";
       version = "0.3.0.2";
       sha256 = "80e7f52a5fb88880be9a166fbe664bda7e9f94d64d70c877471c833567722aee";
       libraryHaskellDepends = [ base singletons ];
       description = "Operations on type-level lists and tuples";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-natural" = callPackage
    ({ mkDerivation, base, constraints, equational-reasoning
     , monomorphic, singletons, template-haskell
     }:
     mkDerivation {
       pname = "type-natural";
       version = "0.3.0.0";
       sha256 = "6a85b784389ee2d7240f0222cace4e3ff69ae8827f2d591773c0a02abfc0080b";
       libraryHaskellDepends = [
         base constraints equational-reasoning monomorphic singletons
         template-haskell
       ];
       jailbreak = true;
       homepage = "https://github.com/konn/type-natural";
       description = "Type-level natural and proofs of their properties";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "type-ord" = callPackage
    ({ mkDerivation, base, template-haskell, type-digits, type-spine }:
     mkDerivation {
       pname = "type-ord";
       version = "0.3";
       sha256 = "e5d569e1564dcf457a76840e4e8c59a988cae82a0c0659850bbdd30960b7ce9a";
       libraryHaskellDepends = [
         base template-haskell type-digits type-spine
       ];
       description = "Type-level comparison operator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-ord-spine-cereal" = callPackage
    ({ mkDerivation, base, template-haskell, type-cereal, type-ord
     , type-spine
     }:
     mkDerivation {
       pname = "type-ord-spine-cereal";
       version = "0.2";
       sha256 = "2bef8c500aed7afabcf4de19a4deba45a55d5349bfab1b4295401d4ae2878cbf";
       libraryHaskellDepends = [
         base template-haskell type-cereal type-ord type-spine
       ];
       description = "Generic type-level comparison of types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-prelude" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "type-prelude";
       version = "0.1";
       sha256 = "30d24fa550e380ea4a76367d261362532c0cee703a5356497a612b204328eff9";
       libraryHaskellDepends = [ base ghc-prim ];
       homepage = "http://code.atnnn.com/projects/type-prelude";
       description = "Partial port of prelude to the type level. Requires GHC 7.6.1.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-settheory" = callPackage
    ({ mkDerivation, base, containers, syb, template-haskell
     , transformers, type-equality
     }:
     mkDerivation {
       pname = "type-settheory";
       version = "0.1.3.1";
       sha256 = "51b70030fd760a3cd74067225c460ce394046ac669ac2a2ead02c736804b97ac";
       libraryHaskellDepends = [
         base containers syb template-haskell transformers type-equality
       ];
       description = "Sets and functions-as-relations in the type system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-spine" = callPackage
    ({ mkDerivation, base, template-haskell }:
     mkDerivation {
       pname = "type-spine";
       version = "0.2.20120924";
       sha256 = "110e405bec539dc7aec41acfc2b02426e2838d81409b33406ba3f6f06b8fc96f";
       libraryHaskellDepends = [ base template-haskell ];
       description = "A spine-view on types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-structure" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, hashable, HTF
     , HUnit, loch-th, mtl, placeholders, QuickCheck, QuickCheck-GenT
     , quickcheck-instances, template-haskell, text
     , th-instance-reification, time, transformers, unordered-containers
     , vector
     }:
     mkDerivation {
       pname = "type-structure";
       version = "0.1.1";
       sha256 = "dbf1f4cc6dfa0923010f9c778dfdd032a01ca6666d48b9bc3827104629304378";
       libraryHaskellDepends = [
         array base bytestring containers hashable loch-th mtl placeholders
         template-haskell text th-instance-reification time transformers
         unordered-containers vector
       ];
       testHaskellDepends = [
         array base bytestring containers hashable HTF HUnit loch-th mtl
         placeholders QuickCheck QuickCheck-GenT quickcheck-instances
         template-haskell text th-instance-reification time transformers
         unordered-containers vector
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/type-structure";
       description = "Type structure analysis";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-sub-th" = callPackage
    ({ mkDerivation, base, checkers, DebugTraceHelpers, HUnit
     , QuickCheck, template-haskell, test-framework
     , test-framework-hunit, test-framework-quickcheck2, th-instances
     , tuple, uniplate
     }:
     mkDerivation {
       pname = "type-sub-th";
       version = "0.1.0.6";
       sha256 = "27915d32cdf552cb540a4b9838ec441fc3775ed5a5a6fa27693a53bc57655e85";
       libraryHaskellDepends = [
         base DebugTraceHelpers HUnit QuickCheck template-haskell
         test-framework test-framework-hunit test-framework-quickcheck2
         tuple uniplate
       ];
       testHaskellDepends = [
         base checkers DebugTraceHelpers HUnit QuickCheck template-haskell
         test-framework test-framework-hunit test-framework-quickcheck2
         th-instances tuple uniplate
       ];
       homepage = "http://github.com/jfischoff/type-sub-th";
       description = "Substitute types for other types with Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "type-unary" = callPackage
    ({ mkDerivation, applicative-numbers, base, constraints, newtype
     , ty, vector-space
     }:
     mkDerivation {
       pname = "type-unary";
       version = "0.2.21";
       sha256 = "93ed75c592bfd4916cd89654ed15ea6d7df1fd83bf9e91f43c6e343a403ca627";
       libraryHaskellDepends = [
         applicative-numbers base constraints newtype ty vector-space
       ];
       homepage = "https://github.com/conal/type-unary";
       description = "Type-level and typed unary natural numbers, inequality proofs, vectors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "typeable-th" = callPackage
    ({ mkDerivation, base, template-haskell, transformers }:
     mkDerivation {
       pname = "typeable-th";
       version = "0.1.5";
       sha256 = "dbcc81c6512ab975703c62d186238c7447299e575085f22766eb9faefdcc49df";
       libraryHaskellDepends = [ base template-haskell transformers ];
       testHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://github.com/bennofs/typeable-th";
       description = "Automatic deriving of TypeableN instances with Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "typed-spreadsheet" = callPackage
    ({ mkDerivation, async, base, diagrams-cairo, diagrams-gtk
     , diagrams-lib, foldl, gtk, microlens, stm, text, transformers
     }:
     mkDerivation {
       pname = "typed-spreadsheet";
       version = "1.1.0";
       sha256 = "7838b454cbf87600d0af6c86ad10b164f9313448e11f21b8b8fb85d07f9ec800";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base diagrams-cairo diagrams-gtk diagrams-lib foldl gtk
         microlens stm text transformers
       ];
       executableHaskellDepends = [
         base diagrams-cairo diagrams-lib text
       ];
       jailbreak = true;
       description = "Typed and composable spreadsheets";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "typed-wire" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, directory
     , filepath, gitrev, HTF, http-types, mtl, optparse-applicative
     , parsec, process, temporary, text
     }:
     mkDerivation {
       pname = "typed-wire";
       version = "0.3.0.0";
       sha256 = "3faec8db44caf3658116619d88f9fb00dbf1b4e9f4e8106e4c1aeff2e7ec220f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory filepath http-types mtl parsec text
       ];
       executableHaskellDepends = [
         base directory filepath gitrev optparse-applicative text
       ];
       testHaskellDepends = [
         aeson base bytestring directory filepath HTF process temporary text
       ];
       homepage = "http://github.com/typed-wire/typed-wire#readme";
       description = "Language idependent type-safe communication";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "typed-wire-utils" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring, text
     , time
     }:
     mkDerivation {
       pname = "typed-wire-utils";
       version = "0.1.0.0";
       sha256 = "26edf29617e27d569f4e44d88b0aadc7d028476ae5eb9dbabbb7c605a71ab230";
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring text time
       ];
       homepage = "http://github.com/typed-wire/hs-typed-wire-utils#readme";
       description = "Haskell utility library required for code generated by typed-wire compiler";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "typedquery" = callPackage
    ({ mkDerivation, aeson, base, bytestring, haskell-src-meta, parsec
     , template-haskell, text, transformers
     }:
     mkDerivation {
       pname = "typedquery";
       version = "0.1.0.3";
       sha256 = "73e928ba315cb3e286b395487c9ee74acd57c86441543be3a614cd1edaff2035";
       libraryHaskellDepends = [
         aeson base bytestring haskell-src-meta parsec template-haskell text
         transformers
       ];
       homepage = "https://github.com/tolysz/typedquery";
       description = "Parser for SQL augmented with types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "typehash" = callPackage
    ({ mkDerivation, base, binary, bytestring, mtl, pureMD5, syb }:
     mkDerivation {
       pname = "typehash";
       version = "1.4.0.4";
       sha256 = "fb52604f8c0a48015c800c67dd5d9e8f8d027985d65f27c37121e695b3024187";
       libraryHaskellDepends = [ base binary bytestring mtl pureMD5 syb ];
       jailbreak = true;
       description = "Create a unique hash value for a type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "typelevel" = callPackage
    ({ mkDerivation, base, pretty, pretty-show }:
     mkDerivation {
       pname = "typelevel";
       version = "1.0.4";
       sha256 = "1cc8131a6e2cf9c84968980d73a543c7dc73fd6d878973a9f0a5ddaedf471dc2";
       libraryHaskellDepends = [ base pretty pretty-show ];
       homepage = "https://github.com/wdanilo/typelevel";
       description = "Useful type level operations (type families and related operators)";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "typelevel-tensor" = callPackage
    ({ mkDerivation, array, base, HUnit, numeric-prelude, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "typelevel-tensor";
       version = "0.2.1";
       sha256 = "ed01e0eec64d48bbf529cefd11d6cdccf06fbbe518ce4e122fc4d93f60378e9c";
       libraryHaskellDepends = [ base numeric-prelude QuickCheck ];
       testHaskellDepends = [
         array base HUnit numeric-prelude QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/nushio3/typelevel-tensor";
       description = "Tensors whose ranks and dimensions type-inferred and type-checked";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "typelits-witnesses_0_1_1_0" = callPackage
    ({ mkDerivation, base, constraints, reflection }:
     mkDerivation {
       pname = "typelits-witnesses";
       version = "0.1.1.0";
       sha256 = "cdcf6b821063228a27b18b4f3b437db6b21e2241c0136e3aa14643ddafc03c26";
       libraryHaskellDepends = [ base constraints reflection ];
       homepage = "https://github.com/mstksg/typelits-witnesses";
       description = "Existential witnesses, singletons, and classes for operations on GHC TypeLits";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "typelits-witnesses" = callPackage
    ({ mkDerivation, base, constraints, reflection }:
     mkDerivation {
       pname = "typelits-witnesses";
       version = "0.2.0.0";
       sha256 = "e4119460d139dde387863da5b1169d8f5213ff03c5487e35189015c701b0c362";
       libraryHaskellDepends = [ base constraints reflection ];
       homepage = "https://github.com/mstksg/typelits-witnesses";
       description = "Existential witnesses, singletons, and classes for operations on GHC TypeLits";
       license = stdenv.lib.licenses.mit;
     }) {};

  "typeof" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "typeof";
       version = "0.1.2";
       sha256 = "56240ce1ea585e7337e2f876a67887323f8e908a8675acac222c93db8a9cdfd6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base process ];
       description = "Small script for inferring types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "typeparams" = callPackage
    ({ mkDerivation, base, constraints, deepseq, ghc-prim, primitive
     , reflection, tagged, template-haskell, vector
     }:
     mkDerivation {
       pname = "typeparams";
       version = "0.0.6";
       sha256 = "6b8316e951cc940afeea65dac838c5d933e65f04f5c6f8c5c5f50cb550c590ae";
       libraryHaskellDepends = [
         base constraints deepseq ghc-prim primitive reflection tagged
         template-haskell vector
       ];
       homepage = "http://github.com/mikeizbicki/typeparams/";
       description = "Lens-like interface for type level parameters; allows unboxed unboxed vectors and supercompilation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "types-compat" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "types-compat";
       version = "0.1.1";
       sha256 = "7ec14729ed21bdcb827e584735d06f00df3a27a606f3d36c051ad4f4756b83ba";
       revision = "2";
       editedCabalFile = "8fbb17ec66d4bf5f2fffdb2327647b44292253822c9623a06b489ff547a71041";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/philopon/types-compat";
       description = "ghc-7.6/7.8 compatible GHC.TypeLits, Data.Typeable and Data.Proxy.";
       license = stdenv.lib.licenses.mit;
     }) {};

  "typesafe-endian" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "typesafe-endian";
       version = "0.1.0.1";
       sha256 = "d2b1e7fadef6623a7481a9897e1e4cbedd86004f14a5b458de7c1f67f3bee4cd";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/Ericson2314/typesafe-endian";
       description = "Enforce endianness with types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "typescript-docs" = callPackage
    ({ mkDerivation, base, blaze-html, cmdtheline, containers
     , filemanip, filepath, language-typescript, parsec, split, syb
     , utf8-string
     }:
     mkDerivation {
       pname = "typescript-docs";
       version = "0.0.3";
       sha256 = "73e0a98cb8386b868e7fe488b9401fc25f4a15a9c5829a58daf48b62bcb95d89";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-html cmdtheline containers filemanip filepath
         language-typescript parsec split syb utf8-string
       ];
       homepage = "http://github.com/paf31/typescript-docs";
       description = "A documentation generator for TypeScript Definition files";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "typical" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "typical";
       version = "0.0.1";
       sha256 = "98c0f7dd56285e4dde732aa0d49ea12dd1233adceae101b2a58bc1752faf8637";
       libraryHaskellDepends = [ base ];
       description = "Type level numbers, vectors, list. This lib needs to be extended.";
       license = "GPL";
     }) {};

  "typography-geometry" = callPackage
    ({ mkDerivation, base, containers, parallel, polynomials-bernstein
     , vector
     }:
     mkDerivation {
       pname = "typography-geometry";
       version = "1.0.0.1";
       sha256 = "edaeafb60126be19f0e4fdda54be89b92317dd03b59e9d8b6f119064c1642ad7";
       libraryHaskellDepends = [
         base containers parallel polynomials-bernstein vector
       ];
       description = "Drawings for printed text documents";
       license = "GPL";
     }) {};

  "tz" = callPackage
    ({ mkDerivation, base, binary, bindings-posix, bytestring
     , containers, deepseq, HUnit, QuickCheck, template-haskell
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , test-framework-th, time, tzdata, unix, vector
     }:
     mkDerivation {
       pname = "tz";
       version = "0.1.0.1";
       sha256 = "2efcdae6fbeb7986ae5486de1eb090d646d60519070006379f40e72678fd490c";
       revision = "1";
       editedCabalFile = "485b8652e895108a5c360180fe992cc0f7583889c6d88cd749bf68cfde8f0baa";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq template-haskell time
         tzdata vector
       ];
       testHaskellDepends = [
         base bindings-posix HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 test-framework-th
         time tzdata unix vector
       ];
       homepage = "https://github.com/nilcons/haskell-tz";
       description = "Efficient time zone handling";
       license = stdenv.lib.licenses.asl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "tzdata" = callPackage
    ({ mkDerivation, base, bytestring, containers, deepseq, directory
     , filemanip, filepath, HUnit, MissingH, test-framework
     , test-framework-hunit, test-framework-th, unix, vector
     }:
     mkDerivation {
       pname = "tzdata";
       version = "0.1.20150810.0";
       sha256 = "c980287a435ed411415d049b86b87ddea08611a078080a01c702444402889046";
       libraryHaskellDepends = [
         base bytestring containers deepseq vector
       ];
       testHaskellDepends = [
         base bytestring directory filemanip filepath HUnit MissingH
         test-framework test-framework-hunit test-framework-th unix
       ];
       homepage = "https://github.com/nilcons/haskell-tzdata";
       description = "Time zone database (as files and as a module)";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "uAgda" = callPackage
    ({ mkDerivation, array, base, BNFC-meta, cmdargs, containers, mtl
     , parsec, pretty, split, transformers
     }:
     mkDerivation {
       pname = "uAgda";
       version = "1.2.0.4";
       sha256 = "a82a8130e9fa4c7473daa40c7e8be7fd92cf4ebfc373d4d82f2d6eeaae814105";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base BNFC-meta cmdargs containers mtl parsec pretty split
         transformers
       ];
       jailbreak = true;
       description = "A simplistic dependently-typed language with parametricity";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ua-parser" = callPackage
    ({ mkDerivation, aeson, base, bytestring, data-default, derive
     , file-embed, filepath, HUnit, pcre-light, tasty, tasty-hunit
     , tasty-quickcheck, text, yaml
     }:
     mkDerivation {
       pname = "ua-parser";
       version = "0.7";
       sha256 = "586ae0c948af8a2c671331aeebe85c663a24e5d40c8a71a943ee2520b4d4aa57";
       libraryHaskellDepends = [
         aeson base bytestring data-default file-embed pcre-light text yaml
       ];
       testHaskellDepends = [
         aeson base bytestring data-default derive file-embed filepath HUnit
         pcre-light tasty tasty-hunit tasty-quickcheck text yaml
       ];
       jailbreak = true;
       description = "A library for parsing User-Agent strings, official Haskell port of ua-parser";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uacpid" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, hslogger
     , mtl, network, process, regex-compat, time, time-locale-compat
     , unix
     }:
     mkDerivation {
       pname = "uacpid";
       version = "1.2";
       sha256 = "246c99935f905aa0de1b0106d6876356fa331d44e6628af9df7d9774551780d6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath hslogger mtl network process
         regex-compat time time-locale-compat unix
       ];
       homepage = "http://hub.darcs.net/dino/uacpid";
       description = "Userspace Advanced Configuration and Power Interface event daemon";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uberlast" = callPackage
    ({ mkDerivation, base, lens, tagged, template-haskell }:
     mkDerivation {
       pname = "uberlast";
       version = "0.0";
       sha256 = "89557749b63d79d283c51ed1a1c8860eed419d0a1d6c4ebf8a9269030e22e98a";
       libraryHaskellDepends = [ base lens tagged template-haskell ];
       homepage = "https:/github.com/fumieval/uberlast";
       description = "Generate overloaded lenses from plain data declaration";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uconv" = callPackage
    ({ mkDerivation, base, bytestring, icu }:
     mkDerivation {
       pname = "uconv";
       version = "0.0.3";
       sha256 = "7b9973c5dcf5cab35255b00fe46312e6d8793a3fb76194d5809e4e9208c7e16c";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ icu ];
       description = "String encoding conversion with ICU";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) icu;};

  "udbus" = callPackage
    ({ mkDerivation, base, binary, bytestring, cereal, containers
     , ghc-prim, mtl, network, unix, utf8-string
     }:
     mkDerivation {
       pname = "udbus";
       version = "0.2.1";
       sha256 = "d325b0c1f2a7b1eabde17d85734175f622c6597e9dfc40704894da94a09ef328";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring cereal containers ghc-prim mtl network unix
         utf8-string
       ];
       homepage = "http://github.com/vincenthz/hs-udbus";
       description = "Small DBus implementation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "udbus-model" = callPackage
    ({ mkDerivation, base, bytestring, udbus, xml }:
     mkDerivation {
       pname = "udbus-model";
       version = "0.2.1";
       sha256 = "517ea7b540848f782f3dd6890a5cf41747eca445952649827c2addd3c11f3f76";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring udbus xml ];
       homepage = "http://github.com/vincenthz/hs-udbus";
       description = "Model API for udbus introspection and definitions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "udcode" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "udcode";
       version = "0.2.0.0";
       sha256 = "66a8d62dd9f10959954f71928c4af5d912974e5b8e9f38510f73c71652b555d9";
       libraryHaskellDepends = [ base containers mtl ];
       description = "Does a set of code words form a uniquely decodable code?";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "udev" = callPackage
    ({ mkDerivation, base, bytestring, libudev, posix-paths, select
     , unix
     }:
     mkDerivation {
       pname = "udev";
       version = "0.1.0.0";
       sha256 = "a2bb00c7c75ff9beb1951dfec706c628f5354a6a9d58abcb5e9d6950dc29b1a8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring posix-paths unix ];
       libraryPkgconfigDepends = [ libudev ];
       executableHaskellDepends = [ base bytestring select ];
       homepage = "https://github.com/pxqr/udev";
       description = "libudev bindings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {libudev = null;};

  "uglymemo" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "uglymemo";
       version = "0.1.0.1";
       sha256 = "fe89ef49c0cb15867c58815b050b33f17d394d4c48a9b7240a39780a5a79b847";
       libraryHaskellDepends = [ base containers ];
       description = "A simple (but internally ugly) memoization function";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "uhc-light" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, fgl, filepath, hashable, mtl, network, old-locale
     , primitive, process, syb, transformers, uhc-util, uulib, vector
     }:
     mkDerivation {
       pname = "uhc-light";
       version = "1.1.9.3";
       sha256 = "e1c4868e38987c2938c6c9379bb3d8b1bfcfbfc95541862e118e8ca9439343f3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers directory fgl filepath
         hashable mtl network old-locale primitive process syb transformers
         uhc-util uulib vector
       ];
       executableHaskellDepends = [
         array base binary bytestring containers directory fgl filepath
         hashable mtl network old-locale primitive process syb transformers
         uhc-util uulib vector
       ];
       homepage = "https://github.com/UU-ComputerScience/uhc";
       description = "Part of UHC packaged as cabal/hackage installable library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uhc-util" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , directory, fclabels, fgl, hashable, logict-state, mtl, process
     , syb, time, time-compat, uulib
     }:
     mkDerivation {
       pname = "uhc-util";
       version = "0.1.6.5";
       sha256 = "a296ebd71c34353f69ad42b6b8979dbdc5e2bb5fb117b5e8953ff77ccbc378fc";
       libraryHaskellDepends = [
         array base binary bytestring containers directory fclabels fgl
         hashable logict-state mtl process syb time time-compat uulib
       ];
       homepage = "https://github.com/UU-ComputerScience/uhc-util";
       description = "UHC utilities";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uhexdump" = callPackage
    ({ mkDerivation, base, bytestring, split }:
     mkDerivation {
       pname = "uhexdump";
       version = "0.3";
       sha256 = "d1cb163acce2df791ccf4cdecca56bc87f220f3f274c129c0c24321f46a98c18";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bytestring split ];
       jailbreak = true;
       description = "hex dumper for UTF-8 text";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uhttpc" = callPackage
    ({ mkDerivation, async, base, bytestring, bytestring-lexing
     , deepseq, network, network-uri, optparse-applicative
     }:
     mkDerivation {
       pname = "uhttpc";
       version = "0.1.1.0";
       sha256 = "cbfa7b8d008c766be1055dca52f467cfded9e5577405b96a8bd622fc5146cece";
       revision = "1";
       editedCabalFile = "ff2f7c17cf679f095238229bd36f5438c5f2a6ed2279eee34daf1a3ceef9ba48";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring bytestring-lexing deepseq network network-uri
       ];
       executableHaskellDepends = [
         async base bytestring bytestring-lexing deepseq network
         optparse-applicative
       ];
       homepage = "https://github.com/hvr/uhttpc";
       description = "Minimal HTTP client library optimized for benchmarking";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "ui-command" = callPackage
    ({ mkDerivation, base, data-default, mtl, old-locale, time }:
     mkDerivation {
       pname = "ui-command";
       version = "0.5.4";
       sha256 = "872781d8b75e1286266adff20c3316f5e8a6f232ac2d530aa8e11b5cae0009e3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base data-default mtl old-locale time ];
       description = "A framework for friendly commandline programs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uid" = callPackage
    ({ mkDerivation, aeson, base, bytestring, cereal, dataenc, text
     , uuid
     }:
     mkDerivation {
       pname = "uid";
       version = "0.1.0.1";
       sha256 = "2b95025f91f15940506f9fafc2369f30a983541d96ba9593af2f71ab563b6687";
       libraryHaskellDepends = [
         aeson base bytestring cereal dataenc text uuid
       ];
       homepage = "http://github.com/hargettp/uid.git";
       description = "Simple unique identifier datatype, serializable and encodable as base32";
       license = stdenv.lib.licenses.mit;
     }) {};

  "una" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, directory, filepath
     , io-storage, process
     }:
     mkDerivation {
       pname = "una";
       version = "2.1.0";
       sha256 = "703b3ebf00b0a04da3f0f9bb96e4c092ac1e364fc15e161b3bdcbe061a67fe3e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs directory filepath io-storage process
       ];
       homepage = "https://github.com/jwiegley/una";
       description = "Universal un-archiver utility";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unagi-chan" = callPackage
    ({ mkDerivation, atomic-primops, base, containers, ghc-prim
     , primitive
     }:
     mkDerivation {
       pname = "unagi-chan";
       version = "0.4.0.0";
       sha256 = "deb22e738733a9e014916cb98409cef3f11ac444b1e27a530ccb07268db6a112";
       libraryHaskellDepends = [ atomic-primops base ghc-prim primitive ];
       testHaskellDepends = [
         atomic-primops base containers ghc-prim primitive
       ];
       description = "Fast concurrent queues with a Chan-like API, and more";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unagi-streams" = callPackage
    ({ mkDerivation, base, io-streams, unagi-chan }:
     mkDerivation {
       pname = "unagi-streams";
       version = "0.1.3";
       sha256 = "a612333c5b4f0f367e9a0bf81f3ec62ff047cab4204ad1bc90bc1791b80e1d55";
       libraryHaskellDepends = [ base io-streams unagi-chan ];
       description = "Unagi Chan IO-Streams";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unamb" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "unamb";
       version = "0.2.5";
       sha256 = "3359f05602ae61095c13f8db1df9222030b60ce83ad64faa705a387c18c58b89";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       homepage = "http://haskell.org/haskellwiki/unamb";
       description = "Unambiguous choice";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unamb-custom" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "unamb-custom";
       version = "0.13";
       sha256 = "934bbcb36d12d2d2ea5d490711681a659b5b55d97e0acad9cb0bbd9e2227c964";
       libraryHaskellDepends = [ base containers mtl ];
       homepage = "http://github.com/luqui/unamb-custom";
       description = "Functional concurrency with unamb using a custom scheduler";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unbound" = callPackage
    ({ mkDerivation, base, binary, containers, mtl, RepLib
     , transformers
     }:
     mkDerivation {
       pname = "unbound";
       version = "0.4.4";
       sha256 = "c6454dd5725bf2a02cc99f74b18fc5b3b1ab9d44dd99d6322e42d8399409eb7e";
       libraryHaskellDepends = [
         base binary containers mtl RepLib transformers
       ];
       homepage = "https://github.com/sweirich/replib";
       description = "Generic support for programming with names and binders";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unbound-generics_0_1" = callPackage
    ({ mkDerivation, base, containers, contravariant, mtl, QuickCheck
     , tasty, tasty-hunit, tasty-quickcheck, transformers
     , transformers-compat
     }:
     mkDerivation {
       pname = "unbound-generics";
       version = "0.1";
       sha256 = "1848839b8283b5fbb070e4a9a886b5556ecb43d8b8b8b4c38a7dda5b67e5d481";
       libraryHaskellDepends = [
         base containers contravariant mtl transformers transformers-compat
       ];
       testHaskellDepends = [
         base mtl QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       homepage = "http://github.com/lambdageek/unbound-generics";
       description = "Reimplementation of Unbound using GHC Generics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unbound-generics_0_1_2_1" = callPackage
    ({ mkDerivation, base, containers, contravariant, mtl, profunctors
     , QuickCheck, tasty, tasty-hunit, tasty-quickcheck
     , template-haskell, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "unbound-generics";
       version = "0.1.2.1";
       sha256 = "733bbd7cc56f891b575f3770f3900a0341920d157ef392944b8ca9da075e986f";
       libraryHaskellDepends = [
         base containers contravariant mtl profunctors template-haskell
         transformers transformers-compat
       ];
       testHaskellDepends = [
         base mtl QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       homepage = "http://github.com/lambdageek/unbound-generics";
       description = "Support for programming with names and binders using GHC Generics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unbound-generics_0_2" = callPackage
    ({ mkDerivation, base, containers, contravariant, deepseq, mtl
     , profunctors, QuickCheck, tasty, tasty-hunit, tasty-quickcheck
     , template-haskell, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "unbound-generics";
       version = "0.2";
       sha256 = "29e95364aa02744cbf493bdde8c53e1b225e5f6ae9b2ec83f358cdcfa83fb972";
       libraryHaskellDepends = [
         base containers contravariant deepseq mtl profunctors
         template-haskell transformers transformers-compat
       ];
       testHaskellDepends = [
         base mtl QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       homepage = "http://github.com/lambdageek/unbound-generics";
       description = "Support for programming with names and binders using GHC Generics";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unbound-generics" = callPackage
    ({ mkDerivation, base, containers, contravariant, deepseq, mtl
     , profunctors, QuickCheck, tasty, tasty-hunit, tasty-quickcheck
     , template-haskell, transformers, transformers-compat
     }:
     mkDerivation {
       pname = "unbound-generics";
       version = "0.3";
       sha256 = "8956c309de512339ee6d37501683df2e973c40437554fffab9b48cbe7283af07";
       libraryHaskellDepends = [
         base containers contravariant deepseq mtl profunctors
         template-haskell transformers transformers-compat
       ];
       testHaskellDepends = [
         base mtl QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       homepage = "http://github.com/lambdageek/unbound-generics";
       description = "Support for programming with names and binders using GHC Generics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unbounded-delays_0_1_0_8" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "unbounded-delays";
       version = "0.1.0.8";
       sha256 = "80ec0bdc09c78cf8a0ed02a59759a67e7b2fb5590ef175d233bfd929d0bbb4c9";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/unbounded-delays";
       description = "Unbounded thread delays and timeouts";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unbounded-delays" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "unbounded-delays";
       version = "0.1.0.9";
       sha256 = "4010ca5c4ca800039db259fc7a5180f10fc98f00580c7223ac7ad401ca4190b8";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/basvandijk/unbounded-delays";
       description = "Unbounded thread delays and timeouts";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unbounded-delays-units" = callPackage
    ({ mkDerivation, base, unbounded-delays, units, units-defs }:
     mkDerivation {
       pname = "unbounded-delays-units";
       version = "0.4";
       sha256 = "2498539b0cd384a33f0287622fe9544de67e374ca98eac0e5abb045d9b88440a";
       libraryHaskellDepends = [ base unbounded-delays units units-defs ];
       jailbreak = true;
       homepage = "https://github.com/jcristovao/unbouded-delays-units";
       description = "Thread delays and timeouts using proper time units";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unboxed-containers" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "unboxed-containers";
       version = "0.0.2.4";
       sha256 = "438416d21a11e03a7b17f3e3e3a0e870596274d281b489f4258e5a29f1565079";
       libraryHaskellDepends = [ base containers ];
       homepage = "http://github.com/ekmett/unboxed-containers";
       description = "Self-optimizing unboxed sets using view patterns and data families";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unbreak" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, base, base64-bytestring
     , bytestring, cereal, cmdargs, cryptonite, memory, process, text
     , unix
     }:
     mkDerivation {
       pname = "unbreak";
       version = "0.3.1";
       sha256 = "463b65c79e7d4edac74d23bf10d61956ee6f30ebe1c373624d1583dfcb841286";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty base base64-bytestring bytestring cereal
         cryptonite memory process text unix
       ];
       executableHaskellDepends = [ base bytestring cmdargs ];
       homepage = "https://e.xtendo.org/scs/unbreak";
       description = "Secure and resilient remote file storage utility";
       license = stdenv.lib.licenses.agpl3;
     }) {};

  "unexceptionalio" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "unexceptionalio";
       version = "0.3.0";
       sha256 = "927e2be6bb9ced73c1c17d79c981cadef4039d9ee45d2d3d6b4c133ff93ff0b8";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/singpolyma/unexceptionalio";
       description = "IO without any non-error, synchronous exceptions";
       license = "unknown";
     }) {};

  "unfoldable" = callPackage
    ({ mkDerivation, base, ghc-prim, QuickCheck, random, transformers
     }:
     mkDerivation {
       pname = "unfoldable";
       version = "0.8.3";
       sha256 = "62926d1f12db96468ca2c9c7e55cb63201c62d97c7486ef30a62a910893e2ddd";
       libraryHaskellDepends = [
         base ghc-prim QuickCheck random transformers
       ];
       homepage = "https://github.com/sjoerdvisscher/unfoldable";
       description = "Class of data structures that can be unfolded";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "ungadtagger" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "ungadtagger";
       version = "1.0.0";
       sha256 = "8bd8daf1b635d4b8e90f1cb4a36e7e09eea2586efce7470abc73ebbbd305c3c2";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/andriyp/ungadtagger";
       description = "Abstract GADTs from typelevel tags";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uni-events" = callPackage
    ({ mkDerivation, base, containers, uni-util }:
     mkDerivation {
       pname = "uni-events";
       version = "2.2.2.0";
       sha256 = "1f5f97e9bab1ac047acb3742121784dcf77dbaec328ad97627d7755322a455b5";
       libraryHaskellDepends = [ base containers uni-util ];
       homepage = "http://www.informatik.uni-bremen.de/uniform/wb/";
       description = "Event handling for the uniform workbench";
       license = "LGPL";
     }) {};

  "uni-graphs" = callPackage
    ({ mkDerivation, base, containers, mtl, uni-events, uni-htk
     , uni-reactor, uni-util
     }:
     mkDerivation {
       pname = "uni-graphs";
       version = "2.2.1.0";
       sha256 = "e5af248a27a16cc2bbad6f276396c149bef2ac1c99de4663c38721f9ea0395ef";
       libraryHaskellDepends = [
         base containers mtl uni-events uni-htk uni-reactor uni-util
       ];
       homepage = "http://www.informatik.uni-bremen.de/uniform/wb/";
       description = "Graphs";
       license = "LGPL";
     }) {};

  "uni-htk" = callPackage
    ({ mkDerivation, base, containers, directory, uni-events
     , uni-posixutil, uni-reactor, uni-util
     }:
     mkDerivation {
       pname = "uni-htk";
       version = "2.2.1.2";
       sha256 = "d357582ef386f97ff87f6e299632c2b58a6fad7d5b5016b724fc35f3a578abfd";
       libraryHaskellDepends = [
         base containers directory uni-events uni-posixutil uni-reactor
         uni-util
       ];
       homepage = "http://www.informatik.uni-bremen.de/htk/";
       description = "Graphical User Interface for Haskell Programs";
       license = "LGPL";
     }) {};

  "uni-posixutil" = callPackage
    ({ mkDerivation, base, directory, process, uni-events, uni-util
     , unix
     }:
     mkDerivation {
       pname = "uni-posixutil";
       version = "2.2.1.1";
       sha256 = "ad5461d40d982d68a0cdbdffea3a2cdf2c0f740f6adfeb8bedf9f4404db40372";
       libraryHaskellDepends = [
         base directory process uni-events uni-util unix
       ];
       homepage = "http://www.informatik.uni-bremen.de/uniform/wb/";
       description = "Posix utilities for the uniform workbench";
       license = "LGPL";
     }) {};

  "uni-reactor" = callPackage
    ({ mkDerivation, base, containers, directory, uni-events, uni-util
     }:
     mkDerivation {
       pname = "uni-reactor";
       version = "2.2.1.0";
       sha256 = "027ada030601f706bbcff6ead6f0e897a71c627e194fb48a5cab0391f88ff690";
       libraryHaskellDepends = [
         base containers directory uni-events uni-util
       ];
       homepage = "http://www.informatik.uni-bremen.de/uniform/wb/";
       description = "Reactors for the uniform workbench";
       license = "LGPL";
     }) {};

  "uni-uDrawGraph" = callPackage
    ({ mkDerivation, base, containers, uni-events, uni-graphs
     , uni-posixutil, uni-reactor, uni-util
     }:
     mkDerivation {
       pname = "uni-uDrawGraph";
       version = "2.2.1.3";
       sha256 = "12a4d5347e1b48057b57bf70155294d078a95a6af9b89ef53154259d4c5a74bd";
       libraryHaskellDepends = [
         base containers uni-events uni-graphs uni-posixutil uni-reactor
         uni-util
       ];
       homepage = "http://www.informatik.uni-bremen.de/uniform/wb";
       description = "Graphs binding";
       license = "LGPL";
     }) {};

  "uni-util" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , ghc-prim, mtl, network, old-time, parsec
     }:
     mkDerivation {
       pname = "uni-util";
       version = "2.3.0.1";
       sha256 = "d0a6b1f761b013a73cca76baeb7a2e3c67bd86ff08e1786df72862d0b4ec356a";
       libraryHaskellDepends = [
         array base bytestring containers directory ghc-prim mtl network
         old-time parsec
       ];
       homepage = "http://www.informatik.uni-bremen.de/uniform/wb/";
       description = "Utilities for the uniform workbench";
       license = "LGPL";
     }) {};

  "unicode" = callPackage
    ({ mkDerivation, base, containers, utility-ht }:
     mkDerivation {
       pname = "unicode";
       version = "0.0";
       sha256 = "d41708f5800a83a2b7f44d10f74371625fbc50dd4a9520dd6fc53762904cc83b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       testHaskellDepends = [ base containers utility-ht ];
       homepage = "http://code.haskell.org/~thielema/unicode/";
       description = "Construct and transform unicode characters";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unicode-names" = callPackage
    ({ mkDerivation, array, base, containers, unicode-properties }:
     mkDerivation {
       pname = "unicode-names";
       version = "3.2.0.0";
       sha256 = "ec15a50eb8b7083148781edb883988ff05d2f5ed1c013e2e0a816f5857430894";
       libraryHaskellDepends = [
         array base containers unicode-properties
       ];
       description = "Unicode 3.2.0 character names";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unicode-normalization" = callPackage
    ({ mkDerivation, base, bytestring, compact-string, icu }:
     mkDerivation {
       pname = "unicode-normalization";
       version = "0.1";
       sha256 = "8bbb7bcdc08c047b42c4f3179a724bb44b6a0115516dc034f1267661d461aeea";
       libraryHaskellDepends = [ base bytestring compact-string ];
       librarySystemDepends = [ icu ];
       homepage = "http://sloompie.reinier.de/unicode-normalization/";
       description = "Unicode normalization using the ICU library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) icu;};

  "unicode-prelude" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "unicode-prelude";
       version = "0.1.1";
       sha256 = "5cbbd504beb162ce36e1d78736d623b64967c41b6e90fafe64dc8049619cea17";
       libraryHaskellDepends = [ base ];
       description = "Unicode notation for some definitions in Prelude";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unicode-properties" = callPackage
    ({ mkDerivation, array, base, containers }:
     mkDerivation {
       pname = "unicode-properties";
       version = "3.2.0.0";
       sha256 = "018fd587e115d86fd1f1427b579558d39bf1b4b8d02e771cef7ae598bec8f91b";
       libraryHaskellDepends = [ array base containers ];
       description = "Unicode 3.2.0 character properties";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unicode-show" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, test-framework
     , test-framework-hunit, test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "unicode-show";
       version = "0.1.0.2";
       sha256 = "7ee394879b345ee397aef87ca058628cd79d59cbfc1cec81aeda7fea65f53943";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base HUnit QuickCheck test-framework test-framework-hunit
         test-framework-quickcheck2
       ];
       homepage = "http://github.com/nushio3/unicode-show#readme";
       description = "print and show in unicode";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unicode-symbols" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "unicode-symbols";
       version = "0.1.1.2";
       sha256 = "dbafed928b75d53d7aab794012ee1fdfff6454fdda468a4ab051f4e032e62a78";
       libraryHaskellDepends = [ base containers ];
       jailbreak = true;
       description = "Unicode alternatives for common functions and operators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unicoder" = callPackage
    ({ mkDerivation, attoparsec, base, directory, text }:
     mkDerivation {
       pname = "unicoder";
       version = "0.4.1";
       sha256 = "83f14e70e2e4cf849fe7c79473087356e93d2b052f5449543446915570cf429d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ attoparsec base text ];
       executableHaskellDepends = [ attoparsec base directory text ];
       testHaskellDepends = [ attoparsec base text ];
       jailbreak = true;
       homepage = "https://github.com/Zankoku-Okuno/unicoder";
       description = "Make writing in unicode easy";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unification-fd" = callPackage
    ({ mkDerivation, base, containers, logict, mtl }:
     mkDerivation {
       pname = "unification-fd";
       version = "0.10.0.1";
       sha256 = "5bf46760e6db104c57f915322b32744f7604323281f5c7dd20185f905fb51996";
       libraryHaskellDepends = [ base containers logict mtl ];
       homepage = "http://code.haskell.org/~wren/";
       description = "Simple generic unification algorithms";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uniform-io" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, Cabal
     , data-default-class, iproute, network, openssl, transformers
     , word8
     }:
     mkDerivation {
       pname = "uniform-io";
       version = "1.1.1.0";
       sha256 = "a731b2c38d988631519f7e7487ed2372337c834e56f827e41ec672a71dbfa5ed";
       libraryHaskellDepends = [
         attoparsec base bytestring data-default-class iproute network
         transformers word8
       ];
       librarySystemDepends = [ openssl ];
       testHaskellDepends = [ attoparsec base bytestring Cabal ];
       jailbreak = true;
       homepage = "https://sealgram.com/git/haskell/uniform-io";
       description = "Uniform IO over files, network, anything";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) openssl;};

  "uniform-pair" = callPackage
    ({ mkDerivation, base, deepseq, ShowF }:
     mkDerivation {
       pname = "uniform-pair";
       version = "0.1.10";
       sha256 = "f27805fca8cd9574d0b7c535693c9dda9c9d945af1a50fc36abeb80fb332a2ff";
       libraryHaskellDepends = [ base deepseq ShowF ];
       homepage = "https://github.com/conal/uniform-pair/";
       description = "Uniform pairs with class instances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "union-find" = callPackage
    ({ mkDerivation, base, containers, transformers }:
     mkDerivation {
       pname = "union-find";
       version = "0.2";
       sha256 = "e6c2682bb8c06e8c43e360f45658d0eea17209cce84953e2a7d2f0240591f0ec";
       libraryHaskellDepends = [ base containers transformers ];
       homepage = "http://github.com/nominolo/union-find";
       description = "Efficient union and equivalence testing of sets";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "union-find-array" = callPackage
    ({ mkDerivation, array, base, mtl }:
     mkDerivation {
       pname = "union-find-array";
       version = "0.1.0.2";
       sha256 = "b3993034e95f39e2e6ebfaa05b64333e33f5c851197f64856e281230c50eabdf";
       libraryHaskellDepends = [ array base mtl ];
       homepage = "https://github.com/haskell-rewriting/union-find-array";
       description = "union find data structure";
       license = stdenv.lib.licenses.mit;
     }) {};

  "union-map" = callPackage
    ({ mkDerivation, base, containers, extensible }:
     mkDerivation {
       pname = "union-map";
       version = "0.1";
       sha256 = "b4ac6708abfd6091f6b7f7ed21ac1f6b14f607fd0877901695d707f036783860";
       libraryHaskellDepends = [ base containers extensible ];
       homepage = "http://github.com/minpou/union-map";
       description = "Heterogeneous map by open unions";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uniplate" = callPackage
    ({ mkDerivation, base, containers, hashable, syb
     , unordered-containers
     }:
     mkDerivation {
       pname = "uniplate";
       version = "1.6.12";
       sha256 = "fcc60bc6b3f6e925f611646db90e6db9f05286a9363405f844df1dc15572a8b7";
       libraryHaskellDepends = [
         base containers hashable syb unordered-containers
       ];
       homepage = "http://community.haskell.org/~ndm/uniplate/";
       description = "Help writing simple, concise and fast generic operations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unique" = callPackage
    ({ mkDerivation, base, ghc-prim, hashable }:
     mkDerivation {
       pname = "unique";
       version = "0";
       sha256 = "e3fb171b7b1787683863934df0fc082fb47c0da6972bb1839c2ee8ceb64a0a90";
       revision = "1";
       editedCabalFile = "68933757e4bd3e7f53f226bd344f8ee980e86fe74eed20fa19edb5867c51035f";
       libraryHaskellDepends = [ base ghc-prim hashable ];
       homepage = "http://github.com/ekmett/unique/";
       description = "Fully concurrent unique identifiers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unique-logic" = callPackage
    ({ mkDerivation, base, non-empty, QuickCheck, transformers
     , utility-ht
     }:
     mkDerivation {
       pname = "unique-logic";
       version = "0.3";
       sha256 = "81d0f6e6e0d34895c90902241b4f4ad98b3acb713f65248aefa68d53d5c6535e";
       libraryHaskellDepends = [ base transformers utility-ht ];
       testHaskellDepends = [
         base non-empty QuickCheck transformers utility-ht
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/unique-logic/";
       description = "Solve simple simultaneous equations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unique-logic-tf" = callPackage
    ({ mkDerivation, base, containers, explicit-exception, non-empty
     , QuickCheck, transformers, utility-ht
     }:
     mkDerivation {
       pname = "unique-logic-tf";
       version = "0.4.1.2";
       sha256 = "d00604f3ba2970a714fb656fc79a6481f833356af32ffd2bbb30cf025db9acbd";
       libraryHaskellDepends = [
         base containers explicit-exception transformers utility-ht
       ];
       testHaskellDepends = [
         base non-empty QuickCheck transformers utility-ht
       ];
       homepage = "http://code.haskell.org/~thielema/unique-logic-tf/";
       description = "Solve simple simultaneous equations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uniqueid" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "uniqueid";
       version = "0.1.1";
       sha256 = "e69df591c1ab9901af24bf0e63032765eb2b1ba4ca4fb720a234e9f292e03268";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/sebfisch/uniqueid/wikis";
       description = "Splittable Unique Identifier Supply";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unit" = callPackage
    ({ mkDerivation, base, hspec }:
     mkDerivation {
       pname = "unit";
       version = "0.1.0.0";
       sha256 = "0747cc0c3a8e6bb64343b79c079702757d81f63ae2bc7dd76727b8bcee8edc74";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec ];
       homepage = "http://github.com/cxfreeio/unit#readme";
       description = "Aliases for ()";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "units" = callPackage
    ({ mkDerivation, base, containers, HUnit-approx, mtl, multimap
     , singletons, syb, tasty, tasty-hunit, template-haskell, th-desugar
     , units-parser, vector-space
     }:
     mkDerivation {
       pname = "units";
       version = "2.3";
       sha256 = "f2d76562be958b066b92eb46a8236dae7e2085418af461292e9923b38c290592";
       libraryHaskellDepends = [
         base containers mtl multimap singletons syb template-haskell
         th-desugar units-parser vector-space
       ];
       testHaskellDepends = [
         base containers HUnit-approx mtl multimap singletons syb tasty
         tasty-hunit template-haskell th-desugar units-parser vector-space
       ];
       jailbreak = true;
       homepage = "https://github.com/goldfirere/units";
       description = "A domain-specific type system for dimensional analysis";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "units-attoparsec" = callPackage
    ({ mkDerivation, attoparsec, base, template-haskell, text, units
     , units-defs
     }:
     mkDerivation {
       pname = "units-attoparsec";
       version = "1.0";
       sha256 = "3ff62ea9ae3860f799ce39188620da7be6c8ffb8793fcea15bf79dfef4574a87";
       libraryHaskellDepends = [
         attoparsec base template-haskell text units units-defs
       ];
       homepage = "https://github.com/jcristovao/units-attoparsec";
       description = "Attoparsec parsers for the units package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "units-defs" = callPackage
    ({ mkDerivation, base, template-haskell, units }:
     mkDerivation {
       pname = "units-defs";
       version = "2.0.0.1";
       sha256 = "fb9a490ed58f27e84edefbd6c532619c941963e75474696d42b40e81bde46912";
       libraryHaskellDepends = [ base template-haskell units ];
       homepage = "http://github.com/goldfirere/units-defs";
       description = "Definitions for use with the units package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "units-parser" = callPackage
    ({ mkDerivation, base, containers, mtl, multimap, parsec, syb
     , tasty, tasty-hunit, template-haskell
     }:
     mkDerivation {
       pname = "units-parser";
       version = "0.1.0.0";
       sha256 = "d8558536a4f82795cb880f3910fec536005b7199662810662f61c27b95d24141";
       libraryHaskellDepends = [ base containers mtl multimap parsec ];
       testHaskellDepends = [
         base containers mtl multimap parsec syb tasty tasty-hunit
         template-haskell
       ];
       description = "A parser for units of measure";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unittyped" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "unittyped";
       version = "0.1";
       sha256 = "b4b5d74a863ac2f4d1430305aa4b2277b9d3bbec9492aa8b75cca26b793e62a9";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://bitbucket.org/xnyhps/haskell-unittyped/";
       description = "An extendable library for type-safe computations including units";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "universal-binary" = callPackage
    ({ mkDerivation, base, binary, bytestring }:
     mkDerivation {
       pname = "universal-binary";
       version = "0.11";
       sha256 = "9c15c2e048aaac5d0fd83c2665b40e317ed7c78a7d5e1dbdc3f2c67bb4c1d9be";
       libraryHaskellDepends = [ base binary bytestring ];
       description = "Parser for OS X Universal Binary format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "universe" = callPackage
    ({ mkDerivation, universe-instances-base
     , universe-instances-extended, universe-instances-trans
     , universe-reverse-instances
     }:
     mkDerivation {
       pname = "universe";
       version = "1.0";
       sha256 = "1f80e4788d348d53e39a32c8514940418a71c49c5423eb70b94e1786d94ff9a7";
       libraryHaskellDepends = [
         universe-instances-base universe-instances-extended
         universe-instances-trans universe-reverse-instances
       ];
       homepage = "https://github.com/dmwit/universe";
       description = "Classes for types where we know all the values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "universe-base" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "universe-base";
       version = "1.0.2.1";
       sha256 = "07c48350afacdc0b5569f72e3d6a27a8ff3c208b7a6f22d00e149a201798bb51";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/dmwit/universe";
       description = "A class for finite and recursively enumerable types and some helper functions for enumerating them";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "universe-instances-base" = callPackage
    ({ mkDerivation, base, containers, universe-base }:
     mkDerivation {
       pname = "universe-instances-base";
       version = "1.0";
       sha256 = "a21150ee3bb71283522a573bf092c8d96b2e28a95336a95505aa4c2a067dd212";
       libraryHaskellDepends = [ base containers universe-base ];
       homepage = "https://github.com/dmwit/universe";
       description = "Universe instances for types from the base package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "universe-instances-extended" = callPackage
    ({ mkDerivation, adjunctions, base, comonad
     , universe-instances-base, void
     }:
     mkDerivation {
       pname = "universe-instances-extended";
       version = "1.0.0.1";
       sha256 = "665b272701b16a6bb8d40a5396aa1dcb038f002452ebdc29d353e3be2070c997";
       revision = "1";
       editedCabalFile = "19250a2533aa23a84169d72218dc3f5a055253a866901bb78853fb2b271951db";
       libraryHaskellDepends = [
         adjunctions base comonad universe-instances-base void
       ];
       homepage = "https://github.com/dmwit/universe";
       description = "Universe instances for types from select extra packages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "universe-instances-trans" = callPackage
    ({ mkDerivation, base, mtl, transformers, universe-base
     , universe-instances-base
     }:
     mkDerivation {
       pname = "universe-instances-trans";
       version = "1.0.0.1";
       sha256 = "0d047cf1eb4af9f2052f44f487e7d2d44c86f51b54a3cc1fc5243ad816e8310e";
       revision = "1";
       editedCabalFile = "c96cbeb4bf0240bbe09476ca360e9d35cb07cb0af4324bfbfa5cce55df7a9c35";
       libraryHaskellDepends = [
         base mtl transformers universe-base universe-instances-base
       ];
       homepage = "https://github.com/dmwit/universe";
       description = "Universe instances for types from the transformers and mtl packages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "universe-reverse-instances" = callPackage
    ({ mkDerivation, base, containers, universe-instances-base }:
     mkDerivation {
       pname = "universe-reverse-instances";
       version = "1.0";
       sha256 = "e9d41cbf26eabd77587fddf69493d7ad23028303d1c1d1d2ee1de1bf3d3e8d49";
       libraryHaskellDepends = [
         base containers universe-instances-base
       ];
       homepage = "https://github.com/dmwit/universe";
       description = "instances of standard classes that are made possible by enumerations";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "universe-th" = callPackage
    ({ mkDerivation, base, checkers, composition, DebugTraceHelpers
     , HUnit, mtl, QuickCheck, template-haskell, test-framework
     , test-framework-hunit, test-framework-quickcheck2, th-instances
     , tuple, uniplate
     }:
     mkDerivation {
       pname = "universe-th";
       version = "0.0.0.6";
       sha256 = "9da7e7efae4a4a44867ce70fd6eb49cfc841064507a98f9a31225d4af6637390";
       libraryHaskellDepends = [
         base composition mtl template-haskell tuple uniplate
       ];
       testHaskellDepends = [
         base checkers composition DebugTraceHelpers HUnit mtl QuickCheck
         template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2 th-instances tuple uniplate
       ];
       homepage = "http://github.com/jfishcoff/universe-th";
       description = "Construct a Dec's ancestor list";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unix_2_7_1_0" = callPackage
    ({ mkDerivation, base, bytestring, time }:
     mkDerivation {
       pname = "unix";
       version = "2.7.1.0";
       sha256 = "6bd4e6013855541535a1317197aa6a11e7f24ba0e4dd64a8b7fcfd40b5a4e45c";
       revision = "1";
       editedCabalFile = "ee3232af128d50f0b51e8ee786cd928399371d13942581da1bc73232d8f6d802";
       libraryHaskellDepends = [ base bytestring time ];
       homepage = "https://github.com/haskell/unix";
       description = "POSIX functionality";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unix-bytestring" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "unix-bytestring";
       version = "0.3.7.3";
       sha256 = "a3ec273da411988b7d9eb7317f6d84ce47f4b7fd39bdc721acd5229e7cff808c";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://code.haskell.org/~wren/";
       description = "Unix/Posix-specific functions for ByteStrings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unix-compat_0_4_1_3" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "unix-compat";
       version = "0.4.1.3";
       sha256 = "ab930a71d3cd9884a6c2bf58f330fa13c68cecb26d5cff20d435cdf69d1bdced";
       libraryHaskellDepends = [ base unix ];
       homepage = "http://github.com/jystic/unix-compat";
       description = "Portable POSIX-compatibility layer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unix-compat" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "unix-compat";
       version = "0.4.1.4";
       sha256 = "fafa1a9eefc93287c028cc61f17a91f886f164b3f64392f1756f8a7f8b3cb34b";
       revision = "1";
       editedCabalFile = "401047ed04906f81b78929274ebe1b3f321e2c61a52124a034da7bacccd3b03c";
       libraryHaskellDepends = [ base unix ];
       homepage = "http://github.com/jystic/unix-compat";
       description = "Portable POSIX-compatibility layer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unix-fcntl" = callPackage
    ({ mkDerivation, base, foreign-var, unix }:
     mkDerivation {
       pname = "unix-fcntl";
       version = "0.0.0";
       sha256 = "69c1852fa11e98c99e0f61052bd642e66f2e491ffba1e0ee6d7cd5d049f832a3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base foreign-var ];
       executableHaskellDepends = [ base foreign-var unix ];
       homepage = "https://github.com/maoe/unix-fcntl";
       description = "Comprehensive bindings to fcntl(2)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unix-handle" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "unix-handle";
       version = "0.0.0";
       sha256 = "9126ef725dc5d9a923834922c1bf2ad6e7044a2d67c6161e1595163d53abda1f";
       libraryHaskellDepends = [ base unix ];
       description = "POSIX operations on Handles";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unix-io-extra" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "unix-io-extra";
       version = "0.1";
       sha256 = "2fd2e78408217b78d32711582029c13e0ece89eccf827dc8ed4dd4ab8247c2e3";
       libraryHaskellDepends = [ base ];
       description = "Support for writev, pwrite and pread";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unix-memory" = callPackage
    ({ mkDerivation, base, mtl, QuickCheck, tasty, tasty-hunit
     , tasty-quickcheck, unix
     }:
     mkDerivation {
       pname = "unix-memory";
       version = "0.1.2";
       sha256 = "f766b55f5a356ab4a7289d456972555b2f6a4af0cc46968f0d308c96c63f1ae5";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base mtl QuickCheck tasty tasty-hunit tasty-quickcheck unix
       ];
       homepage = "http://github.com/vincenthz/hs-unix-memory";
       description = "Unix memory syscalls";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unix-process-conduit" = callPackage
    ({ mkDerivation, base, bytestring, conduit, directory, filepath
     , hspec, process, stm, time, transformers, unix
     }:
     mkDerivation {
       pname = "unix-process-conduit";
       version = "0.2.2.3";
       sha256 = "9e6d6b48a410bf5e788cc725bb00066ab500d6eef6ba64fbf3ef41bd1b97af51";
       revision = "1";
       editedCabalFile = "bd35a20a4b51cd11bfcacd873bf6077f44684fdba8a4f6e08aea068f0849ee75";
       libraryHaskellDepends = [
         base bytestring conduit directory filepath process stm time
         transformers unix
       ];
       testHaskellDepends = [
         base bytestring conduit hspec transformers unix
       ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/conduit";
       description = "Run processes on Unix systems, with a conduit interface (deprecated)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unix-pty-light" = callPackage
    ({ mkDerivation, base, unix }:
     mkDerivation {
       pname = "unix-pty-light";
       version = "0.1";
       sha256 = "9227e0771e030cf5b871d0aa91fe9f7e8c324907cb5037cd330846c84c6341d8";
       libraryHaskellDepends = [ base unix ];
       homepage = "http://code.haskell.org/~scook0/unix-pty-light";
       description = "POSIX pseudo-terminal support";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unix-time_0_3_4" = callPackage
    ({ mkDerivation, base, binary, bytestring, doctest, hspec
     , old-locale, old-time, QuickCheck, time
     }:
     mkDerivation {
       pname = "unix-time";
       version = "0.3.4";
       sha256 = "e511b17e3dd905b2e71e4c22d5a245bbc71fc82794f16a24dfe379f5d700d1ae";
       libraryHaskellDepends = [ base binary bytestring old-time ];
       testHaskellDepends = [
         base bytestring doctest hspec old-locale old-time QuickCheck time
       ];
       doHaddock = false;
       doCheck = false;
       description = "Unix time parser/formatter and utilities";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unix-time_0_3_5" = callPackage
    ({ mkDerivation, base, binary, bytestring, doctest, hspec
     , old-locale, old-time, QuickCheck, time
     }:
     mkDerivation {
       pname = "unix-time";
       version = "0.3.5";
       sha256 = "7f1c58cd0328bbcb1d050af05670bc6f44dea3ee0894f30c6f87ee4a0d01675e";
       libraryHaskellDepends = [ base binary bytestring old-time ];
       testHaskellDepends = [
         base bytestring doctest hspec old-locale old-time QuickCheck time
       ];
       doCheck = false;
       description = "Unix time parser/formatter and utilities";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unix-time" = callPackage
    ({ mkDerivation, base, binary, bytestring, doctest, hspec
     , old-locale, old-time, QuickCheck, time
     }:
     mkDerivation {
       pname = "unix-time";
       version = "0.3.6";
       sha256 = "5d15ebd0ee74e13638a7c04a7fc5f05a29ccd3228c8798df226939a778f7db37";
       libraryHaskellDepends = [ base binary bytestring old-time ];
       testHaskellDepends = [
         base bytestring doctest hspec old-locale old-time QuickCheck time
       ];
       doCheck = false;
       description = "Unix time parser/formatter and utilities";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unlambda" = callPackage
    ({ mkDerivation, array, base, mtl, unix }:
     mkDerivation {
       pname = "unlambda";
       version = "0.1.4.1";
       sha256 = "07a5525d1333264e6909732d3c0872a9b2b6d7612f61d387448c3f400a656007";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base mtl ];
       executableHaskellDepends = [ base unix ];
       description = "Unlambda interpreter";
       license = "GPL";
     }) {};

  "unlit" = callPackage
    ({ mkDerivation, base, directory, text }:
     mkDerivation {
       pname = "unlit";
       version = "0.3.0.3";
       sha256 = "ce5ea584d4fef6ef89b2d6c5a105cf31827c5e14045766406f95453a2a238d5b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory text ];
       executableHaskellDepends = [ base directory text ];
       description = "Tool to convert literate code between styles or to code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unm-hip" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, process
     , vector
     }:
     mkDerivation {
       pname = "unm-hip";
       version = "0.3.1.6";
       sha256 = "c5e79f3d4238a2aa59827b40ab785bb22a3d70ace67e866e9ae2c984ccde119c";
       libraryHaskellDepends = [
         array base bytestring containers process vector
       ];
       description = "A Library for the manipulation of images";
       license = "GPL";
     }) {};

  "unordered-containers_0_2_5_1" = callPackage
    ({ mkDerivation, base, ChasingBottoms, containers, deepseq
     , hashable, HUnit, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "unordered-containers";
       version = "0.2.5.1";
       sha256 = "6e5878ade3ea65f2a7cb0a1df155f88f7e710d5bb975a5cbf1b45fb8cfee811a";
       revision = "1";
       editedCabalFile = "573b8855cce6de6c1f4111933e84375e4afa8a250e3a1c17e2206cb705236d4d";
       libraryHaskellDepends = [ base deepseq hashable ];
       testHaskellDepends = [
         base ChasingBottoms containers hashable HUnit QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/tibbe/unordered-containers";
       description = "Efficient hashing-based container types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unordered-containers" = callPackage
    ({ mkDerivation, base, ChasingBottoms, containers, deepseq
     , hashable, HUnit, QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "unordered-containers";
       version = "0.2.7.0";
       sha256 = "6503226d24069698bbb454c15c53a7f9f245aba228e142c6b6ab2d31cecc5ef6";
       libraryHaskellDepends = [ base deepseq hashable ];
       testHaskellDepends = [
         base ChasingBottoms containers hashable HUnit QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/tibbe/unordered-containers";
       description = "Efficient hashing-based container types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unordered-containers-rematch" = callPackage
    ({ mkDerivation, base, hashable, hspec, HUnit, rematch
     , unordered-containers
     }:
     mkDerivation {
       pname = "unordered-containers-rematch";
       version = "0.1.0.0";
       sha256 = "2846f6a032b604b4ddf9335194a3b900f4b030b0ba2921157dbdd4d021478d8e";
       libraryHaskellDepends = [
         base hashable rematch unordered-containers
       ];
       testHaskellDepends = [
         base hashable hspec HUnit rematch unordered-containers
       ];
       jailbreak = true;
       homepage = "http://github.com/tcrayford/rematch";
       description = "Rematch support for unordered containers";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unordered-graphs" = callPackage
    ({ mkDerivation, base, deepseq, dlist, hashable
     , unordered-containers
     }:
     mkDerivation {
       pname = "unordered-graphs";
       version = "0.1.0";
       sha256 = "9c14ac49ccc570dc93aadd45f89c82c92f6872a3077effc16825be81a2e7a9c7";
       libraryHaskellDepends = [
         base deepseq dlist hashable unordered-containers
       ];
       description = "Graph library using unordered-containers";
       license = stdenv.lib.licenses.mit;
     }) {};

  "unpack-funcs" = callPackage
    ({ mkDerivation, base, bytestring, primitive, template-haskell
     , transformers, vector
     }:
     mkDerivation {
       pname = "unpack-funcs";
       version = "0.3.1";
       sha256 = "039ff3165ee7db95b7894761d38833f8dbf19812d1bcfc4acbc01415deea4841";
       libraryHaskellDepends = [
         base bytestring primitive template-haskell transformers vector
       ];
       description = "Monad transformers that mirror worker-wrapper transformations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unroll-ghc-plugin" = callPackage
    ({ mkDerivation, base, ghc }:
     mkDerivation {
       pname = "unroll-ghc-plugin";
       version = "0.1.1";
       sha256 = "f7a04a48840e2111628f32af3939d12ac8c0bd22602999a07deb62ecce390558";
       libraryHaskellDepends = [ base ghc ];
       homepage = "http://thoughtpolice.github.com/unroll-ghc-plugin";
       description = "Compiler plugin for loop unrolling";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unsafe" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "unsafe";
       version = "0.0";
       sha256 = "df0a74ccf7b43956c1b5decd5580e235317d1f96a1bbd75e117fc21143ee8641";
       libraryHaskellDepends = [ base ];
       homepage = "http://code.haskell.org/~thielema/unsafe/";
       description = "Unified interface to unsafe functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unsafe-promises" = callPackage
    ({ mkDerivation, base, threads }:
     mkDerivation {
       pname = "unsafe-promises";
       version = "0.0.1.3";
       sha256 = "e04c6362be8a5f1417208cecc6b7343bae48770bc67c150200d46005f0602880";
       libraryHaskellDepends = [ base threads ];
       homepage = "https://github.com/kallisti-dev/unsafe-promises";
       description = "Create pure futures using lazy IO";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unsafely" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "unsafely";
       version = "0.2.0.0";
       sha256 = "19341a7d3d2e4d4ae3a4a232c566edb071c895a17e5f1d1ad092b1d3fe026583";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://github.com/konn/unsafely";
       description = "Flexible access control for unsafe operations and instances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unsafeperformst" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "unsafeperformst";
       version = "0.9.2";
       sha256 = "6c3fff1fdc9efad11d486ea6ad0c382c3e9da7895b2ecfd20595eb4a7f454650";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/atzeus/unsafeperformst";
       description = "Like unsafeperformIO, but for the ST monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "unscramble" = callPackage
    ({ mkDerivation, array, base, optparse-applicative, stream-fusion
     , unordered-containers
     }:
     mkDerivation {
       pname = "unscramble";
       version = "1.0";
       sha256 = "2e67d6d2be0f5422891448c099324fcd72a1f18067200c6ed2a6453f784b8efe";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base optparse-applicative stream-fusion unordered-containers
       ];
       description = "Solve Boggle-like word games";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "unusable-pkg" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "unusable-pkg";
       version = "0.1";
       sha256 = "f56e8a158ec8502fe278aad68bda4a4ff16337c0065a7b4587cb6e6294fe4d80";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       description = "Utility construction of the graph depending unusable packages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uom-plugin" = callPackage
    ({ mkDerivation, base, containers, deepseq, ghc
     , ghc-tcplugins-extra, tasty, tasty-hunit, template-haskell
     , units-parser
     }:
     mkDerivation {
       pname = "uom-plugin";
       version = "0.2.0.0";
       sha256 = "c9eb1b27d940f7ce7ff2850f5f9c5bc2a5b23d472c8bcfaca0aec6a8b1c72daf";
       libraryHaskellDepends = [
         base containers deepseq ghc ghc-tcplugins-extra template-haskell
         units-parser
       ];
       testHaskellDepends = [ base tasty tasty-hunit ];
       jailbreak = true;
       homepage = "https://github.com/adamgundry/uom-plugin";
       description = "Units of measure as a GHC typechecker plugin";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "up" = callPackage
    ({ mkDerivation, base, directory, filepath, lambda-options, mtl
     , split
     }:
     mkDerivation {
       pname = "up";
       version = "1.0.0.3";
       sha256 = "7e93219da62895cbea56ed91cefe3d0511bf57120b5ad6166f798b5e6d9567f0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base directory filepath lambda-options mtl split
       ];
       jailbreak = true;
       homepage = "https://github.com/thomaseding/up";
       description = "Command line tool to generate pathnames to facilitate moving upward in a file system";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "up-grade" = callPackage
    ({ mkDerivation, base, ports-tools, process }:
     mkDerivation {
       pname = "up-grade";
       version = "0.0.2";
       sha256 = "cb893b55b492d6cbd7b447c320e4a2eaf618a4fcd37352b97dffc22784e955da";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ports-tools process ];
       homepage = "http://github.com/ppenzin/up/";
       description = "Software management tool";
       license = "unknown";
     }) {};

  "uploadcare" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, cryptohash
     , hex, http-conduit, http-types, old-locale, time
     }:
     mkDerivation {
       pname = "uploadcare";
       version = "0.1";
       sha256 = "7f95a569176336d1fc71064f7a0f39f6fea79dc4922a18b7a2be43d9d0ada7d2";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring cryptohash hex http-conduit
         http-types old-locale time
       ];
       jailbreak = true;
       description = "Haskell client for Uploadcare";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "upskirt" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "upskirt";
       version = "0.0.4";
       sha256 = "8ce80fe600d98aec47210ccd38a1df0c3a2cd7ce607fee52ac5de0d80b194814";
       libraryHaskellDepends = [ base bytestring ];
       description = "Binding to upskirt";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ureader" = callPackage
    ({ mkDerivation, ansi-wl-pprint, async, base, bytestring
     , containers, curl, data-default, deepseq, directory, download-curl
     , feed, filepath, implicit-params, network, old-locale, opml
     , optparse-applicative, parallel-io, split, tagsoup, terminal-size
     , text, time, xml
     }:
     mkDerivation {
       pname = "ureader";
       version = "0.2.0.0";
       sha256 = "68f1a84963e2aae0fa58cab89e873552b585db43a9036db06f6dcf5a2bd2ef87";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-wl-pprint async base bytestring containers curl data-default
         deepseq directory download-curl feed filepath implicit-params
         network old-locale opml optparse-applicative parallel-io split
         tagsoup terminal-size text time xml
       ];
       jailbreak = true;
       homepage = "https://github.com/pxqr/ureader";
       description = "Minimalistic CLI RSS reader";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "urembed" = callPackage
    ({ mkDerivation, base, bytestring, cake3, directory, filepath
     , language-javascript, mime-types, mtl, optparse-applicative
     , process, syb, text
     }:
     mkDerivation {
       pname = "urembed";
       version = "0.5.0.1";
       sha256 = "33ea48c7d89f130a988a521e61af0826af8f82c275951dcfecbdf33f751fd93a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cake3 directory filepath language-javascript
         mime-types mtl optparse-applicative process syb text
       ];
       jailbreak = true;
       homepage = "http://github.com/grwlf/urembed";
       description = "Ur/Web static content generator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uri" = callPackage
    ({ mkDerivation, base, parsec, safe, utf8-string }:
     mkDerivation {
       pname = "uri";
       version = "0.1.6.4";
       sha256 = "a90cd3d3ca1d33740dc732f14773266a7707901a872747a6e543129cab4ee409";
       libraryHaskellDepends = [ base parsec safe utf8-string ];
       homepage = "http://gitorious.org/uri";
       description = "Library for working with URIs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uri-bytestring_0_1_6" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , derive, HUnit, lens, QuickCheck, quickcheck-instances, tasty
     , tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "uri-bytestring";
       version = "0.1.6";
       sha256 = "46c6d0d84fcaca2ada708b9e7421fb9529619287696c6b44c755c8dcb32ce473";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring
       ];
       testHaskellDepends = [
         attoparsec base blaze-builder bytestring derive HUnit lens
         QuickCheck quickcheck-instances tasty tasty-hunit tasty-quickcheck
       ];
       homepage = "https://github.com/Soostone/uri-bytestring";
       description = "Haskell URI parsing as ByteStrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uri-bytestring_0_1_7" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , derive, HUnit, lens, QuickCheck, quickcheck-instances, tasty
     , tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "uri-bytestring";
       version = "0.1.7";
       sha256 = "e29aef1ce933239fc3183e785d42f3b1f86478efc4df00f7582e97140d3a5968";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring
       ];
       testHaskellDepends = [
         attoparsec base blaze-builder bytestring derive HUnit lens
         QuickCheck quickcheck-instances tasty tasty-hunit tasty-quickcheck
       ];
       homepage = "https://github.com/Soostone/uri-bytestring";
       description = "Haskell URI parsing as ByteStrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uri-bytestring_0_1_8" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , derive, HUnit, lens, QuickCheck, quickcheck-instances, tasty
     , tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "uri-bytestring";
       version = "0.1.8";
       sha256 = "d1655ca765206ab3f49a6374fe8bd2c6726990dd10814e4600df74c3d0f15dec";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring
       ];
       testHaskellDepends = [
         attoparsec base blaze-builder bytestring derive HUnit lens
         QuickCheck quickcheck-instances tasty tasty-hunit tasty-quickcheck
       ];
       homepage = "https://github.com/Soostone/uri-bytestring";
       description = "Haskell URI parsing as ByteStrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uri-bytestring_0_1_9" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , derive, HUnit, lens, QuickCheck, quickcheck-instances, semigroups
     , tasty, tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "uri-bytestring";
       version = "0.1.9";
       sha256 = "0c0d7e384c53395821fc1d25294533db00bb8110399d1b6751937edeb4146089";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring
       ];
       testHaskellDepends = [
         attoparsec base blaze-builder bytestring derive HUnit lens
         QuickCheck quickcheck-instances semigroups tasty tasty-hunit
         tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "https://github.com/Soostone/uri-bytestring";
       description = "Haskell URI parsing as ByteStrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uri-bytestring_0_1_9_1" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , derive, HUnit, lens, QuickCheck, quickcheck-instances, semigroups
     , tasty, tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "uri-bytestring";
       version = "0.1.9.1";
       sha256 = "38845e3f6b13728e320965759c8bdb14ffcdcf3de78323e4f52f2393a494cc86";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring
       ];
       testHaskellDepends = [
         attoparsec base blaze-builder bytestring derive HUnit lens
         QuickCheck quickcheck-instances semigroups tasty tasty-hunit
         tasty-quickcheck
       ];
       homepage = "https://github.com/Soostone/uri-bytestring";
       description = "Haskell URI parsing as ByteStrings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uri-bytestring" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , derive, HUnit, lens, QuickCheck, quickcheck-instances, semigroups
     , tasty, tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "uri-bytestring";
       version = "0.1.9.2";
       sha256 = "3d51236d957c656f38ebc2f01f256130b8bc48166539d477803295bdffcc5bb0";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring
       ];
       testHaskellDepends = [
         attoparsec base blaze-builder bytestring derive HUnit lens
         QuickCheck quickcheck-instances semigroups tasty tasty-hunit
         tasty-quickcheck
       ];
       homepage = "https://github.com/Soostone/uri-bytestring";
       description = "Haskell URI parsing as ByteStrings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uri-conduit" = callPackage
    ({ mkDerivation, base, bytestring, conduit, containers, deepseq
     , failure, monad-control, network, system-fileio, system-filepath
     , text, transformers
     }:
     mkDerivation {
       pname = "uri-conduit";
       version = "1.1.1.2";
       sha256 = "e66d77fc8d410afbebbeadb16a44c2440c47d15fd59aeb9c5ca0071b0311b82e";
       libraryHaskellDepends = [
         base bytestring conduit containers deepseq failure monad-control
         network system-fileio system-filepath text transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/xml";
       description = "Read and write URIs (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uri-encode_1_5_0_3" = callPackage
    ({ mkDerivation, base, bytestring, network-uri, text, utf8-string
     }:
     mkDerivation {
       pname = "uri-encode";
       version = "1.5.0.3";
       sha256 = "f6d7b0d25a86f7bbc1944914320c204e58e07960e4aba23e3ea5bfd30fb3bc84";
       revision = "1";
       editedCabalFile = "455f71a45ce8ec3646f1215bf1476828fd01bb5fc1e228a6da6657c57b5f53be";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring network-uri text utf8-string
       ];
       jailbreak = true;
       description = "Unicode aware uri-encoding";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uri-encode" = callPackage
    ({ mkDerivation, base, bytestring, network-uri, text, utf8-string
     }:
     mkDerivation {
       pname = "uri-encode";
       version = "1.5.0.4";
       sha256 = "f7ca380f88a3cc815cdffeb7cc714fbed4b9bd8da1a4ac3139e4ab001179f582";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring network-uri text utf8-string
       ];
       description = "Unicode aware uri-encoding";
       license = "unknown";
     }) {};

  "uri-enumerator" = callPackage
    ({ mkDerivation, base, bytestring, containers, enumerator, failure
     , network, text, transformers
     }:
     mkDerivation {
       pname = "uri-enumerator";
       version = "0.1.0.1";
       sha256 = "85c3fae2f6dca8217853ee8ebed08b0da0b557c5f027bab670737a147afd9e98";
       libraryHaskellDepends = [
         base bytestring containers enumerator failure network text
         transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/xml";
       description = "Read and write URIs (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uri-enumerator-file" = callPackage
    ({ mkDerivation, base, bytestring, containers, enumerator
     , lifted-base, monad-control, network, system-fileio
     , system-filepath, text, transformers, uri-enumerator
     }:
     mkDerivation {
       pname = "uri-enumerator-file";
       version = "0.1.1.1";
       sha256 = "a6d52d62452d609a459d7e7eea209de402aabc42944939f1c0dcf23a03d8cc97";
       libraryHaskellDepends = [
         base bytestring containers enumerator lifted-base monad-control
         network system-fileio system-filepath text transformers
         uri-enumerator
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/xml";
       description = "uri-enumerator backend for the file scheme (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uri-template" = callPackage
    ({ mkDerivation, base, containers, utf8-string }:
     mkDerivation {
       pname = "uri-template";
       version = "0.2";
       sha256 = "f4d23fc3f026409071653c52b7e90df7788d6626129c33b96f9cab25abc732f8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers utf8-string ];
       executableHaskellDepends = [ base ];
       description = "URI template library for Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uri-templater" = callPackage
    ({ mkDerivation, ansi-wl-pprint, base, charset, containers, dlist
     , HTTP, HUnit, mtl, parsers, template-haskell, text, trifecta
     , unordered-containers, vector
     }:
     mkDerivation {
       pname = "uri-templater";
       version = "0.2.0.0";
       sha256 = "ba1c40d5c4cfc904ec355c0a179b38a4eebb9cd453b2d803df4fbaf37789fe7a";
       libraryHaskellDepends = [
         ansi-wl-pprint base charset containers dlist HTTP mtl parsers
         template-haskell text trifecta unordered-containers vector
       ];
       testHaskellDepends = [
         ansi-wl-pprint base HUnit mtl template-haskell
       ];
       homepage = "http://github.com/sanetracker/uri-templater";
       description = "Parsing & Quasiquoting for RFC 6570 URI Templates";
       license = stdenv.lib.licenses.mit;
     }) {};

  "url" = callPackage
    ({ mkDerivation, base, utf8-string }:
     mkDerivation {
       pname = "url";
       version = "2.1.3";
       sha256 = "5af27e3f8c0a27e52d0dcb98ef06a0fdd01efe8bb21242c29432e1bc380a4f61";
       libraryHaskellDepends = [ base utf8-string ];
       homepage = "http://www.haskell.org/haskellwiki/Url";
       description = "A library for working with URLs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "url-generic" = callPackage
    ({ mkDerivation, base, mtl, syb }:
     mkDerivation {
       pname = "url-generic";
       version = "0.1";
       sha256 = "b5f00a65dcc190b8685a0e203cc98f0433593e895dd664cfeaf31806adf0cc79";
       revision = "1";
       editedCabalFile = "d9926e2ce6433a73b2ba940d476f7046890752c8a1145b42a78561e8d3ff6fb9";
       libraryHaskellDepends = [ base mtl syb ];
       description = "Parse/format generic key/value URLs from record data types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "urlcheck" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, network
     , old-time
     }:
     mkDerivation {
       pname = "urlcheck";
       version = "0.1.1";
       sha256 = "31a3e5930c16e438cda6997e180c5bfcbccc168880542777bf8981d5eea5add5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers mtl network old-time
       ];
       homepage = "http://code.haskell.org/~dons/code/urlcheck";
       description = "Parallel link checker";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "urldecode" = callPackage
    ({ mkDerivation, base, network }:
     mkDerivation {
       pname = "urldecode";
       version = "1.0.0.2";
       sha256 = "7e60488c514cd12f3b6057eb024f574a2f3c262d8db14f5eb60ca3a303b9d18d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base network ];
       homepage = "https://github.com/beastaugh/urldecode";
       description = "Decode percent-encoded strings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "urldisp-happstack" = callPackage
    ({ mkDerivation, base, bytestring, happstack-server, mtl }:
     mkDerivation {
       pname = "urldisp-happstack";
       version = "0.1";
       sha256 = "48292f305203c2e589f53c27db412bdc61564c331838cb3c9756577b0b2fe2cd";
       libraryHaskellDepends = [ base bytestring happstack-server mtl ];
       description = "Simple, declarative, expressive URL routing -- on happstack";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "urlencoded" = callPackage
    ({ mkDerivation, base, mtl, network, network-uri, split }:
     mkDerivation {
       pname = "urlencoded";
       version = "0.4.1";
       sha256 = "91431808fc26a7a9d2d18100c93c8b0a815de519e33547e8f60da9ed66976799";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl network network-uri split ];
       homepage = "https://github.com/pheaver/urlencoded";
       description = "Generate or process x-www-urlencoded data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "urlpath_2_1_0" = callPackage
    ({ mkDerivation, base, hspec, monoid-subclasses, mtl, QuickCheck
     , quickcheck-instances, text, transformers
     }:
     mkDerivation {
       pname = "urlpath";
       version = "2.1.0";
       sha256 = "096326af70334a620ce235200b598f889203e235fb3d9047ae3d598a84901fe1";
       revision = "1";
       editedCabalFile = "a342b25d9ea3984cf20025d421f59629d7abdf4bd2b42a4e9ef53ba5729f13e1";
       libraryHaskellDepends = [
         base monoid-subclasses mtl transformers
       ];
       testHaskellDepends = [
         base hspec monoid-subclasses mtl QuickCheck quickcheck-instances
         text transformers
       ];
       description = "Painfully simple URL writing combinators";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "urlpath" = callPackage
    ({ mkDerivation, base, exceptions, mmorph, monad-control
     , monad-logger, mtl, path-extra, resourcet, transformers
     , transformers-base
     }:
     mkDerivation {
       pname = "urlpath";
       version = "5.0.0.1";
       sha256 = "03ee80654c36609bb82df91278ec081c3bb415b46f9bb54b9d76fc2fbd587ce3";
       libraryHaskellDepends = [
         base exceptions mmorph monad-control monad-logger mtl path-extra
         resourcet transformers transformers-base
       ];
       description = "Painfully simple URL deployment";
       license = stdenv.lib.licenses.mit;
     }) {};

  "urn" = callPackage
    ({ mkDerivation, base, hspec, parsec }:
     mkDerivation {
       pname = "urn";
       version = "0.1.0.0";
       sha256 = "079adeb93b604e50f80f58344010510fd112721d5dae714ef2d47d5b08c1aff3";
       libraryHaskellDepends = [ base parsec ];
       testHaskellDepends = [ base hspec ];
       jailbreak = true;
       homepage = "https://github.com/pxqr/urn";
       description = "Universal Resource Names";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "urxml" = callPackage
    ({ mkDerivation, base, filepath, mtl, optparse-applicative, parsec
     , process, syb
     }:
     mkDerivation {
       pname = "urxml";
       version = "0.2.0.0";
       sha256 = "89be4d77b9af70959f8778649378df005712a8eea3e65136c539ae8b61132b90";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base filepath mtl optparse-applicative parsec process syb
       ];
       jailbreak = true;
       homepage = "http://github.com/grwlf/urxml";
       description = "XML parser-printer supporting Ur/Web syntax extensions";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "usb" = callPackage
    ({ mkDerivation, base, bindings-libusb, bytestring, containers
     , ghc-prim, text, vector
     }:
     mkDerivation {
       pname = "usb";
       version = "1.3.0.3";
       sha256 = "ce9bc0ab71dd0cc645a52b72c19a4055c21b667347ad476ccf93d91b4c3fc172";
       libraryHaskellDepends = [
         base bindings-libusb bytestring containers ghc-prim text vector
       ];
       jailbreak = true;
       homepage = "http://basvandijk.github.com/usb";
       description = "Communicate with USB devices";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "usb-enumerator" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, bindings-libusb
     , iteratee, monad-control, transformers, usb
     }:
     mkDerivation {
       pname = "usb-enumerator";
       version = "0.3";
       sha256 = "da591186a1061b96e16829de7dfa18adb97f61e8b5859746410a33a8af18a1bd";
       libraryHaskellDepends = [
         base base-unicode-symbols bindings-libusb iteratee monad-control
         transformers usb
       ];
       jailbreak = true;
       description = "Iteratee enumerators for the usb package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "usb-hid" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, usb }:
     mkDerivation {
       pname = "usb-hid";
       version = "0.1.0.0";
       sha256 = "f0a5a13db5bfa121b4989ecf8232295d478ca231d17ea663622881997f70a457";
       revision = "1";
       editedCabalFile = "3fe150e203f72b72c425bef276254a2ca91ca40cab21f6088838bb32c806e8dc";
       libraryHaskellDepends = [ attoparsec base bytestring usb ];
       jailbreak = true;
       homepage = "https://github.com/mapinguari/usb-hid";
       description = "Parser and request Library for USB HIDs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "usb-id-database" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, bytestring, containers
     , containers-unicode-symbols, parsimony
     }:
     mkDerivation {
       pname = "usb-id-database";
       version = "0.4.0.9";
       sha256 = "4187f776f53c50423e1064753c0bf5446db871a6a4113ec8d970d24a5ffe26ca";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base-unicode-symbols bytestring containers
         containers-unicode-symbols parsimony
       ];
       homepage = "https://github.com/roelvandijk/usb-id-database";
       description = "A database of USB identifiers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "usb-iteratee" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, bindings-libusb
     , iteratee, monad-control, usb, vector
     }:
     mkDerivation {
       pname = "usb-iteratee";
       version = "0.5";
       sha256 = "e11c0986019f12f8d962c6784607c1697140dce3d5dc32c232a411c1dd157b12";
       libraryHaskellDepends = [
         base base-unicode-symbols bindings-libusb iteratee monad-control
         usb vector
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/usb-iteratee";
       description = "Iteratee enumerators for the usb package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "usb-safe" = callPackage
    ({ mkDerivation, base, base-unicode-symbols, bindings-libusb
     , bytestring, iteratee, regions, text, transformers, usb
     }:
     mkDerivation {
       pname = "usb-safe";
       version = "0.14";
       sha256 = "d5fd06794cc283899818e4c0a7b198a68591154011744d6b238009478e3f1db6";
       libraryHaskellDepends = [
         base base-unicode-symbols bindings-libusb bytestring iteratee
         regions text transformers usb
       ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/usb-safe/";
       description = "Type-safe communication with USB devices";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "userid_0_1_2_3" = callPackage
    ({ mkDerivation, aeson, base, boomerang, lens, safecopy, web-routes
     , web-routes-th
     }:
     mkDerivation {
       pname = "userid";
       version = "0.1.2.3";
       sha256 = "7d1e9e276ff47ec4717d74432075c568b6859388c8a74057f3efa1a9e80106a3";
       libraryHaskellDepends = [
         aeson base boomerang lens safecopy web-routes web-routes-th
       ];
       homepage = "http://www.github.com/Happstack/userid";
       description = "The UserId type and useful instances for web development";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "userid" = callPackage
    ({ mkDerivation, aeson, base, boomerang, lens, safecopy, web-routes
     , web-routes-th
     }:
     mkDerivation {
       pname = "userid";
       version = "0.1.2.4";
       sha256 = "f4f0e89d43046408b0083a18030af0fb33a23603874efa0763caf1cf28ce6b5b";
       libraryHaskellDepends = [
         aeson base boomerang lens safecopy web-routes web-routes-th
       ];
       homepage = "http://www.github.com/Happstack/userid";
       description = "The UserId type and useful instances for web development";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "users_0_1_0_0" = callPackage
    ({ mkDerivation, aeson, base, path-pieces, text, time }:
     mkDerivation {
       pname = "users";
       version = "0.1.0.0";
       sha256 = "18cb1689dc198f8302ed1d35e612c539e8c1f2d70255585a706ccfa6895c7eeb";
       libraryHaskellDepends = [ aeson base path-pieces text time ];
       homepage = "https://github.com/agrafix/users";
       description = "A library simplifying user management for web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "users_0_3_0_0" = callPackage
    ({ mkDerivation, aeson, base, bcrypt, path-pieces, text, time }:
     mkDerivation {
       pname = "users";
       version = "0.3.0.0";
       sha256 = "6afe602c74368b138608d032172bb0d41f8d99c5710ff3dfb89ee5ee8610c3b8";
       libraryHaskellDepends = [
         aeson base bcrypt path-pieces text time
       ];
       homepage = "https://github.com/agrafix/users";
       description = "A library simplifying user management for web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "users" = callPackage
    ({ mkDerivation, aeson, base, bcrypt, path-pieces, text, time }:
     mkDerivation {
       pname = "users";
       version = "0.4.0.0";
       sha256 = "3e4e213090756e04667872fe41872d0af842949087240237298152d72c569f3f";
       libraryHaskellDepends = [
         aeson base bcrypt path-pieces text time
       ];
       homepage = "https://github.com/agrafix/users";
       description = "A library simplifying user management for web applications";
       license = stdenv.lib.licenses.mit;
     }) {};

  "users-persistent_0_3_0_0" = callPackage
    ({ mkDerivation, aeson, base, bytestring, hspec, monad-logger, mtl
     , persistent, persistent-sqlite, persistent-template, temporary
     , text, time, users, users-test, uuid
     }:
     mkDerivation {
       pname = "users-persistent";
       version = "0.3.0.0";
       sha256 = "b946599417ad1e5bfafbcbbdfa8069706857aac165d3f2f5336af0c8a4d5bb41";
       libraryHaskellDepends = [
         aeson base bytestring mtl persistent persistent-template text time
         users uuid
       ];
       testHaskellDepends = [
         base hspec monad-logger persistent-sqlite temporary text users-test
       ];
       doCheck = false;
       homepage = "https://github.com/agrafix/users";
       description = "A persistent backend for the users package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "users-persistent" = callPackage
    ({ mkDerivation, aeson, base, bytestring, hspec, monad-logger, mtl
     , persistent, persistent-sqlite, persistent-template, temporary
     , text, time, transformers, users, users-test, uuid
     }:
     mkDerivation {
       pname = "users-persistent";
       version = "0.4.0.0";
       sha256 = "bbf67ade5bfffaa6490e3f221717e489caa684d506a81139a221ab1589cf6347";
       libraryHaskellDepends = [
         aeson base bytestring mtl persistent persistent-template text time
         transformers users uuid
       ];
       testHaskellDepends = [
         base hspec monad-logger persistent-sqlite temporary text users-test
       ];
       doCheck = false;
       homepage = "https://github.com/agrafix/users";
       description = "A persistent backend for the users package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "users-postgresql-simple_0_1_0_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, hspec, mtl
     , postgresql-simple, text, time, users, users-test, uuid
     }:
     mkDerivation {
       pname = "users-postgresql-simple";
       version = "0.1.0.1";
       sha256 = "9316f6b1f22ee6ee9ba84324eec6e4cc08aef7733cf68cf3e928a55307ac0dcc";
       libraryHaskellDepends = [
         aeson base bytestring mtl postgresql-simple text time users uuid
       ];
       testHaskellDepends = [ base hspec postgresql-simple users-test ];
       doCheck = false;
       homepage = "https://github.com/agrafix/users";
       description = "A PostgreSQL backend for the users package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "users-postgresql-simple_0_3_0_0" = callPackage
    ({ mkDerivation, aeson, base, bytestring, hspec, mtl
     , postgresql-simple, text, time, users, users-test, uuid
     }:
     mkDerivation {
       pname = "users-postgresql-simple";
       version = "0.3.0.0";
       sha256 = "f9fb605fc0854a63df9838ca7b4f63ededb4589f1896766979b231b9b3512d0d";
       libraryHaskellDepends = [
         aeson base bytestring mtl postgresql-simple text time users uuid
       ];
       testHaskellDepends = [ base hspec postgresql-simple users-test ];
       doCheck = false;
       homepage = "https://github.com/agrafix/users";
       description = "A PostgreSQL backend for the users package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "users-postgresql-simple" = callPackage
    ({ mkDerivation, aeson, base, bytestring, hspec, mtl
     , postgresql-simple, text, time, users, users-test, uuid
     }:
     mkDerivation {
       pname = "users-postgresql-simple";
       version = "0.4.0.0";
       sha256 = "953b326d097edd95ddf5d47832dc392ee70631dfeab38a076556d66a20b26859";
       libraryHaskellDepends = [
         aeson base bytestring mtl postgresql-simple text time users uuid
       ];
       testHaskellDepends = [ base hspec postgresql-simple users-test ];
       doCheck = false;
       homepage = "https://github.com/agrafix/users";
       description = "A PostgreSQL backend for the users package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "users-test_0_1_0_0" = callPackage
    ({ mkDerivation, aeson, base, hspec, text, users }:
     mkDerivation {
       pname = "users-test";
       version = "0.1.0.0";
       sha256 = "a6c6b72cabd164c33e0ef16db7257d4ab1ac4c9f3976830411b7495a64427364";
       libraryHaskellDepends = [ aeson base hspec text users ];
       homepage = "https://github.com/agrafix/users";
       description = "Library to test backends for the users library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "users-test_0_3_0_0" = callPackage
    ({ mkDerivation, aeson, base, hspec, text, users }:
     mkDerivation {
       pname = "users-test";
       version = "0.3.0.0";
       sha256 = "b05b260e390f058af56c639338600e678698c81bbb8de524dab5c5f92268b9b2";
       libraryHaskellDepends = [ aeson base hspec text users ];
       homepage = "https://github.com/agrafix/users";
       description = "Library to test backends for the users library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "users-test" = callPackage
    ({ mkDerivation, aeson, base, hspec, text, users }:
     mkDerivation {
       pname = "users-test";
       version = "0.4.0.0";
       sha256 = "d1f122a3b7876c16fa0a72a644b0c3f016a25fbcd10e04efb2eedd04730c5136";
       libraryHaskellDepends = [ aeson base hspec text users ];
       homepage = "https://github.com/agrafix/users";
       description = "Library to test backends for the users library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "utc" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, Cabal, clock
     , exceptions, QuickCheck, test-framework
     , test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "utc";
       version = "0.2.0.1";
       sha256 = "b0ecedcb32c552a4a5bcbc0d634b6b2dd1cc40a269edc4790d7082bda56cde6e";
       libraryHaskellDepends = [
         attoparsec base bytestring clock exceptions text
       ];
       testHaskellDepends = [
         attoparsec base bytestring Cabal clock exceptions QuickCheck
         test-framework test-framework-quickcheck2 text
       ];
       jailbreak = true;
       homepage = "https://github.com/lpeterse/haskell-utc";
       description = "A pragmatic time and date library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "utf8-env" = callPackage
    ({ mkDerivation, base, mtl, utf8-string }:
     mkDerivation {
       pname = "utf8-env";
       version = "0.1";
       sha256 = "f78bd3c06d545c5fa9b8ad8b86e7dc9d33f7c2d5601caf5aa82f8a6085a64253";
       libraryHaskellDepends = [ base mtl utf8-string ];
       description = "UTF-8 aware substitutes for functions in System.Environment";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "utf8-light" = callPackage
    ({ mkDerivation, base, bytestring, ghc-prim }:
     mkDerivation {
       pname = "utf8-light";
       version = "0.4.2";
       sha256 = "184c428ce7896d702da46f6f107e6873ff100dbc1af40b49b5ce87317e619e67";
       libraryHaskellDepends = [ base bytestring ghc-prim ];
       description = "Unicode";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "utf8-prelude" = callPackage
    ({ mkDerivation, base, utf8-string }:
     mkDerivation {
       pname = "utf8-prelude";
       version = "0.1.6";
       sha256 = "66170599fe057fb42b2577b6fe25d3ecf7c5f14455d3ac81015f00d58695d394";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base utf8-string ];
       jailbreak = true;
       description = "Variants of Prelude and System.IO with UTF8 text I/O operations";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "utf8-string_0_3_8" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "utf8-string";
       version = "0.3.8";
       sha256 = "80757cbc00197ff71311dc8c1ca00284537442c2dc93f06685d369a6816d49c0";
       revision = "2";
       editedCabalFile = "0555d720026fff65342bdc500391ffd300858b6f2c6db441d4dd1eafbcb599ff";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://github.com/glguy/utf8-string/";
       description = "Support for reading and writing UTF8 Strings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "utf8-string_1" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "utf8-string";
       version = "1";
       sha256 = "79f388d3f089e0c483c1dc1afad524b06f1abb6e288ed9029f934cffb3b2ba08";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://github.com/glguy/utf8-string/";
       description = "Support for reading and writing UTF8 Strings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "utf8-string_1_0_1" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "utf8-string";
       version = "1.0.1";
       sha256 = "ecaca87785e52727c7ae6b6f3f8a79ef5799c5ae1092e78264cee01d04b3e596";
       revision = "1";
       editedCabalFile = "10b43956d0100ef545047b3dfa62f25d7ba644aa4ad7fae3987c222bc7c1a93b";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://github.com/glguy/utf8-string/";
       description = "Support for reading and writing UTF8 Strings";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "utf8-string" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "utf8-string";
       version = "1.0.1.1";
       sha256 = "fb0b9e3acbe0605bcd1c63e51f290a7bbbe6628dfa3294ff453e4235fbaef140";
       revision = "1";
       editedCabalFile = "a351111265dd7d3a76113c938d4d3b0b2ba5b17e071f77e5a29fc86e91ee8396";
       libraryHaskellDepends = [ base bytestring ];
       homepage = "http://github.com/glguy/utf8-string/";
       description = "Support for reading and writing UTF8 Strings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "utility-ht" = callPackage
    ({ mkDerivation, base, QuickCheck }:
     mkDerivation {
       pname = "utility-ht";
       version = "0.0.11";
       sha256 = "5cdcc5c1eab4029d18f1712472d69b61265c2d543a8065e1e9762b1ddc235812";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base QuickCheck ];
       description = "Various small helper functions for Lists, Maybes, Tuples, Functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uu-cco" = callPackage
    ({ mkDerivation, ansi-terminal, base }:
     mkDerivation {
       pname = "uu-cco";
       version = "0.1.0.5";
       sha256 = "cd64659a673dbea93892d8e418ababdbe41e1b9abb1a6a662a091896a99e0c01";
       libraryHaskellDepends = [ ansi-terminal base ];
       homepage = "https://github.com/UU-ComputerScience/uu-cco";
       description = "Utilities for compiler construction: core functionality";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uu-cco-examples" = callPackage
    ({ mkDerivation, base, uu-cco, uuagc, uuagc-cabal }:
     mkDerivation {
       pname = "uu-cco-examples";
       version = "0.1.0.1";
       sha256 = "448012cc33c7c819f253f972002c4e55b25756c2d4884163a0500083176b11c5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base uu-cco uuagc uuagc-cabal ];
       homepage = "https://github.com/UU-ComputerScience/uu-cco";
       description = "Utilities for compiler construction: example programs";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uu-cco-hut-parsing" = callPackage
    ({ mkDerivation, base, uu-cco, uulib }:
     mkDerivation {
       pname = "uu-cco-hut-parsing";
       version = "0.1.0.1";
       sha256 = "fd826e15a54388e323a2f3714d7aaf2c6b4df7449dddd7fe5f1ff8cd9c80ad19";
       libraryHaskellDepends = [ base uu-cco uulib ];
       homepage = "https://github.com/UU-ComputerScience/uu-cco";
       description = "Utilities for compiler construction: Feedback wrapper around parser in uulib";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uu-cco-uu-parsinglib" = callPackage
    ({ mkDerivation, base, ListLike, uu-cco, uu-parsinglib }:
     mkDerivation {
       pname = "uu-cco-uu-parsinglib";
       version = "0.1.0.1";
       sha256 = "e1fc313c2c3cc24cbe4f85bee132c7daf5686f1d2c4450617ebd79b030b550eb";
       libraryHaskellDepends = [ base ListLike uu-cco uu-parsinglib ];
       homepage = "https://github.com/UU-ComputerScience/uu-cco";
       description = "Utilities for compiler construction: Feedback wrapper around parser in uu-parsinglib";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uu-interleaved" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "uu-interleaved";
       version = "0.2.0.0";
       sha256 = "3195ec570e94beb3b42d882940d9518bddb66ab6a27895d21a046769d055dae7";
       libraryHaskellDepends = [ base ];
       homepage = "http://www.cs.uu.nl/wiki/bin/view/HUT/ParserCombinators";
       description = "Providing an interleaving combinator for use with applicative/alternative style implementations";
       license = stdenv.lib.licenses.mit;
     }) {};

  "uu-options" = callPackage
    ({ mkDerivation, base, lenses, mtl, template-haskell, transformers
     , uu-interleaved, uu-parsinglib
     }:
     mkDerivation {
       pname = "uu-options";
       version = "0.2.0.0";
       sha256 = "46c6907807a5d8213047b7c3d43eadf086336d5154a61c7b6353e94ecdecf185";
       libraryHaskellDepends = [
         base lenses mtl template-haskell transformers uu-interleaved
         uu-parsinglib
       ];
       homepage = "http://www.cs.uu.nl/wiki/bin/view/HUT/ParserCombinators";
       description = "Parse command line options using uu-interleave and uu-parsinglib";
       license = stdenv.lib.licenses.mit;
     }) {};

  "uu-parsinglib" = callPackage
    ({ mkDerivation, base, ListLike, time, uu-interleaved }:
     mkDerivation {
       pname = "uu-parsinglib";
       version = "2.9.1";
       sha256 = "0d9c0fa5a8d9fcce596cc46c7caff3c19313eedc5ec641a216d6a8848c032c32";
       libraryHaskellDepends = [ base ListLike time uu-interleaved ];
       homepage = "http://www.cs.uu.nl/wiki/bin/view/HUT/ParserCombinators";
       description = "Fast, online, error-correcting, monadic, applicative, merging, permuting, interleaving, idiomatic parser combinators";
       license = stdenv.lib.licenses.mit;
     }) {};

  "uu-tc" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "uu-tc";
       version = "2015.1.1";
       sha256 = "8f82237e6fd473dd6702e22fb48b3f14ca6c9fe0fe2d4e1b0e1f6756e3d1a70f";
       libraryHaskellDepends = [ base ];
       description = "Haskell 98 parser combintors for INFOB3TC at Utrecht University";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uuagc" = callPackage
    ({ mkDerivation, array, base, containers, directory, filepath
     , ghc-prim, haskell-src-exts, mtl, uuagc-cabal, uulib
     }:
     mkDerivation {
       pname = "uuagc";
       version = "0.9.52.1";
       sha256 = "98092b13cb32e4493e877c3752deed471db762f04e7d979be4e6e89065502185";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers directory filepath ghc-prim haskell-src-exts
         mtl uuagc-cabal uulib
       ];
       executableHaskellDepends = [ base uuagc-cabal ];
       homepage = "http://www.cs.uu.nl/wiki/HUT/WebHome";
       description = "Attribute Grammar System of Universiteit Utrecht";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uuagc-bootstrap" = callPackage
    ({ mkDerivation, array, base, containers, directory, filepath
     , ghc-prim, haskell-src-exts, mtl, uulib
     }:
     mkDerivation {
       pname = "uuagc-bootstrap";
       version = "0.9.40.2";
       sha256 = "b83bcb9466026f1edaa396fd28efadff373066bb50a471a546fef42ffe454b7f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers directory filepath ghc-prim haskell-src-exts
         mtl uulib
       ];
       executableHaskellDepends = [
         array base containers directory filepath ghc-prim haskell-src-exts
         mtl uulib
       ];
       homepage = "http://www.cs.uu.nl/wiki/HUT/WebHome";
       description = "Attribute Grammar System of Universiteit Utrecht";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uuagc-cabal" = callPackage
    ({ mkDerivation, base, Cabal, containers, directory, filepath, mtl
     , process, uulib
     }:
     mkDerivation {
       pname = "uuagc-cabal";
       version = "1.0.6.0";
       sha256 = "dcc87f9e738cbd5228e91f433b69ac540ab1f109c522da290539c2f33791b80b";
       libraryHaskellDepends = [
         base Cabal containers directory filepath mtl process uulib
       ];
       homepage = "http://www.cs.uu.nl/wiki/HUT/WebHome";
       description = "Cabal plugin for the Universiteit Utrecht Attribute Grammar System";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uuagc-diagrams" = callPackage
    ({ mkDerivation, base, diagrams-lib, SVGFonts }:
     mkDerivation {
       pname = "uuagc-diagrams";
       version = "0.1.1.0";
       sha256 = "bf5a6797c6127e71ec35900b3edc96f50957c2c376e4dbaa1a51f727d7244e9b";
       libraryHaskellDepends = [ base diagrams-lib SVGFonts ];
       jailbreak = true;
       description = "Utility for drawing attribute grammar pictures with the diagrams package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uuagd" = callPackage
    ({ mkDerivation, base, blaze-html, process }:
     mkDerivation {
       pname = "uuagd";
       version = "0.1.0.2";
       sha256 = "8aeaddb8286d15ce54b4e495829e49946629b785d8bd5b722d5d6488d6b79fbd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base blaze-html ];
       executableHaskellDepends = [ base process ];
       homepage = "https://github.com/matthijssteen/uuagd";
       description = "A debugger for the UUAG system";
       license = "unknown";
     }) {};

  "uuid_1_3_5" = callPackage
    ({ mkDerivation, base, binary, bytestring, cryptohash, deepseq
     , hashable, HUnit, network-info, QuickCheck, random, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time
     }:
     mkDerivation {
       pname = "uuid";
       version = "1.3.5";
       sha256 = "098bb14920900eefcbd20bacb12da2ef04136cdbb81026888a6536855d5274dd";
       libraryHaskellDepends = [
         base binary bytestring cryptohash deepseq hashable network-info
         random time
       ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck random test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/uuid/";
       description = "For creating, comparing, parsing and printing Universally Unique Identifiers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uuid_1_3_6" = callPackage
    ({ mkDerivation, base, binary, bytestring, cryptohash, deepseq
     , hashable, HUnit, network-info, QuickCheck, random, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time
     }:
     mkDerivation {
       pname = "uuid";
       version = "1.3.6";
       sha256 = "efe930e86e4b18a5e1ed956c823b7da81c67b818d72c54119a4e5f693abb8e52";
       libraryHaskellDepends = [
         base binary bytestring cryptohash deepseq hashable network-info
         random time
       ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck random test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/aslatter/uuid";
       description = "For creating, comparing, parsing and printing Universally Unique Identifiers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uuid_1_3_7" = callPackage
    ({ mkDerivation, base, binary, bytestring, cryptohash, deepseq
     , hashable, HUnit, network-info, QuickCheck, random, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time
     }:
     mkDerivation {
       pname = "uuid";
       version = "1.3.7";
       sha256 = "41a816103a34474114fcd6ff0cb2e8a4c369fe5d4039fba6439fd5b653742d06";
       libraryHaskellDepends = [
         base binary bytestring cryptohash deepseq hashable network-info
         random time
       ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck random test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/aslatter/uuid";
       description = "For creating, comparing, parsing and printing Universally Unique Identifiers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uuid_1_3_8" = callPackage
    ({ mkDerivation, base, binary, bytestring, cryptohash, deepseq
     , hashable, HUnit, network-info, QuickCheck, random, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time
     }:
     mkDerivation {
       pname = "uuid";
       version = "1.3.8";
       sha256 = "668541762d32cc69d5d8bd72535a81553154c8aafda61cc4c1d0d32ece31f81c";
       libraryHaskellDepends = [
         base binary bytestring cryptohash deepseq hashable network-info
         random time
       ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck random test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/aslatter/uuid";
       description = "For creating, comparing, parsing and printing Universally Unique Identifiers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uuid_1_3_9" = callPackage
    ({ mkDerivation, base, binary, bytestring, cryptohash, HUnit
     , network-info, QuickCheck, random, test-framework
     , test-framework-hunit, test-framework-quickcheck2, time
     , uuid-types
     }:
     mkDerivation {
       pname = "uuid";
       version = "1.3.9";
       sha256 = "deb2cab7e17bac6d16861ff981ff5aa17ff5367394c084f131b26bf02a93ead9";
       libraryHaskellDepends = [
         base binary bytestring cryptohash network-info random time
         uuid-types
       ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck random test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/aslatter/uuid";
       description = "For creating, comparing, parsing and printing Universally Unique Identifiers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uuid_1_3_10" = callPackage
    ({ mkDerivation, base, binary, bytestring, cryptohash, HUnit
     , network-info, QuickCheck, random, tasty, tasty-hunit
     , tasty-quickcheck, time, uuid-types
     }:
     mkDerivation {
       pname = "uuid";
       version = "1.3.10";
       sha256 = "7efb8d975db3d5496e7ef800cc70d74a0a7254df385ef29465c8b79f91175833";
       libraryHaskellDepends = [
         base binary bytestring cryptohash network-info random time
         uuid-types
       ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck random tasty tasty-hunit
         tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "https://github.com/aslatter/uuid";
       description = "For creating, comparing, parsing and printing Universally Unique Identifiers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uuid" = callPackage
    ({ mkDerivation, base, binary, bytestring, cryptohash, HUnit
     , network-info, QuickCheck, random, tasty, tasty-hunit
     , tasty-quickcheck, text, time, uuid-types
     }:
     mkDerivation {
       pname = "uuid";
       version = "1.3.11";
       sha256 = "671876d2f848c9155bfe661eb138d585897ab5b0a2f2e143ef85114d459814d5";
       libraryHaskellDepends = [
         base binary bytestring cryptohash network-info random text time
         uuid-types
       ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck random tasty tasty-hunit
         tasty-quickcheck
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/aslatter/uuid";
       description = "For creating, comparing, parsing and printing Universally Unique Identifiers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uuid-aeson" = callPackage
    ({ mkDerivation, aeson, base, text, uuid }:
     mkDerivation {
       pname = "uuid-aeson";
       version = "0.1.0.0";
       sha256 = "cf8bdb82959d249ced20dff22935bd2ea79b1869267a95ebcacc7f0452eda259";
       libraryHaskellDepends = [ aeson base text uuid ];
       description = "Aeson types for UUID instances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uuid-le" = callPackage
    ({ mkDerivation, base, bytestring, uuid }:
     mkDerivation {
       pname = "uuid-le";
       version = "0.2014.1";
       sha256 = "e45cfed1a7cf0f42074700896ec6e5362ca0721822b7d1898565895cfb3ad5bd";
       libraryHaskellDepends = [ base bytestring uuid ];
       description = "Universally Unique Identifiers with little-endian-ish encoding tools";
       license = stdenv.lib.licenses.mit;
     }) {};

  "uuid-orphans" = callPackage
    ({ mkDerivation, base, safecopy, text, uuid-types, web-routes }:
     mkDerivation {
       pname = "uuid-orphans";
       version = "1.3.11.1";
       sha256 = "264028379dc6bfea1d84ebd6c745d666c51957430822b52480dd6413717a8b75";
       libraryHaskellDepends = [
         base safecopy text uuid-types web-routes
       ];
       description = "Orphan instances for the UUID datatype";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uuid-quasi" = callPackage
    ({ mkDerivation, base, template-haskell, uuid }:
     mkDerivation {
       pname = "uuid-quasi";
       version = "0.1.0.1";
       sha256 = "f28a1c03cf1641f2be9b26f20ca5b6606117bc1f14c3d7955558d92fe4b23226";
       libraryHaskellDepends = [ base template-haskell uuid ];
       homepage = "http://github.com/lpeterse/uuid-quasi";
       description = "Supplemental package for 'uuid' allowing quasiquotation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uuid-types_1_0_0" = callPackage
    ({ mkDerivation, base, binary, bytestring, deepseq, hashable, HUnit
     , QuickCheck, random, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "uuid-types";
       version = "1.0.0";
       sha256 = "986eaf295f20853437448f18a38a0b05af547326190d9e1576459de656c3b225";
       libraryHaskellDepends = [
         base binary bytestring deepseq hashable random
       ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       jailbreak = true;
       homepage = "https://github.com/aslatter/uuid";
       description = "Type definitions for Universally Unique Identifiers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uuid-types_1_0_1" = callPackage
    ({ mkDerivation, base, binary, bytestring, deepseq, hashable, HUnit
     , QuickCheck, random, tasty, tasty-hunit, tasty-quickcheck
     }:
     mkDerivation {
       pname = "uuid-types";
       version = "1.0.1";
       sha256 = "4b1e7f72892249195cb29a5b85b4e8ac75a5b278711a74b01eadde816dd03caf";
       libraryHaskellDepends = [
         base binary bytestring deepseq hashable random
       ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "https://github.com/aslatter/uuid";
       description = "Type definitions for Universally Unique Identifiers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uuid-types" = callPackage
    ({ mkDerivation, base, binary, bytestring, deepseq, hashable, HUnit
     , QuickCheck, random, tasty, tasty-hunit, tasty-quickcheck, text
     }:
     mkDerivation {
       pname = "uuid-types";
       version = "1.0.2";
       sha256 = "56c6e9d6c05f30461419d2c3b90ef7e5f2fb8dd51c09846b5f4ce12d034f2e05";
       libraryHaskellDepends = [
         base binary bytestring deepseq hashable random text
       ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/aslatter/uuid";
       description = "Type definitions for Universally Unique Identifiers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uulib" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "uulib";
       version = "0.9.22";
       sha256 = "cdd0a15d33834e367e2b9d9a6b78cb17e1947e31c7d2d26344a144bf3ab131ad";
       libraryHaskellDepends = [ base ghc-prim ];
       homepage = "https://github.com/UU-ComputerScience/uulib";
       description = "Haskell Utrecht Tools Library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "uvector" = callPackage
    ({ mkDerivation, base, ghc-prim }:
     mkDerivation {
       pname = "uvector";
       version = "0.1.1.1";
       sha256 = "08c42d9a31df299c2aa8e0e21e2c1077fc3bf9e755449b3243225b20b06e4bdf";
       revision = "1";
       editedCabalFile = "e289ff93c365248deb93e6268b57be8a47d724a39702887979fd842c80577508";
       libraryHaskellDepends = [ base ghc-prim ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~dons/code/uvector";
       description = "Fast unboxed arrays with a flexible interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uvector-algorithms" = callPackage
    ({ mkDerivation, base, uvector }:
     mkDerivation {
       pname = "uvector-algorithms";
       version = "0.2";
       sha256 = "01411922955d572c2fb44cd3c465769507bf7dff424c01e0c0f99dac728ef44b";
       libraryHaskellDepends = [ base uvector ];
       homepage = "http://code.haskell.org/~dolio/";
       description = "Efficient algorithms for uvector unboxed arrays";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "uxadt" = callPackage
    ({ mkDerivation, base, json, MissingH, mtl }:
     mkDerivation {
       pname = "uxadt";
       version = "0.0.16.0";
       sha256 = "833496d8e31b16939c187ff3c68b12546dc91d72597126d0104a96c7c92cb762";
       libraryHaskellDepends = [ base json MissingH mtl ];
       description = "Cross-language extensible representation for algebraic data type instances";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "uzbl-with-source" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "uzbl-with-source";
       version = "0.1.0.0";
       sha256 = "8a262a20f5a376572d3ec152890384a4babbec729ab7d7e64b03a987270ad660";
       libraryHaskellDepends = [ base process ];
       homepage = "http://github.com/Fuuzetsu/uzbl-with-source";
       description = "Utility function for reading a source of loaded uzbl pages";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "v4l2" = callPackage
    ({ mkDerivation, base, bindings-DSL, bindings-libv4l2
     , bindings-linux-videodev2, bindings-posix, containers, ioctl
     }:
     mkDerivation {
       pname = "v4l2";
       version = "0.1.0.3";
       sha256 = "f7e99865dca5420f64a96a953e683e3b5ff3095069db77c1f733b04825bd0dc2";
       libraryHaskellDepends = [
         base bindings-DSL bindings-libv4l2 bindings-linux-videodev2
         bindings-posix containers ioctl
       ];
       homepage = "https://gitorious.org/hsv4l2";
       description = "interface to Video For Linux Two (V4L2)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "v4l2-examples" = callPackage
    ({ mkDerivation, base, GLUT, v4l2 }:
     mkDerivation {
       pname = "v4l2-examples";
       version = "0.1.0.2";
       sha256 = "858688aadb1a80b415dde721704120c406739ec3f0201793d53bccbd1723d6ce";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base GLUT v4l2 ];
       jailbreak = true;
       homepage = "https://gitorious.org/hsv4l2";
       description = "video for linux two examples";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vacuum" = callPackage
    ({ mkDerivation, array, base, containers, ghc-prim }:
     mkDerivation {
       pname = "vacuum";
       version = "2.2.0.0";
       sha256 = "c15be102d2e4dbf8d289f7811b281e5126cb4e001d41435d33d07da84597fc94";
       libraryHaskellDepends = [ array base containers ghc-prim ];
       homepage = "http://thoughtpolice.github.com/vacuum";
       description = "Graph representation of the GHC heap";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vacuum-cairo" = callPackage
    ({ mkDerivation, base, cairo, deepseq, directory, gtk, pretty
     , process, strict-concurrency, svgcairo, vacuum
     }:
     mkDerivation {
       pname = "vacuum-cairo";
       version = "0.5";
       sha256 = "8c538f56a2313bc08911ce81e86d532786d0b972f1a4d5c7632f220183ede34a";
       libraryHaskellDepends = [
         base cairo deepseq directory gtk pretty process strict-concurrency
         svgcairo vacuum
       ];
       homepage = "http://code.haskell.org/~dons/code/vacuum-cairo";
       description = "Visualize live Haskell data structures using vacuum, graphviz and cairo";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vacuum-graphviz" = callPackage
    ({ mkDerivation, base, filepath, graphviz, vacuum }:
     mkDerivation {
       pname = "vacuum-graphviz";
       version = "2.1.0.1";
       sha256 = "552c33f48aa2046caf4853ef84b16c14a33e33286d8d695df4cf2830ac516b24";
       libraryHaskellDepends = [ base filepath graphviz vacuum ];
       jailbreak = true;
       description = "A library for transforming vacuum graphs into GraphViz output";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vacuum-opengl" = callPackage
    ({ mkDerivation, base, bitmap, bitmap-opengl, directory, filepath
     , GLUT, network, OpenGL, pretty, process, stb-image, vacuum
     }:
     mkDerivation {
       pname = "vacuum-opengl";
       version = "0.0.3";
       sha256 = "f2fc00d6572c3d768a38daa6d377c242071593b8f60545e23e2b15b7ae1abcb7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base network pretty vacuum ];
       executableHaskellDepends = [
         base bitmap bitmap-opengl directory filepath GLUT network OpenGL
         process stb-image
       ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "Visualize live Haskell data structures using vacuum, graphviz and OpenGL";
       license = stdenv.lib.licenses.publicDomain;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vacuum-ubigraph" = callPackage
    ({ mkDerivation, base, containers, hubigraph, vacuum }:
     mkDerivation {
       pname = "vacuum-ubigraph";
       version = "0.2.0.2";
       sha256 = "3f188444086aac662a5e833b490f10a64d4c0939c7379e5b1be688dc0479ea7e";
       libraryHaskellDepends = [ base containers hubigraph vacuum ];
       jailbreak = true;
       description = "Visualize Haskell data structures using vacuum and Ubigraph";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vado" = callPackage
    ({ mkDerivation, attoparsec, base, directory, filepath, process
     , QuickCheck, text
     }:
     mkDerivation {
       pname = "vado";
       version = "0.0.6";
       sha256 = "cc9b6ffa83eaedf2c793a93e47b8341b2f8014382aaae63a46b4028c3e86212c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base directory filepath process text
       ];
       executableHaskellDepends = [
         attoparsec base directory filepath process text
       ];
       testHaskellDepends = [
         attoparsec base directory filepath process QuickCheck text
       ];
       homepage = "https://github.com/hamishmack/vado";
       description = "Runs commands on remote machines using ssh";
       license = stdenv.lib.licenses.mit;
     }) {};

  "valid-names" = callPackage
    ({ mkDerivation, base, containers, MonadRandom }:
     mkDerivation {
       pname = "valid-names";
       version = "0.1.0.1";
       sha256 = "e850ddb908aa6d712acf2cbf695985eae069a2c1f7897782b775cf75cd9af791";
       libraryHaskellDepends = [ base containers MonadRandom ];
       jailbreak = true;
       homepage = "https://i.joelt.io/symbols.html";
       description = "Valid operator/module characters";
       license = stdenv.lib.licenses.mit;
     }) {};

  "validate" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "validate";
       version = "2.0.0";
       sha256 = "97d0b101d796a43e853be666faaf78bf7fca36d18cd64cf31de7754f9716a0a5";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "validate-input_0_2_0_0" = callPackage
    ({ mkDerivation, base, bytestring, either, hspec, mtl, pcre-heavy
     , QuickCheck, stringable, text
     }:
     mkDerivation {
       pname = "validate-input";
       version = "0.2.0.0";
       sha256 = "9abebe0e9eccfeb35398e8fb0c1a7ee7582f83743f15b8403e5edefea39b5446";
       libraryHaskellDepends = [
         base bytestring either mtl pcre-heavy stringable text
       ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "https://github.com/agrafix/validate-input";
       description = "Input validation combinator library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "validate-input" = callPackage
    ({ mkDerivation, base, bytestring, either, hspec, mtl, pcre-heavy
     , QuickCheck, semigroups, string-conversions, text
     }:
     mkDerivation {
       pname = "validate-input";
       version = "0.4.0.0";
       sha256 = "20fae24b17429df923b835968720b76c581dc2c5037a2df9374b98a3fa41a1f9";
       libraryHaskellDepends = [
         base bytestring either mtl pcre-heavy semigroups string-conversions
         text
       ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "https://github.com/agrafix/validate-input";
       description = "Input validation combinator library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "validated-literals" = callPackage
    ({ mkDerivation, base, bytestring, template-haskell }:
     mkDerivation {
       pname = "validated-literals";
       version = "0.2.0";
       sha256 = "020b42ae331ee77c24402210c2715088b3b6084234b20a17eeacba27b66fa471";
       libraryHaskellDepends = [ base bytestring template-haskell ];
       homepage = "https://github.com/merijn/validated-literals";
       description = "Compile-time checking for partial smart-constructors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "validation" = callPackage
    ({ mkDerivation, base, bifunctors, directory, doctest, filepath
     , lens, mtl, QuickCheck, semigroupoids, semigroups
     , template-haskell, transformers
     }:
     mkDerivation {
       pname = "validation";
       version = "0.5.2";
       sha256 = "dd1a5857ead5b9ceec3839c9b6af7f3096bbc5694e37e34dfd4be7c1d5f35437";
       libraryHaskellDepends = [
         base bifunctors lens mtl semigroupoids semigroups transformers
       ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck template-haskell
       ];
       homepage = "https://github.com/NICTA/validation";
       description = "A data-type like Either but with an accumulating Applicative";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "validations" = callPackage
    ({ mkDerivation, base, containers, digestive-functors, HUnit, mtl
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2, text, transformers
     }:
     mkDerivation {
       pname = "validations";
       version = "0.1.0.2";
       sha256 = "93b72915af9088955403a11e7c01b9dc58d156657932bfc4a5f1520baef7715b";
       libraryHaskellDepends = [
         base containers digestive-functors mtl text transformers
       ];
       testHaskellDepends = [
         base containers digestive-functors HUnit mtl QuickCheck
         test-framework test-framework-hunit test-framework-quickcheck2 text
         transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/mavenraven/validations";
       description = "A nice way to define field validations in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "value-supply" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "value-supply";
       version = "0.6";
       sha256 = "6555ab70c48b28f1ca383b5198daab5ef18f87039ea7dc5c6dab3d6dc8cca639";
       libraryHaskellDepends = [ base ];
       description = "A library for generating values without having to thread state";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vampire" = callPackage
    ({ mkDerivation, base, deepseq, directory, dlist, fgl, graphviz
     , haskell-src-exts, mtl, optparse-applicative, process, uniplate
     }:
     mkDerivation {
       pname = "vampire";
       version = "0.1.3.0";
       sha256 = "3858dda568d5967ad2f53ef8140350d4b42171b8c3fd3c2e93af39ef75abc199";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base deepseq dlist fgl graphviz haskell-src-exts mtl uniplate
       ];
       executableHaskellDepends = [
         base deepseq directory dlist fgl graphviz haskell-src-exts mtl
         optparse-applicative process uniplate
       ];
       jailbreak = true;
       homepage = "https://github.com/benzrf/vampire";
       description = "Analyze and visualize expression trees";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "var" = callPackage
    ({ mkDerivation, base, QuickCheck, test-framework
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "var";
       version = "0.2.0.0";
       sha256 = "51ec39cb631e3a73bfbd6d6027fd6379a74658a3c853242509feef8abc3783ed";
       libraryHaskellDepends = [ base transformers ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       homepage = "http://github.com/sonyandy/var";
       description = "Mutable variables and tuples";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "varan" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, cmdargs, mtl
     , parallel, random, statistics
     }:
     mkDerivation {
       pname = "varan";
       version = "0.5.1";
       sha256 = "e28ccaf370237435e165a770d5cf4de7a09dcfc58d6fd409b38c53c025e977c3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base bytestring cmdargs mtl parallel random
         statistics
       ];
       description = "Process mpileup output to identify significant differences";
       license = "GPL";
     }) {};

  "variable-precision" = callPackage
    ({ mkDerivation, base, complex-generic, floatshow, integer-gmp
     , type-level-natural-number
     }:
     mkDerivation {
       pname = "variable-precision";
       version = "0.4";
       sha256 = "c4940b4ce1f70abb3da927d32ca9acde779c91559eb4747718d619f096ada6e1";
       libraryHaskellDepends = [
         base complex-generic floatshow integer-gmp
         type-level-natural-number
       ];
       jailbreak = true;
       homepage = "https://gitorious.org/variable-precision";
       description = "variable-precision floating point";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "variables" = callPackage
    ({ mkDerivation, base, hspec, mtl, QuickCheck, stm }:
     mkDerivation {
       pname = "variables";
       version = "0.1.1";
       sha256 = "3787a5c18d56a0b2f06a93bee1be5f38ba49b3252bf653b9b81087507bed593d";
       libraryHaskellDepends = [ base mtl stm ];
       testHaskellDepends = [ base hspec mtl QuickCheck stm ];
       jailbreak = true;
       homepage = "https://github.com/prophile/variables";
       description = "Monads with variables, without deep magic";
       license = stdenv.lib.licenses.mit;
     }) {};

  "varying" = callPackage
    ({ mkDerivation, base, hspec, QuickCheck, time, transformers }:
     mkDerivation {
       pname = "varying";
       version = "0.4.0.0";
       sha256 = "9a9c6b0e6f89deb748f72c1b1cf58a291235a0989305be190ebf4ec50d566092";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base time transformers ];
       executableHaskellDepends = [ base time transformers ];
       testHaskellDepends = [ base hspec QuickCheck time transformers ];
       homepage = "https://github.com/schell/varying";
       description = "FRP through value streams and monadic splines";
       license = stdenv.lib.licenses.mit;
     }) {};

  "vault_0_3_0_3" = callPackage
    ({ mkDerivation, base, containers, hashable, unordered-containers
     }:
     mkDerivation {
       pname = "vault";
       version = "0.3.0.3";
       sha256 = "056ad8ffe6059d005b12159cdf781cccd14193bb0b30e960509b3dbee438f272";
       libraryHaskellDepends = [
         base containers hashable unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/HeinrichApfelmus/vault";
       description = "a persistent store for values of arbitrary types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vault_0_3_0_4" = callPackage
    ({ mkDerivation, base, containers, hashable, unordered-containers
     }:
     mkDerivation {
       pname = "vault";
       version = "0.3.0.4";
       sha256 = "561ef32877935067e458333a44a37f15b4063559c4cb4ddc412ccf705ec6062a";
       libraryHaskellDepends = [
         base containers hashable unordered-containers
       ];
       homepage = "https://github.com/HeinrichApfelmus/vault";
       description = "a persistent store for values of arbitrary types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vault_0_3_0_5" = callPackage
    ({ mkDerivation, base, containers, hashable, unordered-containers
     }:
     mkDerivation {
       pname = "vault";
       version = "0.3.0.5";
       sha256 = "c37bf617db6b39333de40540ecbda8ae644ec6cc8e18bbccbe5d976aeb8cdea7";
       libraryHaskellDepends = [
         base containers hashable unordered-containers
       ];
       homepage = "https://github.com/HeinrichApfelmus/vault";
       description = "a persistent store for values of arbitrary types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vault" = callPackage
    ({ mkDerivation, base, containers, hashable, unordered-containers
     }:
     mkDerivation {
       pname = "vault";
       version = "0.3.0.6";
       sha256 = "0b433de60fa3d20e93dce6013293e18089fb3233c34211ffa3f860408866ef48";
       libraryHaskellDepends = [
         base containers hashable unordered-containers
       ];
       homepage = "https://github.com/HeinrichApfelmus/vault";
       description = "a persistent store for values of arbitrary types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vaultaire-common" = callPackage
    ({ mkDerivation, async, attoparsec, base, blaze-builder, bytestring
     , cereal, containers, hashable, hslogger, hspec, locators, mtl
     , old-locale, packer, QuickCheck, siphash, text, time, transformers
     , unix, unordered-containers
     }:
     mkDerivation {
       pname = "vaultaire-common";
       version = "2.9.1";
       sha256 = "594376c0efb6fa7f8110953ab90512c82afacf035a751412595e99d95980149d";
       libraryHaskellDepends = [
         async attoparsec base blaze-builder bytestring cereal containers
         hashable hslogger locators old-locale packer QuickCheck siphash
         text time transformers unix unordered-containers
       ];
       testHaskellDepends = [
         base bytestring containers hspec locators mtl QuickCheck text
         unordered-containers
       ];
       description = "Common types and instances for Vaultaire";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vcache" = callPackage
    ({ mkDerivation, base, bytestring, containers, direct-murmur-hash
     , easy-file, filelock, lmdb, random, stm, transformers
     }:
     mkDerivation {
       pname = "vcache";
       version = "0.2.6";
       sha256 = "0d05456f0c721a2342edc6eec79ebbe6b9ef1723ff5fa3002c557dd80c086f23";
       libraryHaskellDepends = [
         base bytestring containers direct-murmur-hash easy-file filelock
         lmdb random stm transformers
       ];
       homepage = "http://github.com/dmbarbour/haskell-vcache";
       description = "semi-transparent persistence for Haskell using LMDB, STM";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "vcache-trie" = callPackage
    ({ mkDerivation, array, base, bytestring, bytestring-builder
     , vcache
     }:
     mkDerivation {
       pname = "vcache-trie";
       version = "0.2.4";
       sha256 = "051ea7db60c1e414f4dd7f8a6451d88b926484a7a0858579631df0844b89aeee";
       libraryHaskellDepends = [
         array base bytestring bytestring-builder vcache
       ];
       homepage = "http://github.com/dmbarbour/haskell-vcache-trie";
       description = "patricia tries modeled above VCache";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "vcard" = callPackage
    ({ mkDerivation, base, bytestring, containers, mime-directory }:
     mkDerivation {
       pname = "vcard";
       version = "0.1.4";
       sha256 = "d7841a2a57250e0b8b110999e3e08bb6d09852826e18a7c4c175fac35dbb41f1";
       libraryHaskellDepends = [
         base bytestring containers mime-directory
       ];
       homepage = "http://github.com/mboes/vCard";
       description = "A library for parsing/printing vCards from/to various formats";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vcd" = callPackage
    ({ mkDerivation, base, polyparse }:
     mkDerivation {
       pname = "vcd";
       version = "0.2.2";
       sha256 = "f5c35f0d290a69eea9178977a5c7f5a2d91d9cea9c95e96407f6c34729ac1a74";
       libraryHaskellDepends = [ base polyparse ];
       homepage = "http://tomahawkins.org";
       description = "Reading and writing VCD files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vcs-revision" = callPackage
    ({ mkDerivation, base, process }:
     mkDerivation {
       pname = "vcs-revision";
       version = "0.0.2";
       sha256 = "8f95b7b3c72db43e79bdc82ee0cc8db439ecfc038a9edfab8df3584088e3e1d2";
       libraryHaskellDepends = [ base process ];
       description = "Facilities for accessing the version control revision of the current directory";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vcs-web-hook-parse" = callPackage
    ({ mkDerivation, aeson, base, bytestring, text }:
     mkDerivation {
       pname = "vcs-web-hook-parse";
       version = "0.2.0.0";
       sha256 = "db8293f8edabf50787d0290c15fe1971abdc9104c8e2e561757671993f23950a";
       libraryHaskellDepends = [ aeson base bytestring text ];
       homepage = "http://rel4tion.org/projects/vcs-web-hook-parse/";
       description = "Parse development platform web hook messages";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "vcsgui" = callPackage
    ({ mkDerivation, base, directory, filepath, gtk3, mtl, process
     , text, vcswrapper
     }:
     mkDerivation {
       pname = "vcsgui";
       version = "0.1.3.0";
       sha256 = "0d8997fec3f3a0025045408f8e619abd9568247a08228daa0ff7fa9508e7b06b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory filepath gtk3 mtl process text vcswrapper
       ];
       executableHaskellDepends = [
         base directory filepath gtk3 mtl process text vcswrapper
       ];
       homepage = "https://github.com/forste/haskellVCSGUI";
       description = "GUI library for source code management systems";
       license = "GPL";
     }) {};

  "vcswrapper" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, hxt, mtl
     , parsec, process, split, text
     }:
     mkDerivation {
       pname = "vcswrapper";
       version = "0.1.2";
       sha256 = "3a5dd0c147522d50846559ff5164310b7148a12ea859eea40debb8699ea375e5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory filepath hxt mtl parsec process split
         text
       ];
       executableHaskellDepends = [
         base containers directory filepath hxt mtl parsec process split
         text
       ];
       homepage = "https://github.com/forste/haskellVCSWrapper";
       description = "Wrapper for source code management systems";
       license = "GPL";
     }) {};

  "vect" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "vect";
       version = "0.4.7";
       sha256 = "8d38e4f2face37aaf241639af422fd1a3be569d3aad4f227f3d6759611948980";
       libraryHaskellDepends = [ base random ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "A low-dimensional linear algebra library, tailored to computer graphics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vect-floating" = callPackage
    ({ mkDerivation, base, random }:
     mkDerivation {
       pname = "vect-floating";
       version = "0.1.0.4";
       sha256 = "8f6050d788e03dd53fbdd2cc472f1aba90e6443effa4f23b98275e8ca396bacf";
       libraryHaskellDepends = [ base random ];
       jailbreak = true;
       homepage = "http://github.com/cpdurham/vect-floating";
       description = "A low-dimensional linear algebra library, operating on the Floating typeclass";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vect-floating-accelerate" = callPackage
    ({ mkDerivation, accelerate, base, vect-floating }:
     mkDerivation {
       pname = "vect-floating-accelerate";
       version = "0.1.0.4";
       sha256 = "9de872bcce865c2455988a807bbb29b09f09463786b1c3f29124dc79f713b682";
       revision = "1";
       editedCabalFile = "af7a5778a0ab8e79fdd4d535aeda7dba18ead15ea3f0b5ae87c3b17c5a076216";
       libraryHaskellDepends = [ accelerate base vect-floating ];
       jailbreak = true;
       homepage = "http://github.com/cpdurham/vect-floating-accelerate";
       description = "Accelerate instances for vect-floating types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vect-opengl" = callPackage
    ({ mkDerivation, base, OpenGL, vect }:
     mkDerivation {
       pname = "vect-opengl";
       version = "0.4.6.1";
       sha256 = "2fb6809c27528cc2e131820229c3ea3138a90bc3f1b41b8e66b2d1b78c44e9e2";
       libraryHaskellDepends = [ base OpenGL vect ];
       homepage = "http://code.haskell.org/~bkomuves/";
       description = "OpenGL support for the `vect' low-dimensional linear algebra library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector_0_10_9_3" = callPackage
    ({ mkDerivation, base, deepseq, ghc-prim, primitive }:
     mkDerivation {
       pname = "vector";
       version = "0.10.9.3";
       sha256 = "bdcd541262bc538fa43c9b3ea2dd8c1c2cd5ac7bb9efa909a8d558753678b422";
       libraryHaskellDepends = [ base deepseq ghc-prim primitive ];
       jailbreak = true;
       homepage = "https://github.com/haskell/vector";
       description = "Efficient Arrays";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector_0_10_12_2" = callPackage
    ({ mkDerivation, base, deepseq, ghc-prim, primitive, QuickCheck
     , random, template-haskell, test-framework
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "vector";
       version = "0.10.12.2";
       sha256 = "455427a217e98cc20af71906700bf36fed265ac15b7fb21b78a0a61f66380c06";
       libraryHaskellDepends = [ base deepseq ghc-prim primitive ];
       testHaskellDepends = [
         base QuickCheck random template-haskell test-framework
         test-framework-quickcheck2 transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/haskell/vector";
       description = "Efficient Arrays";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector_0_10_12_3" = callPackage
    ({ mkDerivation, base, deepseq, ghc-prim, primitive, QuickCheck
     , random, template-haskell, test-framework
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "vector";
       version = "0.10.12.3";
       sha256 = "0f765ce0238d89ffdb67656a364f7bf5012d68de9642da6bb2a425b61f88e89a";
       libraryHaskellDepends = [ base deepseq ghc-prim primitive ];
       testHaskellDepends = [
         base QuickCheck random template-haskell test-framework
         test-framework-quickcheck2 transformers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/haskell/vector";
       description = "Efficient Arrays";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector" = callPackage
    ({ mkDerivation, base, deepseq, ghc-prim, primitive, QuickCheck
     , random, template-haskell, test-framework
     , test-framework-quickcheck2, transformers
     }:
     mkDerivation {
       pname = "vector";
       version = "0.11.0.0";
       sha256 = "0a5320ed44c3f2b04b7f61e0f63f4fcd5b337524e601e01d5813ace3f5a432e4";
       revision = "1";
       editedCabalFile = "dfdf3252519ff35da59f977b7d37d6c5a6660673ce1234899af0111f7ece9c66";
       libraryHaskellDepends = [ base deepseq ghc-prim primitive ];
       testHaskellDepends = [
         base QuickCheck random template-haskell test-framework
         test-framework-quickcheck2 transformers
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/haskell/vector";
       description = "Efficient Arrays";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vector-algorithms_0_6_0_3" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, mwc-random
     , primitive, QuickCheck, vector
     }:
     mkDerivation {
       pname = "vector-algorithms";
       version = "0.6.0.3";
       sha256 = "c42eaddf416b37c7c281eadb3ce845aa628a5853e381beaa698aebe30359e4cf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring primitive vector ];
       executableHaskellDepends = [ base mtl mwc-random vector ];
       testHaskellDepends = [
         base bytestring containers QuickCheck vector
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~dolio/";
       description = "Efficient algorithms for vector arrays";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-algorithms_0_6_0_4" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, mwc-random
     , primitive, QuickCheck, vector
     }:
     mkDerivation {
       pname = "vector-algorithms";
       version = "0.6.0.4";
       sha256 = "5b8922154baa62c9239ed3efed94e890eeaf7e56f89d81a8c8407550749bc025";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring primitive vector ];
       executableHaskellDepends = [ base mtl mwc-random vector ];
       testHaskellDepends = [
         base bytestring containers QuickCheck vector
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~dolio/";
       description = "Efficient algorithms for vector arrays";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-algorithms_0_7" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, mwc-random
     , primitive, QuickCheck, vector
     }:
     mkDerivation {
       pname = "vector-algorithms";
       version = "0.7";
       sha256 = "9dfded48c97f4ff765b18ae5acd264361e1299736111ac73895848d8f6ab56c6";
       revision = "1";
       editedCabalFile = "ba3ba4dbfe97dc45be68d13c51ba4425900b186a46cdf3eceaafb746030c1b95";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring primitive vector ];
       executableHaskellDepends = [ base mtl mwc-random vector ];
       testHaskellDepends = [
         base bytestring containers QuickCheck vector
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~dolio/";
       description = "Efficient algorithms for vector arrays";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-algorithms" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, mwc-random
     , primitive, QuickCheck, vector
     }:
     mkDerivation {
       pname = "vector-algorithms";
       version = "0.7.0.1";
       sha256 = "ed460a41ca068f568bc2027579ab14185fbb72c7ac469b5179ae5f8a52719070";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring primitive vector ];
       executableHaskellDepends = [ base mtl mwc-random vector ];
       testHaskellDepends = [
         base bytestring containers QuickCheck vector
       ];
       homepage = "http://code.haskell.org/~dolio/";
       description = "Efficient algorithms for vector arrays";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vector-binary" = callPackage
    ({ mkDerivation, base, binary, vector }:
     mkDerivation {
       pname = "vector-binary";
       version = "0.1.1";
       sha256 = "ffabf5a6bf52cffa978da5d29490f158408853b65035ae3605ca713fe08ab2e1";
       libraryHaskellDepends = [ base binary vector ];
       homepage = "https://github.com/kawu/vector-binary";
       description = "Binary instances for vector types (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vector-binary-instances_0_2_1_0" = callPackage
    ({ mkDerivation, base, binary, cereal, vector }:
     mkDerivation {
       pname = "vector-binary-instances";
       version = "0.2.1.0";
       sha256 = "9450018a61ee5a62b802c1b2cfe8d289b7c8f3debeb0f8828679a4c085d31909";
       libraryHaskellDepends = [ base binary cereal vector ];
       homepage = "https://github.com/bos/vector-binary-instances";
       description = "Instances of Data.Binary and Data.Serialize for vector";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-binary-instances" = callPackage
    ({ mkDerivation, base, binary, vector }:
     mkDerivation {
       pname = "vector-binary-instances";
       version = "0.2.1.1";
       sha256 = "9647a467cc248ea967b16982be0a395688882d711b5b6613405064bcae6a4eb7";
       libraryHaskellDepends = [ base binary vector ];
       homepage = "https://github.com/bos/vector-binary-instances";
       description = "Instances of Data.Binary and Data.Serialize for vector";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vector-buffer" = callPackage
    ({ mkDerivation, base, deepseq, vector }:
     mkDerivation {
       pname = "vector-buffer";
       version = "0.4.1";
       sha256 = "9b5a9b57488267a765d9e7a8f2aa387ee0d3153989c169952da1e1229a60fd9b";
       libraryHaskellDepends = [ base deepseq vector ];
       description = "A buffer compatible with Data.Vector.*";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vector-bytestring" = callPackage
    ({ mkDerivation, base, bytestring, criterion, deepseq, directory
     , ghc-prim, primitive, QuickCheck, random, vector
     }:
     mkDerivation {
       pname = "vector-bytestring";
       version = "0.0.0.1";
       sha256 = "641eef86c91a0c742d74c1ea0f29ca69d9105379296ad622cb5f991142d53376";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring deepseq ghc-prim primitive vector
       ];
       executableHaskellDepends = [ base bytestring criterion deepseq ];
       testHaskellDepends = [ base directory QuickCheck random ];
       jailbreak = true;
       homepage = "https://github.com/basvandijk/vector-bytestring";
       description = "ByteStrings as type synonyms of Storable Vectors of Word8s";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-clock" = callPackage
    ({ mkDerivation, array, base, binary, ghc-prim, hashable, HUnit
     , QuickCheck, test-framework, test-framework-hunit
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "vector-clock";
       version = "0.2.2";
       sha256 = "499894210f44613f8f8233eddf6a3e13b630738eb4c3dd942692e5607811b759";
       libraryHaskellDepends = [ base binary ghc-prim hashable ];
       testHaskellDepends = [
         array base binary ghc-prim HUnit QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2
       ];
       homepage = "https://github.com/scvalex/vector-clock";
       description = "Vector clocks for versioning message flows";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-conduit" = callPackage
    ({ mkDerivation, base, conduit, HUnit, primitive, QuickCheck
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , vector
     }:
     mkDerivation {
       pname = "vector-conduit";
       version = "0.5.0.0";
       sha256 = "e119a64b708bd9a96faf2aeee55dab7a004ca30ac16c1d81eb8fe18f5dafb882";
       libraryHaskellDepends = [ base conduit primitive vector ];
       testHaskellDepends = [
         base conduit HUnit primitive QuickCheck test-framework
         test-framework-hunit test-framework-quickcheck2 vector
       ];
       jailbreak = true;
       description = "Conduit utilities for vectors";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-fftw" = callPackage
    ({ mkDerivation, base, fftw, primitive, storable-complex, vector }:
     mkDerivation {
       pname = "vector-fftw";
       version = "0.1.3.5";
       sha256 = "f4d88d3122c2ea3a92a5dffd78743e8942f261fd7d00724c6aa317adbc59abfe";
       libraryHaskellDepends = [ base primitive storable-complex vector ];
       librarySystemDepends = [ fftw ];
       homepage = "http://hackage.haskell.org/package/vector-fftw";
       description = "A binding to the fftw library for one-dimensional vectors";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) fftw;};

  "vector-functorlazy" = callPackage
    ({ mkDerivation, base, ghc-prim, primitive, vector, vector-th-unbox
     }:
     mkDerivation {
       pname = "vector-functorlazy";
       version = "0.0.1";
       sha256 = "03300f28129c9491790be6be4be4bc9dbd0563f2eb9604e62ac7f05edc60517b";
       libraryHaskellDepends = [
         base ghc-prim primitive vector vector-th-unbox
       ];
       homepage = "http://github.com/mikeizbicki/vector-functorlazy/";
       description = "vectors that perform the fmap operation in constant time";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-heterogenous" = callPackage
    ({ mkDerivation, base, vector }:
     mkDerivation {
       pname = "vector-heterogenous";
       version = "0.2.0";
       sha256 = "54aa1594444de8adb9d9309ccc13fd1a2f6d256ebbfa06e5e297209285c46093";
       libraryHaskellDepends = [ base vector ];
       homepage = "http://github.com/mikeizbicki/vector-heterogenous/";
       description = "A type-safe library for vectors whose elements can be of any type, or any type satisfying some constraints";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vector-instances_3_3" = callPackage
    ({ mkDerivation, base, comonad, keys, pointed, semigroupoids
     , semigroups, vector
     }:
     mkDerivation {
       pname = "vector-instances";
       version = "3.3";
       sha256 = "bee0ea0636363ddd20324deb9929e3edc5058df5c4b71d10d4aeb11dc54d3c46";
       revision = "1";
       editedCabalFile = "2d1c2d77aaaa578c00df578c720ad661401ed60006fb5cc9ed91e6ab4ade33c2";
       libraryHaskellDepends = [
         base comonad keys pointed semigroupoids semigroups vector
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/vector-instances";
       description = "Orphan Instances for 'Data.Vector'";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-instances_3_3_0_1" = callPackage
    ({ mkDerivation, base, comonad, keys, pointed, semigroupoids
     , semigroups, vector
     }:
     mkDerivation {
       pname = "vector-instances";
       version = "3.3.0.1";
       sha256 = "84b19901a496ffbba0115296452abc49e5248b4d55b153ba62bdf08bb6ddefda";
       libraryHaskellDepends = [
         base comonad keys pointed semigroupoids semigroups vector
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/vector-instances";
       description = "Orphan Instances for 'Data.Vector'";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-instances" = callPackage
    ({ mkDerivation, base, comonad, keys, pointed, semigroupoids
     , semigroups, vector
     }:
     mkDerivation {
       pname = "vector-instances";
       version = "3.3.1";
       sha256 = "68c7f154fe4ad53e29433e150c8718b0e74b4cf4c45a79af89940fff83868c59";
       libraryHaskellDepends = [
         base comonad keys pointed semigroupoids semigroups vector
       ];
       homepage = "http://github.com/ekmett/vector-instances";
       description = "Orphan Instances for 'Data.Vector'";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vector-instances-collections" = callPackage
    ({ mkDerivation, base, collections-api, template-haskell, vector }:
     mkDerivation {
       pname = "vector-instances-collections";
       version = "0.1.0.1";
       sha256 = "1a44b8349b49e330febb050fea158131c7f13491d5813f466dd566de7814b38f";
       libraryHaskellDepends = [
         base collections-api template-haskell vector
       ];
       jailbreak = true;
       homepage = "http://github.com/kreuzschlitzschraubenzieher/vector-instances-collections";
       description = "Instances of the Data.Collections classes for Data.Vector.*";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-mmap" = callPackage
    ({ mkDerivation, base, mmap, primitive, vector }:
     mkDerivation {
       pname = "vector-mmap";
       version = "0.0.2";
       sha256 = "b93e701bdd2a6d21df1f808b002a7f0824cb5ba78b8990bcb51d067998fc0c0e";
       libraryHaskellDepends = [ base mmap primitive vector ];
       homepage = "http://github.com/pumpkin/vector-mmap";
       description = "Memory map immutable and mutable vectors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vector-random" = callPackage
    ({ mkDerivation, base, mersenne-random-pure64, vector }:
     mkDerivation {
       pname = "vector-random";
       version = "0.2";
       sha256 = "6bb735a7bf2c81ac75029499bc160d22f4a2a721ab6bf23ae26cd5a217c1e4b8";
       libraryHaskellDepends = [ base mersenne-random-pure64 vector ];
       homepage = "http://code.haskell.org/~dons/code/vector-random";
       description = "Generate vectors filled with high quality pseudorandom numbers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-read-instances" = callPackage
    ({ mkDerivation, base, vector }:
     mkDerivation {
       pname = "vector-read-instances";
       version = "0.0.2.0";
       sha256 = "66af9d1e4752840e0f7a1b1c2bab73615151fa02e1ee737c774d9b0071b160cc";
       libraryHaskellDepends = [ base vector ];
       homepage = "http://www.tbi.univie.ac.at/~choener/";
       description = "(deprecated) Read instances for 'Data.Vector'";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-space_0_8_7" = callPackage
    ({ mkDerivation, base, Boolean, MemoTrie, NumInstances }:
     mkDerivation {
       pname = "vector-space";
       version = "0.8.7";
       sha256 = "75076924a56c58cd44ca1e07286a6b32f0e8d0558d42ba08af7a3e3b16196cc4";
       libraryHaskellDepends = [ base Boolean MemoTrie NumInstances ];
       description = "Vector & affine spaces, linear maps, and derivatives";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-space_0_9" = callPackage
    ({ mkDerivation, base, Boolean, MemoTrie, NumInstances }:
     mkDerivation {
       pname = "vector-space";
       version = "0.9";
       sha256 = "424e4ec98aae53ff2780b43071b308271be725d2ae93c9e4e865549747390167";
       libraryHaskellDepends = [ base Boolean MemoTrie NumInstances ];
       description = "Vector & affine spaces, linear maps, and derivatives";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-space_0_10_2" = callPackage
    ({ mkDerivation, base, Boolean, MemoTrie, NumInstances }:
     mkDerivation {
       pname = "vector-space";
       version = "0.10.2";
       sha256 = "507dc397e48da9f889d06a314355a82aa31fb0dd785aad278dec1a2e8778e858";
       libraryHaskellDepends = [ base Boolean MemoTrie NumInstances ];
       description = "Vector & affine spaces, linear maps, and derivatives";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-space" = callPackage
    ({ mkDerivation, base, Boolean, MemoTrie, NumInstances }:
     mkDerivation {
       pname = "vector-space";
       version = "0.10.3";
       sha256 = "efe39aa83d5ec5187c26f88496faf7411d3ee943cbc719797e58d115b004c885";
       libraryHaskellDepends = [ base Boolean MemoTrie NumInstances ];
       description = "Vector & affine spaces, linear maps, and derivatives";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vector-space-map" = callPackage
    ({ mkDerivation, base, containers, doctest, vector-space }:
     mkDerivation {
       pname = "vector-space-map";
       version = "0.2.0";
       sha256 = "ceec244a880e7abba75dd9c3324f6a6421a085ff270b30480455a30883c95424";
       libraryHaskellDepends = [ base containers vector-space ];
       testHaskellDepends = [ base doctest ];
       homepage = "https://github.com/conklech/vector-space-map";
       description = "vector-space operations for finite maps using Data.Map";
       license = stdenv.lib.licenses.mit;
     }) {};

  "vector-space-opengl" = callPackage
    ({ mkDerivation, base, ieee754, OpenGL, QuickCheck, test-framework
     , test-framework-quickcheck2, test-framework-th, vector-space
     }:
     mkDerivation {
       pname = "vector-space-opengl";
       version = "0.2";
       sha256 = "5c45df48192075c34f2cc3318cc9282f9e3a8aefccad934d827445599bfa2c9f";
       libraryHaskellDepends = [ base OpenGL vector-space ];
       testHaskellDepends = [
         base ieee754 OpenGL QuickCheck test-framework
         test-framework-quickcheck2 test-framework-th vector-space
       ];
       description = "Instances of vector-space classes for OpenGL types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-space-points_0_2" = callPackage
    ({ mkDerivation, base, vector-space }:
     mkDerivation {
       pname = "vector-space-points";
       version = "0.2";
       sha256 = "51380d5e54d324963df6a9103333d2d6e0e577e9a455b049661073ccf6fb8c17";
       libraryHaskellDepends = [ base vector-space ];
       jailbreak = true;
       description = "A type for points, as distinct from vectors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-space-points_0_2_1" = callPackage
    ({ mkDerivation, base, vector-space }:
     mkDerivation {
       pname = "vector-space-points";
       version = "0.2.1";
       sha256 = "64eccf1af070f40c659f95f976c2c1ac3fd780d6a43ba385851a7cfcbdba2f18";
       libraryHaskellDepends = [ base vector-space ];
       jailbreak = true;
       description = "A type for points, as distinct from vectors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-space-points" = callPackage
    ({ mkDerivation, base, vector-space }:
     mkDerivation {
       pname = "vector-space-points";
       version = "0.2.1.1";
       sha256 = "d77ea5caa08e9bc123fc760c00a7758b5b74ed0ac73be2a2143e55c82b3fb334";
       libraryHaskellDepends = [ base vector-space ];
       description = "A type for points, as distinct from vectors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vector-static" = callPackage
    ({ mkDerivation, base, primitive, vector }:
     mkDerivation {
       pname = "vector-static";
       version = "0.3.0.1";
       sha256 = "216d3db923ae25dbd09e5d69bd7c3acc8ebedc437ab712a27f59486266fe57a7";
       libraryHaskellDepends = [ base primitive vector ];
       jailbreak = true;
       homepage = "http://github.com/geezusfreeek/vector-static";
       description = "Statically checked sizes on Data.Vector";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-strategies" = callPackage
    ({ mkDerivation, base, deepseq, parallel, vector }:
     mkDerivation {
       pname = "vector-strategies";
       version = "0.4";
       sha256 = "86493bccc5ded0e694c0ac4aa374e6d64c4e218f4878aaee2609a3c3d88f6a13";
       libraryHaskellDepends = [ base deepseq parallel vector ];
       description = "A parallel evaluation strategy for boxed vectors";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vector-th-unbox_0_2_1_0" = callPackage
    ({ mkDerivation, base, data-default, template-haskell, vector }:
     mkDerivation {
       pname = "vector-th-unbox";
       version = "0.2.1.0";
       sha256 = "30dfe03ef275d327006396c2de14a625acb067596156e48748756e388cec1e65";
       revision = "2";
       editedCabalFile = "ca09cfbd155faf95ea8bccab39ce28368e70b473fa2249a0c44b308cea8ecb3a";
       libraryHaskellDepends = [ base template-haskell vector ];
       testHaskellDepends = [ base data-default vector ];
       description = "Deriver for Data.Vector.Unboxed using Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-th-unbox_0_2_1_2" = callPackage
    ({ mkDerivation, base, data-default, template-haskell, vector }:
     mkDerivation {
       pname = "vector-th-unbox";
       version = "0.2.1.2";
       sha256 = "0df696462d424bab569cc7a8ba1b1d0057bc5a71c510567fe5bcd1a940ae4d05";
       revision = "2";
       editedCabalFile = "8818c78bc7bb1b72b6963416e90c75e4eea18b7f7dd367a2a33d742f5b55f46d";
       libraryHaskellDepends = [ base template-haskell vector ];
       testHaskellDepends = [ base data-default vector ];
       jailbreak = true;
       description = "Deriver for Data.Vector.Unboxed using Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-th-unbox_0_2_1_3" = callPackage
    ({ mkDerivation, base, data-default, template-haskell, vector }:
     mkDerivation {
       pname = "vector-th-unbox";
       version = "0.2.1.3";
       sha256 = "33db750d3d867f23d0406a7165952b030831ed610b06ef777cfae8439b382689";
       revision = "1";
       editedCabalFile = "45fb308090cd50c13a24b46c0eef6bb9afcbf82fdcf944e3dc9bba27c63d5868";
       libraryHaskellDepends = [ base template-haskell vector ];
       testHaskellDepends = [ base data-default vector ];
       description = "Deriver for Data.Vector.Unboxed using Template Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vector-th-unbox" = callPackage
    ({ mkDerivation, base, data-default, template-haskell, vector }:
     mkDerivation {
       pname = "vector-th-unbox";
       version = "0.2.1.4";
       sha256 = "a765f8a679d2c59d0ab73d8c158cb020a362ab9e825c845f8202cd11ba660551";
       libraryHaskellDepends = [ base template-haskell vector ];
       testHaskellDepends = [ base data-default vector ];
       description = "Deriver for Data.Vector.Unboxed using Template Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "verbalexpressions" = callPackage
    ({ mkDerivation, base, regex-pcre }:
     mkDerivation {
       pname = "verbalexpressions";
       version = "1.0.0.0";
       sha256 = "9ef23bffc3c29b988f7c15ee14158cf4c9599b14d2075acf2577878597385171";
       libraryHaskellDepends = [ base regex-pcre ];
       jailbreak = true;
       homepage = "https://github.com/VerbalExpressions/HaskellVerbalExpressions";
       description = "Regular expressions made easy";
       license = stdenv.lib.licenses.mit;
     }) {};

  "verbosity" = callPackage
    ({ mkDerivation, base, binary, data-default-class, deepseq }:
     mkDerivation {
       pname = "verbosity";
       version = "0.2.1.0";
       sha256 = "faa4121629a8e397572bb61a37e0dd95e281f68c5f779eb7ee756517796f39d3";
       libraryHaskellDepends = [ base binary data-default-class deepseq ];
       homepage = "https://github.com/trskop/verbosity";
       description = "Simple enum that encodes application verbosity";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "verdict" = callPackage
    ({ mkDerivation, base, hspec, markdown-unlit, mtl, text
     , transformers
     }:
     mkDerivation {
       pname = "verdict";
       version = "0.0.0.0";
       sha256 = "01f2f6ef514f4d4ad47ca819500d304b0b3717969fc33859e3f4972b91cc35d2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base mtl text transformers ];
       executableHaskellDepends = [ base markdown-unlit text ];
       testHaskellDepends = [ base hspec ];
       description = "Validation framework";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "verdict-json" = callPackage
    ({ mkDerivation, aeson, base, containers, hspec, text
     , unordered-containers, vector, verdict
     }:
     mkDerivation {
       pname = "verdict-json";
       version = "0.0.0.0";
       sha256 = "7b64ab1ec3ae42db778f8adc52219a472af76ea0dd4d91d9376ad57dc9abaf4a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base containers text unordered-containers vector verdict
       ];
       executableHaskellDepends = [ aeson base containers verdict ];
       testHaskellDepends = [
         aeson base containers hspec unordered-containers vector verdict
       ];
       jailbreak = true;
       description = "JSON instances and JSON Schema for verdict";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "verilog" = callPackage
    ({ mkDerivation, alex, array, base, happy }:
     mkDerivation {
       pname = "verilog";
       version = "0.0.11";
       sha256 = "863487a4cdd6e7d208498b2b0def869617453c0e52cfd3b16f1639e4d8371452";
       libraryHaskellDepends = [ array base ];
       libraryToolDepends = [ alex happy ];
       homepage = "http://github.com/tomahawkins/verilog";
       description = "Verilog preprocessor, parser, and AST";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "versions" = callPackage
    ({ mkDerivation, base, either, extra, parsec, semigroups, tasty
     , tasty-hunit, text, text-show
     }:
     mkDerivation {
       pname = "versions";
       version = "1.0.2";
       sha256 = "739275e9d1d286786c2b9f62c1aa96beebb28912005e80f37acb56048ae6dc9e";
       libraryHaskellDepends = [ base parsec semigroups text ];
       testHaskellDepends = [
         base either extra semigroups tasty tasty-hunit text text-show
       ];
       description = "Types and parsers for software version numbers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vhd" = callPackage
    ({ mkDerivation, base, byteable, bytestring, cereal, cipher-aes
     , cryptohash, directory, filepath, mmap, QuickCheck, random
     , storable-endian, test-framework, test-framework-quickcheck2, text
     , time
     }:
     mkDerivation {
       pname = "vhd";
       version = "0.2.2";
       sha256 = "7c678f076395f44d853f87a4538635bc83d7a10319933dec9e06b40ce409ea7c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base byteable bytestring cereal cipher-aes cryptohash directory
         filepath mmap random storable-endian text time
       ];
       testHaskellDepends = [
         base byteable bytestring cereal cryptohash filepath mmap QuickCheck
         random test-framework test-framework-quickcheck2 text time
       ];
       homepage = "https://github.com/vincenthz/hs-vhd";
       description = "Provides functions to inspect and manipulate virtual hard disk (VHD) files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vhdl" = callPackage
    ({ mkDerivation, base, mtl, pretty, regex-posix }:
     mkDerivation {
       pname = "vhdl";
       version = "0.1.2.1";
       sha256 = "4b9402db91832b18e30cd1b9b809b662bca63c765144c388643058952ab228ae";
       libraryHaskellDepends = [ base mtl pretty regex-posix ];
       description = "VHDL AST and pretty printer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "views" = callPackage
    ({ mkDerivation, base, mtl }:
     mkDerivation {
       pname = "views";
       version = "1.0";
       sha256 = "90805dfd7cd14becc4156746dc0f491eb67812cb881b9b40df72c44951b9fc4f";
       libraryHaskellDepends = [ base mtl ];
       jailbreak = true;
       description = "Views allow you to run a State monad on part of a state";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vigilance" = callPackage
    ({ mkDerivation, acid-state, aeson, async, attoparsec, base
     , blaze-builder, bytestring, classy-prelude, configurator
     , containers, data-store, derive, directory, either, entropy
     , errors, fast-logger, hspec, hspec-expectations, http-streams
     , http-types, HUnit, interpolatedstring-perl6, io-streams, lens
     , mime-mail, monad-logger, monad-loops, mtl, optparse-applicative
     , QuickCheck, quickcheck-properties, safecopy, stm
     , template-haskell, text, time, transformers, unix
     , unordered-containers, vector, wai, wai-extra, warp, yesod
     , yesod-core, yesod-platform
     }:
     mkDerivation {
       pname = "vigilance";
       version = "0.1.0.1";
       sha256 = "853c9b62d6211ce7eba179f97ad6e2f9e718acab107cee1a93ace6c704c3bce2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         acid-state aeson async attoparsec base blaze-builder bytestring
         classy-prelude configurator containers data-store directory either
         entropy errors fast-logger http-streams http-types
         interpolatedstring-perl6 io-streams lens mime-mail monad-logger
         monad-loops mtl optparse-applicative safecopy stm template-haskell
         text time transformers unix unordered-containers vector wai
         wai-extra warp yesod yesod-core yesod-platform
       ];
       testHaskellDepends = [
         acid-state aeson async attoparsec base blaze-builder bytestring
         classy-prelude configurator containers data-store derive directory
         entropy errors fast-logger hspec hspec-expectations http-streams
         http-types HUnit interpolatedstring-perl6 io-streams lens mime-mail
         monad-loops mtl QuickCheck quickcheck-properties safecopy stm text
         time transformers unix unordered-containers vector warp yesod
         yesod-core yesod-platform
       ];
       jailbreak = true;
       homepage = "http://github.com/michaelxavier/vigilance";
       description = "An extensible dead-man's switch system";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vimeta" = callPackage
    ({ mkDerivation, aeson, base, byline, bytestring, containers
     , directory, either, filepath, http-client, http-client-tls
     , http-types, mtl, old-locale, optparse-applicative, parsec
     , process, temporary, text, themoviedb, time, time-locale-compat
     , transformers, xdg-basedir, yaml
     }:
     mkDerivation {
       pname = "vimeta";
       version = "0.2.1.0";
       sha256 = "38cb637b241ed59a4b149f57f1b3bfcdc67c846d6d1099cd7e59a74636ad8569";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base byline bytestring containers directory either filepath
         http-client http-client-tls http-types mtl old-locale
         optparse-applicative parsec process temporary text themoviedb time
         time-locale-compat transformers xdg-basedir yaml
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://github.com/pjones/vimeta";
       description = "Frontend for video metadata tagging tools";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vimus" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, containers, data-default
     , deepseq, directory, filepath, hspec, hspec-expectations, libmpd
     , mtl, ncurses, old-locale, process, QuickCheck, template-haskell
     , time, time-locale-compat, transformers, utf8-string, wcwidth
     }:
     mkDerivation {
       pname = "vimus";
       version = "0.2.1";
       sha256 = "e2a1b359607b0f4408f641dc5e992ba9a5cc31d6719aa7f5bee6dc6775269248";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers data-default deepseq directory filepath
         libmpd mtl old-locale process template-haskell time
         time-locale-compat utf8-string wcwidth
       ];
       librarySystemDepends = [ ncurses ];
       libraryToolDepends = [ c2hs ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base data-default hspec hspec-expectations mtl QuickCheck
         transformers wcwidth
       ];
       description = "An MPD client with vim-like key bindings";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) ncurses;};

  "vintage-basic" = callPackage
    ({ mkDerivation, array, base, directory, filepath, HUnit, mtl
     , parsec, process, random, regex-base, regex-posix, time
     }:
     mkDerivation {
       pname = "vintage-basic";
       version = "1.0.1";
       sha256 = "45cc99a45a2a7e07384d8e3e559d196b9d5d3f6d361e48af15e07c6d5e9db642";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base directory filepath HUnit mtl parsec process random
         regex-base regex-posix time
       ];
       homepage = "http://www.vintage-basic.net";
       description = "Interpreter for microcomputer-era BASIC";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vinyl" = callPackage
    ({ mkDerivation, base, doctest, ghc-prim, lens, singletons }:
     mkDerivation {
       pname = "vinyl";
       version = "0.5.1";
       sha256 = "6b9847e00e6cf8f3cdaa884242d2bc37ec37fd759669e9604fed20f21f45d008";
       revision = "1";
       editedCabalFile = "50e1bca6222b12611120dedc27b84a96960f6684dc278d54aea0215321a2f5ac";
       libraryHaskellDepends = [ base ghc-prim ];
       testHaskellDepends = [ base doctest lens singletons ];
       description = "Extensible Records";
       license = stdenv.lib.licenses.mit;
     }) {};

  "vinyl-gl" = callPackage
    ({ mkDerivation, base, containers, GLUtil, HUnit, linear, OpenGL
     , tagged, test-framework, test-framework-hunit, transformers
     , vector, vinyl
     }:
     mkDerivation {
       pname = "vinyl-gl";
       version = "0.3.0.1";
       sha256 = "aa7ce361d5b8abbaac651e43e0d1250563af970d75f85b4f74657efbd1bf51a0";
       libraryHaskellDepends = [
         base containers GLUtil linear OpenGL tagged transformers vector
         vinyl
       ];
       testHaskellDepends = [
         base HUnit linear OpenGL tagged test-framework test-framework-hunit
         vinyl
       ];
       description = "Utilities for working with OpenGL's GLSL shading language and vinyl records";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vinyl-json" = callPackage
    ({ mkDerivation, aeson, base, bytestring, hlint, template-haskell
     , text, vinyl
     }:
     mkDerivation {
       pname = "vinyl-json";
       version = "0.1.0.0";
       sha256 = "acc46e4e3eb4257d29d3a8d7e8c957fd16beb000dd28780983c7e04b15a7321f";
       libraryHaskellDepends = [
         aeson base bytestring template-haskell text vinyl
       ];
       testHaskellDepends = [ base hlint ];
       jailbreak = true;
       description = "Provide json instances automagically to vinyl types";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vinyl-utils" = callPackage
    ({ mkDerivation, base, contravariant, transformers, vinyl }:
     mkDerivation {
       pname = "vinyl-utils";
       version = "0.2.0.2";
       sha256 = "e38f74e57ef29514c3e655f9ae6415e6005c971a46504c1859b5ba602672297c";
       libraryHaskellDepends = [ base contravariant transformers vinyl ];
       jailbreak = true;
       homepage = "https://github.com/marcinmrotek/vinyl-utils";
       description = "Utilities for vinyl";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vinyl-vectors" = callPackage
    ({ mkDerivation, base, bytestring, constraints, data-default
     , primitive, template-haskell, text, vector, vinyl
     }:
     mkDerivation {
       pname = "vinyl-vectors";
       version = "0.2.0";
       sha256 = "6f9b6b8772937c967ad2b51e062cab27cb94fdbfb6d5e35eaae7c396e42362d7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring constraints data-default primitive template-haskell
         text vector vinyl
       ];
       homepage = "http://github.com/andrewthad/vinyl-vectors";
       description = "Vectors for vinyl vectors";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "virthualenv" = callPackage
    ({ mkDerivation, base, bytestring, Cabal, directory, file-embed
     , filepath, mtl, process, safe, split
     }:
     mkDerivation {
       pname = "virthualenv";
       version = "0.2.2";
       sha256 = "82f507e8f43e8c34aa5fbd48851ec307aba211756c43bc5b38ca4cb2e16ee623";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring Cabal directory file-embed filepath mtl process
         safe split
       ];
       jailbreak = true;
       homepage = "https://github.com/Paczesiowa/virthualenv";
       description = "Virtual Haskell Environment builder";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "visibility" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "visibility";
       version = "0.1.0.2";
       sha256 = "a4c32de7a4e069f97b3b6248c5cd81013a2ae6a6aa1d5b6bef8130f1245f2a28";
       libraryHaskellDepends = [ base containers ];
       homepage = "https://github.com/LukaHorvat/visibility";
       description = "Simple computation of visibility polygons";
       license = stdenv.lib.licenses.mit;
     }) {};

  "vision" = callPackage
    ({ mkDerivation, array, base, containers, directory, filepath, glib
     , gtk, json, MonadCatchIO-transformers, mtl, parsec, PSQueue, stm
     , url, utf8-string, xmms2-client, xmms2-client-glib
     }:
     mkDerivation {
       pname = "vision";
       version = "0.0.5.0";
       sha256 = "42750ca0729d32eb2c054206d934c77a4384f0788fb876d068d3920729fb6588";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory filepath glib gtk json
         MonadCatchIO-transformers mtl parsec PSQueue stm url utf8-string
         xmms2-client xmms2-client-glib
       ];
       description = "An XMMS2 client";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "visual-graphrewrite" = callPackage
    ({ mkDerivation, base, cairo, containers, directory, fgl, glade
     , graphviz, gtk, haskell-src, ipprint, isevaluated, lazysmallcheck
     , parallel, pretty, process, strict-concurrency, svgcairo
     , value-supply
     }:
     mkDerivation {
       pname = "visual-graphrewrite";
       version = "0.4.0.1";
       sha256 = "9793f50268811ea403c8959423105e40dcc900b80dd39062846ea1b652bfd757";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cairo containers directory fgl glade graphviz gtk haskell-src
         ipprint isevaluated lazysmallcheck parallel pretty process
         strict-concurrency svgcairo value-supply
       ];
       executableHaskellDepends = [
         base cairo containers directory fgl glade graphviz gtk haskell-src
         ipprint isevaluated lazysmallcheck parallel pretty process
         strict-concurrency svgcairo value-supply
       ];
       jailbreak = true;
       homepage = "http://github.com/zsol/visual-graphrewrite/";
       description = "Visualize the graph-rewrite steps of a Haskell program";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "visual-prof" = callPackage
    ({ mkDerivation, base, containers, directory, filepath
     , haskell-src-exts, mtl, pretty, process, regexpr, split, uniplate
     }:
     mkDerivation {
       pname = "visual-prof";
       version = "0.5";
       sha256 = "6978910fdc51a0898c4f7ebae111ce7a22f9dddebab71fc58e2d2a6fb0ee9b03";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath haskell-src-exts mtl pretty
         process regexpr split uniplate
       ];
       jailbreak = true;
       homepage = "http://github.com/djv/VisualProf";
       description = "Create a visual profile of a program's source code";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vivid" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, deepseq
     , hashable, mtl, network, split, stm
     }:
     mkDerivation {
       pname = "vivid";
       version = "0.1.0.3";
       sha256 = "a884a88d96cff6ada34d83bf5bcda9d351953e635d858f1a246bb94ec594930c";
       revision = "1";
       editedCabalFile = "de2442ab5d53f8044c99cd0489281bf902ef6615028be780e0df937ae60266da";
       libraryHaskellDepends = [
         base binary bytestring containers deepseq hashable mtl network
         split stm
       ];
       description = "Sound synthesis with SuperCollider";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vk-aws-route53" = callPackage
    ({ mkDerivation, aws, base, bytestring, containers, http-conduit
     , http-types, old-locale, resourcet, text, time, xml-conduit
     , xml-hamlet
     }:
     mkDerivation {
       pname = "vk-aws-route53";
       version = "0.1.2";
       sha256 = "9dacbfc16ac79f93c16f133dae6e153c310c2f7b08d504fcebfbac9590dc7469";
       libraryHaskellDepends = [
         aws base bytestring containers http-conduit http-types old-locale
         resourcet text time xml-conduit xml-hamlet
       ];
       description = "Amazon Route53 DNS service plugin for the aws package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vk-posix-pty" = callPackage
    ({ mkDerivation, base, bytestring, process, unix }:
     mkDerivation {
       pname = "vk-posix-pty";
       version = "0.2.1";
       sha256 = "27650d5b07f6c6cbc6fede3bf48866d921c78ed1abec7ba1a76469c6a33540ce";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring process unix ];
       executableHaskellDepends = [ base bytestring process unix ];
       homepage = "https://github.com/proger/posix-pty/tree/fork";
       description = "Pseudo terminal interaction with subprocesses";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vocabulary-kadma" = callPackage
    ({ mkDerivation, base, smaoin }:
     mkDerivation {
       pname = "vocabulary-kadma";
       version = "0.1.0.0";
       sha256 = "eb5644a76fe5c04ea8b95299518afb8215fb064e3e387e774686c591e80cfde3";
       revision = "1";
       editedCabalFile = "40477768ad6d879ecac71eec138bb3c1ecbf6f1c7a3a1512f5e9b13207fae05c";
       libraryHaskellDepends = [ base smaoin ];
       homepage = "http://rel4tion.org/projects/vocabularies-hs/";
       description = "Smaoin vocabulary definitions of the base framework";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "void_0_7" = callPackage
    ({ mkDerivation, base, ghc-prim, hashable, semigroups }:
     mkDerivation {
       pname = "void";
       version = "0.7";
       sha256 = "981b85d19bb51c1ac60103b184b86061621e0b016d4db24dd965751b2bc96f47";
       revision = "1";
       editedCabalFile = "1b66c93e483af13df0006943e863733902407792760dc38d394512c755a1f4ad";
       libraryHaskellDepends = [ base ghc-prim hashable semigroups ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/void";
       description = "A Haskell 98 logically uninhabited data type";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "void" = callPackage
    ({ mkDerivation, base, deepseq, ghc-prim, hashable, semigroups }:
     mkDerivation {
       pname = "void";
       version = "0.7.1";
       sha256 = "c9f0fd93680c029abb9654b5464be260652829961b18b7046f96a0df95e825f4";
       libraryHaskellDepends = [
         base deepseq ghc-prim hashable semigroups
       ];
       homepage = "http://github.com/ekmett/void";
       description = "A Haskell 98 logically uninhabited data type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vorbiscomment" = callPackage
    ({ mkDerivation, base, binary-strict, bytestring, mtl, utf8-string
     }:
     mkDerivation {
       pname = "vorbiscomment";
       version = "0.0.2";
       sha256 = "9dc7f458e1bcf3cb78014c000fbd306e1c6e3c7e7d73e313bf996555018c6e8a";
       libraryHaskellDepends = [
         base binary-strict bytestring mtl utf8-string
       ];
       description = "Reading of Vorbis comments from Ogg Vorbis files";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vowpal-utils" = callPackage
    ({ mkDerivation, base, bytestring }:
     mkDerivation {
       pname = "vowpal-utils";
       version = "0.1.2";
       sha256 = "0fad96ceff3126968dc69755093aba416856b3cef49533f5841f6722f5b2e627";
       libraryHaskellDepends = [ base bytestring ];
       jailbreak = true;
       homepage = "https://github.com/cartazio/Vowpal-Utils";
       description = "Vowpal Wabbit utilities";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "voyeur" = callPackage
    ({ mkDerivation, base, bytestring, process, utf8-string }:
     mkDerivation {
       pname = "voyeur";
       version = "0.1.0.1";
       sha256 = "cef156c54919dd74980e92e8b392a16560ea94f478efdc2de26a404a0ddcfd84";
       libraryHaskellDepends = [ base bytestring process utf8-string ];
       jailbreak = true;
       homepage = "https://github.com/sethfowler/hslibvoyeur";
       description = "Haskell bindings for libvoyeur";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vrpn" = callPackage
    ({ mkDerivation, base, vrpn }:
     mkDerivation {
       pname = "vrpn";
       version = "0.2.1.3";
       sha256 = "3268782b9412fe9cc3757dcaea0d9756ef9db4c80ea4004065df548384109d68";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ vrpn ];
       executableHaskellDepends = [ base ];
       executableSystemDepends = [ vrpn ];
       homepage = "https://bitbucket.org/bwbush/vrpn";
       description = "Bindings to VRPN";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) vrpn;};

  "vte" = callPackage
    ({ mkDerivation, base, glib, gtk, gtk2hs-buildtools, pango, vte }:
     mkDerivation {
       pname = "vte";
       version = "0.13.0.3";
       sha256 = "70efa9daec459aa3d7d49e767af2449752c62f47985d5bac9ef50fc1cdb4f90f";
       libraryHaskellDepends = [ base glib gtk pango ];
       libraryPkgconfigDepends = [ vte ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the VTE library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.gnome) vte;};

  "vtegtk3" = callPackage
    ({ mkDerivation, base, glib, gtk2hs-buildtools, gtk3, pango, vte }:
     mkDerivation {
       pname = "vtegtk3";
       version = "0.13.0.3";
       sha256 = "d712bf11446133f3146985db6ced3d932cf8f65d6a81900f4b65bb6e914c176a";
       libraryHaskellDepends = [ base glib gtk3 pango ];
       libraryPkgconfigDepends = [ vte ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       jailbreak = true;
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the VTE library";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.gnome) vte;};

  "vty" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, Cabal, containers
     , data-default, deepseq, directory, filepath, hashable, HUnit, lens
     , mtl, parallel, parsec, QuickCheck, quickcheck-assertions, random
     , smallcheck, stm, string-qq, terminfo, test-framework
     , test-framework-hunit, test-framework-smallcheck, text
     , transformers, unix, utf8-string, vector
     }:
     mkDerivation {
       pname = "vty";
       version = "5.4.0";
       sha256 = "2f318a1919089e5ad2af8ba142e638b5ad90c522d006553011dca48e707489d2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring containers data-default deepseq
         directory filepath hashable lens mtl parallel parsec stm terminfo
         text transformers unix utf8-string vector
       ];
       executableHaskellDepends = [
         base containers data-default lens mtl
       ];
       testHaskellDepends = [
         base blaze-builder bytestring Cabal containers data-default deepseq
         HUnit lens mtl QuickCheck quickcheck-assertions random smallcheck
         stm string-qq terminfo test-framework test-framework-hunit
         test-framework-smallcheck text unix utf8-string vector
       ];
       homepage = "https://github.com/coreyoconnor/vty";
       description = "A simple terminal UI library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vty-examples" = callPackage
    ({ mkDerivation, array, base, bytestring, Cabal, containers
     , data-default, deepseq, lens, mtl, parallel, parsec, QuickCheck
     , random, string-qq, terminfo, text, unix, utf8-string, vector, vty
     }:
     mkDerivation {
       pname = "vty-examples";
       version = "5.4.0";
       sha256 = "4c324ed6d398c8792f84860252680ee2b2a3a32ed158a647423818ee08b7ca17";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bytestring Cabal containers data-default deepseq lens
         mtl parallel parsec QuickCheck random string-qq terminfo text unix
         utf8-string vector vty
       ];
       homepage = "https://github.com/coreyoconnor/vty";
       description = "Examples programs using the vty library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vty-menu" = callPackage
    ({ mkDerivation, base, vty }:
     mkDerivation {
       pname = "vty-menu";
       version = "0.0.3";
       sha256 = "71618d00d34595c96b6cd42704f72ce37d3e17d4651656037938a0c1079966aa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base vty ];
       jailbreak = true;
       description = "A lib for displaying a menu and getting a selection using VTY";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "vty-ui" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, data-default
     , directory, filepath, mtl, QuickCheck, random, regex-base, stm
     , text, time, unix, vector, vty
     }:
     mkDerivation {
       pname = "vty-ui";
       version = "1.9";
       sha256 = "023b6229e7a2491957383e2a680ddfcfcde693b4769aa718d7d3524d84107ad7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base containers data-default directory filepath mtl
         regex-base stm text unix vector vty
       ];
       executableHaskellDepends = [
         base bytestring mtl QuickCheck random text time vty
       ];
       jailbreak = true;
       homepage = "http://jtdaugherty.github.com/vty-ui/";
       description = "An interactive terminal user interface library for Vty";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "vty-ui-extras" = callPackage
    ({ mkDerivation, base, regex-base, regex-pcre, vty, vty-ui }:
     mkDerivation {
       pname = "vty-ui-extras";
       version = "0.1";
       sha256 = "a7db07f3221854597754415f308533e5f9d408b7a71faa8fa431e630e15ec0b0";
       libraryHaskellDepends = [ base regex-base regex-pcre vty vty-ui ];
       jailbreak = true;
       description = "Extra vty-ui functionality not included in the core library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "waddle" = callPackage
    ({ mkDerivation, base, binary, bytestring, case-insensitive
     , containers, directory, JuicyPixels
     }:
     mkDerivation {
       pname = "waddle";
       version = "0.1.0.6";
       sha256 = "48782ba072e71678cb7d01043f8c10981ea7e7e5a123f0d8fb7a482f75c4ca15";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring case-insensitive containers directory
         JuicyPixels
       ];
       executableHaskellDepends = [
         base binary bytestring case-insensitive containers directory
         JuicyPixels
       ];
       homepage = "https://github.com/mgrabmueller/waddle";
       description = "DOOM WAD file utilities";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai_3_0_2" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, hspec, http-types
     , network, text, vault
     }:
     mkDerivation {
       pname = "wai";
       version = "3.0.2";
       sha256 = "fcb536879480b09c176e46d48c97e249d21ae67bffdbaa3097dbb402f2f7c74c";
       libraryHaskellDepends = [
         base blaze-builder bytestring http-types network text vault
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec ];
       jailbreak = true;
       homepage = "https://github.com/yesodweb/wai";
       description = "Web Application Interface";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai_3_0_2_1" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, hspec, http-types
     , network, text, vault
     }:
     mkDerivation {
       pname = "wai";
       version = "3.0.2.1";
       sha256 = "2930db958626f1316b01724904149ad7876d2f5b952a0eddbddef81d3c092a2a";
       libraryHaskellDepends = [
         base blaze-builder bytestring http-types network text vault
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec ];
       jailbreak = true;
       homepage = "https://github.com/yesodweb/wai";
       description = "Web Application Interface";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai_3_0_2_2" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, hspec, http-types
     , network, text, vault
     }:
     mkDerivation {
       pname = "wai";
       version = "3.0.2.2";
       sha256 = "ecfbe91e9da62d7942a3b3b91b257672765762cdef6f4a03ea5d48c699bf0ef2";
       libraryHaskellDepends = [
         base blaze-builder bytestring http-types network text vault
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec ];
       jailbreak = true;
       homepage = "https://github.com/yesodweb/wai";
       description = "Web Application Interface";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai_3_0_2_3" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, hspec, http-types
     , network, text, vault
     }:
     mkDerivation {
       pname = "wai";
       version = "3.0.2.3";
       sha256 = "da22c07a204c0dbe4cfdf528edcf833cb318f583b38c9a0c14edc91e44f039d7";
       libraryHaskellDepends = [
         base blaze-builder bytestring http-types network text vault
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec ];
       homepage = "https://github.com/yesodweb/wai";
       description = "Web Application Interface";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai_3_0_3_0" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, hspec, http-types
     , network, text, vault
     }:
     mkDerivation {
       pname = "wai";
       version = "3.0.3.0";
       sha256 = "c47eb435a3320795f21bee8585abc8164aaf3bfde86f7e1e13e98190cb968d10";
       libraryHaskellDepends = [
         base blaze-builder bytestring http-types network text vault
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec ];
       homepage = "https://github.com/yesodweb/wai";
       description = "Web Application Interface";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai_3_0_4_0" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring
     , bytestring-builder, hspec, http-types, network, text
     , transformers, unix-compat, vault
     }:
     mkDerivation {
       pname = "wai";
       version = "3.0.4.0";
       sha256 = "0e5399a5a4e50715c2c34def47553ad278265f2f5f823d06ad5b080b1eb0a194";
       revision = "2";
       editedCabalFile = "7aa2b653e1caf34214eaec510e8ccdf3cd0375884aabbc871637befafa87a285";
       libraryHaskellDepends = [
         base blaze-builder bytestring bytestring-builder http-types network
         text transformers unix-compat vault
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec ];
       homepage = "https://github.com/yesodweb/wai";
       description = "Web Application Interface";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai_3_0_5_0" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring
     , bytestring-builder, hspec, http-types, network, text
     , transformers, unix-compat, vault
     }:
     mkDerivation {
       pname = "wai";
       version = "3.0.5.0";
       sha256 = "0e417e6e8eff087585c0079917e6141a4e006fcd6cb736d1c6b49c503e9a08f3";
       libraryHaskellDepends = [
         base blaze-builder bytestring bytestring-builder http-types network
         text transformers unix-compat vault
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec ];
       homepage = "https://github.com/yesodweb/wai";
       description = "Web Application Interface";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring
     , bytestring-builder, hspec, http-types, network, text
     , transformers, vault
     }:
     mkDerivation {
       pname = "wai";
       version = "3.2.0";
       sha256 = "7f8e6903de20d64251657fdaba77c798249b6ddbe358cdb5eb277c1193467c9a";
       libraryHaskellDepends = [
         base blaze-builder bytestring bytestring-builder http-types network
         text transformers vault
       ];
       testHaskellDepends = [ base blaze-builder bytestring hspec ];
       homepage = "https://github.com/yesodweb/wai";
       description = "Web Application Interface";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-accept-language" = callPackage
    ({ mkDerivation, base, bytestring, file-embed, http-types, text
     , wai, wai-app-static, wai-extra, warp, word8
     }:
     mkDerivation {
       pname = "wai-accept-language";
       version = "0.1.0.1";
       sha256 = "d0d3f3e9c45edfa0c6f05e7d58091806825a1e02261d70cb448dc146480a4a31";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring http-types text wai wai-extra word8
       ];
       executableHaskellDepends = [
         base file-embed wai wai-app-static warp
       ];
       homepage = "https://github.com/mitsuji/wai-accept-language";
       description = "Rewrite based on Accept-Language header";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-app-file-cgi" = callPackage
    ({ mkDerivation, array, attoparsec, attoparsec-conduit, base
     , blaze-builder, blaze-html, bytestring, case-insensitive, conduit
     , conduit-extra, containers, data-default-class, directory, doctest
     , filepath, hspec, HTTP, http-client, http-conduit, http-date
     , http-types, io-choice, lifted-base, mime-types, network, process
     , sockaddr, static-hash, text, transformers, unix, wai, wai-conduit
     , warp, word8
     }:
     mkDerivation {
       pname = "wai-app-file-cgi";
       version = "3.1.0";
       sha256 = "fef1e40473f5d2a3355f8160c88f1626c0c90ca04e0bc5d57a06747384ab5a92";
       libraryHaskellDepends = [
         array attoparsec attoparsec-conduit base blaze-builder blaze-html
         bytestring case-insensitive conduit conduit-extra containers
         data-default-class directory filepath http-client http-conduit
         http-date http-types io-choice lifted-base mime-types network
         process sockaddr static-hash text transformers unix wai wai-conduit
         warp word8
       ];
       testHaskellDepends = [
         base bytestring conduit conduit-extra directory doctest filepath
         hspec HTTP http-types unix wai warp
       ];
       homepage = "http://www.mew.org/~kazu/proj/mighttpd/";
       description = "File/CGI/Rev Proxy App of WAI";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-app-static_3_0_0_3" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, cryptohash
     , cryptohash-conduit, directory, file-embed, filepath, hspec
     , http-date, http-types, mime-types, network, old-locale
     , optparse-applicative, system-fileio, system-filepath
     , template-haskell, text, time, transformers, unix-compat
     , unordered-containers, wai, wai-extra, warp, zlib
     }:
     mkDerivation {
       pname = "wai-app-static";
       version = "3.0.0.3";
       sha256 = "cbc27f906a08d8aa6d2c4a6e11b93e62545520a4e6d6128e6e58b9aabd953b4f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder blaze-html blaze-markup
         byteable bytestring containers cryptohash cryptohash-conduit
         directory file-embed filepath http-date http-types mime-types
         old-locale optparse-applicative system-fileio system-filepath
         template-haskell text time transformers unix-compat
         unordered-containers wai wai-extra warp zlib
       ];
       executableHaskellDepends = [
         base bytestring containers directory mime-types text
       ];
       testHaskellDepends = [
         base bytestring hspec http-date http-types mime-types network
         old-locale text time transformers unix-compat wai wai-extra zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/web-application-interface";
       description = "WAI application for static serving";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-app-static_3_0_0_4" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, cryptohash
     , cryptohash-conduit, directory, file-embed, filepath, hspec
     , http-date, http-types, mime-types, network, old-locale
     , optparse-applicative, system-fileio, system-filepath
     , template-haskell, text, time, transformers, unix-compat
     , unordered-containers, wai, wai-extra, warp, zlib
     }:
     mkDerivation {
       pname = "wai-app-static";
       version = "3.0.0.4";
       sha256 = "71feb0da15ea3af9792c7d6b08ede55f764760172b12b4282e88ee11607d41d7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder blaze-html blaze-markup
         byteable bytestring containers cryptohash cryptohash-conduit
         directory file-embed filepath http-date http-types mime-types
         old-locale optparse-applicative system-fileio system-filepath
         template-haskell text time transformers unix-compat
         unordered-containers wai wai-extra warp zlib
       ];
       executableHaskellDepends = [
         base bytestring containers directory mime-types text
       ];
       testHaskellDepends = [
         base bytestring hspec http-date http-types mime-types network
         old-locale text time transformers unix-compat wai wai-extra zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/web-application-interface";
       description = "WAI application for static serving";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-app-static_3_0_0_5" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, cryptohash
     , cryptohash-conduit, directory, file-embed, filepath, hspec
     , http-date, http-types, mime-types, network, old-locale
     , optparse-applicative, system-fileio, system-filepath
     , template-haskell, text, time, transformers, unix-compat
     , unordered-containers, wai, wai-extra, warp, zlib
     }:
     mkDerivation {
       pname = "wai-app-static";
       version = "3.0.0.5";
       sha256 = "942f3407bea881e92c4db8742a7f724d4aa5adafe85553d36d99f8a2d3f17fec";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder blaze-html blaze-markup
         byteable bytestring containers cryptohash cryptohash-conduit
         directory file-embed filepath http-date http-types mime-types
         old-locale optparse-applicative system-fileio system-filepath
         template-haskell text time transformers unix-compat
         unordered-containers wai wai-extra warp zlib
       ];
       executableHaskellDepends = [
         base bytestring containers directory mime-types text
       ];
       testHaskellDepends = [
         base bytestring hspec http-date http-types mime-types network
         old-locale text time transformers unix-compat wai wai-extra zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/web-application-interface";
       description = "WAI application for static serving";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-app-static_3_0_0_6" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, cryptohash
     , cryptohash-conduit, directory, file-embed, filepath, hspec
     , http-date, http-types, mime-types, network, old-locale
     , optparse-applicative, system-fileio, system-filepath
     , template-haskell, text, time, transformers, unix-compat
     , unordered-containers, wai, wai-extra, warp, zlib
     }:
     mkDerivation {
       pname = "wai-app-static";
       version = "3.0.0.6";
       sha256 = "68095c3e0f90c238d65c947f5d793c76a4286a614c168cd20d2b6ee7b8a29c46";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder blaze-html blaze-markup
         byteable bytestring containers cryptohash cryptohash-conduit
         directory file-embed filepath http-date http-types mime-types
         old-locale optparse-applicative system-fileio system-filepath
         template-haskell text time transformers unix-compat
         unordered-containers wai wai-extra warp zlib
       ];
       executableHaskellDepends = [
         base bytestring containers directory mime-types text
       ];
       testHaskellDepends = [
         base bytestring hspec http-date http-types mime-types network
         old-locale text time transformers unix-compat wai wai-extra zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/web-application-interface";
       description = "WAI application for static serving";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-app-static_3_0_1" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, cryptohash
     , cryptohash-conduit, directory, file-embed, filepath, hspec
     , http-date, http-types, mime-types, network, old-locale
     , optparse-applicative, system-fileio, system-filepath
     , template-haskell, text, time, transformers, unix-compat
     , unordered-containers, wai, wai-extra, warp, zlib
     }:
     mkDerivation {
       pname = "wai-app-static";
       version = "3.0.1";
       sha256 = "5361898308ca423587f972aa6e4d91de6652e92ef15a1084543d2696ea845f30";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder blaze-html blaze-markup
         byteable bytestring containers cryptohash cryptohash-conduit
         directory file-embed filepath http-date http-types mime-types
         old-locale optparse-applicative system-fileio system-filepath
         template-haskell text time transformers unix-compat
         unordered-containers wai wai-extra warp zlib
       ];
       executableHaskellDepends = [
         base bytestring containers directory mime-types text
       ];
       testHaskellDepends = [
         base bytestring hspec http-date http-types mime-types network
         old-locale text time transformers unix-compat wai wai-extra zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/web-application-interface";
       description = "WAI application for static serving";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-app-static_3_0_1_1" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, cryptohash
     , cryptohash-conduit, directory, file-embed, filepath, hspec
     , http-date, http-types, mime-types, network, old-locale
     , optparse-applicative, system-fileio, system-filepath
     , template-haskell, text, time, transformers, unix-compat
     , unordered-containers, wai, wai-extra, warp, zlib
     }:
     mkDerivation {
       pname = "wai-app-static";
       version = "3.0.1.1";
       sha256 = "fe743a9b2e830fc7496ba780cf23dfb4c2fa4d9a1c6a249ebfcc53a6e32751fe";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder blaze-html blaze-markup
         byteable bytestring containers cryptohash cryptohash-conduit
         directory file-embed filepath http-date http-types mime-types
         old-locale optparse-applicative system-fileio system-filepath
         template-haskell text time transformers unix-compat
         unordered-containers wai wai-extra warp zlib
       ];
       executableHaskellDepends = [
         base bytestring containers directory mime-types text
       ];
       testHaskellDepends = [
         base bytestring hspec http-date http-types mime-types network
         old-locale text time transformers unix-compat wai wai-extra zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/web-application-interface";
       description = "WAI application for static serving";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-app-static_3_1_1" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, cryptohash
     , cryptohash-conduit, directory, file-embed, filepath, hspec
     , http-date, http-types, mime-types, network, old-locale
     , optparse-applicative, template-haskell, text, time, transformers
     , unix-compat, unordered-containers, wai, wai-extra, warp, zlib
     }:
     mkDerivation {
       pname = "wai-app-static";
       version = "3.1.1";
       sha256 = "5b7ed5028584bbefbbf3da6869ad9fe5ed4fe28ad599ca5d9ad715a1cee43e2a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder blaze-html blaze-markup
         byteable bytestring containers cryptohash cryptohash-conduit
         directory file-embed filepath http-date http-types mime-types
         old-locale optparse-applicative template-haskell text time
         transformers unix-compat unordered-containers wai wai-extra warp
         zlib
       ];
       executableHaskellDepends = [
         base bytestring containers directory mime-types text
       ];
       testHaskellDepends = [
         base bytestring hspec http-date http-types mime-types network
         old-locale text time transformers unix-compat wai wai-extra zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/web-application-interface";
       description = "WAI application for static serving";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-app-static_3_1_2" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, cryptohash
     , cryptohash-conduit, directory, file-embed, filepath, hspec
     , http-date, http-types, mime-types, network, old-locale
     , optparse-applicative, template-haskell, temporary, text, time
     , transformers, unix-compat, unordered-containers, wai, wai-extra
     , warp, zlib
     }:
     mkDerivation {
       pname = "wai-app-static";
       version = "3.1.2";
       sha256 = "5c592511781fcb3185998faba55c2f6869ad829b64103a0da499058a43b19cd3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder blaze-html blaze-markup
         byteable bytestring containers cryptohash cryptohash-conduit
         directory file-embed filepath http-date http-types mime-types
         old-locale optparse-applicative template-haskell text time
         transformers unix-compat unordered-containers wai wai-extra warp
         zlib
       ];
       executableHaskellDepends = [
         base bytestring containers directory mime-types text
       ];
       testHaskellDepends = [
         base bytestring filepath hspec http-date http-types mime-types
         network old-locale temporary text time transformers unix-compat wai
         wai-extra zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/web-application-interface";
       description = "WAI application for static serving";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-app-static_3_1_3" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, cryptohash
     , cryptohash-conduit, directory, file-embed, filepath, hspec
     , http-date, http-types, mime-types, network, old-locale
     , optparse-applicative, template-haskell, temporary, text, time
     , transformers, unix-compat, unordered-containers, wai, wai-extra
     , warp, zlib
     }:
     mkDerivation {
       pname = "wai-app-static";
       version = "3.1.3";
       sha256 = "4ab82503abdb43ad2759585ef0ed1ee66a2a5f5febe35cae9a2875cc3c4e67cd";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder blaze-html blaze-markup
         byteable bytestring containers cryptohash cryptohash-conduit
         directory file-embed filepath http-date http-types mime-types
         old-locale optparse-applicative template-haskell text time
         transformers unix-compat unordered-containers wai wai-extra warp
         zlib
       ];
       executableHaskellDepends = [
         base bytestring containers directory mime-types text
       ];
       testHaskellDepends = [
         base bytestring filepath hspec http-date http-types mime-types
         network old-locale temporary text time transformers unix-compat wai
         wai-extra zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/web-application-interface";
       description = "WAI application for static serving";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-app-static_3_1_4" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, cryptohash
     , cryptohash-conduit, directory, file-embed, filepath, hspec
     , http-date, http-types, mime-types, network, old-locale
     , optparse-applicative, template-haskell, temporary, text, time
     , transformers, unix-compat, unordered-containers, wai, wai-extra
     , warp, zlib
     }:
     mkDerivation {
       pname = "wai-app-static";
       version = "3.1.4";
       sha256 = "630e34d404da96327d312cf6a6002a098877282177b07eb875afbbcf47f43a67";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder blaze-html blaze-markup
         byteable bytestring containers cryptohash cryptohash-conduit
         directory file-embed filepath http-date http-types mime-types
         old-locale optparse-applicative template-haskell text time
         transformers unix-compat unordered-containers wai wai-extra warp
         zlib
       ];
       executableHaskellDepends = [
         base bytestring containers directory mime-types text
       ];
       testHaskellDepends = [
         base bytestring filepath hspec http-date http-types mime-types
         network old-locale temporary text time transformers unix-compat wai
         wai-extra zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/web-application-interface";
       description = "WAI application for static serving";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-app-static" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, cryptohash
     , cryptohash-conduit, directory, file-embed, filepath, hspec
     , http-date, http-types, mime-types, network, old-locale
     , optparse-applicative, template-haskell, temporary, text, time
     , transformers, unix-compat, unordered-containers, wai, wai-extra
     , warp, zlib
     }:
     mkDerivation {
       pname = "wai-app-static";
       version = "3.1.4.1";
       sha256 = "7280e15192be2d80b2505da152ea828c448e1466401fc4a02e87052ce3515bd4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder blaze-html blaze-markup
         byteable bytestring containers cryptohash cryptohash-conduit
         directory file-embed filepath http-date http-types mime-types
         old-locale optparse-applicative template-haskell text time
         transformers unix-compat unordered-containers wai wai-extra warp
         zlib
       ];
       executableHaskellDepends = [
         base bytestring containers directory mime-types text
       ];
       testHaskellDepends = [
         base bytestring filepath hspec http-date http-types mime-types
         network old-locale temporary text time transformers unix-compat wai
         wai-extra zlib
       ];
       homepage = "http://www.yesodweb.com/book/web-application-interface";
       description = "WAI application for static serving";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-conduit_3_0_0_1" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, conduit
     , http-types, transformers, wai
     }:
     mkDerivation {
       pname = "wai-conduit";
       version = "3.0.0.1";
       sha256 = "d543f85df31a2d493d2eac3c43fb658e33f2484b4b5de2d738687d7a4d76b554";
       libraryHaskellDepends = [
         base blaze-builder bytestring conduit http-types transformers wai
       ];
       jailbreak = true;
       homepage = "https://github.com/yesodweb/wai";
       description = "conduit wrappers for WAI";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-conduit_3_0_0_2" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, conduit
     , http-types, transformers, wai
     }:
     mkDerivation {
       pname = "wai-conduit";
       version = "3.0.0.2";
       sha256 = "47d2882f3f95edf32cdde9db9c663dcc0bdcee3efd605a673c1f3e80e34216f3";
       libraryHaskellDepends = [
         base blaze-builder bytestring conduit http-types transformers wai
       ];
       jailbreak = true;
       homepage = "https://github.com/yesodweb/wai";
       description = "conduit wrappers for WAI";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-conduit" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, conduit
     , http-types, transformers, wai
     }:
     mkDerivation {
       pname = "wai-conduit";
       version = "3.0.0.3";
       sha256 = "e49720a7c7b58e78a56991e42fa550a722936af274dc27755a735781258f7aff";
       libraryHaskellDepends = [
         base blaze-builder bytestring conduit http-types transformers wai
       ];
       homepage = "https://github.com/yesodweb/wai";
       description = "conduit wrappers for WAI";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-cors_0_2_3" = callPackage
    ({ mkDerivation, attoparsec, base, base-unicode-symbols, bytestring
     , case-insensitive, charset, directory, filepath, http-types, mtl
     , network, parsers, process, text, transformers, wai
     , wai-websockets, warp, websockets
     }:
     mkDerivation {
       pname = "wai-cors";
       version = "0.2.3";
       sha256 = "2271e9aa556c9f475ac4d80a70490d2b97423571131025de921134501c5bded6";
       libraryHaskellDepends = [
         attoparsec base base-unicode-symbols bytestring case-insensitive
         charset http-types mtl parsers transformers wai
       ];
       testHaskellDepends = [
         base base-unicode-symbols directory filepath http-types network
         process text wai wai-websockets warp websockets
       ];
       doCheck = false;
       homepage = "https://github.com/larskuhtz/wai-cors";
       description = "CORS for WAI";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-cors" = callPackage
    ({ mkDerivation, attoparsec, base, base-unicode-symbols, bytestring
     , case-insensitive, charset, directory, filepath, http-types, mtl
     , network, parsers, process, tasty, tasty-hunit, text, transformers
     , wai, wai-extra, wai-websockets, warp, websockets
     }:
     mkDerivation {
       pname = "wai-cors";
       version = "0.2.4";
       sha256 = "1d404aa28cdc89da3ca8f9edf990508dc9b106409f786204eb951cc548f27568";
       libraryHaskellDepends = [
         attoparsec base base-unicode-symbols bytestring case-insensitive
         charset http-types mtl parsers transformers wai
       ];
       testHaskellDepends = [
         base base-unicode-symbols directory filepath http-types network
         process tasty tasty-hunit text wai wai-extra wai-websockets warp
         websockets
       ];
       doCheck = false;
       homepage = "https://github.com/larskuhtz/wai-cors";
       description = "CORS for WAI";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-devel" = callPackage
    ({ mkDerivation, array, base, blaze-html, bytestring
     , Cabal-ide-backend, directory, file-embed, filepath, fsnotify, ghc
     , Glob, hspec, http-client, http-conduit, http-reverse-proxy
     , http-types, ide-backend, MissingH, network, optparse-applicative
     , process, shakespeare, split, stm, streaming-commons
     , system-filepath, text, time, transformers, wai, warp, websockets
     }:
     mkDerivation {
       pname = "wai-devel";
       version = "0.0.0.3";
       sha256 = "3ff4291b31a24e02b859f44b2aba55dcce7dc55850c29a9802570b2431fdf646";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base blaze-html bytestring Cabal-ide-backend directory
         file-embed filepath fsnotify ghc Glob http-client http-conduit
         http-reverse-proxy http-types ide-backend MissingH network
         optparse-applicative process shakespeare split stm
         streaming-commons system-filepath text time transformers wai warp
         websockets
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec stm ];
       homepage = "https://github.com/urbanslug/wai-devel";
       description = "A web server for the development of WAI compliant web applications";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-digestive-functors" = callPackage
    ({ mkDerivation, base, digestive-functors, http-types, resourcet
     , text, transformers, wai, wai-extra, wai-util
     }:
     mkDerivation {
       pname = "wai-digestive-functors";
       version = "0.3";
       sha256 = "8dded7f0d5ec1b1437c37b92f509b907f9e72738081c26067eec87fa06a98912";
       libraryHaskellDepends = [
         base digestive-functors http-types resourcet text transformers wai
         wai-extra wai-util
       ];
       homepage = "https://github.com/singpolyma/wai-digestive-functors";
       description = "Helpers to bind digestive-functors onto wai requests";
       license = "unknown";
     }) {};

  "wai-dispatch" = callPackage
    ({ mkDerivation, base, text, wai, yesod-routes }:
     mkDerivation {
       pname = "wai-dispatch";
       version = "0.1";
       sha256 = "ea6777536f39811f9f89db12d99fc713b9e161de753e714417eb597b97cccae3";
       libraryHaskellDepends = [ base text wai yesod-routes ];
       homepage = "https://github.com/singpolyma/wai-dispatch";
       description = "Nice wrapper around yesod-routes for use with WAI";
       license = "unknown";
     }) {};

  "wai-eventsource" = callPackage
    ({ mkDerivation, wai }:
     mkDerivation {
       pname = "wai-eventsource";
       version = "3.0.0";
       sha256 = "785005f23bf9bf4e1dfaae0705472c0e3ea4c3843ff6a8625db8d1e327a6bfc0";
       libraryHaskellDepends = [ wai ];
       doHaddock = false;
       doCheck = false;
       homepage = "http://www.yesodweb.com/book/web-application-interface";
       description = "WAI support for server-sent events (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-extra_3_0_2_2" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, lifted-base, network, old-locale, resourcet
     , streaming-commons, stringsearch, text, time, transformers, unix
     , void, wai, wai-logger, word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.2.2";
       sha256 = "49138b4f847adb23e4ab6dd3ed2c31f298047544a92472880f5aebefc82f7551";
       revision = "1";
       editedCabalFile = "c8d756c56f709ab3c76285cc7603c50e301b4de9403ee01d8e07892684d93536";
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers data-default-class deepseq directory
         fast-logger http-types lifted-base network old-locale resourcet
         streaming-commons stringsearch text time transformers unix void wai
         wai-logger word8
       ];
       testHaskellDepends = [
         base bytestring fast-logger hspec http-types HUnit resourcet text
         transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_3" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, lifted-base, network, old-locale, resourcet
     , streaming-commons, stringsearch, text, time, transformers, unix
     , void, wai, wai-logger, word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.3";
       sha256 = "439c0559e875efb2b7998842a64f59974aeeadecd58c496a47e90540d71f97b0";
       revision = "1";
       editedCabalFile = "92900068c7608309744242b53c64bb0094916c3597f7ce5fef768dbe264e3f42";
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers data-default-class deepseq directory
         fast-logger http-types lifted-base network old-locale resourcet
         streaming-commons stringsearch text time transformers unix void wai
         wai-logger word8
       ];
       testHaskellDepends = [
         base bytestring fast-logger hspec http-types HUnit resourcet text
         transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_3_1" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, lifted-base, network, old-locale, resourcet
     , streaming-commons, stringsearch, text, time, transformers, unix
     , void, wai, wai-logger, word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.3.1";
       sha256 = "7691e8a7db56fc0cec98b7f5f9aeb87eec31b842cd528205547acece3af6e833";
       revision = "1";
       editedCabalFile = "aae73d71f92280118b73a896d273608a605ea62fbf4eb785c43bc9a50d37c3c6";
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers data-default-class deepseq directory
         fast-logger http-types lifted-base network old-locale resourcet
         streaming-commons stringsearch text time transformers unix void wai
         wai-logger word8
       ];
       testHaskellDepends = [
         base bytestring fast-logger hspec http-types HUnit resourcet text
         transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_3_2" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, lifted-base, network, old-locale, resourcet
     , streaming-commons, stringsearch, text, time, transformers, unix
     , void, wai, wai-logger, word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.3.2";
       sha256 = "d8d344bf0a9e5547427a787a85c5e3bf100fcb295d29bf2d6ef676ab7ef7f064";
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers data-default-class deepseq directory
         fast-logger http-types lifted-base network old-locale resourcet
         streaming-commons stringsearch text time transformers unix void wai
         wai-logger word8
       ];
       testHaskellDepends = [
         base bytestring fast-logger hspec http-types HUnit resourcet text
         transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_4_1" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, lifted-base, network, old-locale, resourcet
     , streaming-commons, stringsearch, text, time, transformers, unix
     , unix-compat, void, wai, wai-logger, word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.4.1";
       sha256 = "efbf7790acf36c5eaf6a5de21a3b2953445b936877222318fae5c1bc36dfb134";
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers data-default-class deepseq directory
         fast-logger http-types lifted-base network old-locale resourcet
         streaming-commons stringsearch text time transformers unix
         unix-compat void wai wai-logger word8
       ];
       testHaskellDepends = [
         base bytestring fast-logger hspec http-types HUnit resourcet text
         transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_4_5" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, lifted-base, network, old-locale, resourcet
     , streaming-commons, stringsearch, text, time, transformers, unix
     , unix-compat, void, wai, wai-logger, word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.4.5";
       sha256 = "44590f690d74bdc33ebfeefa3c114254a156be59e9d4030c310e17d3a24c23b4";
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers data-default-class deepseq directory
         fast-logger http-types lifted-base network old-locale resourcet
         streaming-commons stringsearch text time transformers unix
         unix-compat void wai wai-logger word8
       ];
       testHaskellDepends = [
         base bytestring fast-logger hspec http-types HUnit resourcet text
         transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_4_6" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, lifted-base, network, old-locale, resourcet
     , streaming-commons, stringsearch, text, time, transformers, unix
     , unix-compat, void, wai, wai-logger, word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.4.6";
       sha256 = "e5f72aa87e87a3d538ccc8280285c453d75ad63f42fee57479ae10e19770866e";
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers data-default-class deepseq directory
         fast-logger http-types lifted-base network old-locale resourcet
         streaming-commons stringsearch text time transformers unix
         unix-compat void wai wai-logger word8
       ];
       testHaskellDepends = [
         base bytestring fast-logger hspec http-types HUnit resourcet text
         transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_5" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, lifted-base, network, old-locale, resourcet
     , streaming-commons, stringsearch, text, time, transformers, unix
     , unix-compat, void, wai, wai-logger, word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.5";
       sha256 = "a2d08ef2b6b68e1ab4ebeaf9ec4369c5a5312f91082f2b8f9b4686daa87691fc";
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers data-default-class deepseq directory
         fast-logger http-types lifted-base network old-locale resourcet
         streaming-commons stringsearch text time transformers unix
         unix-compat void wai wai-logger word8
       ];
       testHaskellDepends = [
         base bytestring fast-logger hspec http-types HUnit resourcet text
         transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_6_1" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, lifted-base, network, old-locale, resourcet
     , streaming-commons, stringsearch, text, time, transformers, unix
     , unix-compat, void, wai, wai-logger, word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.6.1";
       sha256 = "aec46505f7603e9624efcc50d324d16955c14f3b3bcf5f201ff820177cca9d97";
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         directory fast-logger http-types lifted-base network old-locale
         resourcet streaming-commons stringsearch text time transformers
         unix unix-compat void wai wai-logger word8
       ];
       testHaskellDepends = [
         base blaze-builder bytestring cookie fast-logger hspec http-types
         HUnit resourcet text time transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_7" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, lifted-base, network, old-locale, resourcet
     , streaming-commons, stringsearch, text, time, transformers, unix
     , unix-compat, vault, void, wai, wai-logger, word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.7";
       sha256 = "150f82efee3ba4008c10d7b73f2c55539473b5e833c22c6f47c733066db16342";
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         directory fast-logger http-types lifted-base network old-locale
         resourcet streaming-commons stringsearch text time transformers
         unix unix-compat vault void wai wai-logger word8
       ];
       testHaskellDepends = [
         base blaze-builder bytestring cookie fast-logger hspec http-types
         HUnit resourcet text time transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_7_1" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, lifted-base, network, old-locale, resourcet
     , streaming-commons, stringsearch, text, time, transformers, unix
     , unix-compat, vault, void, wai, wai-logger, word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.7.1";
       sha256 = "23e4f497e6876c32042588eacaa277fc18a8a30bec42472c3f5bccad2cc6d7c9";
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         directory fast-logger http-types lifted-base network old-locale
         resourcet streaming-commons stringsearch text time transformers
         unix unix-compat vault void wai wai-logger word8
       ];
       testHaskellDepends = [
         base blaze-builder bytestring cookie fast-logger hspec http-types
         HUnit resourcet text time transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_8_2" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, lifted-base, network, old-locale, resourcet
     , streaming-commons, stringsearch, text, time, transformers, unix
     , unix-compat, vault, void, wai, wai-logger, word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.8.2";
       sha256 = "29f77aad39d315587f75cf6e0c5b115bb2479e558f5e7841afead6c03fdfde48";
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         directory fast-logger http-types lifted-base network old-locale
         resourcet streaming-commons stringsearch text time transformers
         unix unix-compat vault void wai wai-logger word8
       ];
       testHaskellDepends = [
         base blaze-builder bytestring case-insensitive cookie fast-logger
         hspec http-types HUnit resourcet text time transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_10" = callPackage
    ({ mkDerivation, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, lifted-base, network, old-locale, resourcet
     , streaming-commons, stringsearch, text, time, transformers, unix
     , unix-compat, vault, void, wai, wai-logger, word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.10";
       sha256 = "503af31217c29d1bcec10a6806ea119aab9d68f29f12a1c1006fe4f931771b37";
       libraryHaskellDepends = [
         ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         directory fast-logger http-types lifted-base network old-locale
         resourcet streaming-commons stringsearch text time transformers
         unix unix-compat vault void wai wai-logger word8
       ];
       testHaskellDepends = [
         base blaze-builder bytestring case-insensitive cookie fast-logger
         hspec http-types HUnit resourcet text time transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_11_1" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, iproute, lifted-base, network, old-locale
     , resourcet, streaming-commons, stringsearch, text, time
     , transformers, unix, unix-compat, vault, void, wai, wai-logger
     , word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.11.1";
       sha256 = "086fb0ea800085e8f49bdda4de2ed8b23f4d14bb078a3332b7bb85ee71d122cf";
       libraryHaskellDepends = [
         aeson ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         directory fast-logger http-types iproute lifted-base network
         old-locale resourcet streaming-commons stringsearch text time
         transformers unix unix-compat vault void wai wai-logger word8 zlib
       ];
       testHaskellDepends = [
         base blaze-builder bytestring case-insensitive cookie fast-logger
         hspec http-types HUnit resourcet text time transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_12" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, iproute, lifted-base, network, old-locale
     , resourcet, streaming-commons, stringsearch, text, time
     , transformers, unix, unix-compat, vault, void, wai, wai-logger
     , word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.12";
       sha256 = "4b2362b111c7de228b0370fb22d0322becfa3d1a61d077cbfc2158003f8ede64";
       libraryHaskellDepends = [
         aeson ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         directory fast-logger http-types iproute lifted-base network
         old-locale resourcet streaming-commons stringsearch text time
         transformers unix unix-compat vault void wai wai-logger word8 zlib
       ];
       testHaskellDepends = [
         base blaze-builder bytestring case-insensitive cookie fast-logger
         hspec http-types HUnit resourcet text time transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_13" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, iproute, lifted-base, network, old-locale
     , resourcet, streaming-commons, stringsearch, text, time
     , transformers, unix, unix-compat, vault, void, wai, wai-logger
     , word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.13";
       sha256 = "ec3720bf506247cf0dd6029c23348f431fe3a15816556156be41eb5612d2fce0";
       libraryHaskellDepends = [
         aeson ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         directory fast-logger http-types iproute lifted-base network
         old-locale resourcet streaming-commons stringsearch text time
         transformers unix unix-compat vault void wai wai-logger word8 zlib
       ];
       testHaskellDepends = [
         base blaze-builder bytestring case-insensitive cookie fast-logger
         hspec http-types HUnit resourcet text time transformers wai zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra_3_0_13_1" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, iproute, lifted-base, network, old-locale
     , resourcet, streaming-commons, stringsearch, text, time
     , transformers, unix, unix-compat, vault, void, wai, wai-logger
     , word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.13.1";
       sha256 = "37540b32387929716922be563238fe29c4db2c820356cc9b27d9ab1554300756";
       libraryHaskellDepends = [
         aeson ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         directory fast-logger http-types iproute lifted-base network
         old-locale resourcet streaming-commons stringsearch text time
         transformers unix unix-compat vault void wai wai-logger word8 zlib
       ];
       testHaskellDepends = [
         base blaze-builder bytestring case-insensitive cookie fast-logger
         hspec http-types HUnit resourcet text time transformers wai zlib
       ];
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-extra" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, base, base64-bytestring
     , blaze-builder, bytestring, case-insensitive, containers, cookie
     , data-default-class, deepseq, directory, fast-logger, hspec
     , http-types, HUnit, iproute, lifted-base, network, old-locale
     , resourcet, streaming-commons, stringsearch, text, time
     , transformers, unix, unix-compat, vault, void, wai, wai-logger
     , word8, zlib
     }:
     mkDerivation {
       pname = "wai-extra";
       version = "3.0.14";
       sha256 = "63f0df82dcd7c871c458e1ee67aca6d48b8794ff474e6b5e93873d4bbf6f7f2c";
       libraryHaskellDepends = [
         aeson ansi-terminal base base64-bytestring blaze-builder bytestring
         case-insensitive containers cookie data-default-class deepseq
         directory fast-logger http-types iproute lifted-base network
         old-locale resourcet streaming-commons stringsearch text time
         transformers unix unix-compat vault void wai wai-logger word8 zlib
       ];
       testHaskellDepends = [
         base blaze-builder bytestring case-insensitive cookie fast-logger
         hspec http-types HUnit resourcet text time transformers wai zlib
       ];
       homepage = "http://github.com/yesodweb/wai";
       description = "Provides some basic WAI handlers and middleware";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-frontend-monadcgi" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, cgi
     , containers, http-types, transformers, wai
     }:
     mkDerivation {
       pname = "wai-frontend-monadcgi";
       version = "3.0.0.2";
       sha256 = "c3e01b29a1a1c2a0934adc7e0c208454be525b2da1303a8b86391aa70c8ddc91";
       libraryHaskellDepends = [
         base bytestring case-insensitive cgi containers http-types
         transformers wai
       ];
       description = "Run CGI apps on WAI";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-graceful" = callPackage
    ({ mkDerivation, base, http-types, mtl, resourcet, unix, wai }:
     mkDerivation {
       pname = "wai-graceful";
       version = "0.1.0.1";
       sha256 = "58c96367884118ac36aaa6482588f91d4524c921d92647a494fca53755f60628";
       libraryHaskellDepends = [ base http-types mtl resourcet unix wai ];
       jailbreak = true;
       homepage = "https://bitbucket.org/dpwiz/wai-graceful";
       description = "Graceful shutdown for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-handler-devel" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, cmdargs, directory
     , hint, http-types, network, old-time, text, time, transformers
     , wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "wai-handler-devel";
       version = "2.0.0.2";
       sha256 = "fe2f849ab810ddc24e1b502f9a431c1ffb4b151fde447328b5f18f3cc3e0c38d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring directory hint http-types network
         old-time text time transformers wai wai-extra warp
       ];
       executableHaskellDepends = [ cmdargs ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "WAI server that automatically reloads code after modification. (deprecated)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-handler-fastcgi" = callPackage
    ({ mkDerivation, base, bytestring, fcgi, wai, wai-extra }:
     mkDerivation {
       pname = "wai-handler-fastcgi";
       version = "3.0.0.2";
       sha256 = "b555badd0fcae6519eb6f52dc0579d6a6ec4964aadf8b725bab8501cf7f473df";
       libraryHaskellDepends = [ base bytestring wai wai-extra ];
       librarySystemDepends = [ fcgi ];
       homepage = "http://www.yesodweb.com/book/web-application-interface";
       description = "Wai handler to fastcgi";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) fcgi;};

  "wai-handler-launch_3_0_0_3" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, http-types
     , process, streaming-commons, transformers, wai, warp
     }:
     mkDerivation {
       pname = "wai-handler-launch";
       version = "3.0.0.3";
       sha256 = "7429ad854ede2f942ee4cb9945d9fd51a6840edf2fa70a207e260977c607a9db";
       libraryHaskellDepends = [
         base blaze-builder bytestring http-types process streaming-commons
         transformers wai warp
       ];
       jailbreak = true;
       description = "Launch a web app in the default browser";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-handler-launch_3_0_0_4" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, http-types
     , process, streaming-commons, transformers, wai, warp
     }:
     mkDerivation {
       pname = "wai-handler-launch";
       version = "3.0.0.4";
       sha256 = "f1c0a7b7bd2f20b9a9ababa31fba2ff712823afa15a42c03119dc29c82d2d1e1";
       libraryHaskellDepends = [
         base blaze-builder bytestring http-types process streaming-commons
         transformers wai warp
       ];
       jailbreak = true;
       description = "Launch a web app in the default browser";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-handler-launch" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, http-types
     , process, streaming-commons, transformers, wai, warp
     }:
     mkDerivation {
       pname = "wai-handler-launch";
       version = "3.0.0.5";
       sha256 = "768eee5028d2ebf8684fb01ee064f8034c9c5c0f7b4e7a4a503d0b7f08df1227";
       libraryHaskellDepends = [
         base blaze-builder bytestring http-types process streaming-commons
         transformers wai warp
       ];
       description = "Launch a web app in the default browser";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-handler-scgi" = callPackage
    ({ mkDerivation, base, bytestring, wai, wai-extra }:
     mkDerivation {
       pname = "wai-handler-scgi";
       version = "2.0.0.2";
       sha256 = "4ced87a85c165be2436974a1d881079df09bf459e45bddabd57205621a3aed40";
       libraryHaskellDepends = [ base bytestring wai wai-extra ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/book/web-application-interface";
       description = "Wai handler to SCGI (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-handler-snap" = callPackage
    ({ mkDerivation, base, bytestring, containers, enumerator
     , snap-core, snap-server, transformers, wai
     }:
     mkDerivation {
       pname = "wai-handler-snap";
       version = "0.1.1";
       sha256 = "340c398b33d2d503b70d45becaaa1ba17e4992d6f90109d77b0dc2500f4c732a";
       libraryHaskellDepends = [
         base bytestring containers enumerator snap-core snap-server
         transformers wai
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/wai-handler-snap";
       description = "Web Application Interface handler using snap-server. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-handler-webkit" = callPackage
    ({ mkDerivation, base, QtWebKit, wai, warp }:
     mkDerivation {
       pname = "wai-handler-webkit";
       version = "3.0.0.3";
       sha256 = "08609d9bd78fafc130fc231b532a64b8292fb1700ab2ba3ee3cc96d45e4f5983";
       libraryHaskellDepends = [ base wai warp ];
       libraryPkgconfigDepends = [ QtWebKit ];
       homepage = "https://github.com/yesodweb/wai/tree/master/wai-handler-webkit";
       description = "Turn WAI applications into standalone GUIs using QtWebkit";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {QtWebKit = null;};

  "wai-hastache" = callPackage
    ({ mkDerivation, base, bytestring, hastache, http-types
     , transformers, wai
     }:
     mkDerivation {
       pname = "wai-hastache";
       version = "0.1";
       sha256 = "087f1a64c15e078984c0574f767202afc7d06d09c8f50e383cb95436864576ce";
       libraryHaskellDepends = [
         base bytestring hastache http-types transformers wai
       ];
       homepage = "https://github.com/singpolyma/wai-hastache";
       description = "Nice wrapper around hastache for use with WAI";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-hmac-auth" = callPackage
    ({ mkDerivation, base, base64-bytestring, bifunctors, byteable
     , bytestring, containers, cryptohash, hspec, http-types
     , monad-loops, mtl, transformers, wai, wai-extra
     }:
     mkDerivation {
       pname = "wai-hmac-auth";
       version = "1.0.0";
       sha256 = "24077731c9401de12aeff8bd0562164a1e8d042149297782f149f80f13e45fc2";
       libraryHaskellDepends = [
         base base64-bytestring bifunctors byteable bytestring containers
         cryptohash http-types monad-loops mtl transformers wai
       ];
       testHaskellDepends = [
         base base64-bytestring bifunctors byteable bytestring containers
         cryptohash hspec http-types monad-loops mtl transformers wai
         wai-extra
       ];
       jailbreak = true;
       homepage = "https://github.com/raptros/wai-hmac-auth";
       description = "hmac authentication tools for WAI apps";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-lens" = callPackage
    ({ mkDerivation, base, bytestring, http-types, lens, network, text
     , vault, wai
     }:
     mkDerivation {
       pname = "wai-lens";
       version = "0.1";
       sha256 = "9d6c41743155f878e40de50202c221f996ec17159058ea4358eb49c3e53d6d17";
       libraryHaskellDepends = [
         base bytestring http-types lens network text vault wai
       ];
       jailbreak = true;
       homepage = "https://github.com/webcrank/wai-lens";
       description = "Lenses for WAI";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-lite" = callPackage
    ({ mkDerivation, base, bytestring, conduit, http-types, text
     , transformers, wai, wai-extra
     }:
     mkDerivation {
       pname = "wai-lite";
       version = "0.2.0.0";
       sha256 = "e47fc90d24e39f479ded9df6381dc4d2380f68bdafb9b77de9048c1a8ab21dbe";
       libraryHaskellDepends = [
         base bytestring conduit http-types text transformers wai wai-extra
       ];
       jailbreak = true;
       description = "DEPCRECATED (use package \"simple\" instead) A minimalist web framework for WAI web applications";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-logger_2_2_3" = callPackage
    ({ mkDerivation, auto-update, base, blaze-builder, byteorder
     , bytestring, case-insensitive, doctest, easy-file, fast-logger
     , http-types, network, unix, unix-time, wai
     }:
     mkDerivation {
       pname = "wai-logger";
       version = "2.2.3";
       sha256 = "1c74063036301219614d9b596ccdd3af52436693c9c84d9febe347e707fe5752";
       libraryHaskellDepends = [
         auto-update base blaze-builder byteorder bytestring
         case-insensitive easy-file fast-logger http-types network unix
         unix-time wai
       ];
       testHaskellDepends = [ base doctest ];
       doHaddock = false;
       doCheck = false;
       description = "A logging system for WAI";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-logger_2_2_4" = callPackage
    ({ mkDerivation, auto-update, base, blaze-builder, byteorder
     , bytestring, case-insensitive, doctest, easy-file, fast-logger
     , http-types, network, unix, unix-time, wai
     }:
     mkDerivation {
       pname = "wai-logger";
       version = "2.2.4";
       sha256 = "7bb519741664eb2d41582f712fb2066270ea309813ae755ab930d8cfdc68f250";
       libraryHaskellDepends = [
         auto-update base blaze-builder byteorder bytestring
         case-insensitive easy-file fast-logger http-types network unix
         unix-time wai
       ];
       testHaskellDepends = [ base doctest ];
       doCheck = false;
       description = "A logging system for WAI";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-logger_2_2_4_1" = callPackage
    ({ mkDerivation, auto-update, base, blaze-builder, byteorder
     , bytestring, case-insensitive, doctest, easy-file, fast-logger
     , http-types, network, unix, unix-time, wai
     }:
     mkDerivation {
       pname = "wai-logger";
       version = "2.2.4.1";
       sha256 = "f37d6bb6ea4a5f881ab2c9df571c923c5624cc83882b19640b924436fcdedae8";
       libraryHaskellDepends = [
         auto-update base blaze-builder byteorder bytestring
         case-insensitive easy-file fast-logger http-types network unix
         unix-time wai
       ];
       testHaskellDepends = [ base doctest ];
       doCheck = false;
       description = "A logging system for WAI";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-logger" = callPackage
    ({ mkDerivation, auto-update, base, blaze-builder, byteorder
     , bytestring, case-insensitive, doctest, easy-file, fast-logger
     , http-types, network, unix, unix-time, wai
     }:
     mkDerivation {
       pname = "wai-logger";
       version = "2.2.5";
       sha256 = "678e6fa92d2a8c71182b96e809c69cca4558ddd132ec41bdcf786cf5f1800ba3";
       libraryHaskellDepends = [
         auto-update base blaze-builder byteorder bytestring
         case-insensitive easy-file fast-logger http-types network unix
         unix-time wai
       ];
       testHaskellDepends = [ base doctest ];
       doCheck = false;
       description = "A logging system for WAI";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-logger-prefork" = callPackage
    ({ mkDerivation, base, bytestring, date-cache, fast-logger
     , http-types, unix, wai, wai-logger
     }:
     mkDerivation {
       pname = "wai-logger-prefork";
       version = "0.3.0";
       sha256 = "c4e370feb55967fa8770179eeab9eec266491b748ae9d506ea40b62f32a6da31";
       libraryHaskellDepends = [
         base bytestring date-cache fast-logger http-types unix wai
         wai-logger
       ];
       description = "A logging system for preforked WAI apps";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-cache" = callPackage
    ({ mkDerivation, base, binary, blaze-builder-conduit, bytestring
     , conduit, crypto-conduit, http-types, HUnit, pureMD5
     , test-framework, test-framework-hunit, wai, wai-test
     }:
     mkDerivation {
       pname = "wai-middleware-cache";
       version = "0.3.6";
       sha256 = "bc41c478be6afc164c5427206020680b9f894717d5740e3ddb8a735bb5c419cf";
       libraryHaskellDepends = [
         base binary blaze-builder-conduit bytestring conduit crypto-conduit
         http-types pureMD5 wai
       ];
       testHaskellDepends = [
         base bytestring http-types HUnit test-framework
         test-framework-hunit wai wai-test
       ];
       jailbreak = true;
       homepage = "https://github.com/akaspin/wai-middleware-cache";
       description = "Caching middleware for WAI";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-cache-redis" = callPackage
    ({ mkDerivation, base, binary, blaze-builder-conduit, bytestring
     , case-insensitive, conduit, hedis, hedis-pile, http-types
     , transformers, wai, wai-middleware-cache
     }:
     mkDerivation {
       pname = "wai-middleware-cache-redis";
       version = "0.4.3";
       sha256 = "89d300e7d6a6e0b570d217039ee50aa266d5cbb01828feb197662b1d990ca8ed";
       libraryHaskellDepends = [
         base binary blaze-builder-conduit bytestring case-insensitive
         conduit hedis hedis-pile http-types transformers wai
         wai-middleware-cache
       ];
       jailbreak = true;
       homepage = "https://github.com/akaspin/wai-middleware-cache-redis";
       description = "Redis backend for wai-middleware-cache";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-caching" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, http-types, wai
     }:
     mkDerivation {
       pname = "wai-middleware-caching";
       version = "0.1.0.2";
       sha256 = "15b5fb9c92599d5ecb6a70ba40bad024488f9eca7139abe23b961ba21602d78d";
       libraryHaskellDepends = [
         base blaze-builder bytestring http-types wai
       ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/yogsototh/wai-middleware-caching/tree/master/wai-middleware-caching#readme";
       description = "WAI Middleware to cache things";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-middleware-caching-lru" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, http-types
     , lrucache, text, wai, wai-middleware-caching
     }:
     mkDerivation {
       pname = "wai-middleware-caching-lru";
       version = "0.1.0.0";
       sha256 = "377dc842f5ad77b98e8a817e092c891ccfd0da978fb9f69a380f001a95da28d3";
       libraryHaskellDepends = [
         base blaze-builder bytestring http-types lrucache text wai
         wai-middleware-caching
       ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/yogsototh/wai-middleware-caching/tree/master/wai-middleware-caching-lru#readme";
       description = "Initial project template from stack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-middleware-caching-redis" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, hedis, http-types
     , text, wai, wai-middleware-caching
     }:
     mkDerivation {
       pname = "wai-middleware-caching-redis";
       version = "0.2.0.0";
       sha256 = "6ff53783db20d8f0ff00514ea2679f7022ca59eb20ffad22628ac17c13bf7c4c";
       libraryHaskellDepends = [
         base blaze-builder bytestring hedis http-types text wai
         wai-middleware-caching
       ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/yogsototh/wai-middleware-caching/tree/master/wai-middleware-caching-redis#readme";
       description = "Cache Wai Middleware using Redis backend";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-middleware-catch" = callPackage
    ({ mkDerivation, base, bytestring, http-types, lifted-base, wai }:
     mkDerivation {
       pname = "wai-middleware-catch";
       version = "0.3.6";
       sha256 = "d014ccbad8341d47a6cc274c33c9ce3b61bb264cbeee5817eebcc13f9ad205ee";
       libraryHaskellDepends = [
         base bytestring http-types lifted-base wai
       ];
       jailbreak = true;
       homepage = "https://github.com/akaspin/wai-middleware-catch";
       description = "Wai error catching middleware";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-consul" = callPackage
    ({ mkDerivation, async, base, base-prelude, bytestring, conduit
     , conduit-extra, consul-haskell, enclosed-exceptions, http-client
     , http-types, monad-control, monad-logger, network, process
     , resourcet, text, transformers, void, wai, wai-app-static
     , wai-conduit, wai-extra, warp
     }:
     mkDerivation {
       pname = "wai-middleware-consul";
       version = "0.1.0.2";
       sha256 = "d89d5a5bf0b08cf4fcd300d9e16c351a146119c34a9f31949498a874699c0763";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         async base base-prelude bytestring conduit conduit-extra
         consul-haskell enclosed-exceptions http-client http-types
         monad-control monad-logger network process resourcet text
         transformers void wai wai-conduit
       ];
       executableHaskellDepends = [
         async base base-prelude monad-logger transformers wai
         wai-app-static wai-extra warp
       ];
       homepage = "https://github.com/fpco/wai-middleware-consul";
       description = "Wai Middleware for Consul";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-middleware-content-type_0_2_0" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, blaze-html, bytestring
     , clay, exceptions, hashable, hspec, hspec-wai, http-media
     , http-types, lucid, mmorph, monad-control, monad-logger, mtl
     , pandoc, pandoc-types, resourcet, shakespeare, tasty, tasty-hspec
     , text, transformers, transformers-base, unordered-containers
     , urlpath, wai, wai-transformers, warp
     }:
     mkDerivation {
       pname = "wai-middleware-content-type";
       version = "0.2.0";
       sha256 = "d45ace35cf7a7ac92d8bd46b9001d1c237d68a20810634467663779b228f5866";
       revision = "1";
       editedCabalFile = "6958bfd062d09a59c33c0d5f0c52356df462bd2185ee8088ac3e8078ffacf692";
       libraryHaskellDepends = [
         aeson base blaze-builder blaze-html bytestring clay exceptions
         hashable http-media http-types lucid mmorph monad-control
         monad-logger mtl pandoc resourcet shakespeare text transformers
         transformers-base unordered-containers urlpath wai
       ];
       testHaskellDepends = [
         aeson base blaze-builder blaze-html bytestring clay exceptions
         hashable hspec hspec-wai http-media http-types lucid mmorph
         monad-control monad-logger mtl pandoc pandoc-types resourcet
         shakespeare tasty tasty-hspec text transformers transformers-base
         unordered-containers urlpath wai wai-transformers warp
       ];
       jailbreak = true;
       description = "Route to different middlewares based on the incoming Accept header";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-content-type" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, blaze-html, bytestring
     , clay, exceptions, hashable, hspec, hspec-wai, http-media
     , http-types, lucid, mmorph, monad-control, monad-logger, mtl
     , pandoc, pandoc-types, resourcet, shakespeare, tasty, tasty-hspec
     , text, transformers, transformers-base, unordered-containers
     , urlpath, wai, wai-transformers, warp
     }:
     mkDerivation {
       pname = "wai-middleware-content-type";
       version = "0.4.0";
       sha256 = "bccf5fb49c39cde628d8e73b4afff934186cba6824a8b04501bb3fbada4229eb";
       libraryHaskellDepends = [
         aeson base blaze-builder blaze-html bytestring clay exceptions
         hashable http-media http-types lucid mmorph monad-control
         monad-logger mtl pandoc resourcet shakespeare text transformers
         transformers-base unordered-containers urlpath wai wai-transformers
       ];
       testHaskellDepends = [
         aeson base blaze-builder blaze-html bytestring clay exceptions
         hashable hspec hspec-wai http-media http-types lucid mmorph
         monad-control monad-logger mtl pandoc pandoc-types resourcet
         shakespeare tasty tasty-hspec text transformers transformers-base
         unordered-containers urlpath wai wai-transformers warp
       ];
       description = "A simple WAI library for responding with content";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-middleware-crowd_0_1_1_2" = callPackage
    ({ mkDerivation, authenticate, base, base64-bytestring, binary
     , blaze-builder, bytestring, case-insensitive, clientsession
     , containers, cookie, gitrev, http-client, http-client-tls
     , http-reverse-proxy, http-types, optparse-applicative, resourcet
     , template-haskell, text, time, transformers, unix-compat, vault
     , wai, wai-app-static, warp
     }:
     mkDerivation {
       pname = "wai-middleware-crowd";
       version = "0.1.1.2";
       sha256 = "5e3959a0a7640c48a7cd037ff0c16e7d2f2eaba580defb5f648773133cc33b0d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         authenticate base base64-bytestring binary blaze-builder bytestring
         case-insensitive clientsession containers cookie http-client
         http-client-tls http-types resourcet text time unix-compat vault
         wai
       ];
       executableHaskellDepends = [
         base clientsession gitrev http-client http-client-tls
         http-reverse-proxy optparse-applicative template-haskell text
         transformers wai wai-app-static warp
       ];
       jailbreak = true;
       description = "Middleware and utilities for using Atlassian Crowd authentication";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-crowd_0_1_2_1" = callPackage
    ({ mkDerivation, authenticate, base, base64-bytestring, binary
     , blaze-builder, bytestring, case-insensitive, clientsession
     , containers, cookie, gitrev, http-client, http-client-tls
     , http-reverse-proxy, http-types, optparse-applicative, resourcet
     , template-haskell, text, time, transformers, unix-compat, vault
     , wai, wai-app-static, warp
     }:
     mkDerivation {
       pname = "wai-middleware-crowd";
       version = "0.1.2.1";
       sha256 = "80665cab1b695ff665f497611869a80b48a2b45b0b7bc9be256b313f537e5adf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         authenticate base base64-bytestring binary blaze-builder bytestring
         case-insensitive clientsession containers cookie http-client
         http-client-tls http-types resourcet text time unix-compat vault
         wai
       ];
       executableHaskellDepends = [
         base clientsession gitrev http-client http-client-tls
         http-reverse-proxy optparse-applicative template-haskell text
         transformers wai wai-app-static warp
       ];
       description = "Middleware and utilities for using Atlassian Crowd authentication";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-crowd_0_1_3" = callPackage
    ({ mkDerivation, authenticate, base, base64-bytestring, binary
     , blaze-builder, bytestring, case-insensitive, clientsession
     , containers, cookie, gitrev, http-client, http-client-tls
     , http-reverse-proxy, http-types, optparse-applicative, resourcet
     , template-haskell, text, time, transformers, unix-compat, vault
     , wai, wai-app-static, wai-extra, warp
     }:
     mkDerivation {
       pname = "wai-middleware-crowd";
       version = "0.1.3";
       sha256 = "ae39aacc5cad59ff26053e8650b8dde3d4432efa6176ef2101501fe8d0008704";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         authenticate base base64-bytestring binary blaze-builder bytestring
         case-insensitive clientsession containers cookie http-client
         http-client-tls http-types resourcet text time unix-compat vault
         wai
       ];
       executableHaskellDepends = [
         base bytestring clientsession gitrev http-client http-client-tls
         http-reverse-proxy http-types optparse-applicative template-haskell
         text transformers wai wai-app-static wai-extra warp
       ];
       description = "Middleware and utilities for using Atlassian Crowd authentication";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-crowd" = callPackage
    ({ mkDerivation, authenticate, base, base64-bytestring, binary
     , blaze-builder, bytestring, case-insensitive, clientsession
     , containers, cookie, gitrev, http-client, http-client-tls
     , http-reverse-proxy, http-types, optparse-applicative, resourcet
     , template-haskell, text, time, transformers, unix-compat, vault
     , wai, wai-app-static, wai-extra, warp
     }:
     mkDerivation {
       pname = "wai-middleware-crowd";
       version = "0.1.4";
       sha256 = "f496aa3581ecb75ec611c50fbbb10b17cbca612c7caba00dfa24191aba1585cb";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         authenticate base base64-bytestring binary blaze-builder bytestring
         case-insensitive clientsession containers cookie http-client
         http-client-tls http-types resourcet text time unix-compat vault
         wai
       ];
       executableHaskellDepends = [
         base bytestring clientsession gitrev http-client http-client-tls
         http-reverse-proxy http-types optparse-applicative template-haskell
         text transformers wai wai-app-static wai-extra warp
       ];
       description = "Middleware and utilities for using Atlassian Crowd authentication";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "wai-middleware-etag" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, cryptohash
     , filepath, http-date, http-types, unix-compat
     , unordered-containers, wai
     }:
     mkDerivation {
       pname = "wai-middleware-etag";
       version = "0.1.1.1";
       sha256 = "6279ff3c0ec0bdc8a37388dbea30a790f82d1e536b40a21fc3856e0a8e237be4";
       libraryHaskellDepends = [
         base base64-bytestring bytestring cryptohash filepath http-date
         http-types unix-compat unordered-containers wai
       ];
       jailbreak = true;
       homepage = "https://github.com/ameingast/wai-middleware-etag";
       description = "WAI ETag middleware for static files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-middleware-gunzip" = callPackage
    ({ mkDerivation, base, bytestring, http-types, streaming-commons
     , wai
     }:
     mkDerivation {
       pname = "wai-middleware-gunzip";
       version = "0.0.2";
       sha256 = "bd9d542ee4b1255c01161266da2bcf7056111ae77f792a23ac2263e209bf7b65";
       libraryHaskellDepends = [
         base bytestring http-types streaming-commons wai
       ];
       homepage = "https://github.com/twittner/wai-middleware-gunzip";
       description = "WAI middleware to unzip request bodies";
       license = stdenv.lib.licenses.mpl20;
     }) {};

  "wai-middleware-headers" = callPackage
    ({ mkDerivation, base, bytestring, http-types, wai }:
     mkDerivation {
       pname = "wai-middleware-headers";
       version = "0.1";
       sha256 = "30df18e1184b23f5571cb10a83c1fe8a13f0d6a53738e68f17a437224b195781";
       libraryHaskellDepends = [ base bytestring http-types wai ];
       homepage = "http://github.com/seanhess/wai-middleware-headers";
       description = "cors and addHeaders for WAI";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-hmac" = callPackage
    ({ mkDerivation, base, base64-bytestring, byteable, bytestring
     , case-insensitive, cryptohash, doctest, Glob, hlint, hspec
     , http-types, HUnit, process, regex-compat, transformers, wai
     , wai-extra, word8
     }:
     mkDerivation {
       pname = "wai-middleware-hmac";
       version = "0.1.0.0";
       sha256 = "1a7fc07c9d43168c980cc14c3ec5123733355ba9e32bad0da48e9a14a10dad07";
       libraryHaskellDepends = [
         base base64-bytestring byteable bytestring case-insensitive
         cryptohash http-types transformers wai word8
       ];
       testHaskellDepends = [
         base bytestring doctest Glob hlint hspec http-types HUnit process
         regex-compat wai wai-extra
       ];
       jailbreak = true;
       homepage = "https://github.com/creichert/wai-middleware-hmac";
       description = "HMAC Authentication Middleware for WAI";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-middleware-hmac-client" = callPackage
    ({ mkDerivation, base, base64-bytestring, byteable, bytestring
     , case-insensitive, cryptohash, http-client, http-types, mtl
     , old-locale, time, transformers, word8
     }:
     mkDerivation {
       pname = "wai-middleware-hmac-client";
       version = "0.1.0.2";
       sha256 = "ba419c0e9a6d00e7ab03150219012128908bc3018b43d7d4cb46cbb01babaeca";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base base64-bytestring byteable bytestring case-insensitive
         cryptohash http-client http-types mtl old-locale time transformers
         word8
       ];
       executableHaskellDepends = [
         base bytestring http-client transformers
       ];
       description = "WAI HMAC Authentication Middleware Client";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-metrics" = callPackage
    ({ mkDerivation, base, bytestring, ekg-core, http-types, QuickCheck
     , scotty, tasty, tasty-hunit, tasty-quickcheck, time, transformers
     , wai, wai-extra
     }:
     mkDerivation {
       pname = "wai-middleware-metrics";
       version = "0.2.2";
       sha256 = "2a75f6405d811e719c9bf78a6cf6331ee959a0a18eef6702da29dad7cb9b6e91";
       libraryHaskellDepends = [ base ekg-core http-types time wai ];
       testHaskellDepends = [
         base bytestring ekg-core http-types QuickCheck scotty tasty
         tasty-hunit tasty-quickcheck time transformers wai wai-extra
       ];
       homepage = "https://github.com/Helkafen/wai-middleware-metrics";
       description = "A WAI middleware to collect EKG request metrics";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-middleware-preprocessor" = callPackage
    ({ mkDerivation, base, Cabal, directory, mtl, split, text, wai
     , wai-middleware-static, warp
     }:
     mkDerivation {
       pname = "wai-middleware-preprocessor";
       version = "0.2.0.0";
       sha256 = "41ae57db57d9b9a1dd13b0b585129b4623842434a236268456b71c5536003fd9";
       libraryHaskellDepends = [
         base directory mtl split text wai wai-middleware-static
       ];
       testHaskellDepends = [
         base Cabal directory mtl split text wai wai-middleware-static warp
       ];
       jailbreak = true;
       homepage = "https://github.com/taktoa/wai-middleware-preprocessor";
       description = "WAI middleware for preprocessing static files";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-prometheus" = callPackage
    ({ mkDerivation, base, bytestring, data-default, doctest
     , http-types, prometheus-client, text, time, wai
     }:
     mkDerivation {
       pname = "wai-middleware-prometheus";
       version = "0.1.0.1";
       sha256 = "6da4cb9dd96912332050dd2abf6f489ef94aa856c409bd6205f706257bbe3037";
       libraryHaskellDepends = [
         base bytestring data-default http-types prometheus-client text time
         wai
       ];
       testHaskellDepends = [ base doctest prometheus-client ];
       homepage = "https://github.com/fimad/prometheus-haskell";
       description = "WAI middlware for exposing http://prometheus.io metrics.";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "wai-middleware-route" = callPackage
    ({ mkDerivation, base, bytestring, http-types, HUnit
     , test-framework, test-framework-hunit, text, wai, wai-test
     , yesod-routes
     }:
     mkDerivation {
       pname = "wai-middleware-route";
       version = "0.7.3";
       sha256 = "a7570a70f8b80e20ef2eb89293317379f955e72f2a8435b99b54e25c5857f17d";
       libraryHaskellDepends = [
         base bytestring http-types text wai yesod-routes
       ];
       testHaskellDepends = [
         base bytestring http-types HUnit test-framework
         test-framework-hunit text wai wai-test
       ];
       jailbreak = true;
       homepage = "https://github.com/akaspin/wai-middleware-route";
       description = "Wai dispatch middleware";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-static_0_6_0_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , http-types, mtl, text, wai
     }:
     mkDerivation {
       pname = "wai-middleware-static";
       version = "0.6.0.1";
       sha256 = "cd18a1dfc28ceb7e4b73ede6363faee82cb2c2772d293d016fa39551aa158efa";
       libraryHaskellDepends = [
         base bytestring containers directory filepath http-types mtl text
         wai
       ];
       jailbreak = true;
       homepage = "https://github.com/scotty-web/wai-middleware-static";
       description = "WAI middleware that serves requests to static files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-static_0_7_0_1" = callPackage
    ({ mkDerivation, base, base16-bytestring, bytestring, containers
     , cryptohash, directory, expiring-cache-map, filepath, http-types
     , mtl, old-locale, text, time, wai
     }:
     mkDerivation {
       pname = "wai-middleware-static";
       version = "0.7.0.1";
       sha256 = "3c1a12c7b07fe04a597a0accb5f806629e27427c2151f8fe91e1795ff61a7a4f";
       libraryHaskellDepends = [
         base base16-bytestring bytestring containers cryptohash directory
         expiring-cache-map filepath http-types mtl old-locale text time wai
       ];
       jailbreak = true;
       homepage = "https://github.com/scotty-web/wai-middleware-static";
       description = "WAI middleware that serves requests to static files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-static" = callPackage
    ({ mkDerivation, base, base16-bytestring, bytestring, containers
     , cryptohash, directory, expiring-cache-map, filepath, http-types
     , mime-types, mtl, old-locale, text, time, wai
     }:
     mkDerivation {
       pname = "wai-middleware-static";
       version = "0.8.0";
       sha256 = "a37aaf452e3816928934d39b4eef3c1f7186c9db618d0b303e5136fc858e5e58";
       revision = "2";
       editedCabalFile = "41421955e1c4c86f72ea709dd43ff1e8a7a4b5ad59fb90923441d449a9506327";
       libraryHaskellDepends = [
         base base16-bytestring bytestring containers cryptohash directory
         expiring-cache-map filepath http-types mime-types mtl old-locale
         text time wai
       ];
       homepage = "https://github.com/scotty-web/wai-middleware-static";
       description = "WAI middleware that serves requests to static files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-middleware-static-caching" = callPackage
    ({ mkDerivation, base, base16-bytestring, bytestring, containers
     , cryptohash, directory, expiring-cache-map, filepath, http-types
     , mtl, old-locale, text, time, unix, wai
     }:
     mkDerivation {
       pname = "wai-middleware-static-caching";
       version = "0.6.0.1";
       sha256 = "13fadccc87d248dbcc1dc781ba9d82c9fe0237ebaf18acdff20ebc905dc84476";
       libraryHaskellDepends = [
         base base16-bytestring bytestring containers cryptohash directory
         expiring-cache-map filepath http-types mtl old-locale text time
         unix wai
       ];
       jailbreak = true;
       homepage = "https://github.com/agrafix/wai-middleware-static";
       description = "WAI middleware that serves requests to static files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-throttle_0_2_0_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, hlint, hspec
     , http-types, HUnit, network, stm, token-bucket, transformers, wai
     , wai-extra
     }:
     mkDerivation {
       pname = "wai-middleware-throttle";
       version = "0.2.0.1";
       sha256 = "56b55cdb8e081693c35b35791a59b155a91a628e205c9645cbe9d160176b1d23";
       libraryHaskellDepends = [
         base containers http-types network stm token-bucket transformers
         wai
       ];
       testHaskellDepends = [
         base bytestring hlint hspec http-types HUnit stm transformers wai
         wai-extra
       ];
       description = "WAI Middleware for Request Throttling";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-middleware-throttle" = callPackage
    ({ mkDerivation, base, bytestring, containers, hashable, hlint
     , hspec, http-types, HUnit, network, stm, token-bucket
     , transformers, wai, wai-extra
     }:
     mkDerivation {
       pname = "wai-middleware-throttle";
       version = "0.2.0.2";
       sha256 = "b38b28d2a2dcda631cf12ff066343539986028106867594dbf07efe40e81d712";
       libraryHaskellDepends = [
         base containers hashable http-types network stm token-bucket
         transformers wai
       ];
       testHaskellDepends = [
         base bytestring hlint hspec http-types HUnit stm transformers wai
         wai-extra
       ];
       doCheck = false;
       description = "WAI Middleware for Request Throttling";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-middleware-verbs" = callPackage
    ({ mkDerivation, base, errors, exceptions, hashable, http-types
     , mmorph, monad-logger, mtl, resourcet, text, transformers
     , transformers-base, unordered-containers, wai
     , wai-middleware-content-type, wai-transformers, warp
     }:
     mkDerivation {
       pname = "wai-middleware-verbs";
       version = "0.2.0";
       sha256 = "5e88a38e8e838be9334b72a4dcec70874fe02c8b128dc7a64e682cacfb6ffbf3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base errors exceptions hashable http-types mmorph monad-logger mtl
         resourcet transformers transformers-base unordered-containers wai
       ];
       executableHaskellDepends = [
         base errors exceptions hashable http-types mmorph monad-logger mtl
         resourcet text transformers transformers-base unordered-containers
         wai wai-middleware-content-type wai-transformers warp
       ];
       description = "Route different middleware responses based on the incoming HTTP verb";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-predicates_0_8_4" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , bytestring-conversion, case-insensitive, cookie, http-types
     , singletons, tasty, tasty-hunit, tasty-quickcheck, transformers
     , vault, vector, wai
     }:
     mkDerivation {
       pname = "wai-predicates";
       version = "0.8.4";
       sha256 = "c5af9c66fa03446bcb71d975544ecf394cc5626dd9ec5a7109b02a3453192b1a";
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-conversion case-insensitive
         cookie http-types singletons transformers vault vector wai
       ];
       testHaskellDepends = [
         base blaze-builder bytestring case-insensitive http-types tasty
         tasty-hunit tasty-quickcheck wai
       ];
       jailbreak = true;
       homepage = "https://github.com/twittner/wai-predicates/";
       description = "WAI request predicates";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-predicates_0_8_5" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , bytestring-conversion, case-insensitive, cookie, http-types
     , singletons, tasty, tasty-hunit, tasty-quickcheck, transformers
     , vault, vector, wai
     }:
     mkDerivation {
       pname = "wai-predicates";
       version = "0.8.5";
       sha256 = "2e93981ccb8a1179b784ed9dff6eb2cd8b4d8abde1a7e576ba9a9bfa04852fe1";
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-conversion case-insensitive
         cookie http-types singletons transformers vault vector wai
       ];
       testHaskellDepends = [
         base blaze-builder bytestring case-insensitive http-types tasty
         tasty-hunit tasty-quickcheck wai
       ];
       homepage = "https://github.com/twittner/wai-predicates/";
       description = "WAI request predicates";
       license = stdenv.lib.licenses.mpl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-predicates" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , bytestring-conversion, case-insensitive, cookie, http-types
     , singletons, tasty, tasty-hunit, tasty-quickcheck, transformers
     , vault, vector, wai
     }:
     mkDerivation {
       pname = "wai-predicates";
       version = "0.8.6";
       sha256 = "7aba73c37a27975b37077b6f06d6c34488750ff022210e29a0966c68fafde918";
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-conversion case-insensitive
         cookie http-types singletons transformers vault vector wai
       ];
       testHaskellDepends = [
         base blaze-builder bytestring case-insensitive http-types tasty
         tasty-hunit tasty-quickcheck wai
       ];
       homepage = "https://gitlab.com/twittner/wai-predicates/";
       description = "WAI request predicates";
       license = stdenv.lib.licenses.mpl20;
     }) {};

  "wai-request-spec" = callPackage
    ({ mkDerivation, base, bytestring, case-insensitive, containers
     , http-types, text, wai
     }:
     mkDerivation {
       pname = "wai-request-spec";
       version = "0.10.2.0";
       sha256 = "a5789b5995628b72eec33b5ca462e23f506a01c4dcd8d37116ce76b491753497";
       libraryHaskellDepends = [
         base bytestring case-insensitive containers http-types text wai
       ];
       homepage = "https://gitlab.com/cpp.cabrera/wai-request-spec";
       description = "Declarative request parsing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-responsible" = callPackage
    ({ mkDerivation, base, bytestring, http-types, wai }:
     mkDerivation {
       pname = "wai-responsible";
       version = "0.0.0.0";
       sha256 = "6a03b90b6e00d64bb46391a19c5e6f99cb36a3902258b70aa16f8410c223c661";
       libraryHaskellDepends = [ base bytestring http-types wai ];
       jailbreak = true;
       homepage = "https://github.com/pharpend/wai-responsible";
       description = "Response interface for WAI";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-route_0_3" = callPackage
    ({ mkDerivation, base, bytestring, http-types, mtl, QuickCheck
     , tasty, tasty-quickcheck, unordered-containers, wai
     }:
     mkDerivation {
       pname = "wai-route";
       version = "0.3";
       sha256 = "7792dbca9f278eea6c9533c71dd40073c2b0fe7f7a87914e169d98385b6faabe";
       libraryHaskellDepends = [
         base bytestring http-types unordered-containers wai
       ];
       testHaskellDepends = [
         base bytestring http-types mtl QuickCheck tasty tasty-quickcheck
         wai
       ];
       jailbreak = true;
       description = "Minimalistic, efficient routing for WAI";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-route" = callPackage
    ({ mkDerivation, base, bytestring, http-types, mtl, QuickCheck
     , tasty, tasty-quickcheck, unordered-containers, wai
     }:
     mkDerivation {
       pname = "wai-route";
       version = "0.3.1";
       sha256 = "6715210058c36baf8476f27807f1ac7ef9c190f5769d516f3edfeae4fb753aef";
       libraryHaskellDepends = [
         base bytestring http-types unordered-containers wai
       ];
       testHaskellDepends = [
         base bytestring http-types mtl QuickCheck tasty tasty-quickcheck
         wai
       ];
       description = "Minimalistic, efficient routing for WAI";
       license = "unknown";
     }) {};

  "wai-router" = callPackage
    ({ mkDerivation, base, text, wai }:
     mkDerivation {
       pname = "wai-router";
       version = "1.0.0.1";
       sha256 = "e7a2f20d2aaa496206a09a508e9e8923a545181802922f026b3bfa4dccac47a0";
       libraryHaskellDepends = [ base text wai ];
       jailbreak = true;
       homepage = "http://github.com/mdmarek/wai-router";
       description = "Provides basic routing on URL paths for WAI";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-routes_0_7_3" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, containers
     , http-types, monad-loops, mtl, path-pieces, random
     , template-haskell, text, wai
     }:
     mkDerivation {
       pname = "wai-routes";
       version = "0.7.3";
       sha256 = "92d694a9b63b8f34e1e62f5f29b65cb85566eeb9cad90b7dd34689bc296b139b";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring containers http-types
         monad-loops mtl path-pieces random template-haskell text wai
       ];
       jailbreak = true;
       homepage = "https://ajnsit.github.io/wai-routes/";
       description = "Typesafe URLs for Wai applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-routes_0_9_4" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring
     , case-insensitive, containers, cookie, data-default-class
     , filepath, hspec, hspec-wai, hspec-wai-json, http-types
     , mime-types, monad-loops, mtl, path-pieces, random
     , template-haskell, text, vault, wai, wai-app-static, wai-extra
     }:
     mkDerivation {
       pname = "wai-routes";
       version = "0.9.4";
       sha256 = "b8c28e1209efd4a45ec90c027cd50a3a415cb6431b3490ce68c79a3bcbde007c";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring case-insensitive containers
         cookie data-default-class filepath http-types mime-types
         monad-loops mtl path-pieces random template-haskell text vault wai
         wai-app-static wai-extra
       ];
       testHaskellDepends = [
         aeson base hspec hspec-wai hspec-wai-json text wai
       ];
       homepage = "https://ajnsit.github.io/wai-routes/";
       description = "Typesafe URLs for Wai applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-routes_0_9_5" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring
     , case-insensitive, containers, cookie, data-default-class
     , filepath, hspec, hspec-wai, hspec-wai-json, http-types
     , mime-types, monad-loops, mtl, path-pieces, random
     , template-haskell, text, vault, wai, wai-app-static, wai-extra
     }:
     mkDerivation {
       pname = "wai-routes";
       version = "0.9.5";
       sha256 = "493083791e875fe9adebc12347a28bb2c7d84d808d54cd33ed6aa5fe99ee12c3";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring case-insensitive containers
         cookie data-default-class filepath http-types mime-types
         monad-loops mtl path-pieces random template-haskell text vault wai
         wai-app-static wai-extra
       ];
       testHaskellDepends = [
         aeson base hspec hspec-wai hspec-wai-json text wai
       ];
       homepage = "https://ajnsit.github.io/wai-routes/";
       description = "Typesafe URLs for Wai applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-routes_0_9_6" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring
     , case-insensitive, containers, cookie, data-default-class
     , filepath, hspec, hspec-wai, hspec-wai-json, http-types
     , mime-types, monad-loops, mtl, path-pieces, random
     , template-haskell, text, vault, wai, wai-app-static, wai-extra
     }:
     mkDerivation {
       pname = "wai-routes";
       version = "0.9.6";
       sha256 = "347725c4e42cca525b376ea7a5017c3aaa55c15af73b600e597aee2d98f0b80b";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring case-insensitive containers
         cookie data-default-class filepath http-types mime-types
         monad-loops mtl path-pieces random template-haskell text vault wai
         wai-app-static wai-extra
       ];
       testHaskellDepends = [
         aeson base hspec hspec-wai hspec-wai-json text wai
       ];
       homepage = "https://ajnsit.github.io/wai-routes/";
       description = "Typesafe URLs for Wai applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-routes" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring
     , case-insensitive, containers, cookie, data-default-class
     , filepath, hspec, hspec-wai, hspec-wai-json, http-types
     , mime-types, monad-loops, mtl, path-pieces, random
     , template-haskell, text, vault, wai, wai-app-static, wai-extra
     }:
     mkDerivation {
       pname = "wai-routes";
       version = "0.9.7";
       sha256 = "326fb3f6da6c87f625b75479dc4881a82129d46053a3e2b42eae37d51ca27166";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring case-insensitive containers
         cookie data-default-class filepath http-types mime-types
         monad-loops mtl path-pieces random template-haskell text vault wai
         wai-app-static wai-extra
       ];
       testHaskellDepends = [
         aeson base hspec hspec-wai hspec-wai-json text wai
       ];
       homepage = "https://ajnsit.github.io/wai-routes/";
       description = "Typesafe URLs for Wai applications";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-routing_0_12_1" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , bytestring-conversion, case-insensitive, containers, cookie
     , http-types, tasty, tasty-hunit, tasty-quickcheck, transformers
     , wai, wai-predicates, wai-route
     }:
     mkDerivation {
       pname = "wai-routing";
       version = "0.12.1";
       sha256 = "c53a2d87134d2b305f75032d55550a64051f8d10b00670ed9eed58e66b2d7a05";
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-conversion case-insensitive
         cookie http-types transformers wai wai-predicates wai-route
       ];
       testHaskellDepends = [
         base blaze-builder bytestring bytestring-conversion
         case-insensitive containers http-types tasty tasty-hunit
         tasty-quickcheck wai wai-predicates
       ];
       homepage = "https://github.com/twittner/wai-routing/";
       description = "Declarative routing for WAI";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-routing_0_12_2" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , bytestring-conversion, case-insensitive, containers, cookie
     , http-types, tasty, tasty-hunit, tasty-quickcheck, transformers
     , wai, wai-predicates, wai-route
     }:
     mkDerivation {
       pname = "wai-routing";
       version = "0.12.2";
       sha256 = "ad89d0d778d6dcd3725b11b685de5ec2c1cc1cd977b6ec6f030d5edb62bf1189";
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-conversion case-insensitive
         cookie http-types transformers wai wai-predicates wai-route
       ];
       testHaskellDepends = [
         base blaze-builder bytestring bytestring-conversion
         case-insensitive containers http-types tasty tasty-hunit
         tasty-quickcheck wai wai-predicates
       ];
       homepage = "https://github.com/twittner/wai-routing/";
       description = "Declarative routing for WAI";
       license = stdenv.lib.licenses.mpl20;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-routing" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , bytestring-conversion, case-insensitive, containers, cookie
     , http-types, tasty, tasty-hunit, tasty-quickcheck, transformers
     , wai, wai-predicates, wai-route
     }:
     mkDerivation {
       pname = "wai-routing";
       version = "0.12.3";
       sha256 = "9ce8d30b45ac65162589236b33f4ea417f784c70a1cc10b564880819d2620b0b";
       libraryHaskellDepends = [
         attoparsec base bytestring bytestring-conversion case-insensitive
         cookie http-types transformers wai wai-predicates wai-route
       ];
       testHaskellDepends = [
         base blaze-builder bytestring bytestring-conversion
         case-insensitive containers http-types tasty tasty-hunit
         tasty-quickcheck wai wai-predicates
       ];
       homepage = "https://gitlab.com/twittner/wai-routing/";
       description = "Declarative routing for WAI";
       license = stdenv.lib.licenses.mpl20;
     }) {};

  "wai-session" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers
     , cookie, http-types, StateVar, time, transformers, vault, wai
     }:
     mkDerivation {
       pname = "wai-session";
       version = "0.3.2";
       sha256 = "83739ca93cf1db1e5b54dec7e2590dabfcc77a97ac1388f2f2f18840917c8326";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers cookie http-types StateVar
         time transformers vault wai
       ];
       homepage = "https://github.com/singpolyma/wai-session";
       description = "Flexible session middleware for WAI";
       license = "unknown";
     }) {};

  "wai-session-alt" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, cookie
     , http-types, time, vault, wai-transformers
     }:
     mkDerivation {
       pname = "wai-session-alt";
       version = "0.0.0";
       sha256 = "89408d5ef5371e8e855ad02cdb056fb375bd1dd024bdd34d961b75fc1ce6c337";
       libraryHaskellDepends = [
         base blaze-builder bytestring cookie http-types time vault
         wai-transformers
       ];
       description = "An alternative session middleware for WAI";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-session-clientsession" = callPackage
    ({ mkDerivation, base, bytestring, cereal, clientsession, errors
     , transformers, wai-session
     }:
     mkDerivation {
       pname = "wai-session-clientsession";
       version = "0.1";
       sha256 = "8ebfd1f303aaf9290f069fe4b1d1fe6e6c9e7ef18e915951070fa13dab869f4d";
       libraryHaskellDepends = [
         base bytestring cereal clientsession errors transformers
         wai-session
       ];
       homepage = "https://github.com/singpolyma/wai-session-clientsession";
       description = "Session store based on clientsession";
       license = "unknown";
     }) {};

  "wai-session-postgresql_0_2_0_3" = callPackage
    ({ mkDerivation, base, bytestring, cereal, cookie, data-default
     , entropy, postgresql-simple, resource-pool, text, time
     , transformers, wai, wai-session
     }:
     mkDerivation {
       pname = "wai-session-postgresql";
       version = "0.2.0.3";
       sha256 = "d85434487e19ca592e0f47185f1c93c588f8116a2746b4b24c0e35e8e557bed3";
       libraryHaskellDepends = [
         base bytestring cereal cookie data-default entropy
         postgresql-simple resource-pool text time transformers wai
         wai-session
       ];
       testHaskellDepends = [
         base bytestring data-default postgresql-simple text wai-session
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/hce/postgresql-session#readme";
       description = "PostgreSQL backed Wai session store";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-session-postgresql" = callPackage
    ({ mkDerivation, base, bytestring, cereal, cookie, data-default
     , entropy, postgresql-simple, resource-pool, text, time
     , transformers, wai, wai-session
     }:
     mkDerivation {
       pname = "wai-session-postgresql";
       version = "0.2.0.4";
       sha256 = "d9fa9493f80ab850e5bccca4b82eaf47193c2006a9123fe0972f83ea995f0f34";
       libraryHaskellDepends = [
         base bytestring cereal cookie data-default entropy
         postgresql-simple resource-pool text time transformers wai
         wai-session
       ];
       testHaskellDepends = [
         base bytestring data-default postgresql-simple text wai-session
       ];
       doCheck = false;
       homepage = "https://github.com/hce/postgresql-session#readme";
       description = "PostgreSQL backed Wai session store";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-session-tokyocabinet" = callPackage
    ({ mkDerivation, base, bytestring, cereal, errors
     , tokyocabinet-haskell, transformers, wai-session
     }:
     mkDerivation {
       pname = "wai-session-tokyocabinet";
       version = "0.1";
       sha256 = "b9dec38fdc636ec5e0bcde5a1a59cb3d0e5f7654f8337765566a22e6d7e8a431";
       libraryHaskellDepends = [
         base bytestring cereal errors tokyocabinet-haskell transformers
         wai-session
       ];
       homepage = "https://github.com/singpolyma/wai-session-tokyocabinet";
       description = "Session store based on Tokyo Cabinet";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-static-cache" = callPackage
    ({ mkDerivation, base, bytestring, cityhash, conduit
     , conduit-combinators, containers, http-types, resourcet
     , system-filepath, text, transformers, vector, vector-algorithms
     , wai
     }:
     mkDerivation {
       pname = "wai-static-cache";
       version = "0.1.0.1";
       sha256 = "d4e0a7e8b58733fe2add7e6104ef1eb18c99e63c652a17ccd238f4fe6382936e";
       libraryHaskellDepends = [
         base bytestring cityhash conduit conduit-combinators containers
         http-types resourcet system-filepath text transformers vector
         vector-algorithms wai
       ];
       description = "A simple cache for serving static files in a WAI middleware";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-static-pages" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, conduit
     , directory, http-types, text, wai, wai-extra
     }:
     mkDerivation {
       pname = "wai-static-pages";
       version = "0.3";
       sha256 = "307d092f5ea5eecc9b59844cf49dd7ea789c76f5f9b7400af659b2fd06125575";
       libraryHaskellDepends = [
         base blaze-builder bytestring conduit directory http-types text wai
         wai-extra
       ];
       homepage = "https://github.com/gregwebs/wai-static-pages";
       description = "generate static html pages from a WAI application";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-test" = callPackage
    ({ mkDerivation, wai }:
     mkDerivation {
       pname = "wai-test";
       version = "3.0.0";
       sha256 = "ddf541f7c7a97e045057c52d109feb8c835f36d0a7b2a6a0bd60c5686500da77";
       libraryHaskellDepends = [ wai ];
       doHaddock = false;
       homepage = "http://www.yesodweb.com/book/web-application-interface";
       description = "Unit test framework (built on HUnit) for WAI applications. (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-thrift" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, http-types
     , thrift, wai
     }:
     mkDerivation {
       pname = "wai-thrift";
       version = "0.0.1.3";
       sha256 = "0da2c042a2aa424a2c4e11f13c9728f8919ec2dd56c469cc346d6df723f879bf";
       libraryHaskellDepends = [
         base blaze-builder bytestring http-types thrift wai
       ];
       homepage = "https://github.com/yogeshsajanikar/wai-thrift";
       description = "Thrift transport layer for Wai";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wai-throttler" = callPackage
    ({ mkDerivation, base, bytestring, containers, http-types, time
     , wai
     }:
     mkDerivation {
       pname = "wai-throttler";
       version = "0.1.0.5";
       sha256 = "e6259bbeba435d4d141bceda533aa41ff5dda2d74ff29a5bd7f3131c981a05ca";
       libraryHaskellDepends = [
         base bytestring containers http-types time wai
       ];
       jailbreak = true;
       description = "Wai middleware for request throttling";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-transformers" = callPackage
    ({ mkDerivation, base, exceptions, transformers, wai }:
     mkDerivation {
       pname = "wai-transformers";
       version = "0.0.4";
       sha256 = "dac72f1396431c591303550eebac0e3b94920a1989eb8964c5ea3eb6609861c0";
       libraryHaskellDepends = [ base exceptions transformers wai ];
       description = "Simple parameterization of Wai's Application type";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wai-util" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , http-accept, http-types, network-uri, text, transformers, wai
     , wai-extra
     }:
     mkDerivation {
       pname = "wai-util";
       version = "0.8";
       sha256 = "55621ef43cd729287947b6e2ee3c5d172b6b050b09511a46afd8ec7e34cc3383";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit http-accept http-types
         network-uri text transformers wai wai-extra
       ];
       homepage = "https://github.com/singpolyma/wai-util";
       description = "Collection of utility functions for use with WAI";
       license = "unknown";
     }) {};

  "wai-websockets_3_0_0_2" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , file-embed, http-types, network, text, transformers, wai
     , wai-app-static, warp, websockets
     }:
     mkDerivation {
       pname = "wai-websockets";
       version = "3.0.0.2";
       sha256 = "4bc37907a31946518f75429b1ab712b068cf4b0f3a5a1931f9c3bc1418a71edc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring case-insensitive http-types network
         transformers wai websockets
       ];
       executableHaskellDepends = [
         base blaze-builder bytestring case-insensitive file-embed
         http-types network text transformers wai wai-app-static warp
         websockets
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provide a bridge betweeen WAI and the websockets package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-websockets_3_0_0_3" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , file-embed, http-types, network, text, transformers, wai
     , wai-app-static, warp, websockets
     }:
     mkDerivation {
       pname = "wai-websockets";
       version = "3.0.0.3";
       sha256 = "69c0f25cab6030df7ada6cbb35961d230a0b4edfeb97c84e0bbf806c81a08fe5";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring case-insensitive http-types network
         transformers wai websockets
       ];
       executableHaskellDepends = [
         base blaze-builder bytestring case-insensitive file-embed
         http-types network text transformers wai wai-app-static warp
         websockets
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provide a bridge betweeen WAI and the websockets package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-websockets_3_0_0_4" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , file-embed, http-types, network, text, transformers, wai
     , wai-app-static, warp, websockets
     }:
     mkDerivation {
       pname = "wai-websockets";
       version = "3.0.0.4";
       sha256 = "8c3ce38089438ccdeb143d1a64735a355bf1b56e3ad0abc406fbe4dd5de8dc2e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring case-insensitive http-types network
         transformers wai websockets
       ];
       executableHaskellDepends = [
         base blaze-builder bytestring case-insensitive file-embed
         http-types network text transformers wai wai-app-static warp
         websockets
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provide a bridge betweeen WAI and the websockets package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-websockets_3_0_0_5" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , file-embed, http-types, network, text, transformers, wai
     , wai-app-static, warp, websockets
     }:
     mkDerivation {
       pname = "wai-websockets";
       version = "3.0.0.5";
       sha256 = "e0171c7663b79b3ab800292493abb97263315f39d36406e7edc6d2dde4dc11bf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring case-insensitive http-types network
         transformers wai websockets
       ];
       executableHaskellDepends = [
         base blaze-builder bytestring case-insensitive file-embed
         http-types network text transformers wai wai-app-static warp
         websockets
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provide a bridge betweeen WAI and the websockets package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-websockets_3_0_0_6" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , file-embed, http-types, network, text, transformers, wai
     , wai-app-static, warp, websockets
     }:
     mkDerivation {
       pname = "wai-websockets";
       version = "3.0.0.6";
       sha256 = "fec7f901859809f1898a213dc4606c730c4c5546c41a43d499cefc41512e1945";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring case-insensitive http-types network
         transformers wai websockets
       ];
       executableHaskellDepends = [
         base blaze-builder bytestring case-insensitive file-embed
         http-types network text transformers wai wai-app-static warp
         websockets
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provide a bridge between WAI and the websockets package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-websockets_3_0_0_7" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , file-embed, http-types, network, text, transformers, wai
     , wai-app-static, warp, websockets
     }:
     mkDerivation {
       pname = "wai-websockets";
       version = "3.0.0.7";
       sha256 = "c4b6505833a09b1f2dda9da0f50f2825689dcb652909994b9217ea3ba92fc1da";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring case-insensitive http-types network
         transformers wai websockets
       ];
       executableHaskellDepends = [
         base blaze-builder bytestring case-insensitive file-embed
         http-types network text transformers wai wai-app-static warp
         websockets
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Provide a bridge between WAI and the websockets package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wai-websockets" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, case-insensitive
     , file-embed, http-types, network, text, transformers, wai
     , wai-app-static, warp, websockets
     }:
     mkDerivation {
       pname = "wai-websockets";
       version = "3.0.0.8";
       sha256 = "353c324bbc26920d8f3adddc415f0d2a7cb01b89230dc95707fb19a74bf8a842";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring case-insensitive http-types network
         transformers wai websockets
       ];
       executableHaskellDepends = [
         base blaze-builder bytestring case-insensitive file-embed
         http-types network text transformers wai wai-app-static warp
         websockets
       ];
       homepage = "http://github.com/yesodweb/wai";
       description = "Provide a bridge between WAI and the websockets package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wait-handle" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "wait-handle";
       version = "0.1.1";
       sha256 = "f5581043a4aeece04aef36e1b9c9b76f3f8126a3f1185450a498926afa070824";
       libraryHaskellDepends = [ base ];
       homepage = "https://www.github.com/fmap/waithandle";
       description = "Wait handles are MVars which can only be written to once, and from which values can never be removed";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "waitfree" = callPackage
    ({ mkDerivation, base, containers }:
     mkDerivation {
       pname = "waitfree";
       version = "0.1.5";
       sha256 = "38a3481433b05a1e19d23f6c84913eb7e7c1de1909eec391729ddd7f22c51426";
       libraryHaskellDepends = [ base containers ];
       description = "A wrapping library for waitfree computation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "waitra_0_0_3_0" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, filepath
     , http-types, regex-applicative, tasty, tasty-hunit
     , template-haskell, text, wai, wai-extra
     }:
     mkDerivation {
       pname = "waitra";
       version = "0.0.3.0";
       sha256 = "7643fda19b754bc79195fefaaf05ec9c3707bc24e4b12514d53a7ffe20ac3a7a";
       libraryHaskellDepends = [
         aeson base bytestring directory filepath http-types
         regex-applicative template-haskell text wai
       ];
       testHaskellDepends = [
         aeson base http-types regex-applicative tasty tasty-hunit wai
         wai-extra
       ];
       homepage = "https://github.com/futurice/waitra";
       description = "A very simple Wai router";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "waitra" = callPackage
    ({ mkDerivation, aeson, base, bytestring, directory, filepath
     , http-types, regex-applicative, tasty, tasty-hunit
     , template-haskell, text, wai, wai-app-static, wai-extra, warp
     }:
     mkDerivation {
       pname = "waitra";
       version = "0.0.4.0";
       sha256 = "5610c69eb377e2714c3e502cf47fff7e116e356890aefb1f4144d3e6c1b16c12";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring directory filepath http-types
         regex-applicative template-haskell text wai
       ];
       executableHaskellDepends = [ aeson base wai wai-app-static warp ];
       testHaskellDepends = [
         aeson base http-types tasty tasty-hunit wai wai-extra
       ];
       homepage = "https://github.com/futurice/waitra";
       description = "A very simple Wai router";
       license = stdenv.lib.licenses.mit;
     }) {};

  "warc" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, either, errors, free
     , lens, pipes, pipes-attoparsec, pipes-bytestring, text, time
     , transformers
     }:
     mkDerivation {
       pname = "warc";
       version = "0.1.1.1";
       sha256 = "9530f595264316d474abb194754d69c4857b8ccc65e49280e430fd596eb65260";
       libraryHaskellDepends = [
         attoparsec base bytestring either errors free lens pipes
         pipes-attoparsec pipes-bytestring text time transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/bgamari/warc";
       description = "A parser for the Web Archive (WARC) format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "warp_3_0_4" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.4";
       sha256 = "b9811653af0509337ce1ff304fd3acf42f063e9950a61f32ae47a538ed70d34f";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types network simple-sendfile
         streaming-commons text unix unix-compat void wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat void wai
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_4_1" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.4.1";
       sha256 = "5f57e70ef14b1c6dbe1604910d9b8d4394ad20f67f3e3105f2b4153567168e96";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types network simple-sendfile
         streaming-commons text unix unix-compat void wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat void wai
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_5" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.5";
       sha256 = "d711c1bf684011f66f1b00988295a0e486358fe41e1dec8fcdd81febb7953617";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types iproute network
         simple-sendfile streaming-commons text unix unix-compat void wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit iproute lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat void wai
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_5_1" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.5.1";
       sha256 = "0732541655ead8278d40b1ad3f18d1559b784af242d8729971ffc95016d8cc7c";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types iproute network
         simple-sendfile streaming-commons text unix unix-compat void wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit iproute lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat void wai
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_5_2" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.5.2";
       sha256 = "e19ff44408becc2789788600eaeaac9d857b438a1b140ae57444557b3efb2aff";
       revision = "1";
       editedCabalFile = "3f68e133c733adf9a17a28ae7361d231214022a70df8e99f07cbe22db4303547";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types iproute network
         simple-sendfile streaming-commons text unix unix-compat void wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit iproute lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat void wai
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_7" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.7";
       sha256 = "7fe8ebdd326a2cfb2995b21c9b98838b193bc3c3c0e0b0cdc7e657226295327f";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types iproute network
         simple-sendfile streaming-commons text unix unix-compat void wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit iproute lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat void wai
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_8" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.8";
       sha256 = "3c583f70e707a25aebb8514c3bad8925e4d5396f8b2e8a6e8ccc218af5f5dbfd";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types iproute network
         simple-sendfile streaming-commons text unix unix-compat void wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit iproute lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat void wai
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_9" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.9";
       sha256 = "f1cdf012403b13bbf3a153dd606d529203a4a6c2442fca066ddffb2c6a7793e6";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types iproute network
         simple-sendfile streaming-commons text unix unix-compat void wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit iproute lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat void wai
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_9_2" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.9.2";
       sha256 = "e48ed078d5d5e5ae481e1c2682d9c1d423578075e8ec310eedb3d3a9730b2473";
       revision = "1";
       editedCabalFile = "a96e8870aad86b7d2d9fcd7fa76fae12155241633366e03340fabacf6da90189";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types iproute network
         simple-sendfile streaming-commons text unix unix-compat void wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit iproute lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat void wai
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_9_3" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.9.3";
       sha256 = "cdc47f9feca205930a4b10c975528385ebb6eb86a45b794255152f5d1a3090ec";
       revision = "1";
       editedCabalFile = "6f7037dc49b4faa98b92ab01bd0eb20582b5226ee2a797d652ebf20a67475aa8";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types iproute network
         simple-sendfile streaming-commons text unix unix-compat void wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit iproute lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat void wai
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_10" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, vault, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.10";
       sha256 = "ba4975f9a9be2b6c358c8575738ea3b33935ef97cf57872f09f70b632a62bf1f";
       revision = "1";
       editedCabalFile = "cab27f33dac337362ad40d4d5b19377b52f720434fd78a373da27afed92dc7fb";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types iproute network
         simple-sendfile streaming-commons text unix unix-compat vault void
         wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit iproute lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat vault void wai
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_10_1" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, vault, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.10.1";
       sha256 = "b02b29967db0c877567ac8505dce1f9bf47770e80aa535ae10525f1198736eec";
       revision = "1";
       editedCabalFile = "b1053c70eb6a4be04421df628e9a8b82457639f60ba2f95bfce8c5b9f0ffbd97";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types iproute network
         simple-sendfile streaming-commons text unix unix-compat vault void
         wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit iproute lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat vault void wai
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_11" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, vault, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.11";
       sha256 = "636337aeeabb755735820e24051ab5933427fea563e2b306dd2838e9104d5517";
       revision = "1";
       editedCabalFile = "779a7bc0347c75d7e9e6f360ecfcb5c9da72ea9eae96d03af285e15b6a8d212b";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types iproute network
         simple-sendfile streaming-commons text unix unix-compat vault void
         wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit iproute lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat vault void wai
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_12" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, vault, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.12";
       sha256 = "aaacbd0f98963ee3e39032b20388609251cea71f96279fca4af0a1c5effb6d79";
       revision = "1";
       editedCabalFile = "1419e91f70bc8b83ec8d27d9e525b72f06757f0953a5991c7970451e679cd285";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types iproute network
         simple-sendfile streaming-commons text unix unix-compat vault void
         wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit iproute lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat vault void wai
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_12_1" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, vault, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.12.1";
       sha256 = "cbdc7f4be8d410eba94d082839e2f1507a131bf9f46e7e557e97b2665ee95035";
       revision = "1";
       editedCabalFile = "20d7e8508667cc19669079ada8ca9b1189bf460b89219a715c42481f10841892";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types iproute network
         simple-sendfile streaming-commons text unix unix-compat vault void
         wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit iproute lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat vault void wai
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_13" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, vault, void, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.13";
       sha256 = "2999d3ec70436b42139316cb20f468c626c20ec8f9e62dab3e71e7dfdf5cf23d";
       revision = "1";
       editedCabalFile = "b7a2fe980a4d024c05e7dec7c3b9e068fdc1f669624cc7bf0c959f2fc5b2f801";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types iproute network
         simple-sendfile streaming-commons text unix unix-compat vault void
         wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit iproute lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat vault void wai
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_0_13_1" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, doctest, ghc-prim, hashable, hspec
     , HTTP, http-date, http-types, HUnit, iproute, lifted-base, network
     , old-locale, QuickCheck, simple-sendfile, streaming-commons, text
     , time, transformers, unix, unix-compat, vault, wai
     }:
     mkDerivation {
       pname = "warp";
       version = "3.0.13.1";
       sha256 = "6ce6fd355fb0d909172c25504a949e3738a3848a8e1fcc2f89be2ae17a99719f";
       revision = "1";
       editedCabalFile = "a6aa1dea4ad2dacbf257a35d632502fbf647470907b0ff439d3b4f235ee217d8";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         ghc-prim hashable http-date http-types iproute network
         simple-sendfile streaming-commons text unix unix-compat vault wai
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive doctest ghc-prim hashable hspec HTTP http-date
         http-types HUnit iproute lifted-base network old-locale QuickCheck
         simple-sendfile streaming-commons text time transformers unix
         unix-compat vault wai
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_1_2" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, case-insensitive, containers, directory, doctest
     , ghc-prim, hashable, hspec, HTTP, http-date, http-types, http2
     , HUnit, iproute, lifted-base, network, old-locale, process
     , QuickCheck, simple-sendfile, stm, streaming-commons, text, time
     , transformers, unix, unix-compat, vault, wai, word8
     }:
     mkDerivation {
       pname = "warp";
       version = "3.1.2";
       sha256 = "b845179b3ec3e78d94408da61fdc9195807adaa25646205769e9a2b0b6ab48f9";
       revision = "2";
       editedCabalFile = "c2b806e76b7fa1b075ab35cb9a806b25984296d0f7639c1486a6f5ca3373e85b";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring case-insensitive
         containers ghc-prim hashable http-date http-types http2 iproute
         network simple-sendfile stm streaming-commons text unix unix-compat
         vault wai word8
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         case-insensitive containers directory doctest ghc-prim hashable
         hspec HTTP http-date http-types http2 HUnit iproute lifted-base
         network old-locale process QuickCheck simple-sendfile stm
         streaming-commons text time transformers unix unix-compat vault wai
         word8
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_1_3" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, bytestring-builder, case-insensitive, containers
     , directory, doctest, ghc-prim, hashable, hspec, HTTP, http-date
     , http-types, http2, HUnit, iproute, lifted-base, network
     , old-locale, process, QuickCheck, simple-sendfile, stm
     , streaming-commons, text, time, transformers, unix, unix-compat
     , vault, wai, word8
     }:
     mkDerivation {
       pname = "warp";
       version = "3.1.3";
       sha256 = "f65d32e374da0c1c1a44624e9744e4e2b5e325ca1e24a6aeae5719ee48c2b8e3";
       revision = "2";
       editedCabalFile = "47bb890c4cb43ebf8efe20b6f473cd1147c35453658105d19b9d65ee5d535973";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring bytestring-builder
         case-insensitive containers ghc-prim hashable http-date http-types
         http2 iproute network simple-sendfile stm streaming-commons text
         unix unix-compat vault wai word8
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         bytestring-builder case-insensitive containers directory doctest
         ghc-prim hashable hspec HTTP http-date http-types http2 HUnit
         iproute lifted-base network old-locale process QuickCheck
         simple-sendfile stm streaming-commons text time transformers unix
         unix-compat vault wai word8
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_1_3_1" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, bytestring-builder, case-insensitive, containers
     , directory, doctest, ghc-prim, hashable, hspec, HTTP, http-date
     , http-types, http2, HUnit, iproute, lifted-base, network
     , old-locale, process, QuickCheck, simple-sendfile, stm
     , streaming-commons, text, time, transformers, unix, unix-compat
     , vault, wai, word8
     }:
     mkDerivation {
       pname = "warp";
       version = "3.1.3.1";
       sha256 = "8754b3554047d767c34362f22b9bdb36c603ff9bde0f5f6155070622e85f3329";
       revision = "1";
       editedCabalFile = "b7b6a5f3a35f3638817f145cf8fbbf55d39f0cc87a7fcf70999e09fcba1eb205";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring bytestring-builder
         case-insensitive containers ghc-prim hashable http-date http-types
         http2 iproute network simple-sendfile stm streaming-commons text
         unix unix-compat vault wai word8
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         bytestring-builder case-insensitive containers directory doctest
         ghc-prim hashable hspec HTTP http-date http-types http2 HUnit
         iproute lifted-base network old-locale process QuickCheck
         simple-sendfile stm streaming-commons text time transformers unix
         unix-compat vault wai word8
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp_3_1_12" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, bytestring-builder, case-insensitive, containers
     , directory, doctest, ghc-prim, hashable, hspec, HTTP, http-date
     , http-types, http2, HUnit, iproute, lifted-base, network, process
     , QuickCheck, simple-sendfile, stm, streaming-commons, text, time
     , transformers, unix, unix-compat, unordered-containers, vault, wai
     , word8
     }:
     mkDerivation {
       pname = "warp";
       version = "3.1.12";
       sha256 = "2a913a576d175e49b206e680b75f4823c7f90f45d8ba89aa57aae9c40d3298e1";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring bytestring-builder
         case-insensitive containers ghc-prim hashable http-date http-types
         http2 iproute network simple-sendfile stm streaming-commons text
         unix unix-compat unordered-containers vault wai word8
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         bytestring-builder case-insensitive containers directory doctest
         ghc-prim hashable hspec HTTP http-date http-types http2 HUnit
         iproute lifted-base network process QuickCheck simple-sendfile stm
         streaming-commons text time transformers unix unix-compat
         unordered-containers vault wai word8
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp" = callPackage
    ({ mkDerivation, array, async, auto-update, base, blaze-builder
     , bytestring, bytestring-builder, case-insensitive, containers
     , directory, doctest, ghc-prim, hashable, hspec, HTTP, http-date
     , http-types, http2, HUnit, iproute, lifted-base, network, process
     , QuickCheck, simple-sendfile, stm, streaming-commons, text, time
     , transformers, unix, unix-compat, vault, wai, word8
     }:
     mkDerivation {
       pname = "warp";
       version = "3.2.2";
       sha256 = "c85382d4affc4a3d606de8f72f1031306da2c32f63d0a99deaeb93440e5796e6";
       libraryHaskellDepends = [
         array auto-update base blaze-builder bytestring bytestring-builder
         case-insensitive containers ghc-prim hashable http-date http-types
         http2 iproute network simple-sendfile stm streaming-commons text
         unix unix-compat vault wai word8
       ];
       testHaskellDepends = [
         array async auto-update base blaze-builder bytestring
         bytestring-builder case-insensitive containers directory doctest
         ghc-prim hashable hspec HTTP http-date http-types http2 HUnit
         iproute lifted-base network process QuickCheck simple-sendfile stm
         streaming-commons text time transformers unix unix-compat vault wai
         word8
       ];
       doCheck = false;
       homepage = "http://github.com/yesodweb/wai";
       description = "A fast, light-weight web server for WAI applications";
       license = stdenv.lib.licenses.mit;
     }) {};

  "warp-dynamic" = callPackage
    ({ mkDerivation, base, data-default, dyre, http-types, wai, warp }:
     mkDerivation {
       pname = "warp-dynamic";
       version = "0.1.0";
       sha256 = "cf4c6a2e90e826e61d22fe6c1c80200a16505cc5ce9d8756357946b095f0b5ce";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base data-default dyre http-types wai warp
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://tanakh.jp";
       description = "Dynamic configurable warp HTTP server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-static" = callPackage
    ({ mkDerivation, base, bytestring, cmdargs, containers, directory
     , mime-types, text, wai-app-static, wai-extra, warp
     }:
     mkDerivation {
       pname = "warp-static";
       version = "2.0.1.1";
       sha256 = "750a2e5cb4adeece260455053c6c2637faf8182f1f7feca5f1cfe25232433fa0";
       revision = "1";
       editedCabalFile = "9084e8207d2178dd585366f7a8310638814409b969752b88878d77807d3f478a";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring cmdargs containers directory mime-types text
         wai-app-static wai-extra warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "Static file server based on Warp and wai-app-static (deprecated)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls_3_0_1" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.0.1";
       sha256 = "fe76f1da11b4fc1f09d6d7b4bd2b6a601f422fa5b5e013aa79be45aa59cc0769";
       revision = "1";
       editedCabalFile = "d2f79e54d7f8e989621b38230d0ead8f9f68612ccf6ab56e260882cef40a40af";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over SSL/TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls_3_0_1_1" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.0.1.1";
       sha256 = "351731d0a00c5db1627ac88d4cce17e8f7efe4c3b5314e868b6c355f854b7281";
       revision = "1";
       editedCabalFile = "2d984fade290388448566b73099486df1abefc4b4a0d4c72d384195372089275";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over SSL/TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls_3_0_1_2" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.0.1.2";
       sha256 = "e268617bc37b0afc18b0f0d7ed30f751536d845a2e08c8ebbdec41b2cadc8ef5";
       revision = "1";
       editedCabalFile = "27eea06a544aa9b966f353c86d33cb229be45d3f694d37a73a039c58817711ff";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over SSL/TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls_3_0_1_3" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.0.1.3";
       sha256 = "ec91266592837736e825657543d8e5f8cae3e436172134fa1ef4d098ce0b1e74";
       revision = "1";
       editedCabalFile = "4bfceb6c80e9b65afe60f307d5ec502f1dedf379a2fe14eb5dfc8dd6b7fae30f";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over SSL/TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls_3_0_1_4" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.0.1.4";
       sha256 = "b3e94ba26894de0943973fcdda69ed3f9c2b92ba355ead9b95e3513399e78bb8";
       revision = "1";
       editedCabalFile = "29c289fa557c1a05d5b3619851aabe78d6c93af9f4162710c0b8cd0f365b7579";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over SSL/TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls_3_0_2" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.0.2";
       sha256 = "ed3bf9d6a084f3fbc059fe06a7add0fc5f95454228615a2c23f0c683235019ca";
       revision = "1";
       editedCabalFile = "24ca7da4a6766a4583c8ee82b22bbf0d5b8c70d4d0ac43ead58c09c6c24e696f";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over SSL/TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls_3_0_3" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.0.3";
       sha256 = "b5260c5fd5f51048448347a2acc72b60fbadfa05e57cc1a70328a2e22accf7d9";
       revision = "1";
       editedCabalFile = "5fd916e672092798e2d24f7cf778229527c602c1156309c1d18d95a87a6488a6";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over SSL/TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls_3_0_4" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.0.4";
       sha256 = "e42d4de7a02997e266272e735dc068c42086f4a2d95b02a56ccca0f2ad8f680e";
       revision = "1";
       editedCabalFile = "58b0585d8b497743315b6c867c5002ca6d89803f6f37d4c47cfc752b9aed0a3f";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over SSL/TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls_3_0_4_1" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.0.4.1";
       sha256 = "9edc7a498c3dc75a1d8eca9a16b2d913d00573424f8688f823a8289da438245d";
       revision = "1";
       editedCabalFile = "0265d3e7e1dbb9ef5fa287d55b1771ea838390335e543b71b9da7cb4d752edad";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over SSL/TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls_3_0_4_2" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.0.4.2";
       sha256 = "610fe047af34a28bc44f9d95e581edb82a72d63852247b78e13e895791c00b1c";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over SSL/TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls_3_1_0" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.1.0";
       sha256 = "3fdb29b9bcbbe41bab87921eb8c0fee5c24a3dd50d6ac103d8ee88a10685209d";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls_3_1_1" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.1.1";
       sha256 = "5e9a75cc877f52053c5e1ceb15427ac28bf9937750336af0f71569b4e9e213bd";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls_3_1_2" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.1.2";
       sha256 = "3940708b273b195eefdeeb63448fcb121ead5a010cad04f1c3ab4bd7470e34a2";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls_3_1_3" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.1.3";
       sha256 = "3f6857fd29226b0bd02bb8e34c31bb2fc631966ec2c00d6580053f7aa0e6a1ce";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls_3_1_5" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.1.5";
       sha256 = "abb057ba735e455c354837f5daf07ea2c0274d8edfb7d39ac48412a6ebb9759f";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "warp-tls" = callPackage
    ({ mkDerivation, base, bytestring, cprng-aes, data-default-class
     , network, streaming-commons, tls, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls";
       version = "3.2.0";
       sha256 = "1751b8fc4e24c909ed94db39a2aa20048e694ddf6e68c4acbdfe8924773f3dd8";
       libraryHaskellDepends = [
         base bytestring cprng-aes data-default-class network
         streaming-commons tls wai warp
       ];
       homepage = "http://github.com/yesodweb/wai";
       description = "HTTP over TLS support for Warp via the TLS package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "warp-tls-uid" = callPackage
    ({ mkDerivation, base, bytestring, certificate, conduit
     , crypto-random, http-types, network, network-conduit, pem, tls
     , tls-extra, unix, wai, warp
     }:
     mkDerivation {
       pname = "warp-tls-uid";
       version = "0.1.0.4";
       sha256 = "beacad56f701aa913e0912a7a319a8b95d8e5100dddbf1f8655d7ce4a64c5b85";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring certificate conduit crypto-random network
         network-conduit pem tls tls-extra unix wai warp
       ];
       executableHaskellDepends = [
         base bytestring certificate conduit crypto-random http-types
         network network-conduit pem tls tls-extra unix wai warp
       ];
       jailbreak = true;
       description = "set group and user id before running server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "watchdog" = callPackage
    ({ mkDerivation, base, mtl, time }:
     mkDerivation {
       pname = "watchdog";
       version = "0.2.2.1";
       sha256 = "db48e9118b17b7cf07352a1e3dd96a0002d473c59f2b2f9734746563311b6919";
       libraryHaskellDepends = [ base mtl time ];
       jailbreak = true;
       description = "Simple control structure to re-try an action with exponential backoff";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "watcher" = callPackage
    ({ mkDerivation, base, basic-prelude, containers, hinotify
     , system-fileio, system-filepath
     }:
     mkDerivation {
       pname = "watcher";
       version = "0.0.3.0";
       sha256 = "fa717e6d7185967a8b89ffda3b9bc1510cc72d9ace5e457be11bc3777f11c0b0";
       libraryHaskellDepends = [
         base basic-prelude containers hinotify system-fileio
         system-filepath
       ];
       jailbreak = true;
       description = "Opinionated filesystem watcher";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "watchit" = callPackage
    ({ mkDerivation, async, base, bytestring, fsnotify, HUnit
     , optparse-applicative, process, QuickCheck, resource-pool
     , smallcheck, streaming-commons, system-fileio, system-filepath
     , tasty, tasty-hunit, tasty-quickcheck, tasty-smallcheck, text
     }:
     mkDerivation {
       pname = "watchit";
       version = "0.1.0.0";
       sha256 = "e688a66bc4660e36141519d0b61181f402211415c7d50e01caac5241b34d8b8c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base fsnotify optparse-applicative process resource-pool
         streaming-commons system-filepath text
       ];
       executableHaskellDepends = [
         base fsnotify optparse-applicative process resource-pool
         streaming-commons system-filepath text
       ];
       testHaskellDepends = [
         async base bytestring HUnit QuickCheck smallcheck system-fileio
         system-filepath tasty tasty-hunit tasty-quickcheck tasty-smallcheck
       ];
       description = "File change watching utility";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wavconvert" = callPackage
    ({ mkDerivation, base, directory, filepath, process }:
     mkDerivation {
       pname = "wavconvert";
       version = "0.1.1";
       sha256 = "7db6861ce1383fc16f389a18c93576706b9f1bbca045689825f9894f56ea1809";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath process ];
       description = "Command-line tool for converting audio files and filling in ID3 tags";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wavefront" = callPackage
    ({ mkDerivation, attoparsec, base, dlist, filepath, mtl, text
     , transformers, vector
     }:
     mkDerivation {
       pname = "wavefront";
       version = "0.7";
       sha256 = "4ccdfd6b8c22a24bdcc91f067b6234e9fe69cef1864dcda4c9b134c7cdfa416c";
       libraryHaskellDepends = [
         attoparsec base dlist filepath mtl text transformers vector
       ];
       homepage = "https://github.com/phaazon/wavefront";
       description = "Wavefront OBJ loader";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wavesurfer" = callPackage
    ({ mkDerivation, base, binary, bytestring, bytestring-lexing
     , bytestring-show, delimited-text
     }:
     mkDerivation {
       pname = "wavesurfer";
       version = "0.0.6";
       sha256 = "c57e151f5201372cbcb0e5bc7e445351a40d499d3607a9095931bfc677d530b9";
       libraryHaskellDepends = [
         base binary bytestring bytestring-lexing bytestring-show
         delimited-text
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~StefanKersten/code/wavesurfer";
       description = "Parse WaveSurfer files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wavy" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, filepath
     , pretty-show, riff, split, vector
     }:
     mkDerivation {
       pname = "wavy";
       version = "0.1.0.0";
       sha256 = "3849bf156ba6b2cb7f8665b66a398a175b3579534c7bc1e0f5357e7a5ad57f67";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary bytestring containers riff split vector
       ];
       executableHaskellDepends = [
         base bytestring filepath pretty-show split vector
       ];
       jailbreak = true;
       homepage = "http://bitbucket.org/robertmassaioli/wavy";
       description = "Process WAVE files in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wcwidth" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , setlocale, utf8-string
     }:
     mkDerivation {
       pname = "wcwidth";
       version = "0.0.2";
       sha256 = "ffc68736a3bbde3e8157710f29f4a99c0ca593c41194579c54a92c62f6c12ed8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers ];
       executableHaskellDepends = [
         attoparsec base bytestring containers setlocale utf8-string
       ];
       homepage = "http://github.com/solidsnack/wcwidth/";
       description = "Native wcwidth";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "weather-api" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, HTTP, network
     , utf8-string, vector
     }:
     mkDerivation {
       pname = "weather-api";
       version = "0.4.3";
       sha256 = "d25b090839089eba2daf2e21f4e7775e9e953f83f2e37793853b6ef1cb1d9072";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring HTTP network utf8-string vector
       ];
       jailbreak = true;
       homepage = "https://github.com/cvb/hs-weather-api.git";
       description = "Weather api implemented in haskell";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "web-browser-in-haskell" = callPackage
    ({ mkDerivation, base, gtk, webkit }:
     mkDerivation {
       pname = "web-browser-in-haskell";
       version = "1.0";
       sha256 = "b3f81b3ef716383684f3a09b5eb5e622b2363d0ef7c821e2a9e0538d7823c7f8";
       libraryHaskellDepends = [ base gtk webkit ];
       description = "Web Browser In Haskell";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "web-css" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "web-css";
       version = "0.1.0";
       sha256 = "620afb1d90ea2fbe3850b13f7e28ff31f4d2ab9622abdbad7faa0367daf65bc1";
       libraryHaskellDepends = [ base text ];
       jailbreak = true;
       description = "Simple functions for CSS";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "web-encodings" = callPackage
    ({ mkDerivation, base, bytestring, directory, failure, old-locale
     , text, time
     }:
     mkDerivation {
       pname = "web-encodings";
       version = "0.3.0.9";
       sha256 = "a30b0e0c596a1e9953fb1d5a5aa2ebe1710561d662294088d0cea657f5dae951";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring directory failure old-locale text time
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/web-encodings/tree/master";
       description = "Encapsulate multiple web encoding in a single package. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "web-fpco" = callPackage
    ({ mkDerivation, base, happstack-server, safe, snap, snap-core
     , snap-server
     }:
     mkDerivation {
       pname = "web-fpco";
       version = "0.1.1.0";
       sha256 = "f618e3e8647cf96e8860e81aa43824a0c7fa7bc78ceba46169dc4bafc3ab3fc6";
       libraryHaskellDepends = [
         base happstack-server safe snap snap-core snap-server
       ];
       homepage = "https://github.com/fpco/web-fpco";
       description = "Wrappers for web frameworks to ease usage with the FP Complete environment";
       license = stdenv.lib.licenses.mit;
     }) {};

  "web-mongrel2" = callPackage
    ({ mkDerivation, base, bytestring, data-default, file-embed
     , haskell98, HStringTemplate, json, mtl, old-time, parsec
     , system-uuid, template-haskell, text, zeromq-haskell
     }:
     mkDerivation {
       pname = "web-mongrel2";
       version = "0.0.3";
       sha256 = "fc05e68bbb55ace70b62fc622ca14ef3a6afe72b954992f38a4fccfae7c057c8";
       libraryHaskellDepends = [
         base bytestring data-default file-embed haskell98 HStringTemplate
         json mtl old-time parsec system-uuid template-haskell text
         zeromq-haskell
       ];
       homepage = "http://github.com/cmoore/web-mongrel2";
       description = "Bindings for the Mongrel2 web server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "web-page" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, bytestring, clay
     , containers, jmacro, lens, mtl, Stream, text, vector
     , wl-pprint-text
     }:
     mkDerivation {
       pname = "web-page";
       version = "0.2.0";
       sha256 = "143301e4a9ff9f01507ef2b4548aebce01811090b176d52adc3dc87bcce5f8c3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder blaze-html bytestring clay containers jmacro
         lens mtl Stream text vector wl-pprint-text
       ];
       homepage = "http://hub.darcs.net/ertes/web-page";
       description = "Monoidally construct web pages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "web-plugins" = callPackage
    ({ mkDerivation, base, containers, mtl, stm, text }:
     mkDerivation {
       pname = "web-plugins";
       version = "0.2.8";
       sha256 = "c9a47f4913efb3e8702d9a29be4d5e7d95e1ec3169e1b015e55d822830d88003";
       libraryHaskellDepends = [ base containers mtl stm text ];
       homepage = "http://www.happstack.com/";
       description = "dynamic plugin system for web applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "web-routes" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, exceptions
     , ghc-prim, hspec, http-types, HUnit, mtl, parsec, QuickCheck
     , split, text, utf8-string
     }:
     mkDerivation {
       pname = "web-routes";
       version = "0.27.10";
       sha256 = "1d0f5da073271aa45dbcc9ef51791841f45d13f16756cfe3c16d731e2dd67b4c";
       libraryHaskellDepends = [
         base blaze-builder bytestring exceptions ghc-prim http-types mtl
         parsec split text utf8-string
       ];
       testHaskellDepends = [ base hspec HUnit QuickCheck ];
       homepage = "http://www.happstack.com/docs/crashcourse/index.html#web-routes";
       description = "portable, type-safe URL routing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "web-routes-boomerang" = callPackage
    ({ mkDerivation, base, boomerang, mtl, parsec, text, web-routes }:
     mkDerivation {
       pname = "web-routes-boomerang";
       version = "0.28.4";
       sha256 = "b02fe4b54a538f56ded560724ff81e04b8f002a69e37543029c0050634e1342a";
       libraryHaskellDepends = [
         base boomerang mtl parsec text web-routes
       ];
       description = "Library for maintaining correctness and composability of URLs within an application";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "web-routes-happstack" = callPackage
    ({ mkDerivation, base, bytestring, happstack-server, text
     , web-routes
     }:
     mkDerivation {
       pname = "web-routes-happstack";
       version = "0.23.10";
       sha256 = "a7bbf337cea91b3dbf41d1785a4edef238a1e7d78e64dd153b90e36df35afbed";
       libraryHaskellDepends = [
         base bytestring happstack-server text web-routes
       ];
       description = "Adds support for using web-routes with Happstack";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "web-routes-hsp" = callPackage
    ({ mkDerivation, base, hsp, text, web-routes }:
     mkDerivation {
       pname = "web-routes-hsp";
       version = "0.24.6.1";
       sha256 = "ca7cf5bf026c52fee5b6af3ca173c7341cd991dcd38508d07589cc7ea8102cab";
       libraryHaskellDepends = [ base hsp text web-routes ];
       description = "Adds XMLGenerator instance for RouteT monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "web-routes-mtl" = callPackage
    ({ mkDerivation, base, web-routes }:
     mkDerivation {
       pname = "web-routes-mtl";
       version = "0.20.1";
       sha256 = "a5e79050923ac9dc1859c8601d863725d99893e7e8c6558f9b575c92046465cc";
       libraryHaskellDepends = [ base web-routes ];
       description = "Extends web-routes with mtl-based MonadIO / MonadTrans RouteT instances";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "web-routes-quasi" = callPackage
    ({ mkDerivation, base, path-pieces, template-haskell, text }:
     mkDerivation {
       pname = "web-routes-quasi";
       version = "0.7.1.1";
       sha256 = "aeb63d0670b2229a246530cb05666957bfa15387d2617104856d1e0b62f50be7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base path-pieces template-haskell text ];
       jailbreak = true;
       homepage = "http://docs.yesodweb.com/web-routes-quasi/";
       description = "Define data types and parse/build functions for web-routes via a quasi-quoted DSL (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "web-routes-regular" = callPackage
    ({ mkDerivation, base, parsec, regular, text, web-routes }:
     mkDerivation {
       pname = "web-routes-regular";
       version = "0.19.0.1";
       sha256 = "5e2aa9d867c0baa3f288b7f84c53053994a12a4bf1484de6455423aada5fda3b";
       libraryHaskellDepends = [ base parsec regular text web-routes ];
       description = "portable, type-safe URL routing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "web-routes-th" = callPackage
    ({ mkDerivation, base, hspec, HUnit, parsec, QuickCheck, split
     , template-haskell, text, web-routes
     }:
     mkDerivation {
       pname = "web-routes-th";
       version = "0.22.4";
       sha256 = "b09ba714032918dd6e2e729ef7ebb1fae50a97d1cd04e1efb94dd191f52ee0b6";
       libraryHaskellDepends = [
         base parsec split template-haskell text web-routes
       ];
       testHaskellDepends = [ base hspec HUnit QuickCheck web-routes ];
       description = "Support for deriving PathInfo using Template Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "web-routes-transformers" = callPackage
    ({ mkDerivation, base, transformers, web-routes }:
     mkDerivation {
       pname = "web-routes-transformers";
       version = "0.19.1";
       sha256 = "2b36864a2d0a1bb9b7df15c5704602a5360dede24b2a2ad263267e8a79daa15e";
       libraryHaskellDepends = [ base transformers web-routes ];
       jailbreak = true;
       description = "Extends web-routes with some transformers instances for RouteT";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "web-routes-wai" = callPackage
    ({ mkDerivation, base, bytestring, http-types, text, wai
     , web-routes
     }:
     mkDerivation {
       pname = "web-routes-wai";
       version = "0.24.3";
       sha256 = "0737b8f1b0324b2c5aa5f90ee14263a391fc62e2d61ca3d5be4f944d67a30f1c";
       libraryHaskellDepends = [
         base bytestring http-types text wai web-routes
       ];
       description = "Library for maintaining correctness of URLs within an application";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "web-routing" = callPackage
    ({ mkDerivation, base, bytestring, doctest, primitive, text
     , types-compat, unordered-containers
     }:
     mkDerivation {
       pname = "web-routing";
       version = "0.6.2";
       sha256 = "ee20a428110d631f4a0c3607e3e83aaca70cd42a5fc44ba643290d7cedabf1f4";
       revision = "1";
       editedCabalFile = "4aa263239149f8ef52999fdc29c8e90c552081672a4476adedce903248e15524";
       libraryHaskellDepends = [
         base bytestring primitive text types-compat unordered-containers
       ];
       testHaskellDepends = [ base doctest ];
       homepage = "https://github.com/philopon/web-routing";
       description = "simple routing library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "webapi" = callPackage
    ({ mkDerivation, aeson, base, binary, blaze-builder, bytestring
     , bytestring-lexing, bytestring-trie, case-insensitive, containers
     , cookie, exceptions, hspec, hspec-wai, http-client
     , http-client-tls, http-media, http-types, network-uri, QuickCheck
     , resourcet, text, time, transformers, vector, wai, wai-extra, warp
     }:
     mkDerivation {
       pname = "webapi";
       version = "0.1.0.0";
       sha256 = "c0d16e251abc585bcf5f3f65a7e8c24039efc08c335515af9c491bc48c2e2465";
       libraryHaskellDepends = [
         aeson base binary blaze-builder bytestring bytestring-lexing
         bytestring-trie case-insensitive containers cookie exceptions
         http-client http-client-tls http-media http-types network-uri
         QuickCheck resourcet text time transformers vector wai wai-extra
       ];
       testHaskellDepends = [
         base bytestring hspec hspec-wai http-types QuickCheck text time
         vector wai wai-extra warp
       ];
       jailbreak = true;
       homepage = "http://byteally.github.io/webapi/";
       description = "WAI based library for web api";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webapp" = callPackage
    ({ mkDerivation, aeson, base, base16-bytestring, blaze-builder
     , bytestring, case-insensitive, http-types, mtl, network
     , optparse-applicative, regex-posix, stm, streaming-commons, text
     , transformers, unix, wai, warp, warp-tls, zlib
     }:
     mkDerivation {
       pname = "webapp";
       version = "0.2.0";
       sha256 = "47c0e2d790cc43318241764b73be95f53d651afcbfb9c9e7e7e1fe3348ff7572";
       libraryHaskellDepends = [
         aeson base base16-bytestring blaze-builder bytestring
         case-insensitive http-types mtl network optparse-applicative
         regex-posix stm streaming-commons text transformers unix wai warp
         warp-tls zlib
       ];
       jailbreak = true;
       homepage = "https://github.com/fhsjaagshs/webapp";
       description = "Haskell web app framework based on WAI & Warp";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webcrank" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, bytestring
     , case-insensitive, either, exceptions, http-date, http-media
     , http-types, lens, mtl, semigroups, tasty, tasty-hunit
     , tasty-quickcheck, text, transformers, unordered-containers
     , utf8-string
     }:
     mkDerivation {
       pname = "webcrank";
       version = "0.2.2";
       sha256 = "52472628ae993982dfb1d315cef0e786397a9fafc544ea84a7951a51c4bdfbe5";
       revision = "1";
       editedCabalFile = "487831902c68484790108f97e32098dad9711eb15e0729b9ab1ba009e8fd5747";
       libraryHaskellDepends = [
         attoparsec base blaze-builder bytestring case-insensitive either
         exceptions http-date http-media http-types lens mtl semigroups text
         transformers unordered-containers utf8-string
       ];
       testHaskellDepends = [
         attoparsec base bytestring case-insensitive exceptions http-date
         http-media http-types lens mtl tasty tasty-hunit tasty-quickcheck
         unordered-containers
       ];
       jailbreak = true;
       homepage = "https://github.com/webcrank/webcrank.hs";
       description = "Webmachine inspired toolkit for building http applications and services";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "webcrank-dispatch" = callPackage
    ({ mkDerivation, base, hvect, mtl, path-pieces, reroute, text
     , unordered-containers
     }:
     mkDerivation {
       pname = "webcrank-dispatch";
       version = "0.2";
       sha256 = "13328e0f7570a29b9938b8effecc6eeadd3d14555cbefc6e3707c98d7695b7ae";
       libraryHaskellDepends = [
         base hvect mtl path-pieces reroute text unordered-containers
       ];
       homepage = "https://github.com/webcrank/webcrank-dispatch.hs";
       description = "A simple request dispatcher";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webcrank-wai" = callPackage
    ({ mkDerivation, base, bytestring, exceptions, lens, mtl
     , unix-compat, unordered-containers, wai, wai-lens, webcrank
     , webcrank-dispatch
     }:
     mkDerivation {
       pname = "webcrank-wai";
       version = "0.2.1";
       sha256 = "db075f154e1409b5e33210b8ebae54f41fe40ef6f9a236484cfdfeed2f14ab8d";
       libraryHaskellDepends = [
         base bytestring exceptions lens mtl unix-compat
         unordered-containers wai wai-lens webcrank webcrank-dispatch
       ];
       homepage = "https://github.com/webcrank/webcrank-wai";
       description = "Build a WAI Application from Webcrank Resources";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webdriver_0_6_0_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bytestring, cond, data-default, directory, directory-tree
     , exceptions, filepath, http-client, http-types, lifted-base
     , monad-control, mtl, network, network-uri, parallel, scientific
     , temporary, text, time, transformers, transformers-base
     , unordered-containers, vector, zip-archive
     }:
     mkDerivation {
       pname = "webdriver";
       version = "0.6.0.3";
       sha256 = "985869bd3f441f3def78635e6d88d0a98c228807241bafb1ff9d1159744e14e0";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring bytestring cond
         data-default directory directory-tree exceptions filepath
         http-client http-types lifted-base monad-control mtl network
         network-uri scientific temporary text time transformers
         transformers-base unordered-containers vector zip-archive
       ];
       testHaskellDepends = [ base parallel text ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/kallisti-dev/hs-webdriver";
       description = "a Haskell client for the Selenium WebDriver protocol";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webdriver_0_6_0_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bytestring, cond, data-default, directory, directory-tree
     , exceptions, filepath, http-client, http-types, lifted-base
     , monad-control, mtl, network, network-uri, parallel, scientific
     , temporary, text, time, transformers, transformers-base
     , unordered-containers, vector, zip-archive
     }:
     mkDerivation {
       pname = "webdriver";
       version = "0.6.0.4";
       sha256 = "0e1f6f7c1a5fce6da68f313c9725e36c505ddbf47216a380abfe01435b313ed6";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring bytestring cond
         data-default directory directory-tree exceptions filepath
         http-client http-types lifted-base monad-control mtl network
         network-uri scientific temporary text time transformers
         transformers-base unordered-containers vector zip-archive
       ];
       testHaskellDepends = [ base parallel text ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/kallisti-dev/hs-webdriver";
       description = "a Haskell client for the Selenium WebDriver protocol";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webdriver_0_6_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bytestring, cond, data-default, directory, directory-tree
     , exceptions, filepath, http-client, http-types, lifted-base
     , monad-control, mtl, network, network-uri, parallel, scientific
     , temporary, text, time, transformers, transformers-base
     , unordered-containers, vector, zip-archive
     }:
     mkDerivation {
       pname = "webdriver";
       version = "0.6.1";
       sha256 = "919fbc0d8eb71ce600ba9edf3fa5da278fef9bb55183f8a68735c6fca188c490";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring bytestring cond
         data-default directory directory-tree exceptions filepath
         http-client http-types lifted-base monad-control mtl network
         network-uri scientific temporary text time transformers
         transformers-base unordered-containers vector zip-archive
       ];
       testHaskellDepends = [ base parallel text ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/kallisti-dev/hs-webdriver";
       description = "a Haskell client for the Selenium WebDriver protocol";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webdriver_0_6_2" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bytestring, cond, data-default, directory, directory-tree
     , exceptions, filepath, http-client, http-types, lifted-base
     , monad-control, mtl, network, network-uri, parallel, scientific
     , temporary, text, time, transformers, transformers-base
     , unordered-containers, vector, zip-archive
     }:
     mkDerivation {
       pname = "webdriver";
       version = "0.6.2";
       sha256 = "f97d7bad0a7b41a86a5afd2cb88b0ffe69f6d16ce42b333b6f7a8562373226b3";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring bytestring cond
         data-default directory directory-tree exceptions filepath
         http-client http-types lifted-base monad-control mtl network
         network-uri scientific temporary text time transformers
         transformers-base unordered-containers vector zip-archive
       ];
       testHaskellDepends = [ base parallel text ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/kallisti-dev/hs-webdriver";
       description = "a Haskell client for the Selenium WebDriver protocol";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webdriver_0_6_2_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bytestring, cond, data-default, directory, directory-tree
     , exceptions, filepath, http-client, http-types, lifted-base
     , monad-control, mtl, network, network-uri, parallel, scientific
     , temporary, text, time, transformers, transformers-base
     , unordered-containers, vector, zip-archive
     }:
     mkDerivation {
       pname = "webdriver";
       version = "0.6.2.1";
       sha256 = "d0f0a31a799da18043163d5d699f778f4d4939e31a0214293db7fa8851759a5e";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring bytestring cond
         data-default directory directory-tree exceptions filepath
         http-client http-types lifted-base monad-control mtl network
         network-uri scientific temporary text time transformers
         transformers-base unordered-containers vector zip-archive
       ];
       testHaskellDepends = [ base parallel text ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/kallisti-dev/hs-webdriver";
       description = "a Haskell client for the Selenium WebDriver protocol";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webdriver_0_6_3_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bytestring, cond, data-default, directory, directory-tree
     , exceptions, filepath, http-client, http-types, lifted-base
     , monad-control, mtl, network, network-uri, parallel, scientific
     , temporary, text, time, transformers, transformers-base
     , unordered-containers, vector, zip-archive
     }:
     mkDerivation {
       pname = "webdriver";
       version = "0.6.3.1";
       sha256 = "69af96c4739d9d189cf8bc75a4b33a1fa525e16a062d3e8f95c578c3f35244c3";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring bytestring cond
         data-default directory directory-tree exceptions filepath
         http-client http-types lifted-base monad-control mtl network
         network-uri scientific temporary text time transformers
         transformers-base unordered-containers vector zip-archive
       ];
       testHaskellDepends = [ base parallel text ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://github.com/kallisti-dev/hs-webdriver";
       description = "a Haskell client for the Selenium WebDriver protocol";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webdriver_0_8_0_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bytestring, data-default-class, directory, directory-tree
     , exceptions, filepath, http-client, http-types, lifted-base
     , monad-control, network, network-uri, scientific, temporary, text
     , time, transformers, transformers-base, unordered-containers
     , vector, zip-archive
     }:
     mkDerivation {
       pname = "webdriver";
       version = "0.8.0.4";
       sha256 = "11a3b0fd53ad2ef2014d57b9964ff258a4394c10ff00947932637180983077db";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring bytestring
         data-default-class directory directory-tree exceptions filepath
         http-client http-types lifted-base monad-control network
         network-uri scientific temporary text time transformers
         transformers-base unordered-containers vector zip-archive
       ];
       doCheck = false;
       homepage = "https://github.com/kallisti-dev/hs-webdriver";
       description = "a Haskell client for the Selenium WebDriver protocol";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webdriver" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bytestring, data-default-class, directory, directory-tree
     , exceptions, filepath, http-client, http-types, lifted-base
     , monad-control, network, network-uri, scientific, temporary, text
     , time, transformers, transformers-base, unordered-containers
     , vector, zip-archive
     }:
     mkDerivation {
       pname = "webdriver";
       version = "0.8.1";
       sha256 = "74ccd22c1fa6ce713d36997a09dc1c1931732a7f005f35d364600ec09d04933f";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring bytestring
         data-default-class directory directory-tree exceptions filepath
         http-client http-types lifted-base monad-control network
         network-uri scientific temporary text time transformers
         transformers-base unordered-containers vector zip-archive
       ];
       doCheck = false;
       homepage = "https://github.com/kallisti-dev/hs-webdriver";
       description = "a Haskell client for the Selenium WebDriver protocol";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "webdriver-angular_0_1_7" = callPackage
    ({ mkDerivation, aeson, base, hspec, hspec-webdriver
     , language-javascript, template-haskell, text, transformers
     , unordered-containers, wai-app-static, warp, webdriver
     }:
     mkDerivation {
       pname = "webdriver-angular";
       version = "0.1.7";
       sha256 = "41dc907ba897cf877fc1877f6ae83cb07c038308203d9f94b63e3dad70e29ea2";
       libraryHaskellDepends = [
         aeson base language-javascript template-haskell text transformers
         unordered-containers webdriver
       ];
       testHaskellDepends = [
         base hspec hspec-webdriver transformers wai-app-static warp
         webdriver
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "https://bitbucket.org/wuzzeb/webdriver-utils";
       description = "Webdriver actions to assist with testing a webpage which uses Angular.Js";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webdriver-angular" = callPackage
    ({ mkDerivation, aeson, base, hspec, hspec-webdriver
     , language-javascript, template-haskell, text, transformers
     , unordered-containers, wai-app-static, warp, webdriver
     }:
     mkDerivation {
       pname = "webdriver-angular";
       version = "0.1.9";
       sha256 = "84640b2c9152c2349319b8156c0f98a65bf52a913f010cc68f4ec2343a93d239";
       libraryHaskellDepends = [
         aeson base language-javascript template-haskell text transformers
         unordered-containers webdriver
       ];
       testHaskellDepends = [
         base hspec hspec-webdriver transformers wai-app-static warp
         webdriver
       ];
       doCheck = false;
       homepage = "https://bitbucket.org/wuzzeb/webdriver-utils";
       description = "Webdriver actions to assist with testing a webpage which uses Angular.Js";
       license = stdenv.lib.licenses.mit;
     }) {};

  "webdriver-snoy" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, base64-bytestring
     , bytestring, cond, data-default, directory, directory-tree
     , exceptions, filepath, http-client, http-types, lifted-base
     , monad-control, mtl, network, parallel, scientific, temporary
     , text, time, transformers, transformers-base, unordered-containers
     , vector, zip-archive
     }:
     mkDerivation {
       pname = "webdriver-snoy";
       version = "0.6.0.4";
       sha256 = "736568c4b0afbf9c67fa8356a67a855664735acb24c81cccb64fbf32318c8209";
       revision = "1";
       editedCabalFile = "7cc952e84c8ff09b8d032df7d8089bd4d5167b32834bda67c79c62a34b12d52a";
       libraryHaskellDepends = [
         aeson attoparsec base base64-bytestring bytestring cond
         data-default directory directory-tree exceptions filepath
         http-client http-types lifted-base monad-control mtl network
         scientific temporary text time transformers transformers-base
         unordered-containers vector zip-archive
       ];
       testHaskellDepends = [ base parallel text ];
       jailbreak = true;
       homepage = "https://github.com/kallisti-dev/hs-webdriver";
       description = "a Haskell client for the Selenium WebDriver protocol (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webfinger-client" = callPackage
    ({ mkDerivation, aeson, base, bytestring, data-default-class
     , hashable, http-client, http-client-tls, http-types
     , link-relations, text, unordered-containers, uri-bytestring
     }:
     mkDerivation {
       pname = "webfinger-client";
       version = "0.2.0.0";
       sha256 = "1311f198704ba1dc9439a20427e1d909ceab86dbd196d31ded52835291b85a2a";
       libraryHaskellDepends = [
         aeson base bytestring data-default-class hashable http-client
         http-client-tls http-types link-relations text unordered-containers
         uri-bytestring
       ];
       homepage = "http://hub.darcs.net/fr33domlover/webfinger-client";
       description = "WebFinger client library";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "webidl" = callPackage
    ({ mkDerivation, base, bytestring, HSFFIG, LEXER, parsec, pretty
     , utf8-env, utf8-string
     }:
     mkDerivation {
       pname = "webidl";
       version = "0.1.1";
       sha256 = "fe3f734dffeafe82abceffca2417968ae454382fa23df7690be48513fcf18416";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring HSFFIG LEXER parsec pretty utf8-env utf8-string
       ];
       executableHaskellDepends = [
         base bytestring HSFFIG LEXER parsec pretty utf8-env utf8-string
       ];
       jailbreak = true;
       description = "Parser and Pretty Printer for the Web IDL Language";
       license = stdenv.lib.licenses.bsd3;
       broken = true;
     }) {LEXER = null;};

  "webify" = callPackage
    ({ mkDerivation, base, binary, binary-strict, blaze-builder
     , bytestring, containers, filepath, hopfli, optparse-applicative
     , text, vector, xmlgen, zlib
     }:
     mkDerivation {
       pname = "webify";
       version = "0.1.7.0";
       sha256 = "14ebc023e92690ea8a6e56d74987666ddc993bebd3d5f22cb6759583ba99da99";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary binary-strict blaze-builder bytestring containers
         filepath hopfli optparse-applicative text vector xmlgen zlib
       ];
       jailbreak = true;
       homepage = "http://github.com/ananthakumaran/webify";
       description = "webfont generator";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webkit" = callPackage
    ({ mkDerivation, base, bytestring, cairo, glib, gtk
     , gtk2hs-buildtools, mtl, pango, text, transformers, webkit
     }:
     mkDerivation {
       pname = "webkit";
       version = "0.14.1.1";
       sha256 = "c80dd015ecbf02b7d018afd1679df78a8c1ce17e3ae6b943f23d4da2ef867e44";
       libraryHaskellDepends = [
         base bytestring cairo glib gtk mtl pango text transformers
       ];
       libraryPkgconfigDepends = [ webkit ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Webkit library";
       license = stdenv.lib.licenses.lgpl21;
     }) {inherit (pkgs) webkit;};

  "webkit-javascriptcore" = callPackage
    ({ mkDerivation, base, glib, gtk, gtk2hs-buildtools, webkit }:
     mkDerivation {
       pname = "webkit-javascriptcore";
       version = "0.13.1.1";
       sha256 = "c54491817b539f2ae5ff75f082ff18efc68038146553e300462a3a8d808ff730";
       libraryHaskellDepends = [ base glib gtk webkit ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       description = "JavaScriptCore FFI from webkitgtk";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webkitgtk3" = callPackage
    ({ mkDerivation, base, bytestring, cairo, glib, gtk2hs-buildtools
     , gtk3, mtl, pango, text, transformers, webkit
     }:
     mkDerivation {
       pname = "webkitgtk3";
       version = "0.14.1.1";
       sha256 = "a8edd6470fe9a6c82f98bc331d23f6c6fb6978b6d63f03f010e0c7e1000eb216";
       libraryHaskellDepends = [
         base bytestring cairo glib gtk3 mtl pango text transformers
       ];
       libraryPkgconfigDepends = [ webkit ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://projects.haskell.org/gtk2hs/";
       description = "Binding to the Webkit library";
       license = stdenv.lib.licenses.lgpl21;
     }) {inherit (pkgs) webkit;};

  "webkitgtk3-javascriptcore" = callPackage
    ({ mkDerivation, base, glib, gtk2hs-buildtools, gtk3, webkit
     , webkitgtk3
     }:
     mkDerivation {
       pname = "webkitgtk3-javascriptcore";
       version = "0.13.1.1";
       sha256 = "0a1583d61f20c8cf0f84443210711222a9f0dc1d8a99a85944c01f487aaa8b79";
       libraryHaskellDepends = [ base glib gtk3 webkitgtk3 ];
       libraryPkgconfigDepends = [ webkit ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       description = "JavaScriptCore FFI from webkitgtk";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) webkit;};

  "webpage_0_0_3_1" = callPackage
    ({ mkDerivation, base, blaze-html, data-default, hastache, lucid
     , text
     }:
     mkDerivation {
       pname = "webpage";
       version = "0.0.3.1";
       sha256 = "32475ba1de732de8f93d6bbf9b4f1789dde4e8246cb0134278c0b0b9392138e9";
       revision = "1";
       editedCabalFile = "1829b0f7db8745498bee16ed1d70917aa781fd14ab8f8032b51472cfc3cd6787";
       libraryHaskellDepends = [
         base blaze-html data-default hastache lucid text
       ];
       description = "Organized and simple web page scaffold for blaze and lucid";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "webpage" = callPackage
    ({ mkDerivation, base, blaze-html, data-default, lucid, text }:
     mkDerivation {
       pname = "webpage";
       version = "0.0.4";
       sha256 = "17fba395357bf4d1462d1a50e2a06d1004d0df02cab524dc26e982a90f70c648";
       libraryHaskellDepends = [
         base blaze-html data-default lucid text
       ];
       description = "Organized and simple web page scaffold for blaze and lucid";
       license = stdenv.lib.licenses.mit;
     }) {};

  "webrtc-vad" = callPackage
    ({ mkDerivation, base, primitive, vector }:
     mkDerivation {
       pname = "webrtc-vad";
       version = "0.1.0.2";
       sha256 = "d3ad3ba58ca2389102be09bda8bca69a525c766ada824898cf833d1993368293";
       libraryHaskellDepends = [ base primitive vector ];
       description = "Easy voice activity detection";
       license = stdenv.lib.licenses.mit;
     }) {};

  "webserver" = callPackage
    ({ mkDerivation, base, bytestring, c10k, containers, directory
     , filepath, network, old-locale, parsec, process, stm, time, unix
     , zlib
     }:
     mkDerivation {
       pname = "webserver";
       version = "0.7.1.1";
       sha256 = "e32436fa0e9d096fdfffef9829cf2f99b075fc393b360ebc8972f80e76e04b56";
       libraryHaskellDepends = [
         base bytestring c10k containers directory filepath network
         old-locale parsec process stm time unix zlib
       ];
       description = "HTTP server library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "websnap" = callPackage
    ({ mkDerivation, base, filepath, gtk, webkit }:
     mkDerivation {
       pname = "websnap";
       version = "0.1.0.1";
       sha256 = "045dca9ddfabb8cda46f2fef6747de7f438c70cc0c2a7e3c1e1eb14b45deca15";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base filepath gtk webkit ];
       homepage = "https://github.com/jrb/websnap";
       description = "Transforms URLs to PNGs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "websockets_0_9_2_1" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, binary
     , blaze-builder, bytestring, case-insensitive, containers, entropy
     , HUnit, mtl, network, QuickCheck, random, SHA, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "websockets";
       version = "0.9.2.1";
       sha256 = "ba147449146bf9f12323a79ee78dfe95bde21c35a6fb84cedb3ae5c35a81ed86";
       libraryHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy mtl network random SHA text
       ];
       testHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy HUnit mtl network QuickCheck
         random SHA test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       doHaddock = false;
       jailbreak = true;
       doCheck = false;
       homepage = "http://jaspervdj.be/websockets";
       description = "A sensible and clean way to write WebSocket-capable servers in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "websockets_0_9_2_2" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, binary
     , blaze-builder, bytestring, case-insensitive, containers, entropy
     , HUnit, mtl, network, QuickCheck, random, SHA, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "websockets";
       version = "0.9.2.2";
       sha256 = "e446d55d2daa412b43a1c63b9b7b4167a7e1e4511a6d459a8235a2beb309fd7e";
       libraryHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy mtl network random SHA text
       ];
       testHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy HUnit mtl network QuickCheck
         random SHA test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://jaspervdj.be/websockets";
       description = "A sensible and clean way to write WebSocket-capable servers in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "websockets_0_9_3_0" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, binary
     , blaze-builder, bytestring, case-insensitive, containers, entropy
     , HUnit, mtl, network, QuickCheck, random, SHA, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "websockets";
       version = "0.9.3.0";
       sha256 = "611fad117d83a26981b79f4075cd091ccb3f2c78c3b36bc82f05ea10ddaa002b";
       libraryHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy mtl network random SHA text
       ];
       testHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy HUnit mtl network QuickCheck
         random SHA test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://jaspervdj.be/websockets";
       description = "A sensible and clean way to write WebSocket-capable servers in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "websockets_0_9_3_1" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, binary
     , blaze-builder, bytestring, case-insensitive, containers, entropy
     , HUnit, mtl, network, QuickCheck, random, SHA, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "websockets";
       version = "0.9.3.1";
       sha256 = "e6385c2ef8cfe018e05a9e8ffcc5549ccb7d1470a4348619b0272821a414187b";
       libraryHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy mtl network random SHA text
       ];
       testHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy HUnit mtl network QuickCheck
         random SHA test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://jaspervdj.be/websockets";
       description = "A sensible and clean way to write WebSocket-capable servers in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "websockets_0_9_4_0" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, binary
     , blaze-builder, bytestring, case-insensitive, containers, entropy
     , HUnit, mtl, network, QuickCheck, random, SHA, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "websockets";
       version = "0.9.4.0";
       sha256 = "e01d0cd47c83c256dd0c0eb63e8e7aff7e9d74cf44f88eb40145e85d62f1f172";
       libraryHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy mtl network random SHA text
       ];
       testHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy HUnit mtl network QuickCheck
         random SHA test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://jaspervdj.be/websockets";
       description = "A sensible and clean way to write WebSocket-capable servers in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "websockets_0_9_5_0" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, binary
     , blaze-builder, bytestring, case-insensitive, containers, entropy
     , HUnit, mtl, network, QuickCheck, random, SHA, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "websockets";
       version = "0.9.5.0";
       sha256 = "beee58d5394a54705b7f2ddfc97030b42acbb8d6415b14b330c68ea94710d004";
       libraryHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy mtl network random SHA text
       ];
       testHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy HUnit mtl network QuickCheck
         random SHA test-framework test-framework-hunit
         test-framework-quickcheck2 text
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://jaspervdj.be/websockets";
       description = "A sensible and clean way to write WebSocket-capable servers in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "websockets_0_9_6_0" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, binary
     , blaze-builder, bytestring, case-insensitive, containers, entropy
     , HUnit, network, QuickCheck, random, SHA, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "websockets";
       version = "0.9.6.0";
       sha256 = "1740d6de660570328239aeb718911d51d27eaf6eb5880fe622b7ac2a4b1dfe1c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy network random SHA text
       ];
       executableHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy network random SHA text
       ];
       testHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy HUnit network QuickCheck random
         SHA test-framework test-framework-hunit test-framework-quickcheck2
         text
       ];
       doCheck = false;
       homepage = "http://jaspervdj.be/websockets";
       description = "A sensible and clean way to write WebSocket-capable servers in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "websockets" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, binary
     , blaze-builder, bytestring, case-insensitive, containers, entropy
     , HUnit, network, QuickCheck, random, SHA, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text
     }:
     mkDerivation {
       pname = "websockets";
       version = "0.9.6.1";
       sha256 = "3c75cb59585710862c57277c8be718903ba727452d5f662288abb8b59eb57cd4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy network random SHA text
       ];
       executableHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy network random SHA text
       ];
       testHaskellDepends = [
         attoparsec base base64-bytestring binary blaze-builder bytestring
         case-insensitive containers entropy HUnit network QuickCheck random
         SHA test-framework test-framework-hunit test-framework-quickcheck2
         text
       ];
       doCheck = false;
       homepage = "http://jaspervdj.be/websockets";
       description = "A sensible and clean way to write WebSocket-capable servers in Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "websockets-snap" = callPackage
    ({ mkDerivation, base, bytestring, enumerator, mtl, snap-core
     , snap-server, websockets
     }:
     mkDerivation {
       pname = "websockets-snap";
       version = "0.9.2.0";
       sha256 = "b7c30525c8a3ba5aeaadccaf47efc23ac52885e520012df6fc813fbf1bf35f0f";
       libraryHaskellDepends = [
         base bytestring enumerator mtl snap-core snap-server websockets
       ];
       description = "Snap integration for the websockets library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "webwire" = callPackage
    ({ mkDerivation, base, base64-bytestring, blaze-builder, blaze-html
     , bytestring, case-insensitive, containers, cookie, cprng-aes
     , hamlet, http-types, netwire, shakespeare-css, shakespeare-js
     , text, time, transformers, wai, wai-extra
     }:
     mkDerivation {
       pname = "webwire";
       version = "0.1.0";
       sha256 = "2293cc4893bd0166d5177e2c1db83ef26ffdcc0b01d9b584f4fe98e7d8a15c54";
       libraryHaskellDepends = [
         base base64-bytestring blaze-builder blaze-html bytestring
         case-insensitive containers cookie cprng-aes hamlet http-types
         netwire shakespeare-css shakespeare-js text time transformers wai
         wai-extra
       ];
       description = "Functional reactive web framework";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wedding-announcement" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "wedding-announcement";
       version = "1.1";
       sha256 = "896c5fe7611d70900667bc1879fd1e042687df04a7069d2538011958dc648b67";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ];
       homepage = "http://web.mornfall.net";
       description = "a wedding announcement";
       license = stdenv.lib.licenses.publicDomain;
     }) {};

  "wedged" = callPackage
    ({ mkDerivation, array, base, colour, containers, diagrams-cairo
     , diagrams-lib, MonadRandom, strict
     }:
     mkDerivation {
       pname = "wedged";
       version = "0";
       sha256 = "2194e355beff9e7a2b8f036a064cf57e7856e61e83632227d8b73c0c08c3b6e9";
       revision = "1";
       editedCabalFile = "64bac15c983cf83ab2b05b002439b8f125b9c942ae46ed75a187f7e2dc68dba5";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base colour containers diagrams-cairo diagrams-lib
         MonadRandom strict
       ];
       jailbreak = true;
       description = "Wedged postcard generator";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "weighted-regexp" = callPackage
    ({ mkDerivation, array, base, happy }:
     mkDerivation {
       pname = "weighted-regexp";
       version = "0.3.1.2";
       sha256 = "f963773841854c56d36f329dae51ec08b9028832eee53b62a9ba7df5ef2de664";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base ];
       libraryToolDepends = [ happy ];
       jailbreak = true;
       homepage = "http://sebfisch.github.com/haskell-regexp";
       description = "Weighted Regular Expression Matcher";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "weighted-search" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "weighted-search";
       version = "0.1.0.1";
       sha256 = "fb233e130fd50b46e81060e940fe7623b1f24b6947b8d312755cc0f1405842ed";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/luqui/weighted-search";
       description = "A weighted nondeterministic search monad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "welshy" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, bytestring, conduit
     , http-types, lifted-base, resourcet, text, transformers
     , unordered-containers, wai, warp
     }:
     mkDerivation {
       pname = "welshy";
       version = "0.1.0.0";
       sha256 = "713e804638810eb5e0cd16bb6b47fbef218ac5e902772a024b70d71c8bb6ef22";
       revision = "1";
       editedCabalFile = "ff6973a67b742efb8d7c1d542ba9f27056de3e547ade96d33e9b68314afec22c";
       libraryHaskellDepends = [
         aeson base blaze-builder bytestring conduit http-types lifted-base
         resourcet text transformers unordered-containers wai warp
       ];
       jailbreak = true;
       homepage = "https://github.com/mcschroeder/welshy";
       description = "Haskell web framework (because Scotty had trouble yodeling)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "werewolf" = callPackage
    ({ mkDerivation, aeson, base, containers, directory, extra
     , filepath, lens, MonadRandom, mtl, optparse-applicative
     , QuickCheck, random-shuffle, tasty, tasty-quickcheck, text
     , transformers
     }:
     mkDerivation {
       pname = "werewolf";
       version = "0.4.6.0";
       sha256 = "9ee65c21f4310c81dbde660482680bb73a5d8423436b844d9c4402aa511f2118";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base containers directory extra filepath lens MonadRandom mtl
         random-shuffle text transformers
       ];
       executableHaskellDepends = [
         aeson base directory extra filepath lens MonadRandom mtl
         optparse-applicative random-shuffle text transformers
       ];
       testHaskellDepends = [
         base containers extra lens mtl QuickCheck tasty tasty-quickcheck
         text
       ];
       homepage = "https://github.com/hjwylde/werewolf";
       description = "A game engine for running werewolf in a chat client";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wheb-mongo" = callPackage
    ({ mkDerivation, base, bson, mongoDB, mtl, text, Wheb }:
     mkDerivation {
       pname = "wheb-mongo";
       version = "0.0.3.0";
       sha256 = "9e3597f9b6559ec1955889acddc6ff482cf04d65da6229ce38f072d925d0b3f7";
       libraryHaskellDepends = [ base bson mongoDB mtl text Wheb ];
       jailbreak = true;
       homepage = "https://github.com/hansonkd/Wheb-Framework";
       description = "MongoDB plugin for Wheb";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wheb-redis" = callPackage
    ({ mkDerivation, base, bytestring, hedis, mtl, text, Wheb }:
     mkDerivation {
       pname = "wheb-redis";
       version = "0.0.1.0";
       sha256 = "b0108514d32798c3469cd9af9d03538a4010ca4eed0e666aca72e140ae84ac08";
       libraryHaskellDepends = [ base bytestring hedis mtl text Wheb ];
       jailbreak = true;
       homepage = "https://github.com/hansonkd/Wheb-Framework";
       description = "Redis connection for Wheb";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wheb-strapped" = callPackage
    ({ mkDerivation, base, mtl, StrappedTemplates, text, Wheb }:
     mkDerivation {
       pname = "wheb-strapped";
       version = "0.1.0.0";
       sha256 = "b739be48d7105d368a8d8ec9c1d5049c4dab9c93d6eea0ce9c668c22c6bdd3f3";
       libraryHaskellDepends = [ base mtl StrappedTemplates text Wheb ];
       jailbreak = true;
       homepage = "https://github.com/hansonkd/Wheb-Framework";
       description = "Strapped templates for Wheb";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "while-lang-parser" = callPackage
    ({ mkDerivation, base, indents, parsec }:
     mkDerivation {
       pname = "while-lang-parser";
       version = "0.1.0.0";
       sha256 = "94f6d8f0fd474166c60523cc70334b651dd95e54a733883858944cd568169836";
       libraryHaskellDepends = [ base indents parsec ];
       homepage = "https://github.com/davnils/while-lang-parser";
       description = "Parser for the While language";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "whim" = callPackage
    ({ mkDerivation, base, containers, GLUT, mtl, OpenGL, process
     , random, X11
     }:
     mkDerivation {
       pname = "whim";
       version = "0.1.1";
       sha256 = "4646008833f00514bb046a971ef7ef412617c4917b46b4a68be8571cb7d5ea39";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers GLUT mtl OpenGL process random X11
       ];
       jailbreak = true;
       homepage = "http://neugierig.org/software/darcs/whim/";
       description = "A Haskell window manager";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "whiskers" = callPackage
    ({ mkDerivation, base, parsec, template-haskell }:
     mkDerivation {
       pname = "whiskers";
       version = "0.1.0.3";
       sha256 = "bb1081d4a4b39ddcf1e1e2618b655c0dfae818af0c3b4517bda2896f30d87e4d";
       libraryHaskellDepends = [ base parsec template-haskell ];
       jailbreak = true;
       description = "Mustache templates with Template Haskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "whitespace" = callPackage
    ({ mkDerivation, haskell98, random }:
     mkDerivation {
       pname = "whitespace";
       version = "0.4";
       sha256 = "e9133161bf712cd584334a4e9d75b1eb7dd64e48f956a73fc6e833a6bc5a09f9";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ haskell98 random ];
       homepage = "https://github.com/haroldl/whitespace-nd";
       description = "Whitespace, an esoteric programming language";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "whois" = callPackage
    ({ mkDerivation, base, network, network-uri, split }:
     mkDerivation {
       pname = "whois";
       version = "1.2.2";
       sha256 = "6047b0dd4c14a2f1b9b094dd6b8d43e1f9d1c03decc6ed653c9dc50fc2692ea5";
       revision = "1";
       editedCabalFile = "c11f42da958683ffb7a2e958dcefe2ef1a3e732732010f44facfbb0fffd7571e";
       libraryHaskellDepends = [ base network network-uri split ];
       homepage = "http://github.com/relrod/whois-hs";
       description = "WHOIS client library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "why3" = callPackage
    ({ mkDerivation, alex, array, base, bytestring, containers, deepseq
     , directory, filepath, happy, monadLib, pretty, pretty-show
     , profunctors, text
     }:
     mkDerivation {
       pname = "why3";
       version = "0.8";
       sha256 = "8e2d6d29c6fd6f0ecd72a28c3075843533db6a086c67a2a9a520f0dcc916fbf5";
       libraryHaskellDepends = [
         array base bytestring containers deepseq directory filepath
         monadLib pretty pretty-show profunctors text
       ];
       libraryToolDepends = [ alex happy ];
       jailbreak = true;
       description = "Haskell support for the Why3 input format";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wigner-symbols" = callPackage
    ({ mkDerivation, base, bytestring, cryptonite }:
     mkDerivation {
       pname = "wigner-symbols";
       version = "1.0.0";
       sha256 = "0d2ae52728e6ef32519a6b648033185617291e76c4996c7107b9a3caf73db28e";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base bytestring cryptonite ];
       homepage = "https://github.com/Rufflewind/wigner-symbols";
       description = "CG coefficients and Wigner symbols";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wikipedia4epub" = callPackage
    ({ mkDerivation, base, bytestring, directory, epub, filepath
     , haskell98, HTTP, network, regex-base, regex-posix, tagsoup, url
     , xml, zip-archive, zlib
     }:
     mkDerivation {
       pname = "wikipedia4epub";
       version = "0.0.12";
       sha256 = "6da5c14db47d113f6b75324e3cc77b9641d032af7c443b55a4133e3b33af3521";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring directory epub filepath haskell98 HTTP network
         regex-base regex-posix tagsoup url xml zip-archive zlib
       ];
       homepage = "http://rampa.sk/static/wikipedia4epub.html";
       description = "Wikipedia EPUB E-Book construction from Firefox history";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "win-hp-path" = callPackage
    ({ mkDerivation, base, process, split }:
     mkDerivation {
       pname = "win-hp-path";
       version = "0.1.2";
       sha256 = "d85934e27cf62cb8aefc5bbeb20708062632bee52e5cff79c5dc1d4c18ca308c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base split ];
       executableHaskellDepends = [ base process split ];
       homepage = "http://github.com/ygale/win-hp-path";
       description = "Work with multiple Haskell Platform versions on Windows";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "windowslive" = callPackage
    ({ mkDerivation, base, Crypto, dataenc, mtl, network, parsec
     , pretty, split, time, urlencoded
     }:
     mkDerivation {
       pname = "windowslive";
       version = "0.3";
       sha256 = "7fc9617306ccbe99a8f910ca442bfeabd8e78b8668db773defefa5b41b1fb395";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Crypto dataenc mtl network parsec pretty split time urlencoded
       ];
       jailbreak = true;
       homepage = "http://patch-tag.com/repo/windowslive";
       description = "Implements Windows Live Web Authentication and Delegated Authentication";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "winerror" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "winerror";
       version = "1.0.1";
       sha256 = "0d527e4024967909171d3aea30d43abb0fd84306f77aa26625466c0f3de95575";
       doHaddock = false;
       description = "Error handling for foreign calls to the Windows API";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "winio" = callPackage
    ({ mkDerivation, base, bytestring, extensible-exceptions, kernel32
     , network, winerror, ws2_32
     }:
     mkDerivation {
       pname = "winio";
       version = "0.1";
       sha256 = "954bcbb0dd5ca68e272d80bf5ce07b2c8fde5d0b7717f55d268b9dc59ce92338";
       libraryHaskellDepends = [
         base bytestring extensible-exceptions network winerror
       ];
       librarySystemDepends = [ kernel32 ws2_32 ];
       homepage = "http://github.com/felixmar/winio";
       description = "I/O library for Windows";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {kernel32 = null; ws2_32 = null;};

  "wiring" = callPackage
    ({ mkDerivation, base, hspec, mtl, QuickCheck, template-haskell
     , transformers
     }:
     mkDerivation {
       pname = "wiring";
       version = "0.4.2";
       sha256 = "f8b9cc8d1811d88ad1a19e67ae071f4bcdef17ae3ce1f63e9664f5255033e689";
       libraryHaskellDepends = [ base mtl template-haskell transformers ];
       testHaskellDepends = [
         base hspec mtl QuickCheck template-haskell transformers
       ];
       homepage = "http://github.com/seanparsons/wiring/";
       description = "Wiring, promotion and demotion of types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "withdependencies" = callPackage
    ({ mkDerivation, base, conduit, containers, hspec, HUnit, mtl }:
     mkDerivation {
       pname = "withdependencies";
       version = "0.2.2.1";
       sha256 = "5f55d1b520b02c158b24646f417aa03363dfea5b508248d483b9431c5fcd167e";
       libraryHaskellDepends = [ base conduit containers mtl ];
       testHaskellDepends = [ base conduit hspec HUnit mtl ];
       homepage = "https://github.com/bartavelle/withdependencies";
       description = "Run computations that depend on one or more elements in a stream";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "witherable_0_1_3" = callPackage
    ({ mkDerivation, base, base-orphans, containers, hashable
     , transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "witherable";
       version = "0.1.3";
       sha256 = "c832bc8419985966e84ae4367302509aa2ff408ac2ff4757116908d893091458";
       libraryHaskellDepends = [
         base base-orphans containers hashable transformers
         unordered-containers vector
       ];
       homepage = "https://github.com/fumieval/witherable";
       description = "Generalization of filter and catMaybes";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "witherable" = callPackage
    ({ mkDerivation, base, base-orphans, containers, hashable
     , transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "witherable";
       version = "0.1.3.2";
       sha256 = "070dd7a703d4d3a1f59a44a977b14cdf1c255ffab764e71ff47efd6f14740edd";
       libraryHaskellDepends = [
         base base-orphans containers hashable transformers
         unordered-containers vector
       ];
       homepage = "https://github.com/fumieval/witherable";
       description = "Generalization of filter and catMaybes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "witness" = callPackage
    ({ mkDerivation, base, categories, constraints, transformers }:
     mkDerivation {
       pname = "witness";
       version = "0.3";
       sha256 = "21345b658dfe646b1753658117e92753fa9164259dd426f47825f74857490364";
       libraryHaskellDepends = [
         base categories constraints transformers
       ];
       homepage = "https://github.com/AshleyYakeley/witness";
       description = "values that witness types";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "witty" = callPackage
    ({ mkDerivation, base, bytestring, network, unix }:
     mkDerivation {
       pname = "witty";
       version = "0.0.4";
       sha256 = "03e1dd7bd54f7a762044ce5b9cd49cf5efbddc8e229f159f21515a2424390ccd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bytestring network unix ];
       homepage = "https://github.com/kazu-yamamoto/witty/blob/master/README.md";
       description = "A network server to show bottlenecks of GHC";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wizards_1_0_1" = callPackage
    ({ mkDerivation, base, containers, control-monad-free, haskeline
     , mtl, transformers
     }:
     mkDerivation {
       pname = "wizards";
       version = "1.0.1";
       sha256 = "8ae930ca5d8c9a06e9e84ee5b650ba26fa6bc6f069704f8686fb3b692311b621";
       libraryHaskellDepends = [
         base containers control-monad-free haskeline mtl transformers
       ];
       jailbreak = true;
       description = "High level, generic library for interrogative user interfaces";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wizards" = callPackage
    ({ mkDerivation, base, containers, control-monad-free, haskeline
     , mtl, transformers
     }:
     mkDerivation {
       pname = "wizards";
       version = "1.0.2";
       sha256 = "4ba12c726d60688b8173db3891aa1dce7f57c6364c40ba2f1c2c8d16404bd30b";
       libraryHaskellDepends = [
         base containers control-monad-free haskeline mtl transformers
       ];
       description = "High level, generic library for interrogative user interfaces";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wkt" = callPackage
    ({ mkDerivation, base, lens, linear, parsec, parsec-numbers }:
     mkDerivation {
       pname = "wkt";
       version = "0.2.6";
       sha256 = "ef27992128212510566866e2d008bfc55999a2e87eb9fa6f25aba00c4039a49d";
       libraryHaskellDepends = [ base lens linear parsec parsec-numbers ];
       jailbreak = true;
       homepage = "http://github.com/bgamari/wkt";
       description = "Parsec parsers and types for geographic data in well-known text (WKT) format";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wl-pprint_1_1" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "wl-pprint";
       version = "1.1";
       sha256 = "0634abe0eabbdcb5fc307d54b0d763659d0d2aaa193767e67f337500a71b779a";
       revision = "1";
       editedCabalFile = "faf1b4364a3b77cf970f7d966be6dea925f6029625e12db730435230527c6aed";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "The Wadler/Leijen Pretty Printer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wl-pprint" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "wl-pprint";
       version = "1.2";
       sha256 = "198003fa7edd3a2d625ec54402cdc5645434b60ad5983e93525f58fec9dcdf98";
       libraryHaskellDepends = [ base ];
       description = "The Wadler/Leijen Pretty Printer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wl-pprint-ansiterm" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, containers, mtl
     , nats, semigroups, text, transformers, wl-pprint-extras
     }:
     mkDerivation {
       pname = "wl-pprint-ansiterm";
       version = "0.2.0.0";
       sha256 = "ffce8de40e3bf7375bfe8cde58e25309988423ee4cb78be5760840858a3b440b";
       libraryHaskellDepends = [
         ansi-terminal base bytestring containers mtl nats semigroups text
         transformers wl-pprint-extras
       ];
       homepage = "https://github.com/seagull-kamome/wl-pprint-ansiterm";
       description = "ANSI Terminal support with wl-pprint-extras";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wl-pprint-extras_3_5_0_3" = callPackage
    ({ mkDerivation, base, containers, HUnit, nats, semigroupoids
     , semigroups, test-framework, test-framework-hunit, text
     , utf8-string
     }:
     mkDerivation {
       pname = "wl-pprint-extras";
       version = "3.5.0.3";
       sha256 = "d77b57b4797e53afb844b6ae34ecea296e8ac24ea80005951deea48621599c88";
       libraryHaskellDepends = [
         base containers nats semigroupoids semigroups text utf8-string
       ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/wl-pprint-extras/";
       description = "A free monad based on the Wadler/Leijen pretty printer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wl-pprint-extras_3_5_0_4" = callPackage
    ({ mkDerivation, base, containers, HUnit, nats, semigroupoids
     , semigroups, test-framework, test-framework-hunit, text
     , utf8-string
     }:
     mkDerivation {
       pname = "wl-pprint-extras";
       version = "3.5.0.4";
       sha256 = "74d5e1f5b6cdbfe544580eed5d30b80cec3ec3f1def2b65ade9d9ce2dc2e6f57";
       libraryHaskellDepends = [
         base containers nats semigroupoids semigroups text utf8-string
       ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       jailbreak = true;
       homepage = "http://github.com/ekmett/wl-pprint-extras/";
       description = "A free monad based on the Wadler/Leijen pretty printer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wl-pprint-extras" = callPackage
    ({ mkDerivation, base, containers, HUnit, nats, semigroupoids
     , semigroups, test-framework, test-framework-hunit, text
     , utf8-string
     }:
     mkDerivation {
       pname = "wl-pprint-extras";
       version = "3.5.0.5";
       sha256 = "a9c21a85a729191fc422938a1f785d61be52f3a2923d8d79dade9b21e8e98d8f";
       libraryHaskellDepends = [
         base containers nats semigroupoids semigroups text utf8-string
       ];
       testHaskellDepends = [
         base HUnit test-framework test-framework-hunit
       ];
       homepage = "http://github.com/ekmett/wl-pprint-extras/";
       description = "A free monad based on the Wadler/Leijen pretty printer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wl-pprint-terminfo" = callPackage
    ({ mkDerivation, base, bytestring, containers, nats, semigroups
     , terminfo, text, transformers, wl-pprint-extras
     }:
     mkDerivation {
       pname = "wl-pprint-terminfo";
       version = "3.7.1.3";
       sha256 = "bbb6c5ffb6f6a455278ff3a3740259b05f67163a9deb9686677d30cc4366e5a7";
       libraryHaskellDepends = [
         base bytestring containers nats semigroups terminfo text
         transformers wl-pprint-extras
       ];
       homepage = "http://github.com/ekmett/wl-pprint-terminfo/";
       description = "A color pretty printer with terminfo support";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wl-pprint-text_1_1_0_2" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "wl-pprint-text";
       version = "1.1.0.2";
       sha256 = "01e9a14016268a6e5fcde9b300c63646ee0f07dd90606d8cbd586885c6c56e71";
       libraryHaskellDepends = [ base text ];
       jailbreak = true;
       description = "A Wadler/Leijen Pretty Printer for Text values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wl-pprint-text_1_1_0_3" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "wl-pprint-text";
       version = "1.1.0.3";
       sha256 = "c3117fd5a5967385ccd7abb7d17caba83d91958a7ddd786b387636ed1a9e19be";
       libraryHaskellDepends = [ base text ];
       description = "A Wadler/Leijen Pretty Printer for Text values";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wl-pprint-text" = callPackage
    ({ mkDerivation, base, text }:
     mkDerivation {
       pname = "wl-pprint-text";
       version = "1.1.0.4";
       sha256 = "ff2d53814b7c66624a2ef3d8f79034273de5b7addb29c1ebad277057e3fff1f5";
       libraryHaskellDepends = [ base text ];
       description = "A Wadler/Leijen Pretty Printer for Text values";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wlc-hs" = callPackage
    ({ mkDerivation, base, c2hs, containers, data-default, lens, pretty
     , process, transformers, wlc, xkbcommon
     }:
     mkDerivation {
       pname = "wlc-hs";
       version = "0.1.0.0";
       sha256 = "696faa722f83aa50329db3573eaa0442a9232e82d0ada7b870dafe66101ca57c";
       libraryHaskellDepends = [
         base containers data-default lens pretty process transformers
         xkbcommon
       ];
       librarySystemDepends = [ wlc ];
       libraryToolDepends = [ c2hs ];
       jailbreak = true;
       description = "Haskell bindings for the wlc library";
       license = stdenv.lib.licenses.isc;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) wlc;};

  "wobsurv" = callPackage
    ({ mkDerivation, aeson, attoparsec, base-prelude, bytestring
     , hastache, HTF, http-client, http-types, HUnit, lifted-async
     , monad-control, mwc-random, network, network-simple, old-locale
     , pipes, pipes-bytestring, pipes-network, pipes-parse, pipes-safe
     , pipes-text, QuickCheck, quickcheck-instances, safe, stm
     , stm-containers, system-fileio, system-filepath, text, time
     , transformers, unordered-containers, yaml
     }:
     mkDerivation {
       pname = "wobsurv";
       version = "0.1.0";
       sha256 = "02d28e70f64614d1e901a699d73e1e87bbdb32475a9af4f91a460147723f52f0";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base-prelude bytestring hastache http-types
         monad-control network network-simple old-locale pipes
         pipes-bytestring pipes-network pipes-parse pipes-safe pipes-text
         stm stm-containers system-fileio system-filepath text time
         transformers unordered-containers
       ];
       executableHaskellDepends = [
         aeson base-prelude bytestring network safe system-fileio
         system-filepath text unordered-containers yaml
       ];
       testHaskellDepends = [
         base-prelude bytestring HTF http-client http-types HUnit
         lifted-async mwc-random network QuickCheck quickcheck-instances
         safe system-fileio system-filepath text transformers
       ];
       jailbreak = true;
       homepage = "https://github.com/nikita-volkov/wobsurv";
       description = "A simple and highly performant HTTP file server";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "woffex" = callPackage
    ({ mkDerivation, base, binary, bytestring, filepath, zlib }:
     mkDerivation {
       pname = "woffex";
       version = "0.1";
       sha256 = "bbf68066fff431fad5a5db99d056d3f95f46f3ebe1d2d90aa1c48d4870d1032d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base binary bytestring filepath zlib
       ];
       jailbreak = true;
       description = "Web Open Font Format (WOFF) unpacker";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wol" = callPackage
    ({ mkDerivation, base, network, split }:
     mkDerivation {
       pname = "wol";
       version = "0.1.2";
       sha256 = "f1942a017fa2353db139cbfb26a2b6916281c8bab209de191e72bd9d75481570";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base network split ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "http://tom.lokhorst.eu/wol";
       description = "Send a Wake on LAN Magic Packet";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wolf" = callPackage
    ({ mkDerivation, aeson, amazonka, amazonka-core, amazonka-s3
     , amazonka-swf, base, basic-prelude, bytestring, conduit
     , conduit-extra, exceptions, fast-logger, formatting, http-conduit
     , http-types, lens, monad-control, monad-logger, mtl, mtl-compat
     , optparse-applicative, resourcet, safe, shelly, system-filepath
     , tasty, tasty-hunit, text, time, transformers, transformers-base
     , unordered-containers, uuid, yaml, zlib
     }:
     mkDerivation {
       pname = "wolf";
       version = "0.2.3";
       sha256 = "53c53f00ccc4ad27efc9164d90722174d28f7bad1850a1659f177d9c4d070fd3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson amazonka amazonka-core amazonka-s3 amazonka-swf base
         basic-prelude bytestring conduit conduit-extra exceptions
         fast-logger formatting http-conduit http-types lens monad-control
         monad-logger mtl mtl-compat optparse-applicative resourcet safe
         text time transformers transformers-base unordered-containers uuid
         yaml
       ];
       executableHaskellDepends = [
         aeson amazonka-core base basic-prelude bytestring
         optparse-applicative resourcet shelly system-filepath text
         transformers yaml zlib
       ];
       testHaskellDepends = [ base basic-prelude tasty tasty-hunit ];
       homepage = "https://github.com/swift-nav/wolf";
       description = "Amazon Simple Workflow Service Wrapper";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "woot" = callPackage
    ({ mkDerivation, base, hspec, vector }:
     mkDerivation {
       pname = "woot";
       version = "0.0.0.5";
       sha256 = "62f135f4c9e3c6c4e9e7efbbd299bd12649cea6be46771d0c1e7ef612cce664d";
       libraryHaskellDepends = [ base vector ];
       testHaskellDepends = [ base hspec ];
       jailbreak = true;
       homepage = "https://github.com/TGOlson/woot-haskell";
       description = "Real time group editor without operational transform";
       license = stdenv.lib.licenses.mit;
     }) {};

  "word-trie" = callPackage
    ({ mkDerivation, base, binary, containers, hspec, QuickCheck }:
     mkDerivation {
       pname = "word-trie";
       version = "0.3.0";
       sha256 = "a3f3c2c088c64219ae35f7383a5dc1a368217183ba603e98785c110ac3f29282";
       revision = "1";
       editedCabalFile = "85582eefb0020e6e35a0e2588e1dd647fb20bb7f70108f29493f994af5b74a05";
       libraryHaskellDepends = [ base binary containers ];
       testHaskellDepends = [ base binary containers hspec QuickCheck ];
       homepage = "https://github.com/yi-editor/word-trie";
       description = "Implementation of a finite trie over words";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "word24" = callPackage
    ({ mkDerivation, base, QuickCheck, test-framework
     , test-framework-quickcheck2
     }:
     mkDerivation {
       pname = "word24";
       version = "1.0.7";
       sha256 = "115ac84f16562a1b95649b70fafc1ff5f6e70576947672838781bb9aa53107e6";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [
         base QuickCheck test-framework test-framework-quickcheck2
       ];
       homepage = "http://www.tiresiaspress.us/haskell/word24";
       description = "24-bit word and int types for GHC";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "word8_0_1_1" = callPackage
    ({ mkDerivation, base, hspec }:
     mkDerivation {
       pname = "word8";
       version = "0.1.1";
       sha256 = "398d201b9bfb839d55bbb72afc8b73e34dcbda2e76f4f13a5db946a61404eaf6";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec ];
       description = "Word8 library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "word8" = callPackage
    ({ mkDerivation, base, hspec }:
     mkDerivation {
       pname = "word8";
       version = "0.1.2";
       sha256 = "3cbae3755a078ecff46524b3f6e0018f7e796e6dac9c710fe09b433c544676dd";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base hspec ];
       description = "Word8 library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wordcloud" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "wordcloud";
       version = "0.1";
       sha256 = "a5b1c3fb58046e74de6ab36e466938432383c10417301ff764bdcc4060d9acc9";
       doHaddock = false;
       description = "None";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wordexp" = callPackage
    ({ mkDerivation, array, base, c2hs, semigroups }:
     mkDerivation {
       pname = "wordexp";
       version = "0.2.0.0";
       sha256 = "718af118344b711314a7ca69ae19ce508bb76185d9776342548740efd7dfd7c1";
       libraryHaskellDepends = [ array base semigroups ];
       libraryToolDepends = [ c2hs ];
       description = "wordexp(3) wrappers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wordpass_1_0_0_2" = callPackage
    ({ mkDerivation, base, containers, deepseq, directory, filepath
     , hflags, random-fu, random-source, text, unix-compat, vector
     }:
     mkDerivation {
       pname = "wordpass";
       version = "1.0.0.2";
       sha256 = "25e027f9fb04a679796010fcea45e82135785e54319bb2d7c6dbcec3464730e4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers deepseq directory filepath random-fu random-source
         text unix-compat vector
       ];
       executableHaskellDepends = [
         base containers deepseq directory filepath hflags random-fu
         random-source text unix-compat vector
       ];
       jailbreak = true;
       homepage = "https://github.com/mgajda/wordpass";
       description = "Dictionary-based password generator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wordpass_1_0_0_3" = callPackage
    ({ mkDerivation, base, containers, deepseq, directory, filepath
     , hflags, random-fu, random-source, text, unix-compat, vector
     }:
     mkDerivation {
       pname = "wordpass";
       version = "1.0.0.3";
       sha256 = "2bf53e37a55ddc88b89620838048a9c182c97d9b1a6b6108626c8e3758fe6fd9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers deepseq directory filepath random-fu random-source
         text unix-compat vector
       ];
       executableHaskellDepends = [
         base containers deepseq directory filepath hflags random-fu
         random-source text unix-compat vector
       ];
       jailbreak = true;
       homepage = "https://github.com/mgajda/wordpass";
       description = "Dictionary-based password generator";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wordpass" = callPackage
    ({ mkDerivation, base, containers, deepseq, directory, filepath
     , hflags, random-fu, random-source, text, unix-compat, vector
     }:
     mkDerivation {
       pname = "wordpass";
       version = "1.0.0.4";
       sha256 = "7b038ea956a0bca632759e10c8bda68de061417b22b157eb42035711d57b9e5e";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers deepseq directory filepath random-fu random-source
         text unix-compat vector
       ];
       executableHaskellDepends = [
         base containers deepseq directory filepath hflags random-fu
         random-source text unix-compat vector
       ];
       homepage = "https://github.com/mgajda/wordpass";
       description = "Dictionary-based password generator";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "words" = callPackage
    ({ mkDerivation, base, directory, text }:
     mkDerivation {
       pname = "words";
       version = "0.1.2";
       sha256 = "2024553a9a31c1f0e87b3f2f0249b6ed384cbe1bdcb0a0a79b0d4f9722565259";
       libraryHaskellDepends = [ base directory text ];
       description = "Cross-platform access to a list of words";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wordsearch" = callPackage
    ({ mkDerivation, array, base, containers, fclabels }:
     mkDerivation {
       pname = "wordsearch";
       version = "1.0.1";
       sha256 = "a2931d01f6197c7c3164001dec4ec0281a9b057f3728ad12a333f6327854014b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ array base containers fclabels ];
       executableHaskellDepends = [ base containers fclabels ];
       description = "A word search solver library and executable";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wordsetdiff" = callPackage
    ({ mkDerivation, ansi-terminal, base, bytestring, containers
     , directory, filepath, hashmap, process
     }:
     mkDerivation {
       pname = "wordsetdiff";
       version = "0.0.3.1";
       sha256 = "1c00a83911d9ec1da4712f2fc35fc1211a1ff87d8c6d7f99d4ad3ba46fd0eb4f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         ansi-terminal base bytestring containers directory filepath hashmap
         process
       ];
       homepage = "http://people.csail.mit.edu/newton/wordsetdiff";
       description = "Compare two files as sets of N-tuples of words";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "workflow-osx" = callPackage
    ({ mkDerivation, base, bv, bytestring, exceptions, filepath, free
     , http-types, mtl, transformers
     }:
     mkDerivation {
       pname = "workflow-osx";
       version = "0.0.1";
       sha256 = "1bb9b7e9df0d99893301f452f35f6f181009617a481d9f25cb14d5bc592bbdd2";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bv bytestring exceptions filepath free http-types mtl
         transformers
       ];
       executableHaskellDepends = [ base ];
       jailbreak = true;
       homepage = "https://github.com/sboosali/workflow-osx#readme";
       description = "a \"Desktop Workflow\" monad with Objective-C bindings";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wp-archivebot" = callPackage
    ({ mkDerivation, base, feed, HTTP, network, parallel, tagsoup }:
     mkDerivation {
       pname = "wp-archivebot";
       version = "0.1";
       sha256 = "bfcc1acc120088b92715e02c1e7194980cc0410334453fc00fc8caf281395811";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base feed HTTP network parallel tagsoup
       ];
       jailbreak = true;
       description = "Subscribe to a wiki's RSS feed and archive external links";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wrap" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "wrap";
       version = "0.0.0";
       sha256 = "f8bbc4b417b2291532784d0c7940c0f1a24d054e6012963f7d727ad13977f50e";
       libraryHaskellDepends = [ base ];
       description = "Wrap a function's return value with another function";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wraparound" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "wraparound";
       version = "0.0.2";
       sha256 = "8e85980e6ce9ae7553d63e4fb4945a1b25ee88d1ba0df855d223f4ea56f93598";
       libraryHaskellDepends = [ base ];
       homepage = "http://frigidcode.com";
       description = "Convenient handling of points on a seamless 2-dimensional plane";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wraxml" = callPackage
    ({ mkDerivation, base, containers, data-accessor
     , explicit-exception, HaXml, hxt, hxt-filter, polyparse, tagchup
     , tagsoup, transformers, utility-ht, xml-basic
     }:
     mkDerivation {
       pname = "wraxml";
       version = "0.4.4";
       sha256 = "2347454654a07e8865c14986db9df95b323ba0170310933d52731b0cb6c214c1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers data-accessor explicit-exception HaXml hxt
         hxt-filter polyparse tagchup tagsoup transformers utility-ht
         xml-basic
       ];
       jailbreak = true;
       homepage = "http://code.haskell.org/~thielema/wraxml/";
       description = "Lazy wrapper to HaXML, HXT, TagSoup via custom XML tree structure";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wreq_0_3_0_1" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, aeson-qq, attoparsec, base
     , base16-bytestring, base64-bytestring, byteable, bytestring
     , case-insensitive, containers, cryptohash, directory, doctest
     , exceptions, filepath, ghc-prim, hashable, http-client
     , http-client-tls, http-types, HUnit, lens, lens-aeson, mime-types
     , network-info, old-locale, PSQueue, QuickCheck, snap-core
     , snap-server, template-haskell, temporary, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , transformers, unix-compat, unordered-containers, uuid
     }:
     mkDerivation {
       pname = "wreq";
       version = "0.3.0.1";
       sha256 = "842a8539e3670732c7f48fe91429d6e940865fcd17374ad2895b74a751c6578d";
       revision = "1";
       editedCabalFile = "b69dc65ef23cfd21ff24b08c2703871b2acff2d23ebb30ed8cb7519f5e42bcf6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring byteable bytestring
         case-insensitive containers cryptohash exceptions ghc-prim hashable
         http-client http-client-tls http-types lens lens-aeson mime-types
         old-locale PSQueue template-haskell text time unordered-containers
       ];
       testHaskellDepends = [
         aeson aeson-pretty aeson-qq base base64-bytestring bytestring
         case-insensitive containers directory doctest filepath hashable
         http-client http-types HUnit lens lens-aeson network-info
         QuickCheck snap-core snap-server temporary test-framework
         test-framework-hunit test-framework-quickcheck2 text transformers
         unix-compat uuid
       ];
       jailbreak = true;
       doCheck = false;
       homepage = "http://www.serpentine.com/wreq";
       description = "An easy-to-use HTTP client library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wreq_0_4_0_0" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, attoparsec, base
     , base16-bytestring, base64-bytestring, byteable, bytestring
     , case-insensitive, containers, cryptohash, directory, doctest
     , exceptions, filepath, ghc-prim, hashable, http-client
     , http-client-tls, http-types, HUnit, lens, lens-aeson, mime-types
     , network-info, old-locale, psqueues, QuickCheck, snap-core
     , snap-server, template-haskell, temporary, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , transformers, unix-compat, unordered-containers, uuid, vector
     }:
     mkDerivation {
       pname = "wreq";
       version = "0.4.0.0";
       sha256 = "4ae67fcd133a9738f7f73b66c8cc5a6bfc0cbc93e041fc1a43362a3d72557297";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base base16-bytestring byteable bytestring
         case-insensitive containers cryptohash exceptions ghc-prim hashable
         http-client http-client-tls http-types lens lens-aeson mime-types
         old-locale psqueues template-haskell text time unordered-containers
       ];
       testHaskellDepends = [
         aeson aeson-pretty base base64-bytestring bytestring
         case-insensitive containers directory doctest filepath hashable
         http-client http-types HUnit lens lens-aeson network-info
         QuickCheck snap-core snap-server temporary test-framework
         test-framework-hunit test-framework-quickcheck2 text time
         transformers unix-compat uuid vector
       ];
       doCheck = false;
       homepage = "http://www.serpentine.com/wreq";
       description = "An easy-to-use HTTP client library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wreq" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, attoparsec
     , authenticate-oauth, base, base16-bytestring, base64-bytestring
     , byteable, bytestring, case-insensitive, containers, cryptohash
     , directory, doctest, exceptions, filepath, ghc-prim, hashable
     , http-client, http-client-tls, http-types, HUnit, lens, lens-aeson
     , mime-types, network-info, psqueues, QuickCheck, snap-core
     , snap-server, template-haskell, temporary, test-framework
     , test-framework-hunit, test-framework-quickcheck2, text, time
     , time-locale-compat, transformers, unix-compat
     , unordered-containers, uuid, vector
     }:
     mkDerivation {
       pname = "wreq";
       version = "0.4.1.0";
       sha256 = "3b8409e2fb7670d7060fdaa780008eeecb08e9b65bdab9d9690d8d26e5cb8e6d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec authenticate-oauth base base16-bytestring byteable
         bytestring case-insensitive containers cryptohash exceptions
         ghc-prim hashable http-client http-client-tls http-types lens
         lens-aeson mime-types psqueues template-haskell text time
         time-locale-compat unordered-containers
       ];
       testHaskellDepends = [
         aeson aeson-pretty base base64-bytestring bytestring
         case-insensitive containers directory doctest filepath hashable
         http-client http-types HUnit lens lens-aeson network-info
         QuickCheck snap-core snap-server temporary test-framework
         test-framework-hunit test-framework-quickcheck2 text time
         transformers unix-compat uuid vector
       ];
       doCheck = false;
       homepage = "http://www.serpentine.com/wreq";
       description = "An easy-to-use HTTP client library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wreq-sb" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, attoparsec
     , authenticate-oauth, base, base16-bytestring, base64-bytestring
     , byteable, bytestring, case-insensitive, containers, cryptohash
     , directory, doctest, exceptions, filepath, ghc-prim, hashable
     , http-client, http-client-tls, http-types, HUnit, lens, lens-aeson
     , mime-types, network-info, old-locale, psqueues, QuickCheck
     , snap-core, snap-server, template-haskell, temporary
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, time, transformers, unix-compat, unordered-containers, uuid
     , vector
     }:
     mkDerivation {
       pname = "wreq-sb";
       version = "0.4.0.0";
       sha256 = "dfc9c0a13696bbe2521a9d440bd9c8a57b8dccef270bdffb011bf320a7971b54";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec authenticate-oauth base base16-bytestring byteable
         bytestring case-insensitive containers cryptohash exceptions
         ghc-prim hashable http-client http-client-tls http-types lens
         lens-aeson mime-types old-locale psqueues template-haskell text
         time unordered-containers
       ];
       testHaskellDepends = [
         aeson aeson-pretty base base64-bytestring bytestring
         case-insensitive containers directory doctest filepath hashable
         http-client http-types HUnit lens lens-aeson network-info
         QuickCheck snap-core snap-server temporary test-framework
         test-framework-hunit test-framework-quickcheck2 text time
         transformers unix-compat uuid vector
       ];
       homepage = "http://www.serpentine.com/wreq";
       description = "An easy-to-use HTTP client library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wright" = callPackage
    ({ mkDerivation, assertions, base, bed-and-breakfast, containers
     , filepath, lens
     }:
     mkDerivation {
       pname = "wright";
       version = "0.1.0.2";
       sha256 = "f193da24c964d1dff94f9a6b21f80828c4581d2170ab6b0d90f952edb70800a0";
       libraryHaskellDepends = [ base bed-and-breakfast containers ];
       testHaskellDepends = [
         assertions base bed-and-breakfast containers filepath lens
       ];
       jailbreak = true;
       description = "Colour space transformations and metrics";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wsdl" = callPackage
    ({ mkDerivation, base, bytestring, conduit, exceptions, file-embed
     , hspec, mtl, network-uri, resourcet, text, xml-conduit, xml-types
     }:
     mkDerivation {
       pname = "wsdl";
       version = "0.1.0.1";
       sha256 = "2e4d565f9d45f420f07b34b6309a15a7f5cac96c657e4afdfa035cf46c135c06";
       libraryHaskellDepends = [
         base bytestring conduit exceptions mtl network-uri resourcet text
         xml-conduit xml-types
       ];
       testHaskellDepends = [
         base bytestring file-embed hspec network-uri
       ];
       description = "WSDL parsing in Haskell";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wsedit" = callPackage
    ({ mkDerivation, base, bencode, bytestring, containers, directory
     , safe, utf8-string
     }:
     mkDerivation {
       pname = "wsedit";
       version = "0.1.0.0";
       sha256 = "310bd1514a5375503e924d21fca8f54f3667f71659473fb298cf5e2158da6580";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bencode bytestring containers directory safe utf8-string
       ];
       jailbreak = true;
       description = "A small tool to list, add and remove webseeds from a torrent file";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "wtk" = callPackage
    ({ mkDerivation, base, old-locale, time, transformers }:
     mkDerivation {
       pname = "wtk";
       version = "0.2.1";
       sha256 = "e960379878738369c628b7b0b0cb1aa1fdca36231d0145773b7b195cf4041e20";
       libraryHaskellDepends = [ base old-locale time transformers ];
       description = "Wojcik Tool Kit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wtk-gtk" = callPackage
    ({ mkDerivation, base, containers, gtk, lenses, mtl, old-locale
     , parsec, time, wtk
     }:
     mkDerivation {
       pname = "wtk-gtk";
       version = "0.2";
       sha256 = "bee0601aa4534a3709da00680b354a481f413219ffca7fccde329c3fd0dd2e59";
       libraryHaskellDepends = [
         base containers gtk lenses mtl old-locale parsec time wtk
       ];
       description = "GTK tools within Wojcik Tool Kit";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wumpus-basic" = callPackage
    ({ mkDerivation, base, containers, directory, filepath
     , vector-space, wumpus-core
     }:
     mkDerivation {
       pname = "wumpus-basic";
       version = "0.24.0";
       sha256 = "cf568cbdd30be89635ea5cf9c515e7ee0ae5d11dc28a51f7374ca6a1e4a650d5";
       libraryHaskellDepends = [
         base containers directory filepath vector-space wumpus-core
       ];
       homepage = "http://code.google.com/p/copperbox/";
       description = "Basic objects and system code built on Wumpus-Core";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wumpus-core" = callPackage
    ({ mkDerivation, base, containers, time, vector-space }:
     mkDerivation {
       pname = "wumpus-core";
       version = "0.52.1";
       sha256 = "a8d92ed717140823acee79c5b6bfc2a6928619ce3c8f82cf1f59ecb47a480983";
       revision = "1";
       editedCabalFile = "309c49da6f6eb268ebcbe9ed3faac18c3e25c884b0b16b7c8e29dfd8a0705fcb";
       libraryHaskellDepends = [ base containers time vector-space ];
       jailbreak = true;
       homepage = "http://code.google.com/p/copperbox/";
       description = "Pure Haskell PostScript and SVG generation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wumpus-drawing" = callPackage
    ({ mkDerivation, base, containers, vector-space, wumpus-basic
     , wumpus-core
     }:
     mkDerivation {
       pname = "wumpus-drawing";
       version = "0.9.0";
       sha256 = "bc2f2acc1fc73f574994a573d7bef29b744be8156be0800c8a5f1834471332f9";
       libraryHaskellDepends = [
         base containers vector-space wumpus-basic wumpus-core
       ];
       homepage = "http://code.google.com/p/copperbox/";
       description = "High-level drawing objects built on Wumpus-Basic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wumpus-microprint" = callPackage
    ({ mkDerivation, base, vector-space, wumpus-basic, wumpus-core
     , wumpus-drawing
     }:
     mkDerivation {
       pname = "wumpus-microprint";
       version = "0.14.0";
       sha256 = "9fa5acb4a96f82893b03ba47a75252bcc4d54107542df8bd4c0a1f6d3f443ce7";
       libraryHaskellDepends = [
         base vector-space wumpus-basic wumpus-core wumpus-drawing
       ];
       jailbreak = true;
       homepage = "http://code.google.com/p/copperbox/";
       description = "Microprints - \"greek-text\" pictures";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wumpus-tree" = callPackage
    ({ mkDerivation, base, containers, vector-space, wumpus-basic
     , wumpus-core, wumpus-drawing
     }:
     mkDerivation {
       pname = "wumpus-tree";
       version = "0.20.0";
       sha256 = "4aa239fbc92bf1acd9296221b622b4053c8a53c9e7cc08bb08ab7b45629ecdf6";
       libraryHaskellDepends = [
         base containers vector-space wumpus-basic wumpus-core
         wumpus-drawing
       ];
       homepage = "http://code.google.com/p/copperbox/";
       description = "Drawing trees";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wuss" = callPackage
    ({ mkDerivation, base, bytestring, connection, doctest, network
     , websockets
     }:
     mkDerivation {
       pname = "wuss";
       version = "1.0.2";
       sha256 = "fae21817931cf16961e64353d8647800689abf0a21b4c8197e2c6cb92fb29444";
       libraryHaskellDepends = [
         base bytestring connection network websockets
       ];
       testHaskellDepends = [ base doctest ];
       homepage = "http://taylor.fausak.me/wuss/";
       description = "Secure WebSocket (WSS) clients";
       license = stdenv.lib.licenses.mit;
     }) {};

  "wx" = callPackage
    ({ mkDerivation, base, stm, time, wxcore }:
     mkDerivation {
       pname = "wx";
       version = "0.92.2.0";
       sha256 = "a1d02b17cd336f0c435381c9f2ce74aad2059c56a00c678954089b74065a97fb";
       libraryHaskellDepends = [ base stm time wxcore ];
       homepage = "https://wiki.haskell.org/WxHaskell";
       description = "wxHaskell";
       license = "unknown";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "wxAsteroids" = callPackage
    ({ mkDerivation, base, directory, random, wx, wxcore }:
     mkDerivation {
       pname = "wxAsteroids";
       version = "1.1.0.1";
       sha256 = "45143005f69843633246948d5070e346324718d7387faf58af8df57828ee319b";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory random wx wxcore ];
       homepage = "https://wiki.haskell.org/WxAsteroids";
       description = "Try to avoid the asteroids with your space ship";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wxFruit" = callPackage
    ({ mkDerivation, base, old-time, wx, wxcore, Yampa }:
     mkDerivation {
       pname = "wxFruit";
       version = "0.1.2.1";
       sha256 = "e99e16e48efc76e65981f1a9a94cb99a6621fbec3f3ac9c22f46f16c3f5ac026";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base old-time wx wxcore Yampa ];
       executableHaskellDepends = [ base wx wxcore Yampa ];
       jailbreak = true;
       homepage = "http://www.haskell.org/haskellwiki/WxFruit";
       description = "An implementation of Fruit using wxHaskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wxc" = callPackage
    ({ mkDerivation, base, libX11, mesa, split, wxdirect, wxGTK }:
     mkDerivation {
       pname = "wxc";
       version = "0.92.2.0";
       sha256 = "e0da20807bafb22d51a0922211da11eb428b2a6661cb53bc98f6e17be9775191";
       libraryHaskellDepends = [ base split wxdirect ];
       librarySystemDepends = [ libX11 mesa ];
       libraryPkgconfigDepends = [ wxGTK ];
       doHaddock = false;
       postInstall = "cp -v dist/build/libwxc.so.0.92.2.0 $out/lib/libwxc.so";
       postPatch = "sed -i -e '/ldconfig inst_lib_dir/d' Setup.hs";
       homepage = "https://wiki.haskell.org/WxHaskell";
       description = "wxHaskell C++ wrapper";
       license = "unknown";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs.xorg) libX11; inherit (pkgs) mesa; 
         inherit (pkgs) wxGTK;};

  "wxcore" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, directory
     , filepath, parsec, stm, time, wxc, wxdirect, wxGTK
     }:
     mkDerivation {
       pname = "wxcore";
       version = "0.92.2.0";
       sha256 = "76128916c5d5df9cea9fc1e1b3b56d800d87874a431e98fca4427cb41cfe283e";
       libraryHaskellDepends = [
         array base bytestring containers directory filepath parsec stm time
         wxc wxdirect
       ];
       libraryPkgconfigDepends = [ wxGTK ];
       homepage = "https://wiki.haskell.org/WxHaskell";
       description = "wxHaskell core";
       license = "unknown";
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) wxGTK;};

  "wxdirect" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, parsec
     , process, strict, time
     }:
     mkDerivation {
       pname = "wxdirect";
       version = "0.92.2.0";
       sha256 = "2303834061c544f7e32ffd7aaf91e644ee89e178487689f109f06625f0eefd3b";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath parsec process strict time
       ];
       homepage = "https://wiki.haskell.org/WxHaskell";
       description = "helper tool for building wxHaskell";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "wxhnotepad" = callPackage
    ({ mkDerivation, base, wx, wxcore }:
     mkDerivation {
       pname = "wxhnotepad";
       version = "1.2.0";
       sha256 = "d77f955dcc41653daf2acd9d943e2dc68a14c8f2299f01848789cd7a963f0981";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base wx wxcore ];
       jailbreak = true;
       homepage = "http://github.com/elbrujohalcon/wxhnotepad";
       description = "An example of how to implement a basic notepad with wxHaskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wxturtle" = callPackage
    ({ mkDerivation, base, convertible, Imlib, wx, yjsvg, yjtools }:
     mkDerivation {
       pname = "wxturtle";
       version = "0.0.1";
       sha256 = "c74ea55899a2b0efb73fe63493007fb9b06107c3fbbd392c505128e95a8aab69";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base convertible Imlib wx yjsvg yjtools
       ];
       description = "turtle like LOGO with wxHaskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "wybor" = callPackage
    ({ mkDerivation, ansi-terminal, base, conduit, containers, hspec
     , lens, process, resourcet, semigroups, terminal-size, text
     , transformers, unix
     }:
     mkDerivation {
       pname = "wybor";
       version = "0.1.0";
       sha256 = "c63dbb0bcc019c35f1ce7abfad5486a257137c097e30b77048a89cb3ae84ce33";
       libraryHaskellDepends = [
         ansi-terminal base conduit containers lens resourcet semigroups
         terminal-size text transformers unix
       ];
       testHaskellDepends = [
         ansi-terminal base conduit containers hspec lens process resourcet
         semigroups terminal-size text transformers unix
       ];
       homepage = "https://github.com/supki/wybor";
       description = "Console line fuzzy search";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "wyvern" = callPackage
    ({ mkDerivation, base, bytestring, ConfigFile, containers, dgs
     , directory, filepath, mtl, parsec, process, sgf, split
     }:
     mkDerivation {
       pname = "wyvern";
       version = "0.1";
       sha256 = "d842d0c9b3d62817d666a56fa607ec0f704c2262824b9dcc5976ab1c5829fb90";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring ConfigFile containers dgs directory filepath mtl
         parsec process sgf split
       ];
       jailbreak = true;
       homepage = "http://dmwit.com/wyvern";
       description = "An autoresponder for Dragon Go Server";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "x-dsp" = callPackage
    ({ mkDerivation, array, base, bytestring, containers, monads-tf
     , text, transformers, type-level
     }:
     mkDerivation {
       pname = "x-dsp";
       version = "0.2.3.1";
       sha256 = "129207d635affd3f1d83d8d2279f0636c99b1613df8f853071fabc4a93ff838a";
       libraryHaskellDepends = [
         array base bytestring containers monads-tf text transformers
         type-level
       ];
       jailbreak = true;
       homepage = "http://jwlato.webfactional.com/haskell/x-dsp";
       description = "A embedded DSL for manipulating DSP languages in Haskell";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "x11-xim" = callPackage
    ({ mkDerivation, base, utf8-string, X11 }:
     mkDerivation {
       pname = "x11-xim";
       version = "0.0.9.0";
       sha256 = "3ccb05847f7eacd607db095e4f655984607f46313d6b70130d09fd096442c76a";
       revision = "1";
       editedCabalFile = "4404aa037f4df2ef8cd16834c8149d596f09b30379f0b85a3b8db9ddd30fa6b0";
       libraryHaskellDepends = [ base utf8-string X11 ];
       homepage = "https://github.com/YoshikuniJujo/x11-xim_haskell/wiki/";
       description = "A binding to the xim of X11 graphics library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "x11-xinput" = callPackage
    ({ mkDerivation, base, c2hs, containers, libXi, mtl, X11 }:
     mkDerivation {
       pname = "x11-xinput";
       version = "0.1.0.0";
       sha256 = "3b095ec124840ada7e1458f27525515de5fc2c026a9810d4fc0f7b299d373296";
       libraryHaskellDepends = [ base containers mtl X11 ];
       librarySystemDepends = [ libXi ];
       libraryToolDepends = [ c2hs ];
       homepage = "http://redmine.iportnov.ru/projects/x11-xinput";
       description = "Haskell FFI bindings for X11 XInput library (-lXi)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs.xorg) libXi;};

  "x509_1_5_0_1" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-parse, asn1-types, base
     , bytestring, containers, crypto-pubkey-types, cryptohash
     , directory, filepath, hourglass, mtl, pem, process, tasty
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "x509";
       version = "1.5.0.1";
       sha256 = "6a0d7adf3dd6cb5b29b2cecbc82d84cdb71e4042315761e10b1403075220f20d";
       revision = "1";
       editedCabalFile = "261a16dba40aebf24b31b014abd300f3d86cb9298ff86c998ae1ec7e7783157d";
       libraryHaskellDepends = [
         asn1-encoding asn1-parse asn1-types base bytestring containers
         crypto-pubkey-types cryptohash directory filepath hourglass mtl pem
         process
       ];
       testHaskellDepends = [
         asn1-types base bytestring crypto-pubkey-types hourglass mtl tasty
         tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "X509 reader and writer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "x509_1_5_1" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-parse, asn1-types, base
     , bytestring, containers, crypto-pubkey-types, cryptohash
     , directory, filepath, hourglass, mtl, pem, process, tasty
     , tasty-quickcheck
     }:
     mkDerivation {
       pname = "x509";
       version = "1.5.1";
       sha256 = "566c23f526c20be1386c492a3923eec31f251b725e816e6cebf8074ae31aafd7";
       revision = "1";
       editedCabalFile = "f4a09a968921e5ff0f6a87b66c97e21f3455d7bc73a5f8675f306785adf595a1";
       libraryHaskellDepends = [
         asn1-encoding asn1-parse asn1-types base bytestring containers
         crypto-pubkey-types cryptohash directory filepath hourglass mtl pem
         process
       ];
       testHaskellDepends = [
         asn1-types base bytestring crypto-pubkey-types hourglass mtl tasty
         tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "X509 reader and writer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "x509_1_6_0" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-parse, asn1-types, base
     , bytestring, containers, cryptonite, directory, filepath
     , hourglass, memory, mtl, pem, process, tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "x509";
       version = "1.6.0";
       sha256 = "939eec164a1dd764d610920d8896c7715c86f9b437c2d44b27119b3fb197c23b";
       revision = "1";
       editedCabalFile = "b849e31b4baa4186008a5dc5544b5acad634f9aee8d3ccbdcae6a217b061a676";
       libraryHaskellDepends = [
         asn1-encoding asn1-parse asn1-types base bytestring containers
         cryptonite directory filepath hourglass memory mtl pem process
       ];
       testHaskellDepends = [
         asn1-types base bytestring cryptonite hourglass mtl tasty
         tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "X509 reader and writer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "x509_1_6_1" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-parse, asn1-types, base
     , bytestring, containers, cryptonite, hourglass, memory, mtl, pem
     , tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "x509";
       version = "1.6.1";
       sha256 = "cc95fc10135998a5a4bf59566a4e0c7ed6c40f0ff175dfb3023b8ec941df2450";
       revision = "1";
       editedCabalFile = "44f30cc360b249fab75aa4f7b6dc940fae9a85571890ad7dc3fea2fa3eb0e1e7";
       libraryHaskellDepends = [
         asn1-encoding asn1-parse asn1-types base bytestring containers
         cryptonite hourglass memory mtl pem
       ];
       testHaskellDepends = [
         asn1-types base bytestring cryptonite hourglass mtl tasty
         tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "X509 reader and writer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "x509" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-parse, asn1-types, base
     , bytestring, containers, cryptonite, hourglass, memory, mtl, pem
     , tasty, tasty-quickcheck
     }:
     mkDerivation {
       pname = "x509";
       version = "1.6.3";
       sha256 = "36c62877046e7ecd6c913da4c21264e18eb56f7cba7abb5d41c42e95845fbade";
       libraryHaskellDepends = [
         asn1-encoding asn1-parse asn1-types base bytestring containers
         cryptonite hourglass memory mtl pem
       ];
       testHaskellDepends = [
         asn1-types base bytestring cryptonite hourglass mtl tasty
         tasty-quickcheck
       ];
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "X509 reader and writer";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "x509-store_1_5_0" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring
     , containers, crypto-pubkey-types, directory, filepath, mtl, pem
     , process, x509
     }:
     mkDerivation {
       pname = "x509-store";
       version = "1.5.0";
       sha256 = "c5dbc4ec7fd9eb302843753c2ae081481446d40898b7bcbfdc8ae803c0c23af1";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base bytestring containers
         crypto-pubkey-types directory filepath mtl pem process x509
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "X.509 collection accessing and storing methods";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "x509-store_1_6_0" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring
     , containers, cryptonite, directory, filepath, mtl, pem, process
     , x509
     }:
     mkDerivation {
       pname = "x509-store";
       version = "1.6.0";
       sha256 = "d5b347a80d66b0424b92d5a340108d6c674246ddbdd21c223b586be19f582e22";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base bytestring containers cryptonite
         directory filepath mtl pem process x509
       ];
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "X.509 collection accessing and storing methods";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "x509-store" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring
     , containers, cryptonite, mtl, pem, x509
     }:
     mkDerivation {
       pname = "x509-store";
       version = "1.6.1";
       sha256 = "83d69d2f5ce39fceaeca8e4dcc6d9ebe8a8e94f55d9c23b06cc7a58844e94b05";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base bytestring containers cryptonite mtl
         pem x509
       ];
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "X.509 collection accessing and storing methods";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "x509-system_1_5_0" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, pem, process, x509, x509-store
     }:
     mkDerivation {
       pname = "x509-system";
       version = "1.5.0";
       sha256 = "235725e9b9a2f16b33f85bcdd320223e0ed720009d5c40739082605bc6e33f95";
       libraryHaskellDepends = [
         base bytestring containers directory filepath mtl pem process x509
         x509-store
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "Handle per-operating-system X.509 accessors and storage";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "x509-system_1_6_0" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, pem, process, x509, x509-store
     }:
     mkDerivation {
       pname = "x509-system";
       version = "1.6.0";
       sha256 = "50f9c24513aba2677d71a1c09cbd4f4d6cb82b5e0bad1ecfdfb407f6f5be1735";
       libraryHaskellDepends = [
         base bytestring containers directory filepath mtl pem process x509
         x509-store
       ];
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "Handle per-operating-system X.509 accessors and storage";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "x509-system_1_6_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, pem, process, x509, x509-store
     }:
     mkDerivation {
       pname = "x509-system";
       version = "1.6.1";
       sha256 = "ee19385663611f9378a7cdf666aa31af1b142f6762699897e55826271a300e83";
       libraryHaskellDepends = [
         base bytestring containers directory filepath mtl pem process x509
         x509-store
       ];
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "Handle per-operating-system X.509 accessors and storage";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "x509-system" = callPackage
    ({ mkDerivation, base, bytestring, containers, directory, filepath
     , mtl, pem, process, x509, x509-store
     }:
     mkDerivation {
       pname = "x509-system";
       version = "1.6.3";
       sha256 = "24237c3df1bf692fcf7bade432970ee2eb06db7437fa0e95986ef7535a68f6e0";
       libraryHaskellDepends = [
         base bytestring containers directory filepath mtl pem process x509
         x509-store
       ];
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "Handle per-operating-system X.509 accessors and storage";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "x509-util" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, bytestring
     , cryptonite, directory, hourglass, pem, x509, x509-store
     , x509-system, x509-validation
     }:
     mkDerivation {
       pname = "x509-util";
       version = "1.6.1";
       sha256 = "d534388d8c633b7dfb0f06a7b498f91f4dfd225b4cd1dd535f45b6e085c9078d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         asn1-encoding asn1-types base bytestring cryptonite directory
         hourglass pem x509 x509-store x509-system x509-validation
       ];
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "Utility for X509 certificate and chain";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "x509-validation_1_5_1" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, byteable
     , bytestring, containers, crypto-pubkey, crypto-pubkey-types
     , cryptohash, data-default-class, directory, filepath, hourglass
     , mtl, network, pem, process, x509, x509-store
     }:
     mkDerivation {
       pname = "x509-validation";
       version = "1.5.1";
       sha256 = "ddd80a46ee18e3f687e33081d5c096d776dc9b167be993e7a70da6160f0a97a5";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base byteable bytestring containers
         crypto-pubkey crypto-pubkey-types cryptohash data-default-class
         directory filepath hourglass mtl network pem process x509
         x509-store
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "X.509 Certificate and CRL validation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "x509-validation_1_5_2" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, byteable
     , bytestring, containers, crypto-pubkey, crypto-pubkey-types
     , cryptohash, data-default-class, directory, filepath, hourglass
     , mtl, network, pem, process, x509, x509-store
     }:
     mkDerivation {
       pname = "x509-validation";
       version = "1.5.2";
       sha256 = "5ea194907cfa9b4037fb0cf0a6c3787009ae61b34f77d837422bce7240ea27f1";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base byteable bytestring containers
         crypto-pubkey crypto-pubkey-types cryptohash data-default-class
         directory filepath hourglass mtl network pem process x509
         x509-store
       ];
       jailbreak = true;
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "X.509 Certificate and CRL validation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "x509-validation_1_6_0" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, byteable
     , bytestring, containers, cryptonite, data-default-class, directory
     , filepath, hourglass, memory, mtl, network, pem, process, x509
     , x509-store
     }:
     mkDerivation {
       pname = "x509-validation";
       version = "1.6.0";
       sha256 = "cc07c92402e685fafc31f1fc9d825d6e2775a7f5a423fb0b9b3453ede8349f1e";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base byteable bytestring containers
         cryptonite data-default-class directory filepath hourglass memory
         mtl network pem process x509 x509-store
       ];
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "X.509 Certificate and CRL validation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "x509-validation_1_6_2" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, byteable
     , bytestring, containers, cryptonite, data-default-class, hourglass
     , memory, mtl, pem, x509, x509-store
     }:
     mkDerivation {
       pname = "x509-validation";
       version = "1.6.2";
       sha256 = "6e0b7637036e8f9607112386c7cd7c88babc8cc3e0ff87217e0956fa8fe1bd48";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base byteable bytestring containers
         cryptonite data-default-class hourglass memory mtl pem x509
         x509-store
       ];
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "X.509 Certificate and CRL validation";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "x509-validation" = callPackage
    ({ mkDerivation, asn1-encoding, asn1-types, base, byteable
     , bytestring, containers, cryptonite, data-default-class, hourglass
     , memory, mtl, pem, x509, x509-store
     }:
     mkDerivation {
       pname = "x509-validation";
       version = "1.6.3";
       sha256 = "80b7d3beef9dda913c7cc7c890ab703d6030574df2a62df1939036184cd921e3";
       libraryHaskellDepends = [
         asn1-encoding asn1-types base byteable bytestring containers
         cryptonite data-default-class hourglass memory mtl pem x509
         x509-store
       ];
       homepage = "http://github.com/vincenthz/hs-certificate";
       description = "X.509 Certificate and CRL validation";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xattr" = callPackage
    ({ mkDerivation, attr, base, bytestring, containers, directory
     , filepath, HUnit, test-framework, test-framework-hunit, unix
     }:
     mkDerivation {
       pname = "xattr";
       version = "0.6.2";
       sha256 = "380db69f9b4e56f3173f421f98ae23a1ffb65749f9fdb0bbdb7d6e0c6cef6b0b";
       libraryHaskellDepends = [ base bytestring unix ];
       librarySystemDepends = [ attr ];
       testHaskellDepends = [
         base bytestring containers directory filepath HUnit test-framework
         test-framework-hunit unix
       ];
       description = "Haskell extended file attributes interface";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) attr;};

  "xbattbar" = callPackage
    ({ mkDerivation, base, old-time, select, X11 }:
     mkDerivation {
       pname = "xbattbar";
       version = "0.2";
       sha256 = "c05246b1becb48d71c30856974ba0ec0efce08e5f75122e51180855ef89883c1";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base old-time select X11 ];
       homepage = "https://github.com/polachok/xbattbar";
       description = "Simple battery indicator";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "xcb-types" = callPackage
    ({ mkDerivation, base, containers, mtl, pretty, xml }:
     mkDerivation {
       pname = "xcb-types";
       version = "0.7.1";
       sha256 = "5927e720e4dee26b1bf8a24fb07e47e6a22f9d78fc87aab8d752f207c1566782";
       libraryHaskellDepends = [ base containers mtl pretty xml ];
       homepage = "http://community.haskell.org/~aslatter/code/xcb-types";
       description = "Parses XML files used by the XCB project";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xcffib" = callPackage
    ({ mkDerivation, attoparsec, base, bytestring, containers
     , directory, filemanip, filepath, HUnit, language-python, mtl
     , optparse-applicative, split, test-framework, test-framework-hunit
     , xcb-types
     }:
     mkDerivation {
       pname = "xcffib";
       version = "0.4.1";
       sha256 = "c5449a61a2415f0be39ca4b1be2b186e2eb0f1563391d819b555a348f35f5248";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         attoparsec base bytestring containers filemanip filepath
         language-python mtl split xcb-types
       ];
       executableHaskellDepends = [
         attoparsec base bytestring containers directory filemanip filepath
         language-python mtl optparse-applicative split xcb-types
       ];
       testHaskellDepends = [
         base filepath HUnit language-python test-framework
         test-framework-hunit xcb-types
       ];
       homepage = "http://github.com/tych0/xcffib";
       description = "A cffi-based python binding for X";
       license = "unknown";
     }) {};

  "xchat-plugin" = callPackage
    ({ mkDerivation, base, directory, filepath, process, unix }:
     mkDerivation {
       pname = "xchat-plugin";
       version = "0.0.3";
       sha256 = "467643d5d6688c0408b39d700860f41954609b5f98c3a14f25a05847a2915766";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory filepath process unix ];
       executableHaskellDepends = [
         base directory filepath process unix
       ];
       description = "XChat";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xcp" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, network
     , transformers
     }:
     mkDerivation {
       pname = "xcp";
       version = "0.1.0.1";
       sha256 = "fad7bae8995dfe539508ce21c85e300df8970805f00706b2c2d9c66ff256a9c3";
       libraryHaskellDepends = [
         base bytestring containers mtl network transformers
       ];
       description = "Partial implementation of the XCP protocol with ethernet as transport layer";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "xdg-basedir" = callPackage
    ({ mkDerivation, base, directory, filepath }:
     mkDerivation {
       pname = "xdg-basedir";
       version = "0.2.2";
       sha256 = "e461c3a5c6007c55ceaea03be3be0ef3a92aa0ea1aea936da0c43671bbfaf42b";
       libraryHaskellDepends = [ base directory filepath ];
       homepage = "http://github.com/willdonnelly/xdg-basedir";
       description = "A basic implementation of the XDG Base Directory specification";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xdg-userdirs" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, xdg-basedir
     }:
     mkDerivation {
       pname = "xdg-userdirs";
       version = "0.1.0.2";
       sha256 = "88aabbcb80dee5b669ad533af20000d561e6fe59ab1014ccc2482055d0a8046e";
       libraryHaskellDepends = [
         base containers directory filepath xdg-basedir
       ];
       homepage = "http://redmine.iportnov.ru/projects/xdg-userdirs";
       description = "Basic implementation of XDG user directories specification";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xdot" = callPackage
    ({ mkDerivation, base, cairo, graphviz, gtk3, mtl, polyparse, text
     , transformers
     }:
     mkDerivation {
       pname = "xdot";
       version = "0.3";
       sha256 = "27f87b5a772d9a86ffc1866fc7f1b76a2ae14fdfaf791a5fcbedd32c5b15e104";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base cairo graphviz gtk3 mtl polyparse text
       ];
       executableHaskellDepends = [
         base cairo graphviz gtk3 text transformers
       ];
       description = "Parse Graphviz xdot files and interactively view them using GTK and Cairo";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xenstore" = callPackage
    ({ mkDerivation, base, bytestring, cereal, mtl, network }:
     mkDerivation {
       pname = "xenstore";
       version = "0.1.1";
       sha256 = "c2b538c9ce6716f4a1b4c0cb63ed5c6e5ee3e69e80dbb7826ee7f5392f45e874";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring cereal mtl network ];
       description = "Xenstore client access";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xfconf" = callPackage
    ({ mkDerivation, base, glib, gtk2hs-buildtools, libxfconf-0 }:
     mkDerivation {
       pname = "xfconf";
       version = "4.8.0.0";
       sha256 = "9febbf8349f27fa184c56959a01db2f78176bd534f103f6b1be0bb01b7fac360";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base glib ];
       libraryPkgconfigDepends = [ libxfconf-0 ];
       libraryToolDepends = [ gtk2hs-buildtools ];
       executablePkgconfigDepends = [ libxfconf-0 ];
       executableToolDepends = [ gtk2hs-buildtools ];
       homepage = "http://patch-tag.com/r/obbele/xfconf/home";
       description = "FFI bindings to xfconf";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {libxfconf-0 = null;};

  "xformat" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "xformat";
       version = "0.1.2.1";
       sha256 = "fdfc9b582ac87175b99bad44200fd6a24fe78f19df8496cb5ef76ee738a85ce0";
       libraryHaskellDepends = [ base ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/spl/xformat";
       description = "Extensible, type-safe formatting with scanf- and printf-like functions";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xhaskell-library" = callPackage
    ({ mkDerivation, base, bytestring, containers, ghc-prim, mtl
     , parsec, regex-base
     }:
     mkDerivation {
       pname = "xhaskell-library";
       version = "0.0.6";
       sha256 = "ca0b4af665d2c244111f30b90b6cdfb7285dce237092792af0fc4753b8a2d68e";
       libraryHaskellDepends = [
         base bytestring containers ghc-prim mtl parsec regex-base
       ];
       jailbreak = true;
       homepage = "http://code.google.com/p/xhaskell-library/";
       description = "Replaces/Enhances Text.Regex";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xhb" = callPackage
    ({ mkDerivation, base, binary, byteorder, bytestring, containers
     , network, parsec, stm, Xauth
     }:
     mkDerivation {
       pname = "xhb";
       version = "0.6.2015.8.1";
       sha256 = "6b8a2cf071e408eef4a8947d768e8224989d3b9b744f5bdb3446bbb04d7a06e7";
       libraryHaskellDepends = [
         base binary byteorder bytestring containers network parsec stm
         Xauth
       ];
       homepage = "https://github.com/aslatter/xhb";
       description = "X Haskell Bindings";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xhb-atom-cache" = callPackage
    ({ mkDerivation, base, hashable, mtl, transformers
     , unordered-containers, xhb
     }:
     mkDerivation {
       pname = "xhb-atom-cache";
       version = "0.1.0.2";
       sha256 = "e9f56068b5c63830de6342eebba212892e32eebaf670f2d904ec96588e737e84";
       libraryHaskellDepends = [
         base hashable mtl transformers unordered-containers xhb
       ];
       jailbreak = true;
       homepage = "http://github.com/jotrk/xhb-atom-cache/";
       description = "Atom cache for XHB";
       license = stdenv.lib.licenses.bsd2;
     }) {};

  "xhb-ewmh" = callPackage
    ({ mkDerivation, base, binary, bytestring, dlist, hashable, mtl
     , transformers, xhb, xhb-atom-cache
     }:
     mkDerivation {
       pname = "xhb-ewmh";
       version = "0.1.3.1";
       sha256 = "94184fad85f3d749128dea63af998217c0942193bd0544c0dc1a959214bf0e0b";
       libraryHaskellDepends = [
         base binary bytestring dlist hashable mtl transformers xhb
         xhb-atom-cache
       ];
       jailbreak = true;
       homepage = "http://github.com/jotrk/xhb-ewmh/";
       description = "EWMH utilities for XHB";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xhtml_3000_2_1" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "xhtml";
       version = "3000.2.1";
       sha256 = "33020782170c1c083bc59fc3bfcb72cec2db223e02d1181c07ae23b9fa7fdcd8";
       libraryHaskellDepends = [ base ];
       homepage = "https://github.com/haskell/xhtml";
       description = "An XHTML combinator library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xhtml-combinators" = callPackage
    ({ mkDerivation, base, containers, random, text, transformers, xml
     }:
     mkDerivation {
       pname = "xhtml-combinators";
       version = "0.3";
       sha256 = "130a5fedcc548cc98e15275397afe4519f7b2a0c1cde237131c9d349066d7519";
       libraryHaskellDepends = [
         base containers random text transformers xml
       ];
       homepage = "http://www.dcs.shef.ac.uk/~aca08aa/xhtmlc.html";
       description = "Fast and easy to use XHTML combinators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xilinx-lava" = callPackage
    ({ mkDerivation, array, base, directory, mtl, old-time, process }:
     mkDerivation {
       pname = "xilinx-lava";
       version = "5.0.1.9";
       sha256 = "6768564e61562ec9b68186d6a544def902f213a1a71a334674ebb1351021e48d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base directory mtl old-time process
       ];
       executableHaskellDepends = [ base directory process ];
       description = "The Lava system for Xilinx FPGA design with layout combinators";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xine" = callPackage
    ({ mkDerivation, base, c2hs, containers, libxine, xine }:
     mkDerivation {
       pname = "xine";
       version = "0.0.0.4";
       sha256 = "66749399cebd326b7bdabb7dccda3bb6e477d6e644e819cdcb8b38b90d2271d7";
       libraryHaskellDepends = [ base containers ];
       librarySystemDepends = [ xine ];
       libraryPkgconfigDepends = [ libxine ];
       libraryToolDepends = [ c2hs ];
       homepage = "http://github.com/joachifm/hxine";
       description = "Bindings to xine-lib";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {libxine = null; xine = null;};

  "xing-api" = callPackage
    ({ mkDerivation, aeson, authenticate-oauth, base, bytestring
     , containers, HTF, http-conduit, http-types, lifted-base
     , monad-control, resourcet, text, time, transformers
     }:
     mkDerivation {
       pname = "xing-api";
       version = "0.1.3";
       sha256 = "b3e21b098ef46e9d496efa4257172fa5a872149e708f694cd0ea60ef192d23fc";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson authenticate-oauth base bytestring containers http-conduit
         http-types lifted-base monad-control resourcet text time
         transformers
       ];
       testHaskellDepends = [
         aeson base bytestring containers HTF text time
       ];
       jailbreak = true;
       homepage = "http://github.com/JanAhrens/xing-api-haskell";
       description = "Wrapper for the XING API, v1";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xinput-conduit" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra
     , transformers
     }:
     mkDerivation {
       pname = "xinput-conduit";
       version = "0.0.0";
       sha256 = "c4ce1f945ae6329758ed719acc1b2f5368949f3fb7014446d8791a86a752ec16";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra transformers
       ];
       description = "Conduit of keys pressed by xinput";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xkbcommon" = callPackage
    ({ mkDerivation, base, bytestring, cpphs, data-flags, filepath
     , libxkbcommon, process, storable-record, template-haskell, text
     , transformers, unix
     }:
     mkDerivation {
       pname = "xkbcommon";
       version = "0.0.2";
       sha256 = "98e0a2e42bc6a08a56416882a89165adfdf12a762fd93ece076edf37b814dfd8";
       libraryHaskellDepends = [
         base bytestring cpphs data-flags filepath process storable-record
         template-haskell text transformers
       ];
       librarySystemDepends = [ libxkbcommon ];
       testHaskellDepends = [ base unix ];
       description = "Haskell bindings for libxkbcommon";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libxkbcommon;};

  "xkcd" = callPackage
    ({ mkDerivation, base, bytestring, directory, filepath, HTTP
     , network, tagsoup
     }:
     mkDerivation {
       pname = "xkcd";
       version = "0.1.1";
       sha256 = "49a8a7d2ef2c174abbcf159e7563d0942102d349777428bbbda2d43ef3e9fc97";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring directory filepath HTTP network tagsoup
       ];
       homepage = "http://github.com/sellweek/xkcd";
       description = "Downloads the most recent xkcd comic";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xlsior" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-markup, bytestring
     , conduit, conduit-extra, data-default, exceptions, mtl, resourcet
     , scientific, text, time, time-locale-compat, vector, xml-conduit
     , xml-types, zip-archive
     }:
     mkDerivation {
       pname = "xlsior";
       version = "0.1.0.1";
       sha256 = "f34d6bf6c5d35f9be46c9a1ea974befdb4f193a966c35052603b6bc1661b6b36";
       libraryHaskellDepends = [
         attoparsec base blaze-markup bytestring conduit conduit-extra
         data-default exceptions mtl resourcet scientific text time
         time-locale-compat vector xml-conduit xml-types zip-archive
       ];
       testHaskellDepends = [
         base blaze-markup bytestring text time time-locale-compat
         zip-archive
       ];
       doCheck = false;
       description = "Streaming Excel file generation and parsing";
       license = stdenv.lib.licenses.mit;
     }) {};

  "xlsx_0_1_0_5" = callPackage
    ({ mkDerivation, base, binary-search, bytestring, conduit
     , containers, data-default, digest, HUnit, lens, old-locale
     , old-time, smallcheck, tasty, tasty-hunit, tasty-smallcheck, text
     , time, transformers, utf8-string, vector, xml-conduit, xml-types
     , zip-archive, zlib
     }:
     mkDerivation {
       pname = "xlsx";
       version = "0.1.0.5";
       sha256 = "5fff47fe6b60a9c387f45fb80b7aa921bff08979e6ee3a1a7b6993351bb8a37d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary-search bytestring conduit containers data-default
         digest lens old-locale old-time text time transformers utf8-string
         vector xml-conduit xml-types zip-archive zlib
       ];
       executableHaskellDepends = [
         base binary-search bytestring conduit containers data-default
         digest lens old-locale old-time text time transformers utf8-string
         vector xml-conduit xml-types zip-archive zlib
       ];
       testHaskellDepends = [
         base containers HUnit old-time smallcheck tasty tasty-hunit
         tasty-smallcheck time
       ];
       homepage = "https://github.com/qrilka/xlsx";
       description = "Simple and incomplete Excel file parser/writer";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xlsx_0_1_1" = callPackage
    ({ mkDerivation, base, binary-search, bytestring, conduit
     , containers, data-default, digest, HUnit, lens, old-locale
     , old-time, smallcheck, tasty, tasty-hunit, tasty-smallcheck, text
     , time, transformers, utf8-string, vector, xml-conduit, xml-types
     , zip-archive, zlib
     }:
     mkDerivation {
       pname = "xlsx";
       version = "0.1.1";
       sha256 = "b952a5772ded4007d3ab58942efc8a3e927172829a5fb1fa048cfadf2fe94e92";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary-search bytestring conduit containers data-default
         digest lens old-locale old-time text time transformers utf8-string
         vector xml-conduit xml-types zip-archive zlib
       ];
       executableHaskellDepends = [
         base binary-search bytestring conduit containers data-default
         digest lens old-locale old-time text time transformers utf8-string
         vector xml-conduit xml-types zip-archive zlib
       ];
       testHaskellDepends = [
         base containers HUnit old-time smallcheck tasty tasty-hunit
         tasty-smallcheck time xml-conduit
       ];
       homepage = "https://github.com/qrilka/xlsx";
       description = "Simple and incomplete Excel file parser/writer";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xlsx_0_1_1_1" = callPackage
    ({ mkDerivation, base, binary-search, bytestring, conduit
     , containers, data-default, digest, HUnit, lens, old-locale
     , old-time, smallcheck, tasty, tasty-hunit, tasty-smallcheck, text
     , time, transformers, utf8-string, vector, xml-conduit, xml-types
     , zip-archive, zlib
     }:
     mkDerivation {
       pname = "xlsx";
       version = "0.1.1.1";
       sha256 = "16a03bca7ac10760633a839e8bf249e249da7d1275810e5caac876e03c69c2b9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary-search bytestring conduit containers data-default
         digest lens old-locale old-time text time transformers utf8-string
         vector xml-conduit xml-types zip-archive zlib
       ];
       executableHaskellDepends = [
         base binary-search bytestring conduit containers data-default
         digest lens old-locale old-time text time transformers utf8-string
         vector xml-conduit xml-types zip-archive zlib
       ];
       testHaskellDepends = [
         base containers HUnit old-time smallcheck tasty tasty-hunit
         tasty-smallcheck time xml-conduit
       ];
       homepage = "https://github.com/qrilka/xlsx";
       description = "Simple and incomplete Excel file parser/writer";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xlsx_0_1_2" = callPackage
    ({ mkDerivation, base, binary-search, bytestring, conduit
     , containers, data-default, digest, HUnit, lens, old-locale
     , old-time, smallcheck, tasty, tasty-hunit, tasty-smallcheck, text
     , time, transformers, utf8-string, vector, xml-conduit, xml-types
     , zip-archive, zlib
     }:
     mkDerivation {
       pname = "xlsx";
       version = "0.1.2";
       sha256 = "f9d409370e625a17baee9e4d55f2d8c55921c457e60a18f22a1fbc4defc7e8d1";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary-search bytestring conduit containers data-default
         digest lens old-locale old-time text time transformers utf8-string
         vector xml-conduit xml-types zip-archive zlib
       ];
       executableHaskellDepends = [
         base binary-search bytestring conduit containers data-default
         digest lens old-locale old-time text time transformers utf8-string
         vector xml-conduit xml-types zip-archive zlib
       ];
       testHaskellDepends = [
         base containers HUnit old-time smallcheck tasty tasty-hunit
         tasty-smallcheck time xml-conduit
       ];
       homepage = "https://github.com/qrilka/xlsx";
       description = "Simple and incomplete Excel file parser/writer";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xlsx" = callPackage
    ({ mkDerivation, base, binary-search, bytestring, conduit
     , containers, data-default, digest, HUnit, lens, mtl, old-locale
     , smallcheck, tasty, tasty-hunit, tasty-smallcheck, text, time
     , transformers, utf8-string, vector, xml-conduit, xml-types
     , zip-archive, zlib
     }:
     mkDerivation {
       pname = "xlsx";
       version = "0.2.0";
       sha256 = "6f76eefb933916fe14569a5dfb408716cb5e9481be34f886219f770d64fa16de";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base binary-search bytestring conduit containers data-default
         digest lens mtl old-locale text time transformers utf8-string
         vector xml-conduit xml-types zip-archive zlib
       ];
       executableHaskellDepends = [
         base binary-search bytestring conduit containers data-default
         digest lens old-locale text time transformers utf8-string vector
         xml-conduit xml-types zip-archive zlib
       ];
       testHaskellDepends = [
         base bytestring containers HUnit lens smallcheck tasty tasty-hunit
         tasty-smallcheck time vector xml-conduit
       ];
       homepage = "https://github.com/qrilka/xlsx";
       description = "Simple and incomplete Excel file parser/writer";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xlsx-templater" = callPackage
    ({ mkDerivation, base, bytestring, conduit, containers
     , data-default, parsec, text, time, transformers, xlsx
     }:
     mkDerivation {
       pname = "xlsx-templater";
       version = "0.0.1";
       sha256 = "99cb5f86c7c1ce967e10e09463977fe4c8dbcb51c6c6c7bf422e030a77eaa502";
       isLibrary = true;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring conduit containers data-default parsec text time
         transformers xlsx
       ];
       jailbreak = true;
       homepage = "https://github.com/qrilka/xlsx-templater";
       description = "Simple and incomplete Excel file templater";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml_1_3_13" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "xml";
       version = "1.3.13";
       sha256 = "c33607cef8a48d878b0e617e115135fc6f025fe43dcb65c2c7afb8285415b813";
       libraryHaskellDepends = [ base bytestring text ];
       homepage = "http://code.galois.com";
       description = "A simple XML library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml" = callPackage
    ({ mkDerivation, base, bytestring, text }:
     mkDerivation {
       pname = "xml";
       version = "1.3.14";
       sha256 = "32d1a1a9f21a59176d84697f96ae3a13a0198420e3e4f1c48abbab7d2425013d";
       libraryHaskellDepends = [ base bytestring text ];
       homepage = "http://code.galois.com";
       description = "A simple XML library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xml-basic" = callPackage
    ({ mkDerivation, base, containers, data-accessor
     , explicit-exception, utility-ht
     }:
     mkDerivation {
       pname = "xml-basic";
       version = "0.1.1.3";
       sha256 = "cc7c122cba27c099f7ddc82bf692ab744ebbd3c0f6dc544a8278dfb4d0e37754";
       libraryHaskellDepends = [
         base containers data-accessor explicit-exception utility-ht
       ];
       homepage = "http://www.haskell.org/haskellwiki/XML-Basic";
       description = "Basics for XML/HTML representation and processing";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xml-catalog" = callPackage
    ({ mkDerivation, base, bytestring, conduit, containers, text
     , transformers, uri-conduit, xml-conduit
     }:
     mkDerivation {
       pname = "xml-catalog";
       version = "1.1.0.2";
       sha256 = "cc799b696536e41c407c1d4d50b788a774ae40a0ec8e3033ce7a8a8df630f14b";
       libraryHaskellDepends = [
         base bytestring conduit containers text transformers uri-conduit
         xml-conduit
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/xml";
       description = "Parse XML catalog files (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-conduit_1_2_3" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, conduit, conduit-extra, containers
     , data-default, deepseq, hspec, HUnit, monad-control, resourcet
     , system-filepath, text, transformers, xml-types
     }:
     mkDerivation {
       pname = "xml-conduit";
       version = "1.2.3";
       sha256 = "bb9482c5efd9f0c9013e7cec688d4e41d8d9838f0c1e11bd9df43398f4aedcce";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         conduit conduit-extra containers data-default deepseq monad-control
         resourcet system-filepath text transformers xml-types
       ];
       testHaskellDepends = [
         base blaze-markup bytestring conduit containers hspec HUnit
         resourcet text transformers xml-types
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/xml";
       description = "Pure-Haskell utilities for dealing with XML with the conduit package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-conduit_1_2_3_1" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, conduit, conduit-extra, containers
     , data-default, deepseq, hspec, HUnit, monad-control, resourcet
     , system-filepath, text, transformers, xml-types
     }:
     mkDerivation {
       pname = "xml-conduit";
       version = "1.2.3.1";
       sha256 = "282a4251074a4045f78d914a8dfbcdcd9ccaf7fc5741c0e441fd17c42e869881";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         conduit conduit-extra containers data-default deepseq monad-control
         resourcet system-filepath text transformers xml-types
       ];
       testHaskellDepends = [
         base blaze-markup bytestring conduit containers hspec HUnit
         resourcet text transformers xml-types
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/xml";
       description = "Pure-Haskell utilities for dealing with XML with the conduit package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-conduit_1_2_3_2" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, conduit, conduit-extra, containers
     , data-default, deepseq, hspec, HUnit, monad-control, resourcet
     , system-filepath, text, transformers, xml-types
     }:
     mkDerivation {
       pname = "xml-conduit";
       version = "1.2.3.2";
       sha256 = "694aa3b167a0ce1505cf4e0bc8c03e50e359743845b38b23ac8e5fa658a364ee";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         conduit conduit-extra containers data-default deepseq monad-control
         resourcet system-filepath text transformers xml-types
       ];
       testHaskellDepends = [
         base blaze-markup bytestring conduit containers hspec HUnit
         resourcet text transformers xml-types
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/xml";
       description = "Pure-Haskell utilities for dealing with XML with the conduit package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-conduit_1_2_3_3" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, conduit, conduit-extra, containers
     , data-default, deepseq, hspec, HUnit, monad-control, resourcet
     , system-filepath, text, transformers, xml-types
     }:
     mkDerivation {
       pname = "xml-conduit";
       version = "1.2.3.3";
       sha256 = "0bc599d6473f9c19c1f2c0f598799c586cf03c96fc21c8107d856ea20c15b378";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         conduit conduit-extra containers data-default deepseq monad-control
         resourcet system-filepath text transformers xml-types
       ];
       testHaskellDepends = [
         base blaze-markup bytestring conduit containers hspec HUnit
         resourcet text transformers xml-types
       ];
       homepage = "http://github.com/snoyberg/xml";
       description = "Pure-Haskell utilities for dealing with XML with the conduit package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-conduit_1_2_4" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, conduit, conduit-extra, containers
     , data-default, deepseq, hspec, HUnit, monad-control, resourcet
     , system-filepath, text, transformers, xml-types
     }:
     mkDerivation {
       pname = "xml-conduit";
       version = "1.2.4";
       sha256 = "f8b65060c0e125206d5d3015ab3ca4d211daaa0f500627786fc04b55928f69dd";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         conduit conduit-extra containers data-default deepseq monad-control
         resourcet system-filepath text transformers xml-types
       ];
       testHaskellDepends = [
         base blaze-markup bytestring conduit containers hspec HUnit
         resourcet text transformers xml-types
       ];
       homepage = "http://github.com/snoyberg/xml";
       description = "Pure-Haskell utilities for dealing with XML with the conduit package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-conduit_1_2_6" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, conduit, conduit-extra, containers
     , data-default, deepseq, hspec, HUnit, monad-control, resourcet
     , system-filepath, text, transformers, xml-types
     }:
     mkDerivation {
       pname = "xml-conduit";
       version = "1.2.6";
       sha256 = "3fb26cfd24c79005638c215d2f29b2a202f81e77ea46ba16ce8afca9540574f9";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         conduit conduit-extra containers data-default deepseq monad-control
         resourcet system-filepath text transformers xml-types
       ];
       testHaskellDepends = [
         base blaze-markup bytestring conduit containers hspec HUnit
         resourcet text transformers xml-types
       ];
       homepage = "http://github.com/snoyberg/xml";
       description = "Pure-Haskell utilities for dealing with XML with the conduit package";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-conduit_1_3_1" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, conduit, conduit-extra, containers
     , data-default, deepseq, hspec, HUnit, monad-control, resourcet
     , text, transformers, xml-types
     }:
     mkDerivation {
       pname = "xml-conduit";
       version = "1.3.1";
       sha256 = "19e65bb1753f99c8a9f2011f2088639db3b8c06f72d29fea1464f623879b8f24";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         conduit conduit-extra containers data-default deepseq monad-control
         resourcet text transformers xml-types
       ];
       testHaskellDepends = [
         base blaze-markup bytestring conduit containers hspec HUnit
         resourcet text transformers xml-types
       ];
       homepage = "http://github.com/snoyberg/xml";
       description = "Pure-Haskell utilities for dealing with XML with the conduit package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-conduit_1_3_2" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, conduit, conduit-extra, containers
     , data-default, deepseq, hspec, HUnit, monad-control, resourcet
     , text, transformers, xml-types
     }:
     mkDerivation {
       pname = "xml-conduit";
       version = "1.3.2";
       sha256 = "d45d056e2e7a1ebb0572b630eb8223aac3bd1ce2419bea8074e6607f2a0a06c6";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         conduit conduit-extra containers data-default deepseq monad-control
         resourcet text transformers xml-types
       ];
       testHaskellDepends = [
         base blaze-markup bytestring conduit containers hspec HUnit
         resourcet text transformers xml-types
       ];
       homepage = "http://github.com/snoyberg/xml";
       description = "Pure-Haskell utilities for dealing with XML with the conduit package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-conduit_1_3_3" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, conduit, conduit-extra, containers
     , data-default, deepseq, hspec, HUnit, monad-control, resourcet
     , text, transformers, xml-types
     }:
     mkDerivation {
       pname = "xml-conduit";
       version = "1.3.3";
       sha256 = "300a0b5eb2ff1062012b61bc4aaa390571daecc671af2d8567a649489b08b66b";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         conduit conduit-extra containers data-default deepseq monad-control
         resourcet text transformers xml-types
       ];
       testHaskellDepends = [
         base blaze-markup bytestring conduit containers hspec HUnit
         resourcet text transformers xml-types
       ];
       homepage = "http://github.com/snoyberg/xml";
       description = "Pure-Haskell utilities for dealing with XML with the conduit package";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-conduit" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, conduit, conduit-extra, containers
     , data-default, deepseq, hspec, HUnit, monad-control, resourcet
     , text, transformers, xml-types
     }:
     mkDerivation {
       pname = "xml-conduit";
       version = "1.3.3.1";
       sha256 = "3d8ad32feade67f989150f253d3df99b3e3af6fab536c18f591d46707430feca";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         conduit conduit-extra containers data-default deepseq monad-control
         resourcet text transformers xml-types
       ];
       testHaskellDepends = [
         base blaze-markup bytestring conduit containers hspec HUnit
         resourcet text transformers xml-types
       ];
       homepage = "http://github.com/snoyberg/xml";
       description = "Pure-Haskell utilities for dealing with XML with the conduit package";
       license = stdenv.lib.licenses.mit;
     }) {};

  "xml-conduit-parse" = callPackage
    ({ mkDerivation, base, conduit, conduit-parse, containers
     , data-default, exceptions, hlint, parsers, resourcet, tasty
     , tasty-hunit, text, xml-conduit, xml-types
     }:
     mkDerivation {
       pname = "xml-conduit-parse";
       version = "0.3.1.0";
       sha256 = "62a8aacdd03e216cc1f89882205b933016c0aebe2ed3e113a966c5956ec572d5";
       libraryHaskellDepends = [
         base conduit conduit-parse containers exceptions parsers text
         xml-conduit xml-types
       ];
       testHaskellDepends = [
         base conduit conduit-parse data-default hlint parsers resourcet
         tasty tasty-hunit
       ];
       homepage = "https://github.com/k0ral/xml-conduit-parse";
       description = "Streaming XML parser based on conduits";
       license = "unknown";
     }) {};

  "xml-conduit-writer" = callPackage
    ({ mkDerivation, base, containers, dlist, mtl, text, xml-conduit
     , xml-types
     }:
     mkDerivation {
       pname = "xml-conduit-writer";
       version = "0.1.1.1";
       sha256 = "4b547cdc629a583f0231bed45d568f12eb0244fdaeb904c11eeb0d9365c771c5";
       libraryHaskellDepends = [
         base containers dlist mtl text xml-conduit xml-types
       ];
       testHaskellDepends = [ base text ];
       homepage = "https://bitbucket.org/dpwiz/xml-conduit-writer";
       description = "Warm and fuzzy creation of XML documents";
       license = stdenv.lib.licenses.mit;
     }) {};

  "xml-enumerator" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-enumerator, base
     , blaze-builder, blaze-builder-enumerator, bytestring, containers
     , data-default, enumerator, failure, hspec, HUnit, text
     , transformers, xml-types
     }:
     mkDerivation {
       pname = "xml-enumerator";
       version = "0.4.4.1";
       sha256 = "f287ee652ef84b9de2ce3362b0f72cb66c3c9fadd03f8a1638c908d38f36966f";
       libraryHaskellDepends = [
         attoparsec attoparsec-enumerator base blaze-builder
         blaze-builder-enumerator bytestring containers data-default
         enumerator failure text transformers xml-types
       ];
       testHaskellDepends = [
         base bytestring containers enumerator hspec HUnit text transformers
         xml-types
       ];
       jailbreak = true;
       homepage = "http://github.com/snoyberg/xml";
       description = "Pure-Haskell utilities for dealing with XML with the enumerator package. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-enumerator-combinators" = callPackage
    ({ mkDerivation, base, containers, enumerator, xml-enumerator
     , xml-types
     }:
     mkDerivation {
       pname = "xml-enumerator-combinators";
       version = "0.1";
       sha256 = "63c9e2548ef8c83116fff84160b48494974b1cf34852fe2e6377cab53ef754d8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers enumerator xml-enumerator xml-types
       ];
       jailbreak = true;
       description = "Parser combinators for xml-enumerator and compatible XML parsers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-extractors" = callPackage
    ({ mkDerivation, base, mtl, safe, transformers, xml }:
     mkDerivation {
       pname = "xml-extractors";
       version = "0.4.0.1";
       sha256 = "38ffa6ab354dcaddbdd1ca4c187418715fd7d7de77abc4861c9840c88bce1e79";
       libraryHaskellDepends = [ base mtl safe transformers xml ];
       homepage = "https://github.com/holmisen/xml-extractors";
       description = "Extension to the xml package to extract data from parsed xml";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xml-hamlet_0_4_0_9" = callPackage
    ({ mkDerivation, base, containers, hspec, HUnit, parsec
     , shakespeare, template-haskell, text, xml-conduit
     }:
     mkDerivation {
       pname = "xml-hamlet";
       version = "0.4.0.9";
       sha256 = "02498a736aac8bba3648349b63ba139bdd54c1830f5a1df5186a14273794a46e";
       libraryHaskellDepends = [
         base containers parsec shakespeare template-haskell text
         xml-conduit
       ];
       testHaskellDepends = [
         base containers hspec HUnit parsec shakespeare template-haskell
         text xml-conduit
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Hamlet-style quasiquoter for XML content";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-hamlet_0_4_0_10" = callPackage
    ({ mkDerivation, base, containers, hspec, HUnit, parsec
     , shakespeare, template-haskell, text, xml-conduit
     }:
     mkDerivation {
       pname = "xml-hamlet";
       version = "0.4.0.10";
       sha256 = "db2ceaab371b7b21cbf11cb1fb81a36fe69361cf01ff5bdb17ad08b6fa686f2f";
       libraryHaskellDepends = [
         base containers parsec shakespeare template-haskell text
         xml-conduit
       ];
       testHaskellDepends = [
         base containers hspec HUnit parsec shakespeare template-haskell
         text xml-conduit
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Hamlet-style quasiquoter for XML content";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-hamlet" = callPackage
    ({ mkDerivation, base, containers, hspec, HUnit, parsec
     , shakespeare, template-haskell, text, xml-conduit
     }:
     mkDerivation {
       pname = "xml-hamlet";
       version = "0.4.0.11";
       sha256 = "3d598ad387e310e76a07f213afe35db06662611840d1bce3bcdf202668bc1e89";
       libraryHaskellDepends = [
         base containers parsec shakespeare template-haskell text
         xml-conduit
       ];
       testHaskellDepends = [
         base containers hspec HUnit parsec shakespeare template-haskell
         text xml-conduit
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Hamlet-style quasiquoter for XML content";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xml-helpers" = callPackage
    ({ mkDerivation, base, xml }:
     mkDerivation {
       pname = "xml-helpers";
       version = "1.0.0";
       sha256 = "9b02c5bfd831e4e275745a3ca521a528a64ab0cf84022e17344873548f043367";
       libraryHaskellDepends = [ base xml ];
       homepage = "http://github.com/acw/xml-helpers";
       description = "Some useful helper functions for the xml library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xml-html-conduit-lens" = callPackage
    ({ mkDerivation, base, bytestring, containers, doctest, hspec
     , hspec-expectations-lens, html-conduit, lens, text, xml-conduit
     }:
     mkDerivation {
       pname = "xml-html-conduit-lens";
       version = "0.3.2.1";
       sha256 = "22dcbfe4e70a87dcc6d477c9e1c3c51cb1317b4799e42efc6c3d9a55b045c547";
       revision = "2";
       editedCabalFile = "6c3305bb07c0fd40c933640ebe9e6114a798115cfb2f3cb976e40f1ece955132";
       libraryHaskellDepends = [
         base bytestring containers html-conduit lens text xml-conduit
       ];
       testHaskellDepends = [
         base doctest hspec hspec-expectations-lens lens xml-conduit
       ];
       jailbreak = true;
       homepage = "https://github.com/supki/xml-html-conduit-lens#readme";
       description = "Optics for xml-conduit and html-conduit";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xml-lens" = callPackage
    ({ mkDerivation, base, case-insensitive, containers, lens, text
     , xml-conduit
     }:
     mkDerivation {
       pname = "xml-lens";
       version = "0.1.6.3";
       sha256 = "4dd7f1a91fbb12ae52d5a14badd9f38c0f0d7556f08ee77d79a67cc546dcb1e8";
       revision = "1";
       editedCabalFile = "1a0768a259fb0aeaaecc092c6a9777c4d498d2695b0385a0e620e47f362773b9";
       libraryHaskellDepends = [
         base case-insensitive containers lens text xml-conduit
       ];
       homepage = "https://github.com/fumieval/xml-lens";
       description = "Lenses, traversals, and prisms for xml-conduit";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xml-monad" = callPackage
    ({ mkDerivation, base, mtl, transformers, transformers-compose, xml
     }:
     mkDerivation {
       pname = "xml-monad";
       version = "0.5";
       sha256 = "999069c96672de8a419a3263383876a2f62824eb70088ff8ae50ff0efcbd5d9d";
       libraryHaskellDepends = [
         base mtl transformers transformers-compose xml
       ];
       jailbreak = true;
       homepage = "http://github.com/aristidb/xml-monad";
       description = "Monadic extensions to the xml package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xml-parsec" = callPackage
    ({ mkDerivation, base, HaXml, parsec }:
     mkDerivation {
       pname = "xml-parsec";
       version = "1.0.3";
       sha256 = "c2b68bd7217d18d4189aac685a04f03c4d7ded7efe0422e804452fc33d8e95fd";
       libraryHaskellDepends = [ base HaXml parsec ];
       homepage = "http://sep07.mroot.net/";
       description = "Parsing XML with Parsec";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-picklers" = callPackage
    ({ mkDerivation, base, Cabal, containers, QuickCheck, tasty
     , tasty-hunit, tasty-quickcheck, text, xml-types
     }:
     mkDerivation {
       pname = "xml-picklers";
       version = "0.3.6";
       sha256 = "d1b802cd9543a228c6699928e6695539c28f6cbd8e7859a65ca874543ef1d1a4";
       libraryHaskellDepends = [ base containers text xml-types ];
       testHaskellDepends = [
         base Cabal QuickCheck tasty tasty-hunit tasty-quickcheck text
         xml-types
       ];
       description = "XML picklers based on xml-types, ported from hexpat-pickle";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xml-pipe" = callPackage
    ({ mkDerivation, base, bytestring, papillon, simple-pipe }:
     mkDerivation {
       pname = "xml-pipe";
       version = "0.0.0.11";
       sha256 = "c4d3da66e838a6d135972a1566aedc069719246fb1441b287b8a9d6c9c95ae48";
       libraryHaskellDepends = [ base bytestring papillon simple-pipe ];
       homepage = "https://github.com/YoshikuniJujo/xml-pipe/wiki";
       description = "XML parser which uses simple-pipe";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-prettify" = callPackage
    ({ mkDerivation, base, cmdargs, unix }:
     mkDerivation {
       pname = "xml-prettify";
       version = "0.1.0.1";
       sha256 = "c081faf3ba09248b11a8abd5acdc00230d08b410e9563211a48d020863af72a9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ];
       executableHaskellDepends = [ base cmdargs unix ];
       homepage = "http://github.com/rosenbergdm/xml-prettify";
       description = "Pretty print XML";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-push" = callPackage
    ({ mkDerivation, base, bytestring, crypto-random, handle-like
     , monad-control, monads-tf, peyotls, random, sasl, simple-pipe, stm
     , tighttp, transformers-base, uuid, x509, x509-store
     , x509-validation, xml-pipe, xmpipe
     }:
     mkDerivation {
       pname = "xml-push";
       version = "0.0.0.18";
       sha256 = "7ed812b6d4721d6a7ad5aee2fadecd2f4477dcc19e7362e7d52ea35ccfaf18c5";
       libraryHaskellDepends = [
         base bytestring crypto-random handle-like monad-control monads-tf
         peyotls random sasl simple-pipe stm tighttp transformers-base uuid
         x509 x509-store x509-validation xml-pipe xmpipe
       ];
       jailbreak = true;
       homepage = "https://github.com/YoshikuniJujo/xml-push/wiki";
       description = "Push XML from/to client to/from server over XMPP or HTTP";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-query" = callPackage
    ({ mkDerivation, base-prelude, free, text }:
     mkDerivation {
       pname = "xml-query";
       version = "0.9.0.2";
       sha256 = "008d596529cffde397c55026c10c8a20951272959e2a6e35cfdfef499719ec7b";
       libraryHaskellDepends = [ base-prelude free text ];
       jailbreak = true;
       homepage = "https://github.com/sannsyn/xml-query";
       description = "A parser-agnostic declarative API for querying XML-documents";
       license = stdenv.lib.licenses.mit;
     }) {};

  "xml-query-xml-conduit" = callPackage
    ({ mkDerivation, base-prelude, text, xml-conduit, xml-query
     , xml-query-xml-types, xml-types
     }:
     mkDerivation {
       pname = "xml-query-xml-conduit";
       version = "0.3";
       sha256 = "daa66b0b16961b090d47278e4ad92b1b776080e1c675e414c65640db13118ecb";
       libraryHaskellDepends = [
         base-prelude text xml-conduit xml-query xml-query-xml-types
         xml-types
       ];
       jailbreak = true;
       homepage = "https://github.com/sannsyn/xml-query-xml-conduit";
       description = "A binding for the \"xml-query\" and \"xml-conduit\" libraries";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-query-xml-types" = callPackage
    ({ mkDerivation, base, base-prelude, data-default-class, free
     , html-entities, QuickCheck, quickcheck-instances, success, tasty
     , tasty-hunit, tasty-quickcheck, tasty-smallcheck, text
     , transformers, xml-conduit, xml-query, xml-types
     }:
     mkDerivation {
       pname = "xml-query-xml-types";
       version = "0.4";
       sha256 = "28291319efbb60d4a2889cf1319d3fd5aa63b71ec9f29562ec1fdfa243ce7b81";
       libraryHaskellDepends = [
         base-prelude free html-entities success text transformers xml-query
         xml-types
       ];
       testHaskellDepends = [
         base base-prelude data-default-class QuickCheck
         quickcheck-instances tasty tasty-hunit tasty-quickcheck
         tasty-smallcheck text xml-conduit xml-query xml-types
       ];
       jailbreak = true;
       homepage = "https://github.com/sannsyn/xml-query-xml-types";
       description = "An interpreter of \"xml-query\" queries for the \"xml-types\" documents";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-to-json" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, curl
     , hashable, hxt, hxt-curl, hxt-expat, hxt-tagsoup, regex-posix
     , tagsoup, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "xml-to-json";
       version = "2.0.1";
       sha256 = "ad1a2501828052a1798178c309638a9b8e4fe66ad24dae9c76de939c156d2e2f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base bytestring containers curl hashable hxt hxt-curl
         hxt-expat hxt-tagsoup regex-posix tagsoup text unordered-containers
         vector
       ];
       executableHaskellDepends = [ base ];
       homepage = "https://github.com/sinelaw/xml-to-json";
       description = "Library and command line tool for converting XML files to json";
       license = stdenv.lib.licenses.mit;
     }) {};

  "xml-to-json-fast" = callPackage
    ({ mkDerivation, base, directory, process, tagsoup, text }:
     mkDerivation {
       pname = "xml-to-json-fast";
       version = "2.0.0";
       sha256 = "dd852fe1aa54db3c6d87a2e74b5345b0f14effdd49bad5b73d79571e1b47563f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base tagsoup text ];
       executableHaskellDepends = [ base directory process ];
       homepage = "https://github.com/sinelaw/xml-to-json-fast";
       description = "Fast, light converter of xml to json capable of handling huge xml files";
       license = stdenv.lib.licenses.mit;
     }) {};

  "xml-types_0_3_4" = callPackage
    ({ mkDerivation, base, deepseq, text }:
     mkDerivation {
       pname = "xml-types";
       version = "0.3.4";
       sha256 = "1ee502b032e9a97c43250f476af69f65147667e3a1b4dd3bd404f64eb28c0999";
       libraryHaskellDepends = [ base deepseq text ];
       homepage = "https://john-millikin.com/software/haskell-xml/";
       description = "Basic types for representing XML";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-types_0_3_5" = callPackage
    ({ mkDerivation, base, deepseq, text }:
     mkDerivation {
       pname = "xml-types";
       version = "0.3.5";
       sha256 = "4a0b82180e0697326ebb406079bedb95df4c2ddf67c6ee796727faa28059ad6d";
       revision = "1";
       editedCabalFile = "fa3bd0f11105c6c73466dda088406bc89c4de4d81840fd0cec340ab984495c59";
       libraryHaskellDepends = [ base deepseq text ];
       homepage = "https://john-millikin.com/software/haskell-xml/";
       description = "Basic types for representing XML";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml-types" = callPackage
    ({ mkDerivation, base, deepseq, text }:
     mkDerivation {
       pname = "xml-types";
       version = "0.3.6";
       sha256 = "9937d440072552c03c6d8ad79f61e61467dc28dcd5adeaad81038b9b94eef8c9";
       libraryHaskellDepends = [ base deepseq text ];
       homepage = "https://john-millikin.com/software/haskell-xml/";
       description = "Basic types for representing XML";
       license = stdenv.lib.licenses.mit;
     }) {};

  "xml2html" = callPackage
    ({ mkDerivation, base, xml-conduit }:
     mkDerivation {
       pname = "xml2html";
       version = "0.2.0";
       sha256 = "6a6a2124f395520fe47819efe27ca5ef9215c15a335e89fa266d3a469edcc4cd";
       libraryHaskellDepends = [ base xml-conduit ];
       homepage = "http://github.com/snoyberg/xml";
       description = "blaze-html instances for xml-conduit types (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xml2json" = callPackage
    ({ mkDerivation, aeson, attoparsec, attoparsec-conduit, base
     , blaze-builder, blaze-builder-conduit, bytestring
     , case-insensitive, conduit, hspec, resourcet, tagstream-conduit
     , text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "xml2json";
       version = "0.2.0.0";
       sha256 = "bd2a685211cd9b11afcc8e6ab63be1ad6877f8c287b593a4c7e5788cd318a397";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec attoparsec-conduit base blaze-builder
         blaze-builder-conduit bytestring case-insensitive conduit
         tagstream-conduit text transformers unordered-containers vector
       ];
       executableHaskellDepends = [
         aeson attoparsec attoparsec-conduit base blaze-builder
         blaze-builder-conduit bytestring case-insensitive conduit
         tagstream-conduit text transformers unordered-containers vector
       ];
       testHaskellDepends = [
         aeson base bytestring hspec resourcet text transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/yihuang/xml2json";
       description = "translate xml to json";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xml2x" = callPackage
    ({ mkDerivation, array, base, bio, bytestring, containers
     , directory, xhtml
     }:
     mkDerivation {
       pname = "xml2x";
       version = "0.4.2";
       sha256 = "2a2e5db41c68c082bec59fb94abc7fb542ef087bb46b7b6b22eb33fc7f0fe232";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base bio bytestring containers directory xhtml
       ];
       jailbreak = true;
       description = "Convert BLAST output in XML format to CSV or HTML";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xmlgen" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers
     , filepath, HUnit, hxt, mtl, process, QuickCheck, text, unix
     }:
     mkDerivation {
       pname = "xmlgen";
       version = "0.6.2.1";
       sha256 = "9027a17e7ae648997a0e8279d7c01aa6615adda8b93f753b907a01dd797abae6";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers mtl text
       ];
       testHaskellDepends = [
         base bytestring containers filepath HUnit hxt process QuickCheck
         text unix
       ];
       doHaddock = false;
       doCheck = false;
       description = "Fast XML generation library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xmlhtml_0_2_3_3" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, blaze-markup
     , bytestring, containers, parsec, text, unordered-containers
     }:
     mkDerivation {
       pname = "xmlhtml";
       version = "0.2.3.3";
       sha256 = "b26c9f472ef021242f643b12dd59f31deaecadfa587eb40f7fad11f109122559";
       revision = "1";
       editedCabalFile = "83177fd0467f61200293f42205a8611e6fb1034b91c418e29da06e9a83dab230";
       libraryHaskellDepends = [
         base blaze-builder blaze-html blaze-markup bytestring containers
         parsec text unordered-containers
       ];
       jailbreak = true;
       description = "XML parser and renderer with HTML 5 quirks mode";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xmlhtml" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, blaze-markup
     , bytestring, containers, parsec, text, unordered-containers
     }:
     mkDerivation {
       pname = "xmlhtml";
       version = "0.2.3.4";
       sha256 = "d955859d51f4636e3994f77b2ac38e0bdd7c152eb92b9b192db11ebc3e966533";
       revision = "1";
       editedCabalFile = "17e37eb81bbdd03eea4b12e65bd4a00e789bc7a04b792f138dc9056c488443a9";
       libraryHaskellDepends = [
         base blaze-builder blaze-html blaze-markup bytestring containers
         parsec text unordered-containers
       ];
       description = "XML parser and renderer with HTML 5 quirks mode";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xmltv" = callPackage
    ({ mkDerivation, base, bytestring, configurator, filepath
     , http-client, network-uri, old-locale, split, terminfo, time, unix
     , wl-pprint-extras, wl-pprint-terminfo, xdg-basedir, xml
     }:
     mkDerivation {
       pname = "xmltv";
       version = "0.0.1";
       sha256 = "69d312f4d8ad7fcea031f8aea217e03d20ed31e877c0f0e3d7d2a9ad91502096";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base old-locale time xml ];
       executableHaskellDepends = [
         base bytestring configurator filepath http-client network-uri
         old-locale split terminfo time unix wl-pprint-extras
         wl-pprint-terminfo xdg-basedir xml
       ];
       homepage = "http://github.com/dagle/hs-xmltv";
       description = "Show tv channels in the terminal";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xmms2-client" = callPackage
    ({ mkDerivation, base, c2hs, containers, haskell98, mtl
     , utf8-string
     }:
     mkDerivation {
       pname = "xmms2-client";
       version = "0.0.7.0";
       sha256 = "bf156fae117127d684bc0f4a1fcb2213eab3b4da76933ce75bdae518a0ea1a2a";
       libraryHaskellDepends = [
         base containers haskell98 mtl utf8-string
       ];
       libraryToolDepends = [ c2hs ];
       description = "An XMMS2 client library";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xmms2-client-glib" = callPackage
    ({ mkDerivation, base, c2hs, haskell98, xmms2-client }:
     mkDerivation {
       pname = "xmms2-client-glib";
       version = "0.0.7.0";
       sha256 = "0392b25e67c1626a3507a5579346543bcf2001ecadae29ff44b4d76c13472ce7";
       libraryHaskellDepends = [ base haskell98 xmms2-client ];
       libraryToolDepends = [ c2hs ];
       description = "An XMMS2 client library — GLib integration";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xmobar" = callPackage
    ({ mkDerivation, alsa-core, alsa-mixer, base, bytestring
     , containers, dbus, directory, filepath, hinotify, HTTP, libmpd
     , libXpm, libXrandr, mtl, old-locale, parsec, process, regex-compat
     , stm, time, timezone-olson, timezone-series, transformers, unix
     , utf8-string, wirelesstools, X11, X11-xft, Xrender
     }:
     mkDerivation {
       pname = "xmobar";
       version = "0.23.1";
       sha256 = "3b31558373bdb8561f06440da902dd0db8398e5c774fa027931785c263f5567a";
       configureFlags = [ "-fall_extensions" ];
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         alsa-core alsa-mixer base bytestring containers dbus directory
         filepath hinotify HTTP libmpd mtl old-locale parsec process
         regex-compat stm time timezone-olson timezone-series transformers
         unix utf8-string X11 X11-xft
       ];
       executableSystemDepends = [
         libXpm libXrandr wirelesstools Xrender
       ];
       homepage = "http://xmobar.org";
       description = "A Minimalistic Text Based Status Bar";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {Xrender = null; inherit (pkgs.xorg) libXpm; 
         inherit (pkgs.xorg) libXrandr; inherit (pkgs) wirelesstools;};

  "xmonad" = callPackage
    ({ mkDerivation, base, containers, data-default, directory
     , extensible-exceptions, filepath, mtl, process, QuickCheck
     , setlocale, unix, utf8-string, X11
     }:
     mkDerivation {
       pname = "xmonad";
       version = "0.12";
       sha256 = "e8f649dbd4a8d5f75fdac9ceb5ee38b64fd351910ade81c188f5dd7bc21dfdd7";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers data-default directory extensible-exceptions
         filepath mtl process setlocale unix utf8-string X11
       ];
       executableHaskellDepends = [ base mtl unix X11 ];
       testHaskellDepends = [
         base containers extensible-exceptions QuickCheck X11
       ];
       postInstall = ''
         shopt -s globstar
         mkdir -p $out/share/man/man1
         mv "$out/"**"/man/"*.1 $out/share/man/man1/
       '';
       homepage = "http://xmonad.org";
       description = "A tiling window manager";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xmonad-bluetilebranch" = callPackage
    ({ mkDerivation, base, containers, directory, extensible-exceptions
     , filepath, mtl, process, unix, X11
     }:
     mkDerivation {
       pname = "xmonad-bluetilebranch";
       version = "0.9.1.4";
       sha256 = "f6214d8e5482acf00fb247ae9e8cf9369b2fb01af2aea468db7fcec4b229b6fa";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers directory extensible-exceptions filepath mtl
         process unix X11
       ];
       jailbreak = true;
       homepage = "http://xmonad.org";
       description = "A tiling window manager";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xmonad-contrib" = callPackage
    ({ mkDerivation, base, containers, directory, extensible-exceptions
     , filepath, mtl, old-locale, old-time, process, random, unix
     , utf8-string, X11, X11-xft, xmonad
     }:
     mkDerivation {
       pname = "xmonad-contrib";
       version = "0.12";
       sha256 = "131d31c471ac02ece9c7e920497b4839a45df786a2096f56adb1f2de1221f311";
       revision = "2";
       editedCabalFile = "8a17b7fe46dc9d7435538a0db3997bcb2a125e71923ecd401024d84081a41807";
       libraryHaskellDepends = [
         base containers directory extensible-exceptions filepath mtl
         old-locale old-time process random unix utf8-string X11 X11-xft
         xmonad
       ];
       homepage = "http://xmonad.org/";
       description = "Third party extensions for xmonad";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xmonad-contrib-bluetilebranch" = callPackage
    ({ mkDerivation, base, containers, directory, extensible-exceptions
     , mtl, old-locale, old-time, process, random, unix, utf8-string
     , X11, X11-xft, xmonad-bluetilebranch
     }:
     mkDerivation {
       pname = "xmonad-contrib-bluetilebranch";
       version = "0.9.1.4";
       sha256 = "871a5df360b3bada92352802ad8f9d460eed8dc1850f545550c77189ae474efb";
       libraryHaskellDepends = [
         base containers directory extensible-exceptions mtl old-locale
         old-time process random unix utf8-string X11 X11-xft
         xmonad-bluetilebranch
       ];
       jailbreak = true;
       homepage = "http://xmonad.org/";
       description = "Third party extensions for xmonad";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xmonad-contrib-gpl" = callPackage
    ({ mkDerivation, base, mtl, xmonad, xmonad-contrib }:
     mkDerivation {
       pname = "xmonad-contrib-gpl";
       version = "0.12.1";
       sha256 = "c98a6993fe030b2726840a5760009ba5062e666baa759eb814a5f4843fc749f7";
       libraryHaskellDepends = [ base mtl xmonad xmonad-contrib ];
       homepage = "http://xmonad.org/";
       description = "Third party extensions for xmonad";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "xmonad-entryhelper" = callPackage
    ({ mkDerivation, base, directory, extensible-exceptions, filepath
     , mtl, process, unix, X11, xmonad, xmonad-contrib
     }:
     mkDerivation {
       pname = "xmonad-entryhelper";
       version = "0.1.0.0";
       sha256 = "30ed74463c59f462c65f36551486c09793c8f2f1761d0f3ac68b30ae8f6f92f7";
       libraryHaskellDepends = [
         base directory extensible-exceptions filepath mtl process unix X11
         xmonad xmonad-contrib
       ];
       homepage = "https://github.com/Javran/xmonad-entryhelper";
       description = "XMonad config entry point wrapper";
       license = stdenv.lib.licenses.mit;
     }) {};

  "xmonad-eval" = callPackage
    ({ mkDerivation, base, containers, directory, hint, mtl, old-locale
     , old-time, process, random, unix, X11, xmonad, xmonad-contrib
     }:
     mkDerivation {
       pname = "xmonad-eval";
       version = "0.1";
       sha256 = "f3bd9ff6a0b00c059223dd85440becd4b64551bb24c6fadbc0444e503e59144c";
       libraryHaskellDepends = [
         base containers directory hint mtl old-locale old-time process
         random unix X11 xmonad xmonad-contrib
       ];
       jailbreak = true;
       homepage = "http://xmonad.org/";
       description = "Module for evaluation Haskell expressions in the running xmonad instance";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xmonad-extras" = callPackage
    ({ mkDerivation, base, containers, directory, hint, mtl, network
     , old-locale, old-time, parsec, process, random, regex-posix, split
     , unix, X11, xmonad, xmonad-contrib
     }:
     mkDerivation {
       pname = "xmonad-extras";
       version = "0.12.1";
       sha256 = "a5fc71ccf92a4cfa81f8eb690a6df98e6d0d707288c31e70351747b7f388e891";
       configureFlags = [
         "-f-with_hlist" "-fwith_parsec" "-fwith_split"
       ];
       libraryHaskellDepends = [
         base containers directory hint mtl network old-locale old-time
         parsec process random regex-posix split unix X11 xmonad
         xmonad-contrib
       ];
       homepage = "http://projects.haskell.org/xmonad-extras";
       description = "Third party extensions for xmonad with wacky dependencies";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xmonad-screenshot" = callPackage
    ({ mkDerivation, base, gtk, xmonad }:
     mkDerivation {
       pname = "xmonad-screenshot";
       version = "0.1.2";
       sha256 = "21f325c9633e56de0bc0fd420d38292d3ded2b95b6fa1029759cdac060abebd4";
       libraryHaskellDepends = [ base gtk xmonad ];
       homepage = "https://github.com/supki/xmonad-screenshot";
       description = "Workspaces screenshooting utility for XMonad";
       license = stdenv.lib.licenses.mit;
     }) {};

  "xmonad-utils" = callPackage
    ({ mkDerivation, base, ghc, random, unix, X11 }:
     mkDerivation {
       pname = "xmonad-utils";
       version = "0.1.3.3";
       sha256 = "45a5db08e2e8fce4a11f929107c29d5073b897cbe83af0ea24ee2e691b72e2f8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base ghc random unix X11 ];
       homepage = "https://github.com/LeifW/xmonad-utils";
       description = "A small collection of X utilities";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "xmonad-wallpaper" = callPackage
    ({ mkDerivation, base, magic, mtl, random, unix, xmonad }:
     mkDerivation {
       pname = "xmonad-wallpaper";
       version = "0.0.1.2";
       sha256 = "b02e1c7a524dd9cf28d5cff6933194fe245fa4e9247f701ec87195a20a8cf265";
       libraryHaskellDepends = [ base magic mtl random unix xmonad ];
       jailbreak = true;
       description = "xmonad wallpaper extension";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "xmonad-windownames" = callPackage
    ({ mkDerivation, base, containers, utf8-string, xmonad
     , xmonad-contrib
     }:
     mkDerivation {
       pname = "xmonad-windownames";
       version = "0.1.0.1";
       sha256 = "3519dd0ede27ecba3a0694f81e39d2e41fab1144170cb98a3b6e086e270aa885";
       libraryHaskellDepends = [
         base containers utf8-string xmonad xmonad-contrib
       ];
       jailbreak = true;
       homepage = "https://github.com/plindbe2/xmonad-windownames";
       description = "A library to automatically put named windows into the DynamicLog";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xmpipe" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, handle-like
     , monads-tf, sasl, simple-pipe, uuid, xml-pipe
     }:
     mkDerivation {
       pname = "xmpipe";
       version = "0.0.0.4";
       sha256 = "3c0a17c3621c6a1f7a783484c821c05207cc3152bbf99f4f02838f845d0de125";
       libraryHaskellDepends = [
         base base64-bytestring bytestring handle-like monads-tf sasl
         simple-pipe uuid xml-pipe
       ];
       homepage = "https://github.com/YoshikuniJujo/xmpipe/wiki";
       description = "XMPP implementation using simple-PIPE";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xorshift" = callPackage
    ({ mkDerivation, base, random, time }:
     mkDerivation {
       pname = "xorshift";
       version = "2.0.1";
       sha256 = "2e975d3e0b35acce5297363d41440ae2f856261dbce851e1880ce5f8b465f3dd";
       libraryHaskellDepends = [ base random time ];
       description = "Haskell implementation of the xorshift random generator";
       license = "LGPL";
     }) {};

  "xosd" = callPackage
    ({ mkDerivation, base, xosd }:
     mkDerivation {
       pname = "xosd";
       version = "0.2.1";
       sha256 = "3bc30d33a42f3bed7299258ba8a2babf7cc61fba9ee7fe7397206e640c3112c8";
       libraryHaskellDepends = [ base ];
       librarySystemDepends = [ xosd ];
       homepage = "http://code.haskell.org/~dons/code/xosd";
       description = "A binding to the X on-screen display";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {inherit (pkgs) xosd;};

  "xournal-builder" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, double-conversion
     , strict, xournal-types
     }:
     mkDerivation {
       pname = "xournal-builder";
       version = "0.1.1.1";
       sha256 = "2195cacba3622c037e5a13ad3d3c391b42d81a257cc11fffd2f521913d74f46c";
       libraryHaskellDepends = [
         base blaze-builder bytestring double-conversion strict
         xournal-types
       ];
       jailbreak = true;
       description = "text builder for xournal file format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xournal-convert" = callPackage
    ({ mkDerivation, base, bytestring, cairo, cmdargs, directory
     , filepath, HStringTemplate, mtl, xournal-parser, xournal-render
     , xournal-types
     }:
     mkDerivation {
       pname = "xournal-convert";
       version = "0.1.1";
       sha256 = "b1426d06bf046bf07384e0e93e8e6c768855409268f8ce8c9212e1354b9fdeef";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring cairo cmdargs directory filepath HStringTemplate
         mtl xournal-parser xournal-render xournal-types
       ];
       executableHaskellDepends = [ base cmdargs ];
       jailbreak = true;
       homepage = "http://ianwookim.org/hxournal";
       description = "convert utility for xoj files";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xournal-parser" = callPackage
    ({ mkDerivation, attoparsec, attoparsec-conduit, base, bytestring
     , conduit, conduit-extra, containers, exceptions, lens, mtl, strict
     , text, transformers, xml-conduit, xml-types, xournal-types
     , zlib-conduit
     }:
     mkDerivation {
       pname = "xournal-parser";
       version = "0.5.1";
       sha256 = "e8f43a9d6086d76242a6002db0633e0f30ca1fff866f02866d5e4b8da97b611d";
       libraryHaskellDepends = [
         attoparsec attoparsec-conduit base bytestring conduit conduit-extra
         containers exceptions lens mtl strict text transformers xml-conduit
         xml-types xournal-types zlib-conduit
       ];
       homepage = "http://ianwookim.org/hoodle";
       description = "Xournal file parser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xournal-render" = callPackage
    ({ mkDerivation, base, bytestring, cairo, containers, fclabels, mtl
     , poppler, strict, TypeCompose, xournal-types
     }:
     mkDerivation {
       pname = "xournal-render";
       version = "0.6.0";
       sha256 = "c3a9a8d181df6b0f7a9078d61a84c4bfa368a3ce03b11b7a3b0bfed8bf94513b";
       libraryHaskellDepends = [
         base bytestring cairo containers fclabels mtl poppler strict
         TypeCompose xournal-types
       ];
       jailbreak = true;
       description = "Xournal file renderer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xournal-types" = callPackage
    ({ mkDerivation, base, bytestring, cereal, containers, lens, strict
     , TypeCompose
     }:
     mkDerivation {
       pname = "xournal-types";
       version = "0.5.1.0";
       sha256 = "b0e8d4194af0397bdd76352e1174b61947343dfcced21bef062598fb058e69cb";
       revision = "1";
       editedCabalFile = "d6fdc2ac2b741597d72cc1a5ef1fad122858a96212df461e3a97540eeceb78fb";
       libraryHaskellDepends = [
         base bytestring cereal containers lens strict TypeCompose
       ];
       description = "Data types for programs for xournal file format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xsact" = callPackage
    ({ mkDerivation, array, base, containers, directory, process
     , random, unix
     }:
     mkDerivation {
       pname = "xsact";
       version = "1.7.3";
       sha256 = "107cafa5bfb37f2c82594b802181393b1a9ad8832c82b75432d70d3933dc1aa0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory process random unix
       ];
       jailbreak = true;
       homepage = "http://malde.org/~ketil/";
       description = "Cluster EST sequences";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xsd" = callPackage
    ({ mkDerivation, attoparsec, base, directory, doctest, filepath
     , lens, QuickCheck, quickcheck-instances, text, time
     }:
     mkDerivation {
       pname = "xsd";
       version = "0.5.0.1";
       sha256 = "600229acbc0c556ae87e745ad0585a4449ea2f7d728a7b2538b1d4795b14b1a8";
       libraryHaskellDepends = [ attoparsec base lens text time ];
       testHaskellDepends = [
         base directory doctest filepath QuickCheck quickcheck-instances
       ];
       homepage = "https://github.com/tonymorris/xsd";
       description = "XML Schema data structures";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xsha1" = callPackage
    ({ mkDerivation, base, HUnit, QuickCheck, uniplate, vector }:
     mkDerivation {
       pname = "xsha1";
       version = "0.0.0";
       sha256 = "b1e68894cb682655c2cd6dec547d7d01bf48eea5a3aa9621bb73eb8c58659276";
       libraryHaskellDepends = [ base HUnit QuickCheck uniplate vector ];
       description = "cryptanalysis of Blizzard's broken SHA-1 implementation";
       license = stdenv.lib.licenses.mit;
     }) {};

  "xslt" = callPackage
    ({ mkDerivation, base, libxml, xslt }:
     mkDerivation {
       pname = "xslt";
       version = "0.1";
       sha256 = "881862ae1c77bf5a1a7f7132d1fbcc19633331c6b061bac4dc46ca0c268c0344";
       libraryHaskellDepends = [ base libxml ];
       librarySystemDepends = [ xslt ];
       description = "Binding to libxslt";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {xslt = null;};

  "xss-sanitize_0_3_5_4" = callPackage
    ({ mkDerivation, attoparsec, base, containers, css-text, hspec
     , HUnit, network-uri, tagsoup, text, utf8-string
     }:
     mkDerivation {
       pname = "xss-sanitize";
       version = "0.3.5.4";
       sha256 = "ee79b68cf79b94a341c461cc6835e10e546ec781405173cc3341484d86902dc1";
       libraryHaskellDepends = [
         attoparsec base containers css-text network-uri tagsoup text
         utf8-string
       ];
       testHaskellDepends = [
         attoparsec base containers css-text hspec HUnit network-uri tagsoup
         text utf8-string
       ];
       jailbreak = true;
       homepage = "http://github.com/yesodweb/haskell-xss-sanitize";
       description = "sanitize untrusted HTML to prevent XSS attacks";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xss-sanitize_0_3_5_5" = callPackage
    ({ mkDerivation, attoparsec, base, containers, css-text, hspec
     , HUnit, network-uri, tagsoup, text, utf8-string
     }:
     mkDerivation {
       pname = "xss-sanitize";
       version = "0.3.5.5";
       sha256 = "42930cf564da3cead031b6cd67f613c444d25511356fbc2df8c5b7054a831517";
       libraryHaskellDepends = [
         attoparsec base containers css-text network-uri tagsoup text
         utf8-string
       ];
       testHaskellDepends = [
         attoparsec base containers css-text hspec HUnit network-uri tagsoup
         text utf8-string
       ];
       homepage = "http://github.com/yesodweb/haskell-xss-sanitize";
       description = "sanitize untrusted HTML to prevent XSS attacks";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "xss-sanitize" = callPackage
    ({ mkDerivation, attoparsec, base, containers, css-text, hspec
     , HUnit, network-uri, tagsoup, text, utf8-string
     }:
     mkDerivation {
       pname = "xss-sanitize";
       version = "0.3.5.6";
       sha256 = "008a20e0266f7e4255cb6009336bc25cfe74eda3314dff4f0da0bbd584cd58c8";
       libraryHaskellDepends = [
         attoparsec base containers css-text network-uri tagsoup text
         utf8-string
       ];
       testHaskellDepends = [
         attoparsec base containers css-text hspec HUnit network-uri tagsoup
         text utf8-string
       ];
       homepage = "http://github.com/yesodweb/haskell-xss-sanitize";
       description = "sanitize untrusted HTML to prevent XSS attacks";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xtc" = callPackage
    ({ mkDerivation, base, wx, wxcore }:
     mkDerivation {
       pname = "xtc";
       version = "1.0.1";
       sha256 = "54396ce106a2986b7468c6ef5624cd1e135405f36d1c3c73340296ce161eda49";
       libraryHaskellDepends = [ base wx wxcore ];
       homepage = "http://github.com/alanz/xtc";
       description = "eXtended & Typed Controls for wxHaskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "xtest" = callPackage
    ({ mkDerivation, base, libXtst, X11 }:
     mkDerivation {
       pname = "xtest";
       version = "0.2";
       sha256 = "67f60aab2bc7cfc944335c7b308c7dcf15b49e3d2074f071dbfa36af4fef1d85";
       libraryHaskellDepends = [ base X11 ];
       librarySystemDepends = [ libXtst ];
       description = "Thin FFI bindings to X11 XTest library";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs.xorg) libXtst;};

  "xturtle" = callPackage
    ({ mkDerivation, base, convertible, Imlib, setlocale, X11, X11-xft
     , x11-xim, yjsvg, yjtools
     }:
     mkDerivation {
       pname = "xturtle";
       version = "0.1.25";
       sha256 = "adbee9e0c52ceab301a63f129af1962e4ff766e603d77e8b9e53fcf5b7bb2e98";
       revision = "1";
       editedCabalFile = "30df4bd906dac728e4ef75b339d6802b59abe1f1f49e346e6cdc54929f147c1c";
       libraryHaskellDepends = [
         base convertible Imlib setlocale X11 X11-xft x11-xim yjsvg yjtools
       ];
       jailbreak = true;
       description = "turtle like LOGO";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "xxhash" = callPackage
    ({ mkDerivation, base, bytestring, crypto-api, hspec, QuickCheck
     , tagged
     }:
     mkDerivation {
       pname = "xxhash";
       version = "0.0.1";
       sha256 = "b645bff86157f46c8a1194c59bcaa6c182ded708c66a290d50041831f7dc3533";
       revision = "1";
       editedCabalFile = "1d641797e9e431c6152dc41cbe72551bb2f91cec8265d3a5e3b2b9718764d274";
       libraryHaskellDepends = [ base bytestring crypto-api tagged ];
       testHaskellDepends = [ base bytestring hspec QuickCheck ];
       jailbreak = true;
       description = "A Haskell implementation of the xxHash algorithm";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "y0l0bot" = callPackage
    ({ mkDerivation, base, bytestring, containers, mtl, network
     , old-locale, old-time, safe, split, text, time
     }:
     mkDerivation {
       pname = "y0l0bot";
       version = "0.1.1";
       sha256 = "69cfcd47589ef502b7e1a383a402ab6258224694f166751c15399e7e0bb55b3e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers mtl network old-locale old-time safe
         split text time
       ];
       jailbreak = true;
       description = "#plaimi's all-encompassing bot";
       license = stdenv.lib.licenses.agpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yabi" = callPackage
    ({ mkDerivation, base, word8 }:
     mkDerivation {
       pname = "yabi";
       version = "0.1.1.0";
       sha256 = "6b09c5334e1ed2f3294861813ad3f875a3e1bd77c0cbb953fffbd51a6ab05b15";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base word8 ];
       homepage = "https://github.com/fgaz/yabi";
       description = "Yet Another Brainfuck Interpreter";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yabi-muno" = callPackage
    ({ mkDerivation, base, bytestring, containers, lens, mtl
     , mtl-compat, parsec
     }:
     mkDerivation {
       pname = "yabi-muno";
       version = "0.1.0.1";
       sha256 = "4f823cecb1beda83d95148f3b13535fcb07c3b6e6d5583e32052cdcb156e3699";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers lens mtl mtl-compat parsec
       ];
       executableHaskellDepends = [ base containers mtl parsec ];
       jailbreak = true;
       description = "Yet Another Brainfuck Interpreter";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yackage_0_7_0_5" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, bytestring, Cabal
     , cmdargs, conduit, containers, directory, hamlet, http-conduit
     , http-types, shakespeare, tar, text, transformers
     , unordered-containers, vector, wai, warp, yaml, yesod-core
     , yesod-form, zlib
     }:
     mkDerivation {
       pname = "yackage";
       version = "0.7.0.5";
       sha256 = "c97fdc56909f1888763fdf5256e87a21f5a995133dae400c3cf02d44474c769d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-builder blaze-html bytestring Cabal cmdargs conduit
         containers directory hamlet http-conduit http-types shakespeare tar
         text transformers unordered-containers vector wai warp yaml
         yesod-core yesod-form zlib
       ];
       homepage = "http://github.com/snoyberg/yackage";
       description = "Personal Hackage replacement for testing new packages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yackage_0_7_0_6" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, bytestring, Cabal
     , cmdargs, conduit, containers, directory, http-conduit, http-types
     , shakespeare, tar, text, transformers, unordered-containers
     , vector, wai, warp, yaml, yesod-core, yesod-form, zlib
     }:
     mkDerivation {
       pname = "yackage";
       version = "0.7.0.6";
       sha256 = "9e1ed1663b552ce5888bd7bb38984f0aa4403b5ec92ed2a4ddbd041286a51c30";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-builder blaze-html bytestring Cabal cmdargs conduit
         containers directory http-conduit http-types shakespeare tar text
         transformers unordered-containers vector wai warp yaml yesod-core
         yesod-form zlib
       ];
       homepage = "http://github.com/snoyberg/yackage";
       description = "Personal Hackage replacement for testing new packages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yackage_0_7_0_7" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, bytestring, Cabal
     , cmdargs, conduit, containers, directory, http-conduit, http-types
     , shakespeare, tar, text, transformers, unordered-containers
     , vector, wai, warp, yaml, yesod-core, yesod-form, zlib
     }:
     mkDerivation {
       pname = "yackage";
       version = "0.7.0.7";
       sha256 = "e19a4b1a7723b70a2d11f4d2c2b9f3026163bf7ab41c57399824550505650d99";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-builder blaze-html bytestring Cabal cmdargs conduit
         containers directory http-conduit http-types shakespeare tar text
         transformers unordered-containers vector wai warp yaml yesod-core
         yesod-form zlib
       ];
       homepage = "http://github.com/snoyberg/yackage";
       description = "Personal Hackage replacement for testing new packages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yackage_0_7_0_8" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, bytestring, Cabal
     , cmdargs, conduit, containers, directory, http-conduit, http-types
     , shakespeare, tar, text, transformers, unordered-containers
     , vector, wai, warp, yaml, yesod-core, yesod-form, zlib
     }:
     mkDerivation {
       pname = "yackage";
       version = "0.7.0.8";
       sha256 = "6c9075710d8ae24738b1adb467dfcd21e22e932dc2d306a22338766e29dee7f2";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-builder blaze-html bytestring Cabal cmdargs conduit
         containers directory http-conduit http-types shakespeare tar text
         transformers unordered-containers vector wai warp yaml yesod-core
         yesod-form zlib
       ];
       homepage = "http://github.com/snoyberg/yackage";
       description = "Personal Hackage replacement for testing new packages";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yackage" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, bytestring, Cabal
     , cmdargs, conduit, containers, directory, http-conduit, http-types
     , shakespeare, tar, text, transformers, unordered-containers
     , vector, wai, warp, yaml, yesod-core, yesod-form, zlib
     }:
     mkDerivation {
       pname = "yackage";
       version = "0.8.0";
       sha256 = "b42c5fe3b93dbb4c900f462c60e5f6286aed679664e8a4ccdddae7f56f042015";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-builder blaze-html bytestring Cabal cmdargs conduit
         containers directory http-conduit http-types shakespeare tar text
         transformers unordered-containers vector wai warp yaml yesod-core
         yesod-form zlib
       ];
       homepage = "http://github.com/snoyberg/yackage";
       description = "Personal Hackage replacement for testing new packages";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yahoo-finance-conduit" = callPackage
    ({ mkDerivation, attoparsec, base, cassava, conduit, lens, mtl
     , text, vector, wreq
     }:
     mkDerivation {
       pname = "yahoo-finance-conduit";
       version = "0.1.0.0";
       sha256 = "b1056bf70e914ae674b58f93f2dca0780d45ca7065e36ca711fa5182a8087acf";
       libraryHaskellDepends = [
         attoparsec base cassava conduit lens mtl text vector wreq
       ];
       jailbreak = true;
       description = "Streaming aproach to the yahoo finance api";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yahoo-web-search" = callPackage
    ({ mkDerivation, base, HTTP, network, xml }:
     mkDerivation {
       pname = "yahoo-web-search";
       version = "0.2";
       sha256 = "93399fbcf15f5b621ad1d172278c7997a37a113384eb98604cffc349fa549818";
       libraryHaskellDepends = [ base HTTP network xml ];
       homepage = "http://www.people.fas.harvard.edu/~stewart5/code/yahoo-web-search";
       description = "Yahoo Web Search Services";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yajl" = callPackage
    ({ mkDerivation, base, bytestring, c2hs, text, yajl }:
     mkDerivation {
       pname = "yajl";
       version = "0.3.2";
       sha256 = "7376f1557d4d18ad0181e917d551205320256609893e2a43f55f08a66834281c";
       libraryHaskellDepends = [ base bytestring text ];
       librarySystemDepends = [ yajl ];
       libraryToolDepends = [ c2hs ];
       homepage = "https://john-millikin.com/software/haskell-yajl/";
       description = "Bindings for YAJL, an event-based JSON implementation";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) yajl;};

  "yajl-enumerator" = callPackage
    ({ mkDerivation, base, bytestring, enumerator, json-types, text
     , transformers, yajl
     }:
     mkDerivation {
       pname = "yajl-enumerator";
       version = "0.4.1";
       sha256 = "b2f1b2fc02d78d6922aed1db06da91e9e0c7b10067edfacf7ca35e8c0a0de837";
       libraryHaskellDepends = [
         base bytestring enumerator json-types text transformers yajl
       ];
       jailbreak = true;
       homepage = "https://john-millikin.com/software/haskell-yajl/";
       description = "Enumerator-based interface to YAJL, an event-based JSON implementation";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yall" = callPackage
    ({ mkDerivation, base, categories, transformers }:
     mkDerivation {
       pname = "yall";
       version = "0.2.1";
       sha256 = "5ad43611cb77c095fca4bb11bb3b6713e6e648c3bc9a1906e5f72730283c3d8c";
       libraryHaskellDepends = [ base categories transformers ];
       homepage = "http://brandon.si/code/yall/";
       description = "Lenses with a southern twang";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yamemo" = callPackage
    ({ mkDerivation, base, containers, mtl }:
     mkDerivation {
       pname = "yamemo";
       version = "0.6.0";
       sha256 = "f6f97c9c6ea3eb915cd742d4545c1dec636396608f889a2f2d91c856a24b108b";
       libraryHaskellDepends = [ base containers mtl ];
       description = "Simple memoisation function";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yaml_0_8_10_1" = callPackage
    ({ mkDerivation, aeson, aeson-qq, attoparsec, base, bytestring
     , conduit, containers, directory, enclosed-exceptions, filepath
     , hspec, hspec-expectations, HUnit, libyaml, resourcet, scientific
     , text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "yaml";
       version = "0.8.10.1";
       sha256 = "e977912762e13571ec596173405ce328c8f7397aee4dd21f61ac9af762431ba9";
       configureFlags = [ "-fsystem-libyaml" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring conduit containers directory
         enclosed-exceptions filepath resourcet scientific text transformers
         unordered-containers vector
       ];
       libraryPkgconfigDepends = [ libyaml ];
       executableHaskellDepends = [ aeson base bytestring ];
       testHaskellDepends = [
         aeson aeson-qq base bytestring conduit directory hspec
         hspec-expectations HUnit resourcet text transformers
         unordered-containers vector
       ];
       homepage = "http://github.com/snoyberg/yaml/";
       description = "Support for parsing and rendering YAML documents";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libyaml;};

  "yaml_0_8_11" = callPackage
    ({ mkDerivation, aeson, aeson-qq, attoparsec, base, bytestring
     , conduit, containers, directory, enclosed-exceptions, filepath
     , hspec, hspec-expectations, HUnit, libyaml, resourcet, scientific
     , text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "yaml";
       version = "0.8.11";
       sha256 = "3b9c70c1cd01f0d232b594703e940268575d5656194533c8b46f28c64d5259a1";
       configureFlags = [ "-fsystem-libyaml" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring conduit containers directory
         enclosed-exceptions filepath resourcet scientific text transformers
         unordered-containers vector
       ];
       libraryPkgconfigDepends = [ libyaml ];
       executableHaskellDepends = [ aeson base bytestring ];
       testHaskellDepends = [
         aeson aeson-qq base bytestring conduit directory hspec
         hspec-expectations HUnit resourcet text transformers
         unordered-containers vector
       ];
       homepage = "http://github.com/snoyberg/yaml/";
       description = "Support for parsing and rendering YAML documents";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libyaml;};

  "yaml_0_8_12" = callPackage
    ({ mkDerivation, aeson, aeson-qq, attoparsec, base, base-compat
     , bytestring, conduit, containers, directory, enclosed-exceptions
     , filepath, hspec, HUnit, libyaml, mockery, resourcet, scientific
     , text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "yaml";
       version = "0.8.12";
       sha256 = "311df4961499b7ea4899c787a1e64efff70f1a6cb2e00fb15c626b806c60b75a";
       configureFlags = [ "-fsystem-libyaml" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring conduit containers directory
         enclosed-exceptions filepath resourcet scientific text transformers
         unordered-containers vector
       ];
       libraryPkgconfigDepends = [ libyaml ];
       executableHaskellDepends = [ aeson base bytestring ];
       testHaskellDepends = [
         aeson aeson-qq base base-compat bytestring conduit hspec HUnit
         mockery resourcet text transformers unordered-containers vector
       ];
       homepage = "http://github.com/snoyberg/yaml/";
       description = "Support for parsing and rendering YAML documents";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libyaml;};

  "yaml_0_8_13" = callPackage
    ({ mkDerivation, aeson, aeson-qq, attoparsec, base, base-compat
     , bytestring, conduit, containers, directory, enclosed-exceptions
     , filepath, hspec, HUnit, libyaml, mockery, resourcet, scientific
     , text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "yaml";
       version = "0.8.13";
       sha256 = "f366bdd6ddbc5f94f3f783b502178dcd27afc257bdf5e8d67fcf9246aeed0f7a";
       configureFlags = [ "-fsystem-libyaml" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring conduit containers directory
         enclosed-exceptions filepath resourcet scientific text transformers
         unordered-containers vector
       ];
       libraryPkgconfigDepends = [ libyaml ];
       executableHaskellDepends = [ aeson base bytestring ];
       testHaskellDepends = [
         aeson aeson-qq base base-compat bytestring conduit hspec HUnit
         mockery resourcet text transformers unordered-containers vector
       ];
       homepage = "http://github.com/snoyberg/yaml/";
       description = "Support for parsing and rendering YAML documents";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libyaml;};

  "yaml_0_8_14" = callPackage
    ({ mkDerivation, aeson, aeson-qq, attoparsec, base, base-compat
     , bytestring, conduit, containers, directory, enclosed-exceptions
     , filepath, hspec, HUnit, libyaml, mockery, resourcet, scientific
     , text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "yaml";
       version = "0.8.14";
       sha256 = "f40d2c54dd4be0616e1dde897c7388cdb5882f0f7545b37bb3c966fc96bcf69a";
       configureFlags = [ "-fsystem-libyaml" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring conduit containers directory
         enclosed-exceptions filepath resourcet scientific text transformers
         unordered-containers vector
       ];
       libraryPkgconfigDepends = [ libyaml ];
       executableHaskellDepends = [ aeson base bytestring ];
       testHaskellDepends = [
         aeson aeson-qq base base-compat bytestring conduit hspec HUnit
         mockery resourcet text transformers unordered-containers vector
       ];
       homepage = "http://github.com/snoyberg/yaml/";
       description = "Support for parsing and rendering YAML documents";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libyaml;};

  "yaml_0_8_15_1" = callPackage
    ({ mkDerivation, aeson, aeson-qq, attoparsec, base, base-compat
     , bytestring, conduit, containers, directory, enclosed-exceptions
     , filepath, hspec, HUnit, libyaml, mockery, resourcet, scientific
     , text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "yaml";
       version = "0.8.15.1";
       sha256 = "1db2b881cce7a22f2179e05cdcb9294aac09e9c9f882b1fa4fa9bedacb20cc6c";
       configureFlags = [ "-fsystem-libyaml" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring conduit containers directory
         enclosed-exceptions filepath resourcet scientific text transformers
         unordered-containers vector
       ];
       libraryPkgconfigDepends = [ libyaml ];
       executableHaskellDepends = [ aeson base bytestring ];
       testHaskellDepends = [
         aeson aeson-qq base base-compat bytestring conduit hspec HUnit
         mockery resourcet text transformers unordered-containers vector
       ];
       homepage = "http://github.com/snoyberg/yaml/";
       description = "Support for parsing and rendering YAML documents";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libyaml;};

  "yaml_0_8_15_2" = callPackage
    ({ mkDerivation, aeson, aeson-qq, attoparsec, base, base-compat
     , bytestring, conduit, containers, directory, enclosed-exceptions
     , filepath, hspec, HUnit, libyaml, mockery, resourcet, scientific
     , text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "yaml";
       version = "0.8.15.2";
       sha256 = "ec5e9402e96590842bb77d6b66003a2289b4ab415aeb25362ef8f6c370a32712";
       configureFlags = [ "-fsystem-libyaml" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring conduit containers directory
         enclosed-exceptions filepath resourcet scientific text transformers
         unordered-containers vector
       ];
       libraryPkgconfigDepends = [ libyaml ];
       executableHaskellDepends = [ aeson base bytestring ];
       testHaskellDepends = [
         aeson aeson-qq base base-compat bytestring conduit hspec HUnit
         mockery resourcet text transformers unordered-containers vector
       ];
       homepage = "http://github.com/snoyberg/yaml/";
       description = "Support for parsing and rendering YAML documents";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libyaml;};

  "yaml_0_8_15_3" = callPackage
    ({ mkDerivation, aeson, aeson-qq, attoparsec, base, base-compat
     , bytestring, conduit, containers, directory, enclosed-exceptions
     , filepath, hspec, HUnit, libyaml, mockery, resourcet, scientific
     , text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "yaml";
       version = "0.8.15.3";
       sha256 = "f90444f327d8bbcbcab7a99bacbc79236528daf2a1e98aed03d146f1a2202a10";
       configureFlags = [ "-fsystem-libyaml" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring conduit containers directory
         enclosed-exceptions filepath resourcet scientific text transformers
         unordered-containers vector
       ];
       libraryPkgconfigDepends = [ libyaml ];
       executableHaskellDepends = [ aeson base bytestring ];
       testHaskellDepends = [
         aeson aeson-qq base base-compat bytestring conduit hspec HUnit
         mockery resourcet text transformers unordered-containers vector
       ];
       homepage = "http://github.com/snoyberg/yaml/";
       description = "Support for parsing and rendering YAML documents";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libyaml;};

  "yaml" = callPackage
    ({ mkDerivation, aeson, aeson-qq, attoparsec, base, base-compat
     , bytestring, conduit, containers, directory, enclosed-exceptions
     , filepath, hspec, HUnit, libyaml, mockery, resourcet, scientific
     , semigroups, text, transformers, unordered-containers, vector
     }:
     mkDerivation {
       pname = "yaml";
       version = "0.8.16";
       sha256 = "d68ad3dd16e4b8ba943d0f58666d1f53be24923088df15f46be44bbbaf85c529";
       configureFlags = [ "-fsystem-libyaml" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson attoparsec base bytestring conduit containers directory
         enclosed-exceptions filepath resourcet scientific semigroups text
         transformers unordered-containers vector
       ];
       libraryPkgconfigDepends = [ libyaml ];
       executableHaskellDepends = [ aeson base bytestring ];
       testHaskellDepends = [
         aeson aeson-qq base base-compat bytestring conduit hspec HUnit
         mockery resourcet text transformers unordered-containers vector
       ];
       homepage = "http://github.com/snoyberg/yaml/";
       description = "Support for parsing and rendering YAML documents";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) libyaml;};

  "yaml-config" = callPackage
    ({ mkDerivation, base, deepseq, failure, hashable, QuickCheck
     , tasty, tasty-quickcheck, text, unordered-containers, yaml
     }:
     mkDerivation {
       pname = "yaml-config";
       version = "0.3.0";
       sha256 = "ac4bace7a31441c0b5dfeb6b6e2cf4078d19f000011d1f074106ee01fba11c9c";
       libraryHaskellDepends = [
         base deepseq failure text unordered-containers yaml
       ];
       testHaskellDepends = [
         base deepseq failure hashable QuickCheck tasty tasty-quickcheck
         text unordered-containers yaml
       ];
       description = "Configuration management";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yaml-light" = callPackage
    ({ mkDerivation, base, bytestring, containers, HsSyck }:
     mkDerivation {
       pname = "yaml-light";
       version = "0.1.4";
       sha256 = "1352949bf8aea4950ed2d48ace4efc7b9301bf8c58858b882d47d0902e9efd16";
       libraryHaskellDepends = [ base bytestring containers HsSyck ];
       description = "A light-weight wrapper with utility functions around HsSyck";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yaml-light-lens" = callPackage
    ({ mkDerivation, base, bytestring, bytestring-lexing, containers
     , doctest, lens, yaml-light
     }:
     mkDerivation {
       pname = "yaml-light-lens";
       version = "0.3.3.1";
       sha256 = "a8d82e1e6a32739dce6fa754c3ef18818b8c709a1ce077c3f554cfc745f3a735";
       libraryHaskellDepends = [
         base bytestring bytestring-lexing containers lens yaml-light
       ];
       testHaskellDepends = [ base doctest ];
       description = "Lens interface to yaml-light";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yaml-rpc" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, http-client
     , http-types, lens, template-haskell, text, th-lift, transformers
     , unordered-containers, vector, wreq, yaml
     }:
     mkDerivation {
       pname = "yaml-rpc";
       version = "1.0.3";
       sha256 = "2fe5258d9a1e4d0f9d440dfad9e68f17d30e22fbd6792bdef2bb8f77a0473906";
       libraryHaskellDepends = [
         aeson base bytestring containers http-client http-types lens
         template-haskell text th-lift transformers unordered-containers
         vector wreq yaml
       ];
       homepage = "http://redmine.iportnov.ru/projects/yaml-rpc";
       description = "Simple library for network (HTTP REST-like) YAML RPC";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yaml-rpc-scotty" = callPackage
    ({ mkDerivation, aeson, base, containers, http-types, mmorph
     , scotty, text, transformers, yaml, yaml-rpc
     }:
     mkDerivation {
       pname = "yaml-rpc-scotty";
       version = "1.0.2";
       sha256 = "630d972380f9a306d4131a302e251d5e1ad5af61d0203eea21d9a1d370fc7bcd";
       libraryHaskellDepends = [
         aeson base containers http-types mmorph scotty text transformers
         yaml yaml-rpc
       ];
       homepage = "http://redmine.iportnov.ru/projects/yaml-rpc";
       description = "Scotty server backend for yaml-rpc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yaml-rpc-snap" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, http-types
     , snap, text, transformers, yaml, yaml-rpc
     }:
     mkDerivation {
       pname = "yaml-rpc-snap";
       version = "1.0.3";
       sha256 = "c94697a1801df4d75e9de1b0ac9265f9041be1350e4a11bd216b8347b26b9a9d";
       libraryHaskellDepends = [
         aeson base bytestring containers http-types snap text transformers
         yaml yaml-rpc
       ];
       homepage = "http://redmine.iportnov.ru/projects/yaml-rpc";
       description = "Snap server backend for yaml-rpc";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yaml-union" = callPackage
    ({ mkDerivation, base, bytestring, optparse-applicative
     , unordered-containers, yaml
     }:
     mkDerivation {
       pname = "yaml-union";
       version = "0.0.1";
       sha256 = "b3af25a1e50aa778e5628bce31a4abd5a6c1749a191d9f38549f2e949f8ebd85";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base unordered-containers yaml ];
       executableHaskellDepends = [
         base bytestring optparse-applicative yaml
       ];
       testHaskellDepends = [ base ];
       homepage = "https://github.com/michelk/yaml-overrides.hs";
       description = "Read multiple yaml-files and override fields recursively";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yaml2owl" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, network
     , swish, text, xml, yaml
     }:
     mkDerivation {
       pname = "yaml2owl";
       version = "0.0.1";
       sha256 = "c5e0eadb8c771d67bd617b714f9e124abfdb8ea23f4b0a8b1c50f6d50d66e7fb";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath network swish text xml yaml
       ];
       homepage = "http://github.com/leifw/yaml2owl";
       description = "Generate OWL schema from YAML syntax, and an RDFa template";
       license = "LGPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yamlkeysdiff" = callPackage
    ({ mkDerivation, base, containers, parsec, text
     , unordered-containers, yaml
     }:
     mkDerivation {
       pname = "yamlkeysdiff";
       version = "0.5.1";
       sha256 = "c7ab8af8ba9064ca1213140b13f53a1a579abd29e5aa8e24b897b3de7cc4458f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers parsec text unordered-containers yaml
       ];
       jailbreak = true;
       homepage = "https://github.com/acatton/yamlkeysdiff";
       description = "Compares the keys from two yaml files";
       license = "unknown";
     }) {};

  "yampa-canvas" = callPackage
    ({ mkDerivation, base, blank-canvas, stm, text, time, Yampa }:
     mkDerivation {
       pname = "yampa-canvas";
       version = "0.2.2";
       sha256 = "167c8dc3992d98d879eb281b27a0dbf6fde21ca69992e384df4b5babcdda3e3c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base blank-canvas stm time Yampa ];
       executableHaskellDepends = [ base blank-canvas text Yampa ];
       description = "blank-canvas frontend for Yampa";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yampa-glfw" = callPackage
    ({ mkDerivation, base, GLFW-b, newtype, OpenGL, vector-space, Yampa
     }:
     mkDerivation {
       pname = "yampa-glfw";
       version = "0.1.0.0";
       sha256 = "59d6668fe1455cbdcb1310bc0671e50b924eef2470ce68fc5a29311312fa768c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base GLFW-b newtype OpenGL Yampa ];
       executableHaskellDepends = [
         base GLFW-b newtype OpenGL vector-space Yampa
       ];
       jailbreak = true;
       homepage = "https://github.com/deepfire/yampa-glfw";
       description = "Connects GLFW-b (GLFW 3+) with the Yampa FRP library";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yampa-glut" = callPackage
    ({ mkDerivation, base, GLUT, newtype, OpenGL, vector-space
     , vector-space-opengl, Yampa-core
     }:
     mkDerivation {
       pname = "yampa-glut";
       version = "0.1.1.1";
       sha256 = "f7c2b8aec210261341310f0c63f2eed3f80952077ad907ebff4427902ce4c304";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base GLUT newtype OpenGL vector-space Yampa-core
       ];
       executableHaskellDepends = [
         base GLUT newtype OpenGL vector-space vector-space-opengl
         Yampa-core
       ];
       homepage = "https://github.com/ony/yampa-glut";
       description = "Connects Yampa and GLUT";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yampa2048" = callPackage
    ({ mkDerivation, base, gloss, random, Yampa }:
     mkDerivation {
       pname = "yampa2048";
       version = "0.1.0.0";
       sha256 = "bfe221077d1f7558a7bec1b8174762325055ac48492138c4742432ddbfcdf40e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base gloss random Yampa ];
       jailbreak = true;
       homepage = "https://github.com/ksaveljev/yampa-2048";
       description = "2048 game clone using Yampa/Gloss";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "yaop" = callPackage
    ({ mkDerivation, base, mtl, template-haskell }:
     mkDerivation {
       pname = "yaop";
       version = "0.1.2.1";
       sha256 = "b9dd761ef5840f592ccb58d4bfaa3dd327c874453d45e9f0d37325b4ba73c67c";
       revision = "1";
       editedCabalFile = "5333f04af0a27a0197004dc2e686dbbf29e5e2dc248277eb2afcb7587092a55c";
       libraryHaskellDepends = [ base mtl template-haskell ];
       homepage = "https://github.com/esmolanka/yaop";
       description = "Yet another option parser";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yap" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "yap";
       version = "0.2";
       sha256 = "d18417aca635b9806f437c9476a80fa7633463185b06ff6e28ce3e2813299892";
       libraryHaskellDepends = [ base ];
       jailbreak = true;
       description = "yet another prelude - a simplistic refactoring with algebraic classes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yarr_1_3_3_3" = callPackage
    ({ mkDerivation, base, deepseq, fixed-vector, ghc-prim
     , missing-foreign, primitive, template-haskell
     }:
     mkDerivation {
       pname = "yarr";
       version = "1.3.3.3";
       sha256 = "8714884c30b6c331f86209b777607e15c44d9c360705721e813a54e8c10cd926";
       revision = "1";
       editedCabalFile = "290dde1a67c1de78074c60796f5326cf01668fb109345cd100ff1ac5a5663687";
       libraryHaskellDepends = [
         base deepseq fixed-vector ghc-prim missing-foreign primitive
         template-haskell
       ];
       doHaddock = false;
       jailbreak = true;
       description = "Yet another array library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yarr" = callPackage
    ({ mkDerivation, base, deepseq, fixed-vector, ghc-prim
     , missing-foreign, primitive, template-haskell
     }:
     mkDerivation {
       pname = "yarr";
       version = "1.4.0.1";
       sha256 = "541966833028f1476c7d89a100f4bced4d80d073c8400dc6564b320321f4624e";
       libraryHaskellDepends = [
         base deepseq fixed-vector ghc-prim missing-foreign primitive
         template-haskell
       ];
       jailbreak = true;
       description = "Yet another array library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yarr-image-io" = callPackage
    ({ mkDerivation, base, libdevil, yarr }:
     mkDerivation {
       pname = "yarr-image-io";
       version = "1.3.2.1";
       sha256 = "3da00b3cef4d86c9d8cf9ac768da3fc062cec7e2a1f8ad30f9b02c2e0cffb5f2";
       libraryHaskellDepends = [ base yarr ];
       librarySystemDepends = [ libdevil ];
       jailbreak = true;
       description = "Image IO for Yarr library";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) libdevil;};

  "yate" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, hspec, mtl, scientific
     , template-haskell, text, unordered-containers, vector
     }:
     mkDerivation {
       pname = "yate";
       version = "0.1.0.0";
       sha256 = "20275bafdb52ce74f3c3cecb6cbb8925c7d9f40bea74d6872145ff93df49d85d";
       libraryHaskellDepends = [
         aeson attoparsec base mtl scientific template-haskell text
         unordered-containers vector
       ];
       testHaskellDepends = [
         attoparsec base hspec mtl unordered-containers vector
       ];
       jailbreak = true;
       description = "Yet Another Template Engine";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yavie" = callPackage
    ({ mkDerivation, base, Cabal, directory, event-driven, filepath
     , monads-tf, process, regexpr
     }:
     mkDerivation {
       pname = "yavie";
       version = "0.0.1";
       sha256 = "e53f3479210122d1b2fd374d418cf97a828bd9f64a104906cde8af8d26684f40";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base event-driven filepath monads-tf regexpr
       ];
       executableHaskellDepends = [ base Cabal directory process ];
       description = "yet another visual editor";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ycextra" = callPackage
    ({ mkDerivation, base, containers, csv, mtl, uniplate, yhccore }:
     mkDerivation {
       pname = "ycextra";
       version = "0.1";
       sha256 = "a5126ff166497b2e55440de37cf6e8a7a58ddbdcbf633c3117054c76b2784029";
       libraryHaskellDepends = [
         base containers csv mtl uniplate yhccore
       ];
       homepage = "http://www.haskell.org/haskellwiki/Yhc";
       description = "Additional utilities to work with Yhc Core";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yeganesh" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, process
     , strict, time, unix, xdg-basedir
     }:
     mkDerivation {
       pname = "yeganesh";
       version = "2.5";
       sha256 = "6e2f91560e002727877b6a51f012d142a9db2a22ee764f819406d8f2c22efcad";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base containers directory filepath process strict time unix
         xdg-basedir
       ];
       homepage = "http://dmwit.com/yeganesh";
       description = "small dmenu wrapper";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yeller" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, hspec
     , http-client, http-client-tls, http-types, network, stm, text
     , unordered-containers
     }:
     mkDerivation {
       pname = "yeller";
       version = "0.1.0.4";
       sha256 = "72a882c20c42eba7f90a729ef5a727999fe4593935db528d193ba4d295643365";
       libraryHaskellDepends = [
         aeson base bytestring containers http-client http-client-tls
         http-types network stm text unordered-containers
       ];
       testHaskellDepends = [
         aeson base bytestring containers hspec http-client http-client-tls
         http-types network stm text unordered-containers
       ];
       jailbreak = true;
       homepage = "http://yellerapp.com";
       description = "A Yeller Client For Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yes-precure5-command" = callPackage
    ({ mkDerivation, base, Cabal, containers, hspec, mtl, parsec
     , QuickCheck, random
     }:
     mkDerivation {
       pname = "yes-precure5-command";
       version = "5.5.2";
       sha256 = "19ed62fa3277ce1356005bd8715f41526057dd152c9a2c3ab18158431ff0c52a";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal containers mtl parsec random
       ];
       executableHaskellDepends = [
         base Cabal containers mtl parsec random
       ];
       testHaskellDepends = [ base containers hspec QuickCheck ];
       homepage = "https://github.com/igrep/yes-precure5-command/";
       description = "Extended yes command to reproduce phrases in Yes! Precure 5";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod_1_4_1_1" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , conduit-extra, data-default, directory, fast-logger
     , monad-control, monad-logger, safe, semigroups, shakespeare
     , streaming-commons, template-haskell, text, transformers, unix
     , unordered-containers, wai, wai-extra, wai-logger, warp, yaml
     , yesod-auth, yesod-core, yesod-form, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod";
       version = "1.4.1.1";
       sha256 = "bd5f84da159018d1b2adcd6a563235144b7760f70b0a44b54782b22b9f71255d";
       libraryHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring conduit-extra
         data-default directory fast-logger monad-control monad-logger safe
         semigroups shakespeare streaming-commons template-haskell text
         transformers unix unordered-containers wai wai-extra wai-logger
         warp yaml yesod-auth yesod-core yesod-form yesod-persistent
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod_1_4_1_2" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , conduit-extra, data-default, directory, fast-logger
     , monad-control, monad-logger, safe, semigroups, shakespeare
     , streaming-commons, template-haskell, text, transformers, unix
     , unordered-containers, wai, wai-extra, wai-logger, warp, yaml
     , yesod-auth, yesod-core, yesod-form, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod";
       version = "1.4.1.2";
       sha256 = "17b3b9a80ba748920bb2ea0ee1ddcdf3c75af54e469e227cf57b14101d5547d6";
       libraryHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring conduit-extra
         data-default directory fast-logger monad-control monad-logger safe
         semigroups shakespeare streaming-commons template-haskell text
         transformers unix unordered-containers wai wai-extra wai-logger
         warp yaml yesod-auth yesod-core yesod-form yesod-persistent
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod_1_4_1_3" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , conduit-extra, data-default, directory, fast-logger
     , monad-control, monad-logger, safe, semigroups, shakespeare
     , streaming-commons, template-haskell, text, transformers, unix
     , unordered-containers, wai, wai-extra, wai-logger, warp, yaml
     , yesod-auth, yesod-core, yesod-form, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod";
       version = "1.4.1.3";
       sha256 = "b2cfaadec2f8352f1906e06e8cdcd2cd57f8a035af8bd2b7585afa4a5ddd00fc";
       libraryHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring conduit-extra
         data-default directory fast-logger monad-control monad-logger safe
         semigroups shakespeare streaming-commons template-haskell text
         transformers unix unordered-containers wai wai-extra wai-logger
         warp yaml yesod-auth yesod-core yesod-form yesod-persistent
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod_1_4_1_4" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , conduit-extra, data-default, directory, fast-logger
     , monad-control, monad-logger, safe, semigroups, shakespeare
     , streaming-commons, template-haskell, text, transformers, unix
     , unordered-containers, wai, wai-extra, wai-logger, warp, yaml
     , yesod-auth, yesod-core, yesod-form, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod";
       version = "1.4.1.4";
       sha256 = "3dd4ac0b61ac117a8b37ef5f8abd0bef25944ac25ee04fb14bbe60ab6cd166ab";
       libraryHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring conduit-extra
         data-default directory fast-logger monad-control monad-logger safe
         semigroups shakespeare streaming-commons template-haskell text
         transformers unix unordered-containers wai wai-extra wai-logger
         warp yaml yesod-auth yesod-core yesod-form yesod-persistent
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod_1_4_1_5" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , conduit-extra, data-default, directory, fast-logger
     , monad-control, monad-logger, safe, semigroups, shakespeare
     , streaming-commons, template-haskell, text, transformers, unix
     , unordered-containers, wai, wai-extra, wai-logger, warp, yaml
     , yesod-auth, yesod-core, yesod-form, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod";
       version = "1.4.1.5";
       sha256 = "a1160d366cf2c91502bcd5c8f251041ec8a1bc962729c95d5bc572dbe9f8296b";
       libraryHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring conduit-extra
         data-default directory fast-logger monad-control monad-logger safe
         semigroups shakespeare streaming-commons template-haskell text
         transformers unix unordered-containers wai wai-extra wai-logger
         warp yaml yesod-auth yesod-core yesod-form yesod-persistent
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, blaze-markup, bytestring
     , conduit-extra, data-default, directory, fast-logger
     , monad-control, monad-logger, safe, semigroups, shakespeare
     , streaming-commons, template-haskell, text, transformers, unix
     , unordered-containers, wai, wai-extra, wai-logger, warp, yaml
     , yesod-auth, yesod-core, yesod-form, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod";
       version = "1.4.2";
       sha256 = "d6d13e608af954de23721261b39ee79569907beb173477db8820acc5e9f45757";
       libraryHaskellDepends = [
         aeson base blaze-html blaze-markup bytestring conduit-extra
         data-default directory fast-logger monad-control monad-logger safe
         semigroups shakespeare streaming-commons template-haskell text
         transformers unix unordered-containers wai wai-extra wai-logger
         warp yaml yesod-auth yesod-core yesod-form yesod-persistent
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-angular" = callPackage
    ({ mkDerivation, aeson, base, containers, shakespeare
     , template-haskell, text, transformers, yesod
     }:
     mkDerivation {
       pname = "yesod-angular";
       version = "0.1.0.2";
       sha256 = "27f5f4b53db1474d2d019d84047e73c5ee0da07c55379f76709df0f5fa2a9b1e";
       libraryHaskellDepends = [
         aeson base containers shakespeare template-haskell text
         transformers yesod
       ];
       description = "Angular JS integratoin";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-angular-ui" = callPackage
    ({ mkDerivation, base, blaze-html, containers, directory, hjsmin
     , mtl, resourcet, shakespeare, template-haskell, text, transformers
     , yesod, yesod-core
     }:
     mkDerivation {
       pname = "yesod-angular-ui";
       version = "0.1.1.0";
       sha256 = "13d53d0537abf466649fb535f436081be546b97f4986eb1e6452aeb808473923";
       libraryHaskellDepends = [
         base blaze-html containers directory hjsmin mtl resourcet
         shakespeare template-haskell text transformers yesod yesod-core
       ];
       homepage = "https://github.com/tolysz/yesod-angular-ui";
       description = "Angular Helpers";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth_1_4_1" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, persistent, persistent-template, random, resourcet
     , safe, shakespeare, template-haskell, text, time, transformers
     , unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.1";
       sha256 = "b73d52405c4ff96e46696f9a4b079e695b4fc81fba9cec15080bf245a22d6cdb";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth_1_4_1_1" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, persistent, persistent-template, random, resourcet
     , safe, shakespeare, template-haskell, text, time, transformers
     , unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.1.1";
       sha256 = "be34c2ab1d45e942ce7c2021bd217642b05eb704411b26f02ce151cbb8c779de";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth_1_4_1_2" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, persistent, persistent-template, random, resourcet
     , safe, shakespeare, template-haskell, text, time, transformers
     , unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.1.2";
       sha256 = "05cf7eec7ca16becd7ce248006517a50e6be0d50189a545fed46b9dec6dd54c7";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth_1_4_1_3" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, persistent, persistent-template, random, resourcet
     , safe, shakespeare, template-haskell, text, time, transformers
     , unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.1.3";
       sha256 = "9d35ce558518b0bb7dee098ad10217c0fb5db4aaa8e97bd6a4f79f70ca793534";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth_1_4_2" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, persistent, persistent-template, random, resourcet
     , safe, shakespeare, template-haskell, text, time, transformers
     , unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.2";
       sha256 = "1d819b009f3e14aff48a8674c7685ac1f861852531a853036c8b5a033da10917";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth_1_4_3" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, persistent, persistent-template, random, resourcet
     , safe, shakespeare, template-haskell, text, time, transformers
     , unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.3";
       sha256 = "4be9671db9ec6bb2090398102902971843dc0cd5951371dc124b0566dcafa417";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth_1_4_3_1" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, persistent, persistent-template, random, resourcet
     , safe, shakespeare, template-haskell, text, time, transformers
     , unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.3.1";
       sha256 = "eb4f9b6aa0df995e59dca781efb70bba1d819e5baf644a0b0b3f38aa067a7e22";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth_1_4_4" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, persistent, persistent-template, random, resourcet
     , safe, shakespeare, template-haskell, text, time, transformers
     , unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.4";
       sha256 = "082c34d6e57a1f83a88f69a3b5b8bfd025d0c056c19f106eeb1399d724f0361d";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth_1_4_5" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, persistent, persistent-template, random, resourcet
     , safe, shakespeare, template-haskell, text, time, transformers
     , unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.5";
       sha256 = "b64d6b38573384f066b9ed121f9a945755322de77d313a94ca9b61c9a26eed29";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth_1_4_5_1" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, persistent, persistent-template, random, resourcet
     , safe, shakespeare, template-haskell, text, time, transformers
     , unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.5.1";
       sha256 = "c4d0f3130ee07f0ae13ea1cd084035a35e3bf5269ab74d138c2a0b94818c2f98";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth_1_4_6" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, nonce, persistent, persistent-template, random
     , resourcet, safe, shakespeare, template-haskell, text, time
     , transformers, unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.6";
       sha256 = "5d6c74908daabe5e6d5bdff919d3e8e2bccdf5e599da430135474cbce30d1030";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri nonce persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth_1_4_6_1" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, nonce, persistent, persistent-template, random
     , resourcet, safe, shakespeare, template-haskell, text, time
     , transformers, unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.6.1";
       sha256 = "34654dac0d39e14ac5447f83ef28fef6ec824f3b80cafd2d10f089f10e7c6ae9";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri nonce persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth_1_4_7" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, nonce, persistent, persistent-template, random
     , resourcet, safe, shakespeare, template-haskell, text, time
     , transformers, unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.7";
       sha256 = "7b9cfe4f866cbf3726ebfdfc341e0930c4cc60107d94086950701fa1a6e2be88";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri nonce persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth_1_4_8" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, nonce, persistent, persistent-template, random
     , resourcet, safe, shakespeare, template-haskell, text, time
     , transformers, unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.8";
       sha256 = "65a16bb6fb9601be88ec9af99577800041b455eaa5d0b2f645c618c306587cb2";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri nonce persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth_1_4_11" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, nonce, persistent, persistent-template, random
     , resourcet, safe, shakespeare, template-haskell, text, time
     , transformers, unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.11";
       sha256 = "2bf08ed837a32e98002d5d16c5cd751a6871950e7bcb2e8b12045f6c60071a77";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri nonce persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth" = callPackage
    ({ mkDerivation, aeson, authenticate, base, base16-bytestring
     , base64-bytestring, binary, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, data-default, email-validate, file-embed
     , http-client, http-conduit, http-types, lifted-base, mime-mail
     , network-uri, nonce, persistent, persistent-template, random
     , resourcet, safe, shakespeare, template-haskell, text, time
     , transformers, unordered-containers, wai, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth";
       version = "1.4.12";
       sha256 = "d1baf7dc08ee591fd8ba50a8e64a377a3a8d42575963b44e50ab0c145c2d9fa7";
       libraryHaskellDepends = [
         aeson authenticate base base16-bytestring base64-bytestring binary
         blaze-builder blaze-html blaze-markup byteable bytestring conduit
         conduit-extra containers cryptohash data-default email-validate
         file-embed http-client http-conduit http-types lifted-base
         mime-mail network-uri nonce persistent persistent-template random
         resourcet safe shakespeare template-haskell text time transformers
         unordered-containers wai yesod-core yesod-form yesod-persistent
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Authentication for Yesod";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-auth-account" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, hspec, monad-logger
     , mtl, nonce, persistent, persistent-sqlite, pwstore-fast
     , resourcet, text, xml-conduit, yesod, yesod-auth, yesod-core
     , yesod-form, yesod-persistent, yesod-test
     }:
     mkDerivation {
       pname = "yesod-auth-account";
       version = "1.4.1";
       sha256 = "11a42607a419b36b6c5d2590a5e67538dcc831bbe896b80ffcee25d4673971a1";
       libraryHaskellDepends = [
         base blaze-html bytestring mtl nonce persistent pwstore-fast text
         yesod-auth yesod-core yesod-form yesod-persistent
       ];
       testHaskellDepends = [
         base bytestring hspec monad-logger mtl persistent-sqlite resourcet
         text xml-conduit yesod yesod-auth yesod-test
       ];
       homepage = "https://bitbucket.org/wuzzeb/yesod-auth-account";
       description = "An account authentication plugin for Yesod";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-auth-account-fork" = callPackage
    ({ mkDerivation, aeson, base, blaze-html, bytestring
     , email-validate, hspec, http-types, monad-logger, mtl, nonce
     , persistent, persistent-sqlite, pwstore-fast, random, resourcet
     , tagged, text, xml-conduit, yesod, yesod-auth, yesod-core
     , yesod-form, yesod-persistent, yesod-test
     }:
     mkDerivation {
       pname = "yesod-auth-account-fork";
       version = "2.0.3";
       sha256 = "875b3636d727c4adda822794ac2467bd62088420726341f1259f394086bed950";
       libraryHaskellDepends = [
         aeson base blaze-html bytestring email-validate http-types mtl
         nonce persistent pwstore-fast random tagged text yesod-auth
         yesod-core yesod-form yesod-persistent
       ];
       testHaskellDepends = [
         base bytestring hspec monad-logger mtl persistent-sqlite resourcet
         text xml-conduit yesod yesod-auth yesod-test
       ];
       homepage = "https://github.com/meteficha/yesod-auth-account-fork";
       description = "An account authentication plugin for Yesod";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-auth-basic" = callPackage
    ({ mkDerivation, base, base64-bytestring, bytestring, exceptions
     , hlint, hspec, text, wai, word8, yesod, yesod-test
     }:
     mkDerivation {
       pname = "yesod-auth-basic";
       version = "0.1.0.2";
       sha256 = "aaaf330bc05b86ddd53cf092d48df1279e4bea47f67cbc6a8b67f1308ef39b2c";
       libraryHaskellDepends = [
         base base64-bytestring bytestring exceptions text wai word8 yesod
       ];
       testHaskellDepends = [ base hlint hspec text yesod yesod-test ];
       description = "Yesod Middleware for HTTP Basic Authentication";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-auth-bcrypt" = callPackage
    ({ mkDerivation, base, bcrypt, bytestring, text, yesod-auth
     , yesod-core, yesod-form, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth-bcrypt";
       version = "0.2.0";
       sha256 = "e577b2d58f969e3b55d4029017b161e1afe5b2c4577ea64112d9ba9fc0fceb1a";
       libraryHaskellDepends = [
         base bcrypt bytestring text yesod-auth yesod-core yesod-form
         yesod-persistent
       ];
       homepage = "http://www.yesodweb.com/";
       description = "BCrypt salted and hashed passwords in a database as auth for yesod";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-auth-deskcom" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, byteable
     , bytestring, cipher-aes, cprng-aes, crypto-api, crypto-random
     , cryptohash, data-default, http-conduit, http-types
     , template-haskell, text, time, transformers, yesod-auth
     , yesod-core
     }:
     mkDerivation {
       pname = "yesod-auth-deskcom";
       version = "1.4.0";
       sha256 = "dc80b8f0ef1ff6d76b68c51ee8319452fb77e2aad83c39776d1904e6329f979e";
       libraryHaskellDepends = [
         aeson base base64-bytestring byteable bytestring cipher-aes
         cprng-aes crypto-api crypto-random cryptohash data-default
         http-conduit http-types template-haskell text time transformers
         yesod-auth yesod-core
       ];
       homepage = "https://github.com/prowdsponsor/yesod-auth-deskcom";
       description = "Desk.com remote authentication support for Yesod apps.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-auth-fb_1_6_6" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, fb, http-conduit
     , lifted-base, shakespeare, text, time, transformers, wai
     , yesod-auth, yesod-core, yesod-fb
     }:
     mkDerivation {
       pname = "yesod-auth-fb";
       version = "1.6.6";
       sha256 = "e4f8d184461f58464863bbb712dcd11794ed7accd0cde6153d87c516f32ef302";
       libraryHaskellDepends = [
         aeson base bytestring conduit fb http-conduit lifted-base
         shakespeare text time transformers wai yesod-auth yesod-core
         yesod-fb
       ];
       homepage = "https://github.com/prowdsponsor/yesod-auth-fb";
       description = "Authentication backend for Yesod using Facebook";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-fb" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, fb, http-conduit
     , lifted-base, shakespeare, text, time, transformers, wai
     , yesod-auth, yesod-core, yesod-fb
     }:
     mkDerivation {
       pname = "yesod-auth-fb";
       version = "1.7";
       sha256 = "02c041d0f58c630a2b2f4b3e810722fe71aca60c729770fd47324a9dd4dce4ce";
       libraryHaskellDepends = [
         aeson base bytestring conduit fb http-conduit lifted-base
         shakespeare text time transformers wai yesod-auth yesod-core
         yesod-fb
       ];
       homepage = "https://github.com/prowdsponsor/yesod-auth-fb";
       description = "Authentication backend for Yesod using Facebook";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-auth-hashdb_1_4_1_1" = callPackage
    ({ mkDerivation, base, bytestring, cryptohash, hspec, persistent
     , pwstore-fast, text, yesod-auth, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth-hashdb";
       version = "1.4.1.1";
       sha256 = "919950664b0e8a1faeea1054b8776dce0e474afab6491d6ea90337cd553c632d";
       libraryHaskellDepends = [
         base bytestring cryptohash persistent pwstore-fast text yesod-auth
         yesod-core yesod-form yesod-persistent
       ];
       testHaskellDepends = [ base hspec text ];
       jailbreak = true;
       homepage = "https://github.com/paul-rouse/yesod-auth-hashdb";
       description = "Authentication plugin for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-hashdb_1_4_1_2" = callPackage
    ({ mkDerivation, base, bytestring, cryptohash, hspec, persistent
     , pwstore-fast, text, yesod-auth, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth-hashdb";
       version = "1.4.1.2";
       sha256 = "e8fea1e172ef05391b66d4acce96648dc76ebf5e50a4bd368fd6162c81092be3";
       libraryHaskellDepends = [
         base bytestring cryptohash persistent pwstore-fast text yesod-auth
         yesod-core yesod-form yesod-persistent
       ];
       testHaskellDepends = [ base hspec text ];
       jailbreak = true;
       homepage = "https://github.com/paul-rouse/yesod-auth-hashdb";
       description = "Authentication plugin for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-hashdb_1_4_2" = callPackage
    ({ mkDerivation, base, bytestring, cryptohash, hspec, persistent
     , pwstore-fast, text, yesod-auth, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth-hashdb";
       version = "1.4.2";
       sha256 = "3ae3caa40ee6ee8f65af246a3913bddb05cc8defa11d9ca6132aa8a912e4f05b";
       libraryHaskellDepends = [
         base bytestring cryptohash persistent pwstore-fast text yesod-auth
         yesod-core yesod-form yesod-persistent
       ];
       testHaskellDepends = [ base hspec text ];
       jailbreak = true;
       homepage = "https://github.com/paul-rouse/yesod-auth-hashdb";
       description = "Authentication plugin for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-hashdb_1_4_2_1" = callPackage
    ({ mkDerivation, base, bytestring, cryptohash, hspec, persistent
     , pwstore-fast, text, yesod-auth, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth-hashdb";
       version = "1.4.2.1";
       sha256 = "f4b6bf13c89769824131686d3cb379aafb454afeb95d17d2c233ffdd130188bd";
       libraryHaskellDepends = [
         base bytestring cryptohash persistent pwstore-fast text yesod-auth
         yesod-core yesod-form yesod-persistent
       ];
       testHaskellDepends = [ base hspec text ];
       jailbreak = true;
       homepage = "https://github.com/paul-rouse/yesod-auth-hashdb";
       description = "Authentication plugin for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-hashdb" = callPackage
    ({ mkDerivation, base, bytestring, cryptohash, hspec, persistent
     , pwstore-fast, text, yesod-auth, yesod-core, yesod-form
     , yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-auth-hashdb";
       version = "1.4.2.2";
       sha256 = "d904933fa5172cc330785591eb92fa61a3cb86599c617ff4bdedf348ecad5868";
       libraryHaskellDepends = [
         base bytestring cryptohash persistent pwstore-fast text yesod-auth
         yesod-core yesod-form yesod-persistent
       ];
       testHaskellDepends = [ base hspec text ];
       homepage = "https://github.com/paul-rouse/yesod-auth-hashdb";
       description = "Authentication plugin for Yesod";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-auth-kerberos" = callPackage
    ({ mkDerivation, authenticate-kerberos, base, bytestring
     , shakespeare, text, transformers, yesod-auth, yesod-core
     , yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-kerberos";
       version = "1.4.3";
       sha256 = "b1a84a84615aa018e51fb3b0b618fad2ffe569442dbc7ed2e4f36f9b3fdfbb49";
       libraryHaskellDepends = [
         authenticate-kerberos base bytestring shakespeare text transformers
         yesod-auth yesod-core yesod-form
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Kerberos Authentication for Yesod";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-auth-ldap" = callPackage
    ({ mkDerivation, authenticate-ldap, base, bytestring, hamlet, LDAP
     , text, transformers, yesod-auth, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-ldap";
       version = "0.0.3";
       sha256 = "d3bbbf5c5a57c3846868253fa812c8241c35168e5a6c322f8123da7dc5dc42df";
       libraryHaskellDepends = [
         authenticate-ldap base bytestring hamlet LDAP text transformers
         yesod-auth yesod-core yesod-form
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "LDAP Authentication for Yesod";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-ldap-mediocre" = callPackage
    ({ mkDerivation, aeson, base, LDAP, text, yesod-auth, yesod-core
     , yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-ldap-mediocre";
       version = "0.1.1";
       sha256 = "ecf280a3e185d9864a9924681856fa92e5fe441d02e0f29164c3bc4d9eef430b";
       libraryHaskellDepends = [
         aeson base LDAP text yesod-auth yesod-core yesod-form
       ];
       description = "Very simlple LDAP auth for yesod";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-auth-ldap-native" = callPackage
    ({ mkDerivation, base, either, ldap-client, semigroups, text
     , transformers, yesod-auth, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-ldap-native";
       version = "0.1.0.2";
       sha256 = "f94461b1e26ce682122ee105f537afda8ae6a831810eba8e281bfd56b46cd0e1";
       libraryHaskellDepends = [
         base either ldap-client semigroups text transformers yesod-auth
         yesod-core yesod-form
       ];
       testHaskellDepends = [ base ];
       homepage = "http://github.com/mulderr/yesod-auth-ldap-native";
       description = "Yesod LDAP authentication plugin";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-oauth_1_4_0_1" = callPackage
    ({ mkDerivation, authenticate-oauth, base, bytestring, lifted-base
     , text, transformers, yesod-auth, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-oauth";
       version = "1.4.0.1";
       sha256 = "c9c8c0ef23ee6bc4351eb96e441c52c5c62b1204f14267e0d6fa60198e60c373";
       libraryHaskellDepends = [
         authenticate-oauth base bytestring lifted-base text transformers
         yesod-auth yesod-core yesod-form
       ];
       homepage = "http://www.yesodweb.com/";
       description = "OAuth Authentication for Yesod";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-oauth" = callPackage
    ({ mkDerivation, authenticate-oauth, base, bytestring, lifted-base
     , text, transformers, yesod-auth, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-oauth";
       version = "1.4.0.2";
       sha256 = "d4dc203549ad073b7426c8260a9b928d91317409b847936bead82ed23302976f";
       libraryHaskellDepends = [
         authenticate-oauth base bytestring lifted-base text transformers
         yesod-auth yesod-core yesod-form
       ];
       homepage = "http://www.yesodweb.com/";
       description = "OAuth Authentication for Yesod";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-auth-oauth2_0_0_11" = callPackage
    ({ mkDerivation, aeson, authenticate, base, bytestring, hoauth2
     , http-conduit, http-types, lifted-base, network-uri, text
     , transformers, uuid, yesod-auth, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-oauth2";
       version = "0.0.11";
       sha256 = "2ca74256a3b3ecf8ed5b32350b63ee9b9824698bca65c6772d4f07b98240680c";
       libraryHaskellDepends = [
         aeson authenticate base bytestring hoauth2 http-conduit http-types
         lifted-base network-uri text transformers uuid yesod-auth
         yesod-core yesod-form
       ];
       jailbreak = true;
       homepage = "http://github.com/scan/yesod-auth-oauth2";
       description = "Library to authenticate with OAuth 2.0 for Yesod web applications.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-oauth2_0_0_12" = callPackage
    ({ mkDerivation, aeson, authenticate, base, bytestring, hoauth2
     , http-conduit, http-types, lifted-base, network-uri, text
     , transformers, uuid, yesod-auth, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-oauth2";
       version = "0.0.12";
       sha256 = "40afe4a04f175585aa3e785716adbec11db6a9d927fad42ee98da6b49465e0d8";
       libraryHaskellDepends = [
         aeson authenticate base bytestring hoauth2 http-conduit http-types
         lifted-base network-uri text transformers uuid yesod-auth
         yesod-core yesod-form
       ];
       jailbreak = true;
       homepage = "http://github.com/scan/yesod-auth-oauth2";
       description = "Library to authenticate with OAuth 2.0 for Yesod web applications.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-oauth2_0_1_2" = callPackage
    ({ mkDerivation, aeson, authenticate, base, bytestring, hoauth2
     , http-conduit, http-types, lifted-base, network-uri, random, text
     , transformers, yesod-auth, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-oauth2";
       version = "0.1.2";
       sha256 = "c94fb52e7a873968a31a81c00356f4bbd4f88f7a3d3b5fea8b2115272c62f9ae";
       libraryHaskellDepends = [
         aeson authenticate base bytestring hoauth2 http-conduit http-types
         lifted-base network-uri random text transformers yesod-auth
         yesod-core yesod-form
       ];
       jailbreak = true;
       homepage = "http://github.com/thoughtbot/yesod-auth-oauth2";
       description = "OAuth 2.0 authentication plugins";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-oauth2_0_1_3" = callPackage
    ({ mkDerivation, aeson, authenticate, base, bytestring, hoauth2
     , http-client, http-conduit, http-types, lifted-base, network-uri
     , random, text, transformers, vector, yesod-auth, yesod-core
     , yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-oauth2";
       version = "0.1.3";
       sha256 = "43d45faa146f5f3cddc80e8cff76c7091a21bd4ecd0042f1e6dad39b2134a1b9";
       libraryHaskellDepends = [
         aeson authenticate base bytestring hoauth2 http-client http-conduit
         http-types lifted-base network-uri random text transformers vector
         yesod-auth yesod-core yesod-form
       ];
       jailbreak = true;
       homepage = "http://github.com/thoughtbot/yesod-auth-oauth2";
       description = "OAuth 2.0 authentication plugins";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-oauth2_0_1_4" = callPackage
    ({ mkDerivation, aeson, authenticate, base, bytestring, hoauth2
     , http-client, http-conduit, http-types, lifted-base, network-uri
     , random, text, transformers, vector, yesod-auth, yesod-core
     , yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-oauth2";
       version = "0.1.4";
       sha256 = "d92b17c7f2bfac70cdea3b6f5690d36f292cbda33fd81d1700cb3115b349a863";
       libraryHaskellDepends = [
         aeson authenticate base bytestring hoauth2 http-client http-conduit
         http-types lifted-base network-uri random text transformers vector
         yesod-auth yesod-core yesod-form
       ];
       jailbreak = true;
       homepage = "http://github.com/thoughtbot/yesod-auth-oauth2";
       description = "OAuth 2.0 authentication plugins";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-oauth2_0_1_5" = callPackage
    ({ mkDerivation, aeson, authenticate, base, bytestring, hoauth2
     , http-client, http-conduit, http-types, lifted-base, network-uri
     , random, text, transformers, vector, yesod-auth, yesod-core
     , yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-oauth2";
       version = "0.1.5";
       sha256 = "7678dcd4ed18ffb502601cdc069674260ae10019f9619c69a1a7f90aadc88768";
       libraryHaskellDepends = [
         aeson authenticate base bytestring hoauth2 http-client http-conduit
         http-types lifted-base network-uri random text transformers vector
         yesod-auth yesod-core yesod-form
       ];
       jailbreak = true;
       homepage = "http://github.com/thoughtbot/yesod-auth-oauth2";
       description = "OAuth 2.0 authentication plugins";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-oauth2_0_1_6" = callPackage
    ({ mkDerivation, aeson, authenticate, base, bytestring, hoauth2
     , hspec, http-client, http-conduit, http-types, lifted-base
     , network-uri, random, text, transformers, vector, yesod-auth
     , yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-oauth2";
       version = "0.1.6";
       sha256 = "6f10629639a6d8d5886d7375f8a2daa63085fa4427d8308e397ac03093fddb53";
       libraryHaskellDepends = [
         aeson authenticate base bytestring hoauth2 http-client http-conduit
         http-types lifted-base network-uri random text transformers vector
         yesod-auth yesod-core yesod-form
       ];
       testHaskellDepends = [ base hspec ];
       homepage = "http://github.com/thoughtbot/yesod-auth-oauth2";
       description = "OAuth 2.0 authentication plugins";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-oauth2" = callPackage
    ({ mkDerivation, aeson, authenticate, base, bytestring, containers
     , hoauth2, hspec, http-client, http-conduit, http-types
     , lifted-base, load-env, network-uri, random, text, transformers
     , vector, warp, yesod, yesod-auth, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-oauth2";
       version = "0.1.7";
       sha256 = "272ebc701f55b955f2eae69acca68a2344f8ec99988a5eff94853b3b0382b7d4";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson authenticate base bytestring hoauth2 http-client http-conduit
         http-types lifted-base network-uri random text transformers vector
         yesod-auth yesod-core yesod-form
       ];
       executableHaskellDepends = [
         base containers http-conduit load-env text warp yesod yesod-auth
       ];
       testHaskellDepends = [ base hspec ];
       homepage = "http://github.com/thoughtbot/yesod-auth-oauth2";
       description = "OAuth 2.0 authentication plugins";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-auth-pam" = callPackage
    ({ mkDerivation, base, hamlet, pam, text, yesod-auth, yesod-core
     , yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-pam";
       version = "1.0.0.0";
       sha256 = "1ece5d21824aef12e3f292074c0dc31908a6068ef46469964e7bcb468f799709";
       libraryHaskellDepends = [
         base hamlet pam text yesod-auth yesod-core yesod-form
       ];
       description = "Provides PAM authentication module";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-smbclient" = callPackage
    ({ mkDerivation, base, hamlet, sys-auth-smbclient, text, yesod-auth
     , yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-auth-smbclient";
       version = "2.0.0.0";
       sha256 = "4a3d2cbd1c5d9bb9e816067446af75610c16972ce5c320f0e875676496ab0b81";
       libraryHaskellDepends = [
         base hamlet sys-auth-smbclient text yesod-auth yesod-core
         yesod-form
       ];
       homepage = "https://github.com/kkazuo/yesod-auth-smbclient.git";
       description = "Authentication plugin for Yesod using smbclient";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-auth-zendesk" = callPackage
    ({ mkDerivation, base, base16-bytestring, bytestring, cryptohash
     , data-default, http-conduit, http-types, template-haskell, text
     , time, transformers, wai, yesod-auth, yesod-core
     }:
     mkDerivation {
       pname = "yesod-auth-zendesk";
       version = "1.2.1";
       sha256 = "cbe2f448c102d04409dd74a400881dae145a9b640abc437a6ad533f956f34e4a";
       libraryHaskellDepends = [
         base base16-bytestring bytestring cryptohash data-default
         http-conduit http-types template-haskell text time transformers wai
         yesod-auth yesod-core
       ];
       jailbreak = true;
       homepage = "https://github.com/prowdsponsor/yesod-auth-zendesk";
       description = "Zendesk remote authentication support for Yesod apps";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-bin_1_4_1" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, Cabal, conduit, conduit-extra, containers
     , data-default-class, directory, file-embed, filepath, fsnotify
     , ghc, ghc-paths, http-conduit, http-reverse-proxy, http-types
     , lifted-base, network, optparse-applicative, parsec, process
     , project-template, resourcet, shakespeare, split
     , streaming-commons, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, yaml
     , zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.1";
       sha256 = "3cee8a37275a640f398c0f4f0136a55ddcdae4610548fc67c344a35d01b6f04f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring Cabal
         conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_1_1" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, Cabal, conduit, conduit-extra, containers
     , data-default-class, directory, file-embed, filepath, fsnotify
     , ghc, ghc-paths, http-conduit, http-reverse-proxy, http-types
     , lifted-base, network, optparse-applicative, parsec, process
     , project-template, resourcet, shakespeare, split
     , streaming-commons, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, yaml
     , zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.1.1";
       sha256 = "bbac1cbcb3d3f183d844f331c230533fd5fc901b9ea67949c44212c8d4a2c0d4";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring Cabal
         conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_2" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, Cabal, conduit, conduit-extra, containers
     , data-default-class, directory, file-embed, filepath, fsnotify
     , ghc, ghc-paths, http-conduit, http-reverse-proxy, http-types
     , lifted-base, network, optparse-applicative, parsec, process
     , project-template, resourcet, shakespeare, split
     , streaming-commons, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, yaml
     , zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.2";
       sha256 = "08e989b52364ec35aa1f13859e503e566306e35ce62c965ea710bcc078df007e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring Cabal
         conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_3_1" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, Cabal, conduit, conduit-extra, containers
     , data-default-class, directory, file-embed, filepath, fsnotify
     , ghc, ghc-paths, http-conduit, http-reverse-proxy, http-types
     , lifted-base, network, optparse-applicative, parsec, process
     , project-template, resourcet, shakespeare, split
     , streaming-commons, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, yaml
     , zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.3.1";
       sha256 = "083cec2fd5a36df44823ec480240cbd19d64e75938570d55da659d32a0f8379d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring Cabal
         conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_3_2" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, Cabal, conduit, conduit-extra, containers
     , data-default-class, directory, file-embed, filepath, fsnotify
     , ghc, ghc-paths, http-conduit, http-reverse-proxy, http-types
     , lifted-base, network, optparse-applicative, parsec, process
     , project-template, resourcet, shakespeare, split
     , streaming-commons, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, yaml
     , zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.3.2";
       sha256 = "685e56ee8dbea544810db75988ef1aca736892147923dc912f29382bc2f84611";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring Cabal
         conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_3_3" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, Cabal, conduit, conduit-extra, containers
     , data-default-class, directory, file-embed, filepath, fsnotify
     , ghc, ghc-paths, http-conduit, http-reverse-proxy, http-types
     , lifted-base, network, optparse-applicative, parsec, process
     , project-template, resourcet, shakespeare, split
     , streaming-commons, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, yaml
     , zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.3.3";
       sha256 = "7f4dfde3e8d612cd6f7ad55614ef7c8fdfbd4220565fffab988535153a5b7155";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring Cabal
         conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_3_4" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, Cabal, conduit, conduit-extra, containers
     , data-default-class, directory, file-embed, filepath, fsnotify
     , ghc, ghc-paths, http-conduit, http-reverse-proxy, http-types
     , lifted-base, network, optparse-applicative, parsec, process
     , project-template, resourcet, shakespeare, split
     , streaming-commons, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, yaml
     , zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.3.4";
       sha256 = "5485ae70cf5af4f854a8452791848b88ad9a39f2c76207300e7237c39c32045d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring Cabal
         conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_3_5" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, Cabal, conduit, conduit-extra, containers
     , data-default-class, directory, file-embed, filepath, fsnotify
     , ghc, ghc-paths, http-conduit, http-reverse-proxy, http-types
     , lifted-base, network, optparse-applicative, parsec, process
     , project-template, resourcet, shakespeare, split
     , streaming-commons, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, yaml
     , zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.3.5";
       sha256 = "0bc8a369cd1f820c4a48bd52c0f44faf3411d52a1d0438672c93330fcabf0fe3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring Cabal
         conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_3_6" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, Cabal, conduit, conduit-extra, containers
     , data-default-class, directory, file-embed, filepath, fsnotify
     , ghc, ghc-paths, http-conduit, http-reverse-proxy, http-types
     , lifted-base, network, optparse-applicative, parsec, process
     , project-template, resourcet, shakespeare, split
     , streaming-commons, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, yaml
     , zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.3.6";
       sha256 = "fe823f10cddabfb8bd8fb06516e62c38e2e70c9a1a96c85b2cd02e49350b0a56";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring Cabal
         conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_3_7" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, Cabal, conduit, conduit-extra, containers
     , data-default-class, directory, file-embed, filepath, fsnotify
     , ghc, ghc-paths, http-conduit, http-reverse-proxy, http-types
     , lifted-base, network, optparse-applicative, parsec, process
     , project-template, resourcet, shakespeare, split
     , streaming-commons, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, yaml
     , zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.3.7";
       sha256 = "c2ae16ed67c9c9e484bfeab7439716996b2c68449430d0e03aae65d8ab81d61d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring Cabal
         conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_3_10" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, Cabal, conduit, conduit-extra, containers
     , data-default-class, directory, file-embed, filepath, fsnotify
     , ghc, ghc-paths, http-conduit, http-reverse-proxy, http-types
     , lifted-base, network, optparse-applicative, parsec, process
     , project-template, resourcet, shakespeare, split
     , streaming-commons, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, yaml
     , zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.3.10";
       sha256 = "2eab78deac821369d4e77a6b26c784beab4082afb7b9cbc041d7191237960b75";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring Cabal
         conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_4" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, Cabal, conduit, conduit-extra, containers
     , data-default-class, directory, file-embed, filepath, fsnotify
     , ghc, ghc-paths, http-client, http-conduit, http-reverse-proxy
     , http-types, lifted-base, network, optparse-applicative, parsec
     , process, project-template, resourcet, shakespeare, split
     , streaming-commons, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, yaml
     , zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.4";
       sha256 = "d5ee299757039571218e6d7ac406e1544cd84d7c74581a76a948aafb52cfa575";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring Cabal
         conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-client http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_5" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, Cabal, conduit, conduit-extra, containers
     , data-default-class, directory, file-embed, filepath, fsnotify
     , ghc, ghc-paths, http-client, http-conduit, http-reverse-proxy
     , http-types, lifted-base, network, optparse-applicative, parsec
     , process, project-template, resourcet, shakespeare, split
     , streaming-commons, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, yaml
     , zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.5";
       sha256 = "a1530a523c12961cfd46959fae24d36d041d07cd0cd723583d3607a7c1257c97";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring Cabal
         conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-client http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_5_1" = callPackage
    ({ mkDerivation, attoparsec, base, base64-bytestring, blaze-builder
     , bytestring, Cabal, conduit, conduit-extra, containers
     , data-default-class, directory, file-embed, filepath, fsnotify
     , ghc, ghc-paths, http-client, http-conduit, http-reverse-proxy
     , http-types, lifted-base, network, optparse-applicative, parsec
     , process, project-template, resourcet, shakespeare, split
     , streaming-commons, system-fileio, system-filepath, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, yaml
     , zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.5.1";
       sha256 = "65da3dd35e8676b7de0febc3993c9ce0f5c31a626e8a4cf42b0c9fcf5916b660";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         attoparsec base base64-bytestring blaze-builder bytestring Cabal
         conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-client http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_6" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, directory, file-embed, filepath
     , fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, system-fileio
     , system-filepath, tar, template-haskell, text, time, transformers
     , transformers-compat, unix-compat, unordered-containers, wai
     , wai-extra, warp, warp-tls, yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.6";
       sha256 = "44fdb61e0bbfffe74a62d01330d256b7414f85302df56f9adf23d86a6d5b20e3";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-client http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp warp-tls yaml
         zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_7" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, directory, file-embed, filepath
     , fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, system-fileio
     , system-filepath, tar, template-haskell, text, time, transformers
     , transformers-compat, unix-compat, unordered-containers, wai
     , wai-extra, warp, warp-tls, yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.7";
       sha256 = "7733c08b6c0a0cd9a72f791db76a667d1a54b01f66eccf8148efd587648a20f6";
       revision = "1";
       editedCabalFile = "30900e0fe5664a445ea88ea46a4643631825b08db41a8c84ca1e007deda7dc79";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-client http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp warp-tls yaml
         zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_7_1" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, directory, file-embed, filepath
     , fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, system-fileio
     , system-filepath, tar, template-haskell, text, time, transformers
     , transformers-compat, unix-compat, unordered-containers, wai
     , wai-extra, warp, warp-tls, yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.7.1";
       sha256 = "475cc326da5497da3b17a77535f586bdde1a760643c8a1e9f29ee9a47c551220";
       revision = "1";
       editedCabalFile = "a4b2436fca046b83a3e88fc9b923d3d852a87ebd392d9d0704047e01b8a0a7be";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-client http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp warp-tls yaml
         zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_7_2" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, directory, file-embed, filepath
     , fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, system-fileio
     , system-filepath, tar, template-haskell, text, time, transformers
     , transformers-compat, unix-compat, unordered-containers, wai
     , wai-extra, warp, warp-tls, yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.7.2";
       sha256 = "f0fd68bb3f6833841059092f43c609724680926266ed1907a258c2effa4e8696";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class directory
         file-embed filepath fsnotify ghc ghc-paths http-client http-conduit
         http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons system-fileio system-filepath
         tar template-haskell text time transformers transformers-compat
         unix-compat unordered-containers wai wai-extra warp warp-tls yaml
         zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_9_1" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, deepseq, directory, file-embed
     , filepath, fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, warp-tls
     , yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.9.1";
       sha256 = "24f5742fbca841d7a6a9d881ddee55d832c097ab6abb673bcd72d51da8574749";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class deepseq
         directory file-embed filepath fsnotify ghc ghc-paths http-client
         http-conduit http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons tar template-haskell text time
         transformers transformers-compat unix-compat unordered-containers
         wai wai-extra warp warp-tls yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_9_2" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, deepseq, directory, file-embed
     , filepath, fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, warp-tls
     , yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.9.2";
       sha256 = "a03d81cc7007113130bc1c0a20c7dffaa0bf6380697f993082b21cf9e44a792d";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class deepseq
         directory file-embed filepath fsnotify ghc ghc-paths http-client
         http-conduit http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons tar template-haskell text time
         transformers transformers-compat unix-compat unordered-containers
         wai wai-extra warp warp-tls yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_10" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, deepseq, directory, file-embed
     , filepath, fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, warp-tls
     , yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.10";
       sha256 = "013baf29baf14b05dabbf0ed1d6e19fe0d720d033d60de3e3146b1434b09a5c0";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class deepseq
         directory file-embed filepath fsnotify ghc ghc-paths http-client
         http-conduit http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons tar template-haskell text time
         transformers transformers-compat unix-compat unordered-containers
         wai wai-extra warp warp-tls yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_11" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, deepseq, directory, file-embed
     , filepath, fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, warp-tls
     , yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.11";
       sha256 = "62b721c6353f87ded303173ba246212e0b1671b468c1617b7df9bd78ded23a59";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class deepseq
         directory file-embed filepath fsnotify ghc ghc-paths http-client
         http-conduit http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons tar template-haskell text time
         transformers transformers-compat unix-compat unordered-containers
         wai wai-extra warp warp-tls yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_13" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, deepseq, directory, file-embed
     , filepath, fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, warp-tls
     , yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.13";
       sha256 = "33c80d13087277a51565cc45980fe11cc539e5ad9739dfcf7505d02be8ae1c67";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class deepseq
         directory file-embed filepath fsnotify ghc ghc-paths http-client
         http-conduit http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons tar template-haskell text time
         transformers transformers-compat unix-compat unordered-containers
         wai wai-extra warp warp-tls yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_13_1" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, deepseq, directory, file-embed
     , filepath, fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, warp-tls
     , yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.13.1";
       sha256 = "2ccfe5c4020232ee557fd4c368cd461d5e989d126544b40052726ed9568cd8ee";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class deepseq
         directory file-embed filepath fsnotify ghc ghc-paths http-client
         http-conduit http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons tar template-haskell text time
         transformers transformers-compat unix-compat unordered-containers
         wai wai-extra warp warp-tls yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_13_2" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, deepseq, directory, file-embed
     , filepath, fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, warp-tls
     , yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.13.2";
       sha256 = "6ba51159341dc4e13e166cd54cd5af414ea1829f25c4d2f15eeac4507339530f";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class deepseq
         directory file-embed filepath fsnotify ghc ghc-paths http-client
         http-conduit http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons tar template-haskell text time
         transformers transformers-compat unix-compat unordered-containers
         wai wai-extra warp warp-tls yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_13_3" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, deepseq, directory, file-embed
     , filepath, fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, warp-tls
     , yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.13.3";
       sha256 = "cc84e0c8f081211c01a6c8d58544b9b7fe5c5c180d8a2edcb30a79edbe198e61";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class deepseq
         directory file-embed filepath fsnotify ghc ghc-paths http-client
         http-conduit http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons tar template-haskell text time
         transformers transformers-compat unix-compat unordered-containers
         wai wai-extra warp warp-tls yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_14" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, deepseq, directory, file-embed
     , filepath, fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, warp-tls
     , yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.14";
       sha256 = "6ed15a3ac5084926073c92fa7fd3ad2efa5ff8b4dc17fa4e6b1c109d57717a0c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class deepseq
         directory file-embed filepath fsnotify ghc ghc-paths http-client
         http-conduit http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons tar template-haskell text time
         transformers transformers-compat unix-compat unordered-containers
         wai wai-extra warp warp-tls yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_16_1" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, deepseq, directory, file-embed
     , filepath, fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, warp-tls
     , yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.16.1";
       sha256 = "def7ebf5f2d9cc0366fc9309603029b59f750b9045ae5ace4352bce5b0027fbd";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class deepseq
         directory file-embed filepath fsnotify ghc ghc-paths http-client
         http-conduit http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons tar template-haskell text time
         transformers transformers-compat unix-compat unordered-containers
         wai wai-extra warp warp-tls yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin_1_4_17" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, deepseq, directory, file-embed
     , filepath, fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, warp-tls
     , yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.17";
       sha256 = "bc5721479fb3aaa40153c092b899ccd99b18449a48154eb3a1bc5d8b5518dbb7";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class deepseq
         directory file-embed filepath fsnotify ghc ghc-paths http-client
         http-conduit http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons tar template-haskell text time
         transformers transformers-compat unix-compat unordered-containers
         wai wai-extra warp warp-tls yaml zlib
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-bin" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, bytestring, Cabal, conduit, conduit-extra
     , containers, data-default-class, deepseq, directory, file-embed
     , filepath, fsnotify, ghc, ghc-paths, http-client, http-conduit
     , http-reverse-proxy, http-types, lifted-base, network
     , optparse-applicative, parsec, process, project-template
     , resourcet, shakespeare, split, streaming-commons, tar
     , template-haskell, text, time, transformers, transformers-compat
     , unix-compat, unordered-containers, wai, wai-extra, warp, warp-tls
     , yaml, zlib
     }:
     mkDerivation {
       pname = "yesod-bin";
       version = "1.4.17.1";
       sha256 = "0d7052caf0aadc00e04a4d1ce537670d7b8da4d1fc86d36c500abc70777a2ee8";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder bytestring
         Cabal conduit conduit-extra containers data-default-class deepseq
         directory file-embed filepath fsnotify ghc ghc-paths http-client
         http-conduit http-reverse-proxy http-types lifted-base network
         optparse-applicative parsec process project-template resourcet
         shakespeare split streaming-commons tar template-haskell text time
         transformers transformers-compat unix-compat unordered-containers
         wai wai-extra warp warp-tls yaml zlib
       ];
       homepage = "http://www.yesodweb.com/";
       description = "The yesod helper executable";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-bootstrap" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, conduit
     , conduit-extra, containers, either, email-validate
     , lens-family-core, lens-family-th, MonadRandom, mtl, persistent
     , shakespeare, text, time, transformers, yaml, yesod-core
     , yesod-form, yesod-markdown
     }:
     mkDerivation {
       pname = "yesod-bootstrap";
       version = "0.2.1";
       sha256 = "c1eb6ae089f72b389f11c29f7572177c9767e7995d4e50b7a3ed23cdea681492";
       libraryHaskellDepends = [
         base blaze-html blaze-markup conduit conduit-extra containers
         either email-validate lens-family-core lens-family-th MonadRandom
         mtl persistent shakespeare text time transformers yaml yesod-core
         yesod-form yesod-markdown
       ];
       description = "Bootstrap widgets for yesod";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-comments" = callPackage
    ({ mkDerivation, base, bytestring, directory, friendly-time
     , gravatar, old-locale, persistent, template-haskell, text, time
     , wai, yesod, yesod-auth, yesod-form, yesod-markdown
     }:
     mkDerivation {
       pname = "yesod-comments";
       version = "0.9.2";
       sha256 = "f12026d85b1832ae04d81e5e18413fcf35cd2cb71e480cc73d5573fe39435cc7";
       libraryHaskellDepends = [
         base bytestring directory friendly-time gravatar old-locale
         persistent template-haskell text time wai yesod yesod-auth
         yesod-form yesod-markdown
       ];
       jailbreak = true;
       homepage = "http://github.com/pbrisbin/yesod-comments";
       description = "A generic comments interface for a Yesod application";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-content-pdf" = callPackage
    ({ mkDerivation, base, blaze-builder, blaze-html, bytestring
     , conduit, data-default, directory, hspec, hspec-expectations
     , network-uri, process, temporary, transformers, utf8-string
     , yesod-core
     }:
     mkDerivation {
       pname = "yesod-content-pdf";
       version = "0.2.0.3";
       sha256 = "8c5874e54246a70f6fed205cf29b7a6068176f3af80a991a05b0adc532803230";
       libraryHaskellDepends = [
         base blaze-builder blaze-html bytestring conduit data-default
         directory network-uri process temporary transformers yesod-core
       ];
       testHaskellDepends = [
         base blaze-html hspec hspec-expectations utf8-string
       ];
       homepage = "https://github.com/alexkyllo/yesod-content-pdf#readme";
       description = "PDF Content Type for Yesod";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-continuations" = callPackage
    ({ mkDerivation, base, datetime, hashable, hashmap, stm
     , system-uuid, template-haskell, yesod
     }:
     mkDerivation {
       pname = "yesod-continuations";
       version = "0.1";
       sha256 = "368649e1f7af2c87ff405b8d5167b6db92ab2b6496d84b1a5fee2a87c206ecdf";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base datetime hashable hashmap stm system-uuid template-haskell
         yesod
       ];
       homepage = "https://github.com/softmechanics/yesod-continuations/";
       description = "Continuations for Yesod";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_6" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
     , clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , http-types, HUnit, lifted-base, monad-control, monad-logger, mtl
     , mwc-random, network, old-locale, parsec, path-pieces, primitive
     , QuickCheck, random, resourcet, safe, shakespeare
     , streaming-commons, template-haskell, text, time, transformers
     , transformers-base, unix-compat, unordered-containers, vector, wai
     , wai-extra, wai-logger, warp, word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.6";
       sha256 = "ef88d84762406e1607f047f04b6153406546eea415f4993b0e0c5c617dc498f6";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe shakespeare template-haskell text time
         transformers transformers-base unix-compat unordered-containers
         vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring conduit conduit-extra
         containers hspec http-types HUnit lifted-base mwc-random network
         path-pieces QuickCheck random resourcet shakespeare
         streaming-commons template-haskell text transformers wai wai-extra
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_6_2" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
     , clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , http-types, HUnit, lifted-base, monad-control, monad-logger, mtl
     , mwc-random, network, old-locale, parsec, path-pieces, primitive
     , QuickCheck, random, resourcet, safe, shakespeare
     , streaming-commons, template-haskell, text, time, transformers
     , transformers-base, unix-compat, unordered-containers, vector, wai
     , wai-extra, wai-logger, warp, word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.6.2";
       sha256 = "5c6dc2667e2dd18ccdf8fbd61c04b300d4b19651a42dd6c719504d9e6c2a356a";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe shakespeare template-haskell text time
         transformers transformers-base unix-compat unordered-containers
         vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring conduit conduit-extra
         containers hspec http-types HUnit lifted-base mwc-random network
         path-pieces QuickCheck random resourcet shakespeare
         streaming-commons template-haskell text transformers wai wai-extra
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_7" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
     , clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , shakespeare, streaming-commons, template-haskell, text, time
     , transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.7";
       sha256 = "52424317c7a80df8d9ade91a19a22759216cb15a0520a87cb8eee4dcd9e499a8";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe shakespeare template-haskell text time
         transformers transformers-base unix-compat unordered-containers
         vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_7_1" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
     , clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , shakespeare, streaming-commons, template-haskell, text, time
     , transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.7.1";
       sha256 = "7b132b21ada1421cadc1c06eae4951115989d006403b82e3ec062d6c75d8f3d2";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe shakespeare template-haskell text time
         transformers transformers-base unix-compat unordered-containers
         vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_7_2" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
     , clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , shakespeare, streaming-commons, template-haskell, text, time
     , transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.7.2";
       sha256 = "de104ae5ce4002c41809d647a9c3ae7fe868c301df67bb19f09fa4a29bd4df4c";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe shakespeare template-haskell text time
         transformers transformers-base unix-compat unordered-containers
         vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_8" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
     , clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.8";
       sha256 = "f8d2c54735784a5ed352b77a5b252be724e8a315f0cdf471efba21641a628509";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_8_1" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
     , clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.8.1";
       sha256 = "eb421430f8fcd2d38fe9b40f51f197fcc057cf8f502ee57d551f204cd8efd0fa";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_8_2" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
     , clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.8.2";
       sha256 = "9c77f22b401b67ad02215fd211d04b23eff1b5f8153d236816fab1223d7fce6b";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_8_3" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
     , clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.8.3";
       sha256 = "241cc94447fb37111077a5df7dcceb06b3af77bc8a53d1ab9d66e4e559d2894c";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_9" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
     , clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.9";
       sha256 = "abcaa469be5f6d9572eb5768a94cca967419a0283f918076bc387fb0723f2e83";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_9_1" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
     , clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.9.1";
       sha256 = "4c1bdc58cf9da8f2242ec74f6f7013516582b9a01751909f0c2563a8985014bb";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_10" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
     , clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.10";
       sha256 = "fc30350ab94d4e3cc4ad3b0b6cb542bb9a818222468ceea3b3f9a01c4e637172";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_11" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
     , clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.11";
       sha256 = "dac1127f2a60ee42f42b691cccf9522444a589f117391f32ea5dee41b6bbcbd1";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_12" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
     , clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.12";
       sha256 = "035387453f60a9476ac6646675da147eb4b6859c48393732b72f31841e15b7e9";
       revision = "1";
       editedCabalFile = "a6f72da0eb68bc2d5da1d8d8aaa758403e5e86f6de3c61cde01376fd51e50c35";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_13" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, bytestring, case-insensitive, cereal
     , clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.13";
       sha256 = "219bf0858977468d9aa74ab5f2d330e46bbbe95d700c989b3565be5d99d319da";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_14" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, byteable, bytestring, case-insensitive
     , cereal, clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.14";
       sha256 = "351596dc29ef617c2526de34f3825eb72f3427663af82c2bd84960493cdd1a71";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         byteable bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_15" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, byteable, bytestring, case-insensitive
     , cereal, clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.15";
       sha256 = "b9878ee01f66346967a157c597d284735c66db61a18a93c319b85233500050b4";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         byteable bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_15_1" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, byteable, bytestring, case-insensitive
     , cereal, clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.15.1";
       sha256 = "a414a0eb14b4b88ad4d6ec22db9837b4ead9c7958cf236476dce963555a75e29";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         byteable bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_17" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, byteable, bytestring, case-insensitive
     , cereal, clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.17";
       sha256 = "954f0851ec388ef9b9009e087d7b8c214481f7e5bd4c3dff2828030780d0eadf";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         byteable bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core_1_4_18_1" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, byteable, bytestring, case-insensitive
     , cereal, clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.18.1";
       sha256 = "8964a1ce27f7d15037eee05611546a8e5e183640115e92e70fc73e1116beddb0";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         byteable bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-core" = callPackage
    ({ mkDerivation, aeson, async, auto-update, base, blaze-builder
     , blaze-html, blaze-markup, byteable, bytestring, case-insensitive
     , cereal, clientsession, conduit, conduit-extra, containers, cookie
     , data-default, deepseq, directory, exceptions, fast-logger, hspec
     , hspec-expectations, http-types, HUnit, lifted-base, monad-control
     , monad-logger, mtl, mwc-random, network, old-locale, parsec
     , path-pieces, primitive, QuickCheck, random, resourcet, safe
     , semigroups, shakespeare, streaming-commons, template-haskell
     , text, time, transformers, transformers-base, unix-compat
     , unordered-containers, vector, wai, wai-extra, wai-logger, warp
     , word8
     }:
     mkDerivation {
       pname = "yesod-core";
       version = "1.4.19";
       sha256 = "8425c1df703521b020b476035f572e953ac356ce6f5e35c424b29f0d5ff76ded";
       libraryHaskellDepends = [
         aeson auto-update base blaze-builder blaze-html blaze-markup
         byteable bytestring case-insensitive cereal clientsession conduit
         conduit-extra containers cookie data-default deepseq directory
         exceptions fast-logger http-types lifted-base monad-control
         monad-logger mtl mwc-random old-locale parsec path-pieces primitive
         random resourcet safe semigroups shakespeare template-haskell text
         time transformers transformers-base unix-compat
         unordered-containers vector wai wai-extra wai-logger warp word8
       ];
       testHaskellDepends = [
         async base blaze-builder bytestring clientsession conduit
         conduit-extra containers cookie hspec hspec-expectations http-types
         HUnit lifted-base mwc-random network path-pieces QuickCheck random
         resourcet shakespeare streaming-commons template-haskell text
         transformers wai wai-extra
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Creation of type-safe, RESTful web applications";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-crud" = callPackage
    ({ mkDerivation, base, classy-prelude, containers, MissingH
     , monad-control, persistent, random, safe, stm, uuid, yesod-core
     , yesod-form, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-crud";
       version = "0.1.3";
       sha256 = "56b1ed4ad8ac35887e6e327774890a31e662de04afb2b295b88df4a85b89c776";
       libraryHaskellDepends = [
         base classy-prelude containers MissingH monad-control persistent
         random safe stm uuid yesod-core yesod-form yesod-persistent
       ];
       homepage = "https://github.com/league/yesod-crud";
       description = "Generic administrative CRUD operations as a Yesod subsite";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-crud-persist" = callPackage
    ({ mkDerivation, base, either, esqueleto, microlens, microlens-th
     , persistent, text, time, transformers, wai, yesod-core, yesod-form
     , yesod-markdown, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-crud-persist";
       version = "0.2.1";
       sha256 = "9206e96ccb46021be089f1919d2775839dd82ad25cde0240680a152eb214f1ba";
       libraryHaskellDepends = [
         base either esqueleto microlens microlens-th persistent text time
         transformers wai yesod-core yesod-form yesod-markdown
         yesod-persistent
       ];
       homepage = "https://github.com/andrewthad/yesod-crud-persist";
       description = "Flexible CRUD subsite usable with Yesod and Persistent";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-csp" = callPackage
    ({ mkDerivation, attoparsec, base, hspec, mono-traversable
     , network-uri, semigroups, syb, template-haskell, text, uniplate
     , yesod, yesod-core, yesod-test
     }:
     mkDerivation {
       pname = "yesod-csp";
       version = "0.2.0.0";
       sha256 = "3804bdbc7b2f40a707c0af2bd6c2586abdc49c0f2eada5b24c488ed126e37280";
       libraryHaskellDepends = [
         attoparsec base mono-traversable network-uri semigroups syb
         template-haskell text uniplate yesod yesod-core
       ];
       testHaskellDepends = [
         attoparsec base hspec network-uri semigroups template-haskell yesod
         yesod-test
       ];
       description = "Add CSP headers to Yesod apps";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-datatables" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, bytestring, data-default
     , HUnit, monad-control, persistent, persistent-sqlite
     , persistent-template, QuickCheck, resourcet, template-haskell
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, transformers, yesod, yesod-auth, yesod-core, yesod-default
     , yesod-form, yesod-static
     }:
     mkDerivation {
       pname = "yesod-datatables";
       version = "0.1.1";
       sha256 = "e6af50d3a85032ccb37d3f6ac3c8149391495beab48d10c9bdc98081fc74c67a";
       libraryHaskellDepends = [
         aeson attoparsec base bytestring data-default persistent text yesod
         yesod-auth yesod-core yesod-default yesod-form yesod-static
       ];
       testHaskellDepends = [
         aeson attoparsec base bytestring HUnit monad-control persistent
         persistent-sqlite persistent-template QuickCheck resourcet
         template-haskell test-framework test-framework-hunit
         test-framework-quickcheck2 text transformers
       ];
       jailbreak = true;
       homepage = "http://github.com/tlaitinen/yesod-datatables";
       description = "Yesod plugin for DataTables (jQuery grid plugin)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-default" = callPackage
    ({ mkDerivation, base, yesod-core }:
     mkDerivation {
       pname = "yesod-default";
       version = "1.2.0";
       sha256 = "f39ae1953a95c1919a9dd214d93bf81078b1dcbbac737dc9bb7339dbad9dda96";
       libraryHaskellDepends = [ base yesod-core ];
       homepage = "http://www.yesodweb.com/";
       description = "Default config and main functions for your yesod application (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-dsl" = callPackage
    ({ mkDerivation, aeson, aeson-pretty, alex, array, base, bytestring
     , Cabal, containers, directory, filepath, happy, hscolour, MissingH
     , mtl, shakespeare, strict, syb, text, transformers, uniplate
     , vector
     }:
     mkDerivation {
       pname = "yesod-dsl";
       version = "0.2.1";
       sha256 = "4033df3f27a99cfc279cb32b146909e13725adc81e2a0c584de95f8f70d5a2a8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson aeson-pretty array base bytestring Cabal containers directory
         filepath hscolour MissingH mtl shakespeare strict syb text
         transformers uniplate vector
       ];
       libraryToolDepends = [ alex happy ];
       executableHaskellDepends = [
         array base Cabal containers directory filepath MissingH mtl
         shakespeare strict text
       ];
       description = "DSL for generating Yesod subsite to manage an RDBMS;";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-eventsource_1_4_0" = callPackage
    ({ mkDerivation, base, blaze-builder, conduit, transformers, wai
     , wai-eventsource, wai-extra, yesod-core
     }:
     mkDerivation {
       pname = "yesod-eventsource";
       version = "1.4.0";
       sha256 = "495f44d4766db1d980bec684042cc9f08bf35a1a997ad11fb3c17e9f59015948";
       libraryHaskellDepends = [
         base blaze-builder conduit transformers wai wai-eventsource
         wai-extra yesod-core
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Server-sent events support for Yesod apps";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-eventsource" = callPackage
    ({ mkDerivation, base, blaze-builder, conduit, transformers, wai
     , wai-eventsource, wai-extra, yesod-core
     }:
     mkDerivation {
       pname = "yesod-eventsource";
       version = "1.4.0.1";
       sha256 = "a5ec061ca8c426c4a8179bace45edd8100de96c947b8294445aae890dd175d48";
       libraryHaskellDepends = [
         base blaze-builder conduit transformers wai wai-eventsource
         wai-extra yesod-core
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Server-sent events support for Yesod apps";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-examples" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, data-object
     , data-object-yaml, hamlet, persistent-sqlite, persistent-template
     , sqlite, stm, text, transformers, yesod, yesod-core, yesod-static
     }:
     mkDerivation {
       pname = "yesod-examples";
       version = "0.9.0.1";
       sha256 = "e45a157f9d1e322ef3e802e45c8a5447755484aecb895083ab3b32a47dea79c6";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-html bytestring data-object data-object-yaml hamlet
         persistent-sqlite persistent-template stm text transformers yesod
         yesod-core yesod-static
       ];
       executableSystemDepends = [ sqlite ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Example programs using the Yesod Web Framework. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) sqlite;};

  "yesod-fay_0_7_0" = callPackage
    ({ mkDerivation, aeson, base, bytestring, data-default, directory
     , fay, fay-dom, monad-loops, process, pureMD5, shakespeare
     , system-fileio, system-filepath, template-haskell, text
     , transformers, utf8-string, yesod-core, yesod-form, yesod-static
     }:
     mkDerivation {
       pname = "yesod-fay";
       version = "0.7.0";
       sha256 = "e40a721f12a91fa657de0ffdfbd40585b13da4f115411098567039d0dec902e0";
       libraryHaskellDepends = [
         aeson base bytestring data-default directory fay fay-dom
         monad-loops process pureMD5 shakespeare system-fileio
         system-filepath template-haskell text transformers utf8-string
         yesod-core yesod-form yesod-static
       ];
       homepage = "https://github.com/fpco/yesod-fay";
       description = "Utilities for using the Fay Haskell-to-JS compiler with Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-fay_0_7_1" = callPackage
    ({ mkDerivation, aeson, base, bytestring, data-default, directory
     , fay, fay-dom, monad-loops, process, pureMD5, shakespeare
     , system-fileio, system-filepath, template-haskell, text
     , transformers, utf8-string, yesod-core, yesod-form, yesod-static
     }:
     mkDerivation {
       pname = "yesod-fay";
       version = "0.7.1";
       sha256 = "14b6e82cd2ec6d43e92c48d6731cc2960ca6601e81ce1604a4f0878cd5b1273c";
       libraryHaskellDepends = [
         aeson base bytestring data-default directory fay fay-dom
         monad-loops process pureMD5 shakespeare system-fileio
         system-filepath template-haskell text transformers utf8-string
         yesod-core yesod-form yesod-static
       ];
       homepage = "https://github.com/fpco/yesod-fay";
       description = "Utilities for using the Fay Haskell-to-JS compiler with Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-fay" = callPackage
    ({ mkDerivation, aeson, base, bytestring, data-default, directory
     , fay, fay-dom, filepath, monad-loops, process, pureMD5
     , shakespeare, template-haskell, text, transformers, utf8-string
     , yesod-core, yesod-form, yesod-static
     }:
     mkDerivation {
       pname = "yesod-fay";
       version = "0.8.0";
       sha256 = "ee2113c9fe5c04a8d4a855fad7584ba1a4a0311a2755f8705ff6354e7808dd46";
       libraryHaskellDepends = [
         aeson base bytestring data-default directory fay fay-dom filepath
         monad-loops process pureMD5 shakespeare template-haskell text
         transformers utf8-string yesod-core yesod-form yesod-static
       ];
       homepage = "https://github.com/fpco/yesod-fay";
       description = "Utilities for using the Fay Haskell-to-JS compiler with Yesod";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-fb" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, crypto-api, fb
     , http-conduit, text, wai, yesod-core
     }:
     mkDerivation {
       pname = "yesod-fb";
       version = "0.3.4";
       sha256 = "b7e631a440037b7b077d1bcc5d859006cf5e7420923d93dfe26a07e1d3ad9e25";
       libraryHaskellDepends = [
         aeson base bytestring conduit crypto-api fb http-conduit text wai
         yesod-core
       ];
       homepage = "https://github.com/prowdsponsor/yesod-fb";
       description = "Useful glue functions between the fb library and Yesod";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-form_1_4_3" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, data-default
     , email-validate, hspec, network-uri, persistent, resourcet
     , shakespeare, template-haskell, text, time, transformers, wai
     , xss-sanitize, yesod-core, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-form";
       version = "1.4.3";
       sha256 = "b99aac95d977dbf82f5b8b586ee09c26631b2969553b60aadcded34730663b22";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder blaze-html blaze-markup
         byteable bytestring containers data-default email-validate
         network-uri persistent resourcet shakespeare template-haskell text
         time transformers wai xss-sanitize yesod-core yesod-persistent
       ];
       testHaskellDepends = [ base hspec text time ];
       homepage = "http://www.yesodweb.com/";
       description = "Form handling support for Yesod Web Framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-form_1_4_3_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, data-default
     , email-validate, hspec, network-uri, persistent, resourcet
     , shakespeare, template-haskell, text, time, transformers, wai
     , xss-sanitize, yesod-core, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-form";
       version = "1.4.3.1";
       sha256 = "4be16ec5fb10837dbb19c5db615f99e92919c035462e3de66bbc229348084d90";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder blaze-html blaze-markup
         byteable bytestring containers data-default email-validate
         network-uri persistent resourcet shakespeare template-haskell text
         time transformers wai xss-sanitize yesod-core yesod-persistent
       ];
       testHaskellDepends = [ base hspec text time ];
       homepage = "http://www.yesodweb.com/";
       description = "Form handling support for Yesod Web Framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-form_1_4_4" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, data-default
     , email-validate, hspec, network-uri, persistent, resourcet
     , semigroups, shakespeare, template-haskell, text, time
     , transformers, wai, xss-sanitize, yesod-core, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-form";
       version = "1.4.4";
       sha256 = "ac0cf679e79d180e052023b5a7cdd4c2aa5de507946c80e3a2efe5c1997ec4ef";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder blaze-html blaze-markup
         byteable bytestring containers data-default email-validate
         network-uri persistent resourcet semigroups shakespeare
         template-haskell text time transformers wai xss-sanitize yesod-core
         yesod-persistent
       ];
       testHaskellDepends = [ base hspec text time ];
       homepage = "http://www.yesodweb.com/";
       description = "Form handling support for Yesod Web Framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-form_1_4_4_1" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, data-default
     , email-validate, hspec, network-uri, persistent, resourcet
     , semigroups, shakespeare, template-haskell, text, time
     , transformers, wai, xss-sanitize, yesod-core, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-form";
       version = "1.4.4.1";
       sha256 = "83aec216b6c5179c373d1b76ab3cca219ebacc98db2e5163400228b632dc6493";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder blaze-html blaze-markup
         byteable bytestring containers data-default email-validate
         network-uri persistent resourcet semigroups shakespeare
         template-haskell text time transformers wai xss-sanitize yesod-core
         yesod-persistent
       ];
       testHaskellDepends = [ base hspec text time ];
       homepage = "http://www.yesodweb.com/";
       description = "Form handling support for Yesod Web Framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-form_1_4_5" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, data-default
     , email-validate, hspec, network-uri, persistent, resourcet
     , semigroups, shakespeare, template-haskell, text, time
     , transformers, wai, xss-sanitize, yesod-core, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-form";
       version = "1.4.5";
       sha256 = "f9a6e9590588f813a159f5fcccbd9ebed8a94c72e82271d19dae945c54c13ccf";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder blaze-html blaze-markup
         byteable bytestring containers data-default email-validate
         network-uri persistent resourcet semigroups shakespeare
         template-haskell text time transformers wai xss-sanitize yesod-core
         yesod-persistent
       ];
       testHaskellDepends = [ base hspec text time ];
       homepage = "http://www.yesodweb.com/";
       description = "Form handling support for Yesod Web Framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-form" = callPackage
    ({ mkDerivation, aeson, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, byteable, bytestring, containers, data-default
     , email-validate, hspec, network-uri, persistent, resourcet
     , semigroups, shakespeare, template-haskell, text, time
     , transformers, wai, xss-sanitize, yesod-core, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-form";
       version = "1.4.6";
       sha256 = "1a20f58e0f06b92afc5bd31b5ab6b1d5c6645e2f7fd134c4b2e325d818b50e66";
       libraryHaskellDepends = [
         aeson attoparsec base blaze-builder blaze-html blaze-markup
         byteable bytestring containers data-default email-validate
         network-uri persistent resourcet semigroups shakespeare
         template-haskell text time transformers wai xss-sanitize yesod-core
         yesod-persistent
       ];
       testHaskellDepends = [ base hspec text time ];
       homepage = "http://www.yesodweb.com/";
       description = "Form handling support for Yesod Web Framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-form-json" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, text
     , unordered-containers, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-form-json";
       version = "0.0.1";
       sha256 = "bfaf63bbf0c955465c037084494ea43d4468b0d8f380ab023df583abc91d25c3";
       libraryHaskellDepends = [
         aeson base bytestring containers text unordered-containers
         yesod-core yesod-form
       ];
       description = "Extension for Yesod web framework to handle JSON requests as applicative forms";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-gitrepo_0_1_1_0" = callPackage
    ({ mkDerivation, base, directory, enclosed-exceptions, http-types
     , lifted-base, process, system-filepath, temporary, text, wai
     , yesod-core
     }:
     mkDerivation {
       pname = "yesod-gitrepo";
       version = "0.1.1.0";
       sha256 = "f21750fb8964c2b860c5ec4e0be02dd19f98048ddfc049a98f8c91681cccc4ad";
       libraryHaskellDepends = [
         base directory enclosed-exceptions http-types lifted-base process
         system-filepath temporary text wai yesod-core
       ];
       homepage = "https://github.com/snoyberg/yesod-gitrepo";
       description = "Host content provided by a Git repo";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-gitrepo" = callPackage
    ({ mkDerivation, base, directory, enclosed-exceptions, http-types
     , lifted-base, process, temporary, text, wai, yesod-core
     }:
     mkDerivation {
       pname = "yesod-gitrepo";
       version = "0.2.1.0";
       sha256 = "6e6e0f37771f888c687bbc2dff24228ea0461829de8c1b714da10dbe9f6987ec";
       libraryHaskellDepends = [
         base directory enclosed-exceptions http-types lifted-base process
         temporary text wai yesod-core
       ];
       homepage = "https://github.com/snoyberg/yesod-gitrepo";
       description = "Host content provided by a Git repo";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-gitrev" = callPackage
    ({ mkDerivation, aeson, base, gitrev, template-haskell, yesod-core
     }:
     mkDerivation {
       pname = "yesod-gitrev";
       version = "0.1.0.0";
       sha256 = "30e63c0ea5aec72eed0cd1d9e4dccf242e749c9740e5d67887cac02728628f49";
       libraryHaskellDepends = [
         aeson base gitrev template-haskell yesod-core
       ];
       description = "A subsite for displaying git information";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-goodies" = callPackage
    ({ mkDerivation, base, blaze-html, bytestring, directory, HTTP
     , old-locale, pandoc, pureMD5, text, time, yesod, yesod-form
     }:
     mkDerivation {
       pname = "yesod-goodies";
       version = "0.0.5";
       sha256 = "bf4976fd6ba3399e1f6e24cbd5a7897f092e420d74cd0416f300bc5696e7ad73";
       libraryHaskellDepends = [
         base blaze-html bytestring directory HTTP old-locale pandoc pureMD5
         text time yesod yesod-form
       ];
       jailbreak = true;
       homepage = "http://github.com/pbrisbin/yesod-goodies";
       description = "A collection of various small helpers useful in any yesod application";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-json" = callPackage
    ({ mkDerivation, base, yesod-core }:
     mkDerivation {
       pname = "yesod-json";
       version = "1.2.0";
       sha256 = "fce9323acfea7056bf303e190abd5742343c06f376762f020b38164dc32c0334";
       libraryHaskellDepends = [ base yesod-core ];
       homepage = "http://www.yesodweb.com/";
       description = "Generate content for Yesod using the aeson package. (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-links" = callPackage
    ({ mkDerivation, base, text, yesod-core }:
     mkDerivation {
       pname = "yesod-links";
       version = "0.3.0";
       sha256 = "3e982d5e4ae6fd337339c1548e1d32a885d51881a3ba50c4b917a5cd1f252b44";
       libraryHaskellDepends = [ base text yesod-core ];
       jailbreak = true;
       homepage = "http://github.com/pbrisbin/yesod-goodies/yesod-links";
       description = "A typeclass which simplifies creating link widgets throughout your site";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-lucid" = callPackage
    ({ mkDerivation, base, lucid, monads-tf, text, yesod-core }:
     mkDerivation {
       pname = "yesod-lucid";
       version = "0.1";
       sha256 = "37f6409c59a466fe9c138a1281a587015b8ac8d991cb56fd1054def152bcb5fa";
       libraryHaskellDepends = [ base lucid monads-tf text yesod-core ];
       description = "Lucid support for Yesod";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-mangopay_1_11_4" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra
     , containers, country-codes, data-default, directory, fast-logger
     , hamlet, hjsmin, http-conduit, http-types, lifted-base, mangopay
     , monad-control, monad-logger, persistent, persistent-postgresql
     , persistent-template, resourcet, shakespeare, template-haskell
     , text, time, wai, wai-extra, wai-logger, warp, yaml, yesod
     , yesod-auth, yesod-core, yesod-form, yesod-persistent
     , yesod-static
     }:
     mkDerivation {
       pname = "yesod-mangopay";
       version = "1.11.4";
       sha256 = "c785351be1d7d149f772a0bc60db3f51424a8d7bf8adac295b2dc3d8812acf6b";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers http-conduit http-types lifted-base mangopay
         persistent-template text time yesod yesod-core
       ];
       executableHaskellDepends = [
         aeson base bytestring conduit conduit-extra containers
         country-codes data-default directory fast-logger hamlet hjsmin
         http-conduit lifted-base mangopay monad-control monad-logger
         persistent persistent-postgresql persistent-template resourcet
         shakespeare template-haskell text time wai wai-extra wai-logger
         warp yaml yesod yesod-auth yesod-core yesod-form yesod-persistent
         yesod-static
       ];
       jailbreak = true;
       homepage = "https://github.com/prowdsponsor/mangopay";
       description = "Yesod library for MangoPay API access";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-mangopay_1_11_5" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra
     , containers, country-codes, data-default, directory, fast-logger
     , hamlet, hjsmin, http-conduit, http-types, lifted-base, mangopay
     , monad-control, monad-logger, persistent, persistent-postgresql
     , persistent-template, resourcet, shakespeare, template-haskell
     , text, time, wai, wai-extra, wai-logger, warp, yaml, yesod
     , yesod-auth, yesod-core, yesod-form, yesod-persistent
     , yesod-static
     }:
     mkDerivation {
       pname = "yesod-mangopay";
       version = "1.11.5";
       sha256 = "7a02a34fc1e8e3ae320f1f07f66ac672c0c240b1eb39fabfb0befa8e893282c8";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers http-conduit http-types lifted-base mangopay
         persistent-template text time yesod yesod-core
       ];
       executableHaskellDepends = [
         aeson base bytestring conduit conduit-extra containers
         country-codes data-default directory fast-logger hamlet hjsmin
         http-conduit lifted-base mangopay monad-control monad-logger
         persistent persistent-postgresql persistent-template resourcet
         shakespeare template-haskell text time wai wai-extra wai-logger
         warp yaml yesod yesod-auth yesod-core yesod-form yesod-persistent
         yesod-static
       ];
       jailbreak = true;
       homepage = "https://github.com/prowdsponsor/mangopay";
       description = "Yesod library for MangoPay API access";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-mangopay" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, conduit-extra
     , containers, country-codes, data-default, directory, fast-logger
     , hamlet, hjsmin, http-conduit, http-types, lifted-base, mangopay
     , monad-control, monad-logger, persistent, persistent-postgresql
     , persistent-template, resourcet, shakespeare, template-haskell
     , text, time, wai, wai-extra, wai-logger, warp, yaml, yesod
     , yesod-auth, yesod-core, yesod-form, yesod-persistent
     , yesod-static
     }:
     mkDerivation {
       pname = "yesod-mangopay";
       version = "1.12";
       sha256 = "a53c0d1e8e1654a4c251b1830264f581a1ed668fffb303c05993e10e20932754";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base containers http-conduit http-types lifted-base mangopay
         persistent-template text time yesod yesod-core
       ];
       executableHaskellDepends = [
         aeson base bytestring conduit conduit-extra containers
         country-codes data-default directory fast-logger hamlet hjsmin
         http-conduit lifted-base mangopay monad-control monad-logger
         persistent persistent-postgresql persistent-template resourcet
         shakespeare template-haskell text time wai wai-extra wai-logger
         warp yaml yesod yesod-auth yesod-core yesod-form yesod-persistent
         yesod-static
       ];
       homepage = "https://github.com/prowdsponsor/mangopay";
       description = "Yesod library for MangoPay API access";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-markdown" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
     , directory, hspec, pandoc, persistent, shakespeare, texmath, text
     , xss-sanitize, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-markdown";
       version = "0.11.0";
       sha256 = "80465e11fc54ee786109f8e2d2d6c4560ee44e5a1de46618c95c56eeb29ea433";
       libraryHaskellDepends = [
         base blaze-html blaze-markup bytestring directory pandoc persistent
         shakespeare texmath text xss-sanitize yesod-core yesod-form
       ];
       testHaskellDepends = [ base blaze-html hspec text ];
       homepage = "http://github.com/pbrisbin/yesod-markdown";
       description = "Tools for using markdown in a yesod application";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "yesod-media-simple" = callPackage
    ({ mkDerivation, base, bytestring, diagrams-cairo, diagrams-core
     , diagrams-lib, directory, JuicyPixels, vector, yesod
     }:
     mkDerivation {
       pname = "yesod-media-simple";
       version = "0.2.0.0";
       sha256 = "d3489fd4cd6f1e1614301939eea8a61222c22f77fe13a6d5460f62fd590cdfe9";
       libraryHaskellDepends = [
         base bytestring diagrams-cairo diagrams-core diagrams-lib directory
         JuicyPixels vector yesod
       ];
       homepage = "https://github.com/mgsloan/yesod-media-simple";
       description = "Simple display of media types, served by yesod";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-newsfeed_1_4_0" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
     , containers, shakespeare, text, time, xml-conduit, yesod-core
     }:
     mkDerivation {
       pname = "yesod-newsfeed";
       version = "1.4.0";
       sha256 = "bc3b39f0541a565603f388ae8463495f550290898d6236269293fabf9deee93e";
       libraryHaskellDepends = [
         base blaze-html blaze-markup bytestring containers shakespeare text
         time xml-conduit yesod-core
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Helper functions and data types for producing News feeds";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-newsfeed_1_4_0_1" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
     , containers, shakespeare, text, time, xml-conduit, yesod-core
     }:
     mkDerivation {
       pname = "yesod-newsfeed";
       version = "1.4.0.1";
       sha256 = "9eb63fae2e00347d9a8873e09d766d82bd36a15b3e2c31553d35ef21629ecd0b";
       libraryHaskellDepends = [
         base blaze-html blaze-markup bytestring containers shakespeare text
         time xml-conduit yesod-core
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Helper functions and data types for producing News feeds";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-newsfeed_1_5" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
     , containers, shakespeare, text, time, xml-conduit, yesod-core
     }:
     mkDerivation {
       pname = "yesod-newsfeed";
       version = "1.5";
       sha256 = "285958baa34c4783ba9c85370fef6ac94d25dd6447aa62e0345eef4f0c0ed25d";
       libraryHaskellDepends = [
         base blaze-html blaze-markup bytestring containers shakespeare text
         time xml-conduit yesod-core
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Helper functions and data types for producing News feeds";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-newsfeed" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
     , containers, shakespeare, text, time, xml-conduit, yesod-core
     }:
     mkDerivation {
       pname = "yesod-newsfeed";
       version = "1.6";
       sha256 = "4e6dbc06002fe7fd13701941c036c51cf9407c35b28473ed509424bfc0b67516";
       libraryHaskellDepends = [
         base blaze-html blaze-markup bytestring containers shakespeare text
         time xml-conduit yesod-core
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Helper functions and data types for producing News feeds";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-paginate" = callPackage
    ({ mkDerivation, base, template-haskell, yesod }:
     mkDerivation {
       pname = "yesod-paginate";
       version = "0.1";
       sha256 = "fe1ec1a93d938b6dd530f4bd4b689e45fe626497f49feb106c9c9cf3f23d1521";
       libraryHaskellDepends = [ base template-haskell yesod ];
       description = "Pagination for Yesod sites";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-pagination" = callPackage
    ({ mkDerivation, base, esqueleto, hspec, monad-logger, persistent
     , persistent-sqlite, resource-pool, resourcet, shakespeare
     , utf8-string, wai-test, yesod, yesod-test
     }:
     mkDerivation {
       pname = "yesod-pagination";
       version = "2.0.0";
       sha256 = "a19e14e81a714e3f69554b77121e04e1a568b3524c287e1a1186de7f3c5a8234";
       libraryHaskellDepends = [ base esqueleto yesod ];
       testHaskellDepends = [
         base hspec monad-logger persistent persistent-sqlite resource-pool
         resourcet shakespeare utf8-string wai-test yesod yesod-test
       ];
       homepage = "https://github.com/joelteon/yesod-pagination";
       description = "Pagination in Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-paginator" = callPackage
    ({ mkDerivation, base, persistent, resourcet, text, transformers
     , yesod
     }:
     mkDerivation {
       pname = "yesod-paginator";
       version = "0.10.0";
       sha256 = "d5316cc72b8c59fc5cac5b4b31deb4597d3ea9c86a5e58b914d38e07ca34af65";
       libraryHaskellDepends = [
         base persistent resourcet text transformers yesod
       ];
       homepage = "http://github.com/pbrisbin/yesod-paginator";
       description = "A pagination approach for yesod";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-persistent_1_4_0_1" = callPackage
    ({ mkDerivation, base, blaze-builder, conduit, hspec, persistent
     , persistent-sqlite, persistent-template, resource-pool, resourcet
     , text, transformers, wai-extra, yesod-core
     }:
     mkDerivation {
       pname = "yesod-persistent";
       version = "1.4.0.1";
       sha256 = "fc035b0732df193dc0d07f613f33fc1b064486d3772388f7c21a76b28c45c420";
       libraryHaskellDepends = [
         base blaze-builder conduit persistent persistent-template
         resource-pool resourcet transformers yesod-core
       ];
       testHaskellDepends = [
         base blaze-builder conduit hspec persistent persistent-sqlite text
         wai-extra yesod-core
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Some helpers for using Persistent from Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-persistent_1_4_0_2" = callPackage
    ({ mkDerivation, base, blaze-builder, conduit, hspec, persistent
     , persistent-sqlite, persistent-template, resource-pool, resourcet
     , text, transformers, wai-extra, yesod-core
     }:
     mkDerivation {
       pname = "yesod-persistent";
       version = "1.4.0.2";
       sha256 = "2b52136573723bbd85b0d51ea016b13da4fe2ba087406a3082609e55017e1f1b";
       libraryHaskellDepends = [
         base blaze-builder conduit persistent persistent-template
         resource-pool resourcet transformers yesod-core
       ];
       testHaskellDepends = [
         base blaze-builder conduit hspec persistent persistent-sqlite text
         wai-extra yesod-core
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Some helpers for using Persistent from Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-persistent" = callPackage
    ({ mkDerivation, base, blaze-builder, conduit, hspec, persistent
     , persistent-sqlite, persistent-template, resource-pool, resourcet
     , text, transformers, wai-extra, yesod-core
     }:
     mkDerivation {
       pname = "yesod-persistent";
       version = "1.4.0.3";
       sha256 = "6455b79eda028e12caefc9d89808fbc611ece36ef64bab3426f90a26cacf3b5f";
       libraryHaskellDepends = [
         base blaze-builder conduit persistent persistent-template
         resource-pool resourcet transformers yesod-core
       ];
       testHaskellDepends = [
         base blaze-builder conduit hspec persistent persistent-sqlite text
         wai-extra yesod-core
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Some helpers for using Persistent from Yesod";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-platform" = callPackage
    ({ mkDerivation, ansi-terminal, ansi-wl-pprint, asn1-encoding
     , asn1-parse, asn1-types, attoparsec-conduit, authenticate
     , auto-update, base, base16-bytestring, base64-bytestring
     , blaze-builder, blaze-builder-conduit, blaze-html, blaze-markup
     , byteable, byteorder, cereal, cipher-aes, cipher-des, cipher-rc4
     , clientsession, conduit, conduit-extra, connection, cookie
     , cprng-aes, crypto-api, crypto-cipher-types, crypto-numbers
     , crypto-pubkey, crypto-pubkey-types, crypto-random, cryptohash
     , cryptohash-conduit, css-text, data-default, data-default-class
     , data-default-instances-base, data-default-instances-containers
     , data-default-instances-dlist, data-default-instances-old-locale
     , dlist, email-validate, entropy, esqueleto, exceptions
     , fast-logger, file-embed, hamlet, hjsmin, hspec
     , hspec-expectations, html-conduit, http-client, http-client-tls
     , http-conduit, http-date, http-reverse-proxy, http-types
     , language-javascript, lifted-base, mime-mail, mime-types, mmorph
     , monad-control, monad-logger, monad-loops, nats, network-conduit
     , optparse-applicative, path-pieces, pem, persistent
     , persistent-template, publicsuffixlist, pwstore-fast
     , quickcheck-io, resource-pool, resourcet, safe, securemem
     , semigroups, setenv, SHA, shakespeare, shakespeare-css
     , shakespeare-i18n, shakespeare-js, shakespeare-text, silently
     , simple-sendfile, skein, socks, stm-chans, streaming-commons
     , stringsearch, system-fileio, system-filepath, tagged, tagsoup
     , tagstream-conduit, tf-random, tls, transformers-base, utf8-string
     , void, wai, wai-app-static, wai-extra, wai-logger, wai-test, warp
     , warp-tls, word8, x509, x509-store, x509-system, x509-validation
     , xml-conduit, xml-types, xss-sanitize, yaml, yesod, yesod-auth
     , yesod-auth-hashdb, yesod-core, yesod-form, yesod-persistent
     , yesod-routes, yesod-static, yesod-test
     }:
     mkDerivation {
       pname = "yesod-platform";
       version = "1.2.13.3";
       sha256 = "9babd4374a49315d3ad5bdedb9a0011fddab63e17373085fa0ed548557aae1c8";
       libraryHaskellDepends = [
         ansi-terminal ansi-wl-pprint asn1-encoding asn1-parse asn1-types
         attoparsec-conduit authenticate auto-update base base16-bytestring
         base64-bytestring blaze-builder blaze-builder-conduit blaze-html
         blaze-markup byteable byteorder cereal cipher-aes cipher-des
         cipher-rc4 clientsession conduit conduit-extra connection cookie
         cprng-aes crypto-api crypto-cipher-types crypto-numbers
         crypto-pubkey crypto-pubkey-types crypto-random cryptohash
         cryptohash-conduit css-text data-default data-default-class
         data-default-instances-base data-default-instances-containers
         data-default-instances-dlist data-default-instances-old-locale
         dlist email-validate entropy esqueleto exceptions fast-logger
         file-embed hamlet hjsmin hspec hspec-expectations html-conduit
         http-client http-client-tls http-conduit http-date
         http-reverse-proxy http-types language-javascript lifted-base
         mime-mail mime-types mmorph monad-control monad-logger monad-loops
         nats network-conduit optparse-applicative path-pieces pem
         persistent persistent-template publicsuffixlist pwstore-fast
         quickcheck-io resource-pool resourcet safe securemem semigroups
         setenv SHA shakespeare shakespeare-css shakespeare-i18n
         shakespeare-js shakespeare-text silently simple-sendfile skein
         socks stm-chans streaming-commons stringsearch system-fileio
         system-filepath tagged tagsoup tagstream-conduit tf-random tls
         transformers-base utf8-string void wai wai-app-static wai-extra
         wai-logger wai-test warp warp-tls word8 x509 x509-store x509-system
         x509-validation xml-conduit xml-types xss-sanitize yaml yesod
         yesod-auth yesod-auth-hashdb yesod-core yesod-form yesod-persistent
         yesod-routes yesod-static yesod-test
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Meta package for Yesod (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-pnotify" = callPackage
    ({ mkDerivation, aeson, base, shakespeare, text, transformers
     , yesod, yesod-form
     }:
     mkDerivation {
       pname = "yesod-pnotify";
       version = "1.1.2";
       sha256 = "9a128a35e68da0de09bb7d603cbc24f9b21942b673540b8812d5f072a1ec60c9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base shakespeare text transformers yesod yesod-form
       ];
       executableHaskellDepends = [
         aeson base shakespeare text transformers yesod yesod-form
       ];
       jailbreak = true;
       homepage = "https://github.com/cutsea110/yesod-pnotify";
       description = "Yet another getMessage/setMessage using pnotify jquery plugins";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-pure" = callPackage
    ({ mkDerivation, base, fast-logger, text, yesod, yesod-core }:
     mkDerivation {
       pname = "yesod-pure";
       version = "0.1.0.2";
       sha256 = "efb7a83712493ec4b1002eb9bf850e7597470d3fd0f820d8f082755b26dc7d6c";
       libraryHaskellDepends = [ base fast-logger text yesod yesod-core ];
       jailbreak = true;
       homepage = "https://github.com/snoyberg/yesod-pure";
       description = "Yesod in pure Haskell: no Template Haskell or QuasiQuotes (deprecated)";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-purescript" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, data-default
     , formatting, fsnotify, mtl, purescript, regex-tdfa
     , regex-tdfa-text, shakespeare, system-fileio, system-filepath
     , template-haskell, text, time, transformers, yesod-core
     }:
     mkDerivation {
       pname = "yesod-purescript";
       version = "0.0.5";
       sha256 = "be5216df86b8086c6eb649daec725298fca14724b4b0271084c57fc70c92312b";
       libraryHaskellDepends = [
         aeson base bytestring containers data-default formatting fsnotify
         mtl purescript regex-tdfa regex-tdfa-text shakespeare system-fileio
         system-filepath template-haskell text time transformers yesod-core
       ];
       jailbreak = true;
       homepage = "https://github.com/mpietrzak/yesod-purescript";
       description = "PureScript integration for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-raml" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, data-default
     , hspec, network-uri, regex-posix, template-haskell, text, th-lift
     , unordered-containers, vector, yaml, yesod-core
     }:
     mkDerivation {
       pname = "yesod-raml";
       version = "0.2.0";
       sha256 = "435ee3add5ed413b655b21619c9830b10148ac465f812aa66023e1ef4256d96c";
       libraryHaskellDepends = [
         aeson base bytestring containers data-default network-uri
         regex-posix template-haskell text th-lift unordered-containers
         vector yaml yesod-core
       ];
       testHaskellDepends = [
         aeson base bytestring containers data-default hspec network-uri
         regex-posix template-haskell text th-lift unordered-containers
         vector yaml yesod-core
       ];
       description = "RAML style route definitions for Yesod";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-raml-bin" = callPackage
    ({ mkDerivation, base, blaze-html, blaze-markup, bytestring
     , containers, http-types, optparse-applicative, shakespeare
     , template-haskell, text, wai, warp, yaml, yesod-core
     , yesod-markdown, yesod-raml, yesod-raml-docs, yesod-raml-mock
     }:
     mkDerivation {
       pname = "yesod-raml-bin";
       version = "0.1.2";
       sha256 = "ccfe7a183fb3be12ba73028f3bb4f022285d05ffa916ea10ee67976177f04278";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base blaze-html blaze-markup bytestring containers http-types
         optparse-applicative shakespeare template-haskell text wai warp
         yaml yesod-core yesod-markdown yesod-raml yesod-raml-docs
         yesod-raml-mock
       ];
       description = "The raml helper executable";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-raml-docs" = callPackage
    ({ mkDerivation, base, bytestring, containers, shakespeare
     , template-haskell, text, yaml, yesod-markdown, yesod-raml
     }:
     mkDerivation {
       pname = "yesod-raml-docs";
       version = "0.1.1";
       sha256 = "9b256e1de318bbaa781fda8cc0d76eeaa3ab676a780e63f946d5b96a6a10bc51";
       libraryHaskellDepends = [
         base bytestring containers shakespeare template-haskell text yaml
         yesod-markdown yesod-raml
       ];
       description = "A html documentation generator library for RAML";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-raml-mock" = callPackage
    ({ mkDerivation, aeson, base, bytestring, containers, hspec
     , network-uri, regex-posix, template-haskell, text
     , unordered-containers, vector, yaml, yesod-core, yesod-raml
     , yesod-test
     }:
     mkDerivation {
       pname = "yesod-raml-mock";
       version = "0.1.1";
       sha256 = "9e69f82bea91a60fe81d7de039b8a697723a53c726d1f5cf49f053a39b0e2dd3";
       libraryHaskellDepends = [
         base bytestring containers template-haskell text yaml yesod-core
         yesod-raml
       ];
       testHaskellDepends = [
         aeson base bytestring containers hspec network-uri regex-posix
         template-haskell text unordered-containers vector yaml yesod-core
         yesod-raml yesod-test
       ];
       description = "A mock-handler generator library from RAML";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-recaptcha" = callPackage
    ({ mkDerivation, base, bytestring, data-default, http-conduit
     , http-types, lifted-base, network, network-info, resourcet, text
     , wai, yesod-auth, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-recaptcha";
       version = "1.4";
       sha256 = "e1909a88282942014b1d8fbf6d5f5a3c06d900da0f3c14cd405b56eed8bf6bb7";
       libraryHaskellDepends = [
         base bytestring data-default http-conduit http-types lifted-base
         network network-info resourcet text wai yesod-auth yesod-core
         yesod-form
       ];
       homepage = "https://github.com/prowdsponsor/yesod-recaptcha";
       description = "Dead simple support for reCAPTCHA on Yesod applications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-routes" = callPackage
    ({ mkDerivation, base, bytestring, containers, hspec, HUnit
     , path-pieces, template-haskell, text, vector
     }:
     mkDerivation {
       pname = "yesod-routes";
       version = "1.2.0.7";
       sha256 = "d25cd11aef62bb11ea630f758b86f20019dfa1355d36b71bc0b657b8b4b72202";
       revision = "1";
       editedCabalFile = "0d622fd91f5c82a3ae54849a9f55e15b39dcc6240f9f2119151362255cd7334e";
       libraryHaskellDepends = [
         base containers path-pieces template-haskell text vector
       ];
       testHaskellDepends = [
         base bytestring containers hspec HUnit path-pieces template-haskell
         text
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Efficient routing for Yesod. (deprecated)";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-routes-flow" = callPackage
    ({ mkDerivation, attoparsec, base, classy-prelude, containers
     , system-fileio, system-filepath, text, yesod-core
     }:
     mkDerivation {
       pname = "yesod-routes-flow";
       version = "2.0";
       sha256 = "f855b3b6886660d3a0cd3d65e359f7e1447fa3fede167d3add1449cc26612e2f";
       libraryHaskellDepends = [
         attoparsec base classy-prelude containers system-fileio
         system-filepath text yesod-core
       ];
       homepage = "https://github.com/frontrowed/yesod-routes-flow";
       description = "Generate Flow routes for Yesod";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-routes-typescript" = callPackage
    ({ mkDerivation, attoparsec, base, classy-prelude, system-fileio
     , text, yesod-core, yesod-routes
     }:
     mkDerivation {
       pname = "yesod-routes-typescript";
       version = "0.3.0.0";
       sha256 = "c9da75e894a57e2e7ee3c2fa99faf5a852d87612402a77cfbb1ff277f576c0be";
       libraryHaskellDepends = [
         attoparsec base classy-prelude system-fileio text yesod-core
         yesod-routes
       ];
       homepage = "https://github.com/docmunch/yesod-routes-typescript";
       description = "generate TypeScript routes for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-rst" = callPackage
    ({ mkDerivation, base, blaze-html, directory, hamlet, pandoc
     , persistent, text, xss-sanitize, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-rst";
       version = "0.2.3";
       sha256 = "e15c0904792cad06002debf32b86754851b0e99592f766501bf3360b0fee68b7";
       libraryHaskellDepends = [
         base blaze-html directory hamlet pandoc persistent text
         xss-sanitize yesod-core yesod-form
       ];
       jailbreak = true;
       homepage = "http://github.com/pSub/yesod-rst";
       description = "Tools for using reStructuredText (RST) in a yesod application";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-s3" = callPackage
    ({ mkDerivation, base, bytestring, conduit, conduit-extra, gd, hS3
     , mtl, network, resourcet, text, yesod-core
     }:
     mkDerivation {
       pname = "yesod-s3";
       version = "0.1.1";
       sha256 = "7b7d386d1e3e3799a24bbdf8e2a4e906a8ad98b6d00b04d4c9b945251426826e";
       libraryHaskellDepends = [
         base bytestring conduit conduit-extra gd hS3 mtl network resourcet
         text yesod-core
       ];
       homepage = "https://github.com/tvh/yesod-s3";
       description = "Simple Helper Library for using Amazon's Simple Storage Service (S3) with Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-sass" = callPackage
    ({ mkDerivation, base, data-default, hsass, shakespeare
     , template-haskell, text, yesod-core
     }:
     mkDerivation {
       pname = "yesod-sass";
       version = "0.1.2.0";
       sha256 = "24e9c36e0faf344785eac6cbedb2ecf154bc0f788bca6442cfeb57cd0e00b357";
       libraryHaskellDepends = [
         base data-default hsass shakespeare template-haskell text
         yesod-core
       ];
       jailbreak = true;
       description = "A simple quasiquoter to include sass code in yesod";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-session-redis" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers, cookie
     , hedis, mtl, network, pool-conduit, random, text, time, wai
     , yesod-core
     }:
     mkDerivation {
       pname = "yesod-session-redis";
       version = "0.1.0";
       sha256 = "3b2f4106c422b40040fbe9ff7904f310d98399f168456b88ecc6b0287b60341a";
       libraryHaskellDepends = [
         base binary bytestring containers cookie hedis mtl network
         pool-conduit random text time wai yesod-core
       ];
       homepage = "https://github.com/ollieh/yesod-session-redis";
       description = "Redis-Powered Sessions for Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-sitemap_1_4_0" = callPackage
    ({ mkDerivation, base, conduit, containers, data-default, text
     , time, xml-conduit, xml-types, yesod-core
     }:
     mkDerivation {
       pname = "yesod-sitemap";
       version = "1.4.0";
       sha256 = "d3055b29edbc114c898dc798b25291c3fe6e8805de01f706a583d8bd8dd7536c";
       libraryHaskellDepends = [
         base conduit containers data-default text time xml-conduit
         xml-types yesod-core
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Generate XML sitemaps";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-sitemap" = callPackage
    ({ mkDerivation, base, conduit, containers, data-default, text
     , time, xml-conduit, xml-types, yesod-core
     }:
     mkDerivation {
       pname = "yesod-sitemap";
       version = "1.4.0.1";
       sha256 = "008449fd90899f1988f32a1341f5be87a73cb6b0e100494525f659e9473e2666";
       libraryHaskellDepends = [
         base conduit containers data-default text time xml-conduit
         xml-types yesod-core
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Generate XML sitemaps";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-static_1_4_0_3" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, cryptohash-conduit, css-text
     , data-default, directory, file-embed, filepath, hashable, hjsmin
     , hspec, http-types, HUnit, mime-types, old-time, process
     , resourcet, system-fileio, system-filepath, template-haskell, text
     , transformers, unix-compat, unordered-containers, wai
     , wai-app-static, wai-extra, yesod-core, yesod-test
     }:
     mkDerivation {
       pname = "yesod-static";
       version = "1.4.0.3";
       sha256 = "8f1c2d33d097044ab3f290dd9257af4e2df279c56a9cab064501ba6c0ea73c97";
       revision = "1";
       editedCabalFile = "612c36043e6689f411fcfbc8551ff1eaeb8fa7115cdbeede1df06e19d3986633";
       libraryHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder byteable
         bytestring conduit conduit-extra containers cryptohash
         cryptohash-conduit css-text data-default directory file-embed
         filepath hashable hjsmin http-types mime-types old-time process
         resourcet system-fileio system-filepath template-haskell text
         transformers unix-compat unordered-containers wai wai-app-static
         yesod-core
       ];
       testHaskellDepends = [
         async base base64-bytestring byteable bytestring conduit
         conduit-extra containers cryptohash cryptohash-conduit data-default
         directory file-embed filepath hjsmin hspec http-types HUnit
         mime-types old-time process resourcet system-fileio system-filepath
         template-haskell text transformers unix-compat unordered-containers
         wai wai-app-static wai-extra yesod-core yesod-test
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Static file serving subsite for Yesod Web Framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-static_1_4_0_4" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, cryptohash-conduit, css-text
     , data-default, directory, file-embed, filepath, hashable, hjsmin
     , hspec, http-types, HUnit, mime-types, old-time, process
     , resourcet, system-fileio, system-filepath, template-haskell, text
     , transformers, unix-compat, unordered-containers, wai
     , wai-app-static, wai-extra, yesod-core, yesod-test
     }:
     mkDerivation {
       pname = "yesod-static";
       version = "1.4.0.4";
       sha256 = "13ab0f7ac81aa2ebacbccef142e2e5f832e747891e0ac67097cd64b5f3a801fc";
       revision = "1";
       editedCabalFile = "e4382652beed552fd6d551a089d482f103220506275cf1f41395a03c37992cc6";
       libraryHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder byteable
         bytestring conduit conduit-extra containers cryptohash
         cryptohash-conduit css-text data-default directory file-embed
         filepath hashable hjsmin http-types mime-types old-time process
         resourcet system-fileio system-filepath template-haskell text
         transformers unix-compat unordered-containers wai wai-app-static
         yesod-core
       ];
       testHaskellDepends = [
         async base base64-bytestring byteable bytestring conduit
         conduit-extra containers cryptohash cryptohash-conduit data-default
         directory file-embed filepath hjsmin hspec http-types HUnit
         mime-types old-time process resourcet system-fileio system-filepath
         template-haskell text transformers unix-compat unordered-containers
         wai wai-app-static wai-extra yesod-core yesod-test
       ];
       jailbreak = true;
       homepage = "http://www.yesodweb.com/";
       description = "Static file serving subsite for Yesod Web Framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-static_1_5_0_2" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, cryptohash-conduit, css-text
     , data-default, directory, file-embed, filepath, hashable, hjsmin
     , hspec, http-types, HUnit, mime-types, old-time, process
     , resourcet, template-haskell, text, transformers, unix-compat
     , unordered-containers, wai, wai-app-static, wai-extra, yesod-core
     , yesod-test
     }:
     mkDerivation {
       pname = "yesod-static";
       version = "1.5.0.2";
       sha256 = "8aec8fc99df9a9910d7a3f732b669753c01dd3ea4177f9e5a7f8cea936b62ea9";
       libraryHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder byteable
         bytestring conduit conduit-extra containers cryptohash
         cryptohash-conduit css-text data-default directory file-embed
         filepath hashable hjsmin http-types mime-types old-time process
         resourcet template-haskell text transformers unix-compat
         unordered-containers wai wai-app-static yesod-core
       ];
       testHaskellDepends = [
         async base base64-bytestring byteable bytestring conduit
         conduit-extra containers cryptohash cryptohash-conduit data-default
         directory file-embed filepath hjsmin hspec http-types HUnit
         mime-types old-time process resourcet template-haskell text
         transformers unix-compat unordered-containers wai wai-app-static
         wai-extra yesod-core yesod-test
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Static file serving subsite for Yesod Web Framework";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-static" = callPackage
    ({ mkDerivation, async, attoparsec, base, base64-bytestring
     , blaze-builder, byteable, bytestring, conduit, conduit-extra
     , containers, cryptohash, cryptohash-conduit, css-text
     , data-default, directory, file-embed, filepath, hashable, hjsmin
     , hspec, http-types, HUnit, mime-types, old-time, process
     , resourcet, template-haskell, text, transformers, unix-compat
     , unordered-containers, wai, wai-app-static, wai-extra, yesod-core
     , yesod-test
     }:
     mkDerivation {
       pname = "yesod-static";
       version = "1.5.0.3";
       sha256 = "a46f952593fc36323aba1352b4b7a2703bb609ec19b709447268e7be24f8ce74";
       libraryHaskellDepends = [
         async attoparsec base base64-bytestring blaze-builder byteable
         bytestring conduit conduit-extra containers cryptohash
         cryptohash-conduit css-text data-default directory file-embed
         filepath hashable hjsmin http-types mime-types old-time process
         resourcet template-haskell text transformers unix-compat
         unordered-containers wai wai-app-static yesod-core
       ];
       testHaskellDepends = [
         async base base64-bytestring byteable bytestring conduit
         conduit-extra containers cryptohash cryptohash-conduit data-default
         directory file-embed filepath hjsmin hspec http-types HUnit
         mime-types old-time process resourcet template-haskell text
         transformers unix-compat unordered-containers wai wai-app-static
         wai-extra yesod-core yesod-test
       ];
       homepage = "http://www.yesodweb.com/";
       description = "Static file serving subsite for Yesod Web Framework";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-static-angular_0_1_6" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, blaze-markup
     , bytestring, data-default, directory, filepath, hamlet, hspec
     , HUnit, language-javascript, mime-types, shakespeare
     , template-haskell, text, yesod, yesod-core, yesod-static
     , yesod-test
     }:
     mkDerivation {
       pname = "yesod-static-angular";
       version = "0.1.6";
       sha256 = "c16af2c227bc51da843e8032218939d804e5d36b7619492c318a9a038099b89d";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base blaze-builder blaze-markup bytestring data-default
         directory filepath hamlet language-javascript mime-types
         shakespeare template-haskell text yesod-core yesod-static
       ];
       executableHaskellDepends = [
         base data-default shakespeare yesod yesod-static
       ];
       testHaskellDepends = [
         base bytestring hamlet hspec HUnit shakespeare template-haskell
         text yesod-core yesod-static yesod-test
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/wuzzeb/yesod-static-angular";
       description = "Yesod generators for embedding AngularJs code into yesod-static at compile time";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-static-angular" = callPackage
    ({ mkDerivation, aeson, base, blaze-builder, blaze-markup
     , bytestring, data-default, directory, filepath, hamlet, hspec
     , HUnit, language-javascript, mime-types, shakespeare
     , template-haskell, text, yesod, yesod-core, yesod-static
     , yesod-test
     }:
     mkDerivation {
       pname = "yesod-static-angular";
       version = "0.1.7";
       sha256 = "73278c6d5a4c5dce23f0c20de08f7f98f3069b4443d16d027f09a0653a203e73";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base blaze-builder blaze-markup bytestring data-default
         directory filepath hamlet language-javascript mime-types
         shakespeare template-haskell text yesod-core yesod-static
       ];
       executableHaskellDepends = [
         base data-default shakespeare yesod yesod-static
       ];
       testHaskellDepends = [
         base bytestring hamlet hspec HUnit shakespeare template-haskell
         text yesod-core yesod-static yesod-test
       ];
       doCheck = false;
       homepage = "https://bitbucket.org/wuzzeb/yesod-static-angular";
       description = "Yesod generators for embedding AngularJs code into yesod-static at compile time";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-table_1_0_3" = callPackage
    ({ mkDerivation, base, containers, contravariant, text, yesod-core
     }:
     mkDerivation {
       pname = "yesod-table";
       version = "1.0.3";
       sha256 = "45be0cd3a30dcd165b7e8c1f27ec3a4fc428ffb801ac2029dcec7f107d6b870b";
       libraryHaskellDepends = [
         base containers contravariant text yesod-core
       ];
       homepage = "https://github.com/andrewthad/yesod-table";
       description = "HTML tables for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-table_1_0_4" = callPackage
    ({ mkDerivation, base, bytestring, containers, contravariant, text
     , yesod-core
     }:
     mkDerivation {
       pname = "yesod-table";
       version = "1.0.4";
       sha256 = "d0de749b9875ad2f744366c48abe0cca88cf96608cdc3462d888c95dfddf1789";
       libraryHaskellDepends = [
         base bytestring containers contravariant text yesod-core
       ];
       homepage = "https://github.com/andrewthad/yesod-table";
       description = "HTML tables for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-table_1_0_6" = callPackage
    ({ mkDerivation, base, bytestring, containers, contravariant, text
     , yesod-core
     }:
     mkDerivation {
       pname = "yesod-table";
       version = "1.0.6";
       sha256 = "69d4f11c31d9928551c7de3b1fc12a470e29ead58729f1b752b773be862e3b30";
       libraryHaskellDepends = [
         base bytestring containers contravariant text yesod-core
       ];
       homepage = "https://github.com/andrewthad/yesod-table";
       description = "HTML tables for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-table_2_0_1" = callPackage
    ({ mkDerivation, base, bytestring, containers, contravariant, text
     , yesod-core
     }:
     mkDerivation {
       pname = "yesod-table";
       version = "2.0.1";
       sha256 = "48ff72f00f6c957585bef6639b38252ba8aec6a2c409b4f59ef0a7b70e56a086";
       libraryHaskellDepends = [
         base bytestring containers contravariant text yesod-core
       ];
       homepage = "https://github.com/andrewthad/yesod-table";
       description = "HTML tables for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-table" = callPackage
    ({ mkDerivation, base, bytestring, containers, contravariant, text
     , yesod-core
     }:
     mkDerivation {
       pname = "yesod-table";
       version = "2.0.2";
       sha256 = "78876b5fac3a0c9725b1dad6ba44923abcce8e86930ee4c4c3f818a7e11d8877";
       libraryHaskellDepends = [
         base bytestring containers contravariant text yesod-core
       ];
       homepage = "https://github.com/andrewthad/yesod-table";
       description = "HTML tables for Yesod";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-tableview" = callPackage
    ({ mkDerivation, base, hamlet, persistent, yesod }:
     mkDerivation {
       pname = "yesod-tableview";
       version = "0.2.1";
       sha256 = "de97f138aa341860b791b48819ac20b1d14c5b17d6218d41ec4885c1d220c7e1";
       libraryHaskellDepends = [ base hamlet persistent yesod ];
       description = "Table view for Yesod applications";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-test_1_4_2" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, case-insensitive, containers, cookie
     , hspec, hspec-core, html-conduit, http-types, HUnit, monad-control
     , network, persistent, text, time, transformers, wai, wai-extra
     , xml-conduit, xml-types, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-test";
       version = "1.4.2";
       sha256 = "74397acb82b9d9d862453f21a7c1da6aa0634f3ad7850bbd0a84bf4837523126";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         case-insensitive containers cookie hspec-core html-conduit
         http-types HUnit monad-control network persistent text time
         transformers wai wai-extra xml-conduit xml-types yesod-core
       ];
       testHaskellDepends = [
         base bytestring containers hspec html-conduit HUnit text wai
         xml-conduit yesod-core yesod-form
       ];
       homepage = "http://www.yesodweb.com";
       description = "integration testing for WAI/Yesod Applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-test_1_4_2_1" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, case-insensitive, containers, cookie
     , hspec, hspec-core, html-conduit, http-types, HUnit, monad-control
     , network, persistent, text, time, transformers, wai, wai-extra
     , xml-conduit, xml-types, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-test";
       version = "1.4.2.1";
       sha256 = "d16ecd1342cc30b80683cadf6e3b5e8e6193a65dc1891753d25a0aa1f627fa40";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         case-insensitive containers cookie hspec-core html-conduit
         http-types HUnit monad-control network persistent text time
         transformers wai wai-extra xml-conduit xml-types yesod-core
       ];
       testHaskellDepends = [
         base bytestring containers hspec html-conduit HUnit text wai
         xml-conduit yesod-core yesod-form
       ];
       homepage = "http://www.yesodweb.com";
       description = "integration testing for WAI/Yesod Applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-test_1_4_2_2" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, case-insensitive, containers, cookie
     , hspec, hspec-core, html-conduit, http-types, HUnit, monad-control
     , network, persistent, text, time, transformers, wai, wai-extra
     , xml-conduit, xml-types, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-test";
       version = "1.4.2.2";
       sha256 = "9b0765481a1958ca1d71d6e1642d20935658f60ed2d123cea89defac8e9859c6";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         case-insensitive containers cookie hspec-core html-conduit
         http-types HUnit monad-control network persistent text time
         transformers wai wai-extra xml-conduit xml-types yesod-core
       ];
       testHaskellDepends = [
         base bytestring containers hspec html-conduit HUnit text wai
         xml-conduit yesod-core yesod-form
       ];
       homepage = "http://www.yesodweb.com";
       description = "integration testing for WAI/Yesod Applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-test_1_4_3" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, case-insensitive, containers, cookie
     , hspec, hspec-core, html-conduit, http-types, HUnit, monad-control
     , network, persistent, text, time, transformers, wai, wai-extra
     , xml-conduit, xml-types, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-test";
       version = "1.4.3";
       sha256 = "233e256bda907f0c60d15374db8d1972e639e8758a51808493cc8d4f9def79c2";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         case-insensitive containers cookie hspec-core html-conduit
         http-types HUnit monad-control network persistent text time
         transformers wai wai-extra xml-conduit xml-types yesod-core
       ];
       testHaskellDepends = [
         base bytestring containers hspec html-conduit HUnit text wai
         xml-conduit yesod-core yesod-form
       ];
       homepage = "http://www.yesodweb.com";
       description = "integration testing for WAI/Yesod Applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-test_1_4_3_1" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, case-insensitive, containers, cookie
     , hspec, hspec-core, html-conduit, http-types, HUnit, monad-control
     , network, persistent, text, time, transformers, wai, wai-extra
     , xml-conduit, xml-types, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-test";
       version = "1.4.3.1";
       sha256 = "a29e0173b31aacaa4a0235bfdcc8c7809b8685a9069a1f5b6083f204d1fd1394";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         case-insensitive containers cookie hspec-core html-conduit
         http-types HUnit monad-control network persistent text time
         transformers wai wai-extra xml-conduit xml-types yesod-core
       ];
       testHaskellDepends = [
         base bytestring containers hspec html-conduit HUnit text wai
         xml-conduit yesod-core yesod-form
       ];
       homepage = "http://www.yesodweb.com";
       description = "integration testing for WAI/Yesod Applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-test_1_4_4" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, case-insensitive, containers, cookie
     , hspec, hspec-core, html-conduit, http-types, HUnit, monad-control
     , network, persistent, text, time, transformers, wai, wai-extra
     , xml-conduit, xml-types, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-test";
       version = "1.4.4";
       sha256 = "131739ec3d037c51a7d538e9a97b0be7b338675a1dec92e1de70b19c415ee597";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         case-insensitive containers cookie hspec-core html-conduit
         http-types HUnit monad-control network persistent text time
         transformers wai wai-extra xml-conduit xml-types yesod-core
       ];
       testHaskellDepends = [
         base bytestring containers hspec html-conduit HUnit text wai
         xml-conduit yesod-core yesod-form
       ];
       homepage = "http://www.yesodweb.com";
       description = "integration testing for WAI/Yesod Applications";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-test" = callPackage
    ({ mkDerivation, attoparsec, base, blaze-builder, blaze-html
     , blaze-markup, bytestring, case-insensitive, containers, cookie
     , hspec, hspec-core, html-conduit, http-types, HUnit, monad-control
     , network, persistent, text, time, transformers, wai, wai-extra
     , xml-conduit, xml-types, yesod-core, yesod-form
     }:
     mkDerivation {
       pname = "yesod-test";
       version = "1.5.0.1";
       sha256 = "9b19fb51e901935f8b0926e3b9bbae772d45967a747fb3a1bf9cb893724c29a4";
       libraryHaskellDepends = [
         attoparsec base blaze-builder blaze-html blaze-markup bytestring
         case-insensitive containers cookie hspec-core html-conduit
         http-types HUnit monad-control network persistent text time
         transformers wai wai-extra xml-conduit xml-types yesod-core
       ];
       testHaskellDepends = [
         base bytestring containers hspec html-conduit http-types HUnit text
         wai xml-conduit yesod-core yesod-form
       ];
       homepage = "http://www.yesodweb.com";
       description = "integration testing for WAI/Yesod Applications";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-test-json" = callPackage
    ({ mkDerivation, aeson, base, bytestring, conduit, hspec
     , http-types, HUnit, text, transformers, wai, wai-test
     , yesod-default
     }:
     mkDerivation {
       pname = "yesod-test-json";
       version = "0.2.0.0";
       sha256 = "708131165b3bcecdeccc9c389868ea22b3f2833be6035c5df5ef7a5790beccfc";
       libraryHaskellDepends = [
         aeson base bytestring conduit hspec http-types HUnit text
         transformers wai wai-test yesod-default
       ];
       jailbreak = true;
       homepage = "https://github.com/bogiebro/yesod-test-json";
       description = "Utility functions for testing JSON web services written in Yesod";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-text-markdown_0_1_7" = callPackage
    ({ mkDerivation, aeson, base, markdown, persistent, shakespeare
     , text, yesod-core, yesod-form, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-text-markdown";
       version = "0.1.7";
       sha256 = "399786d26f682d0e23d2cde48aa312de413291a869a87f9f5f1810819cd87f8c";
       libraryHaskellDepends = [
         aeson base markdown persistent shakespeare text yesod-core
         yesod-form yesod-persistent
       ];
       jailbreak = true;
       description = "Yesod support for Text.Markdown.";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-text-markdown" = callPackage
    ({ mkDerivation, aeson, base, markdown, persistent, shakespeare
     , text, yesod-core, yesod-form, yesod-persistent
     }:
     mkDerivation {
       pname = "yesod-text-markdown";
       version = "0.1.8";
       sha256 = "0169dbd252696f30bb4d7f49f2f116e7e42aadf2e322b85982746f62ade488cc";
       libraryHaskellDepends = [
         aeson base markdown persistent shakespeare text yesod-core
         yesod-form yesod-persistent
       ];
       description = "Yesod support for Text.Markdown.";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-tls" = callPackage
    ({ mkDerivation, base, fast-logger, monad-logger, template-haskell
     , unix, wai, wai-extra, warp, warp-tls, yesod
     }:
     mkDerivation {
       pname = "yesod-tls";
       version = "1.4.1";
       sha256 = "c8c8b4da7d8d4b312dec12a1601077dca2a474378811c916e437143f2364707f";
       libraryHaskellDepends = [
         base fast-logger monad-logger template-haskell unix wai wai-extra
         warp warp-tls yesod
       ];
       homepage = "http://github.com/netom/yesod-tls";
       description = "Provides main functions using warp-tls for yesod projects";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-transloadit" = callPackage
    ({ mkDerivation, aeson, base, byteable, bytestring, containers
     , cryptohash, hspec, lens, lens-aeson, mime, network-uri
     , old-locale, shakespeare, text, time, transformers
     , unordered-containers, yesod, yesod-core, yesod-form, yesod-test
     }:
     mkDerivation {
       pname = "yesod-transloadit";
       version = "0.7.1.0";
       sha256 = "f04e7b1e46c2a62685d48fad9d7616e6774daa0df07d7d54a1d7cfb5d428ade2";
       libraryHaskellDepends = [
         aeson base byteable bytestring cryptohash lens lens-aeson mime
         network-uri old-locale shakespeare text time transformers
         unordered-containers yesod yesod-core yesod-form
       ];
       testHaskellDepends = [
         aeson base containers hspec mime network-uri old-locale text yesod
         yesod-form yesod-test
       ];
       description = "Transloadit support for Yesod";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-vend" = callPackage
    ({ mkDerivation, base, blaze-html, hamlet, monad-logger, persistent
     , persistent-sqlite, resourcet, text, yesod, yesod-form
     }:
     mkDerivation {
       pname = "yesod-vend";
       version = "0.3.0.0";
       sha256 = "49065a74380fca7d0c790e47a3f5b3a14bf72d8f2ac829eaf55098691e816a98";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-html hamlet persistent text yesod yesod-form
       ];
       executableHaskellDepends = [
         base blaze-html hamlet monad-logger persistent persistent-sqlite
         resourcet text yesod yesod-form
       ];
       jailbreak = true;
       homepage = "https://github.com/Tener/yesod-vend";
       description = "Simple CRUD classes for easy view creation for Yesod";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-websockets_0_2_0" = callPackage
    ({ mkDerivation, async, base, conduit, monad-control, transformers
     , wai, wai-websockets, websockets, yesod-core
     }:
     mkDerivation {
       pname = "yesod-websockets";
       version = "0.2.0";
       sha256 = "60fd537001a9aa71caec88f35c037a5f265400fa16b6dfec44a5d84308a73686";
       libraryHaskellDepends = [
         async base conduit monad-control transformers wai wai-websockets
         websockets yesod-core
       ];
       homepage = "https://github.com/yesodweb/yesod";
       description = "WebSockets support for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-websockets_0_2_1" = callPackage
    ({ mkDerivation, async, base, conduit, monad-control, transformers
     , wai, wai-websockets, websockets, yesod-core
     }:
     mkDerivation {
       pname = "yesod-websockets";
       version = "0.2.1";
       sha256 = "ca1be9696ff8257c984355aa328f634ec083272e42322dd8592a346bd086874b";
       libraryHaskellDepends = [
         async base conduit monad-control transformers wai wai-websockets
         websockets yesod-core
       ];
       homepage = "https://github.com/yesodweb/yesod";
       description = "WebSockets support for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-websockets_0_2_1_1" = callPackage
    ({ mkDerivation, async, base, conduit, monad-control, transformers
     , wai, wai-websockets, websockets, yesod-core
     }:
     mkDerivation {
       pname = "yesod-websockets";
       version = "0.2.1.1";
       sha256 = "aa19fe431c0eeecf4c15ad7812d11468f9c901de7ab77596442716589ef2554f";
       libraryHaskellDepends = [
         async base conduit monad-control transformers wai wai-websockets
         websockets yesod-core
       ];
       homepage = "https://github.com/yesodweb/yesod";
       description = "WebSockets support for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-websockets_0_2_3" = callPackage
    ({ mkDerivation, async, base, conduit, enclosed-exceptions
     , monad-control, transformers, wai, wai-websockets, websockets
     , yesod-core
     }:
     mkDerivation {
       pname = "yesod-websockets";
       version = "0.2.3";
       sha256 = "3501f9fb82e0baccf004d64d96ad612450f51ef24c7ebe75cd94f5c9c9a47396";
       libraryHaskellDepends = [
         async base conduit enclosed-exceptions monad-control transformers
         wai wai-websockets websockets yesod-core
       ];
       homepage = "https://github.com/yesodweb/yesod";
       description = "WebSockets support for Yesod";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yesod-websockets" = callPackage
    ({ mkDerivation, async, base, conduit, enclosed-exceptions
     , monad-control, transformers, wai, wai-websockets, websockets
     , yesod-core
     }:
     mkDerivation {
       pname = "yesod-websockets";
       version = "0.2.4";
       sha256 = "7067115f0e7e282879718798bba627ab967eb38a419fc2180cc6b58259ea9adc";
       libraryHaskellDepends = [
         async base conduit enclosed-exceptions monad-control transformers
         wai wai-websockets websockets yesod-core
       ];
       homepage = "https://github.com/yesodweb/yesod";
       description = "WebSockets support for Yesod";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yesod-websockets-extra" = callPackage
    ({ mkDerivation, base, enclosed-exceptions, transformers
     , websockets, yesod-websockets
     }:
     mkDerivation {
       pname = "yesod-websockets-extra";
       version = "0.1.0.0";
       sha256 = "afccdbe17eb2924f7d0e37a48d4a2d2dc971c11a23c1421d86f24686f8a14f10";
       libraryHaskellDepends = [
         base enclosed-exceptions transformers websockets yesod-websockets
       ];
       description = "Extension to yesod-websockets";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yesod-worker" = callPackage
    ({ mkDerivation, base, containers, fast-logger, monad-control
     , monad-logger, persistent, resourcet, stm, template-haskell
     , transformers, transformers-base, yesod, yesod-core
     }:
     mkDerivation {
       pname = "yesod-worker";
       version = "0.0.1";
       sha256 = "6dde8ff89cd2a4832c6f24172e3694b5a4f8767ad2315c6734b58a0e61e095e7";
       libraryHaskellDepends = [
         base containers fast-logger monad-control monad-logger persistent
         resourcet stm template-haskell transformers transformers-base yesod
         yesod-core
       ];
       jailbreak = true;
       homepage = "https://github.com/jamesdabbs/yesod-worker";
       description = "Drop-in(ish) background worker system for Yesod apps";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yet-another-logger" = callPackage
    ({ mkDerivation, aeson, ansi-terminal, async, base
     , base-unicode-symbols, bytestring, Cabal, case-insensitive, clock
     , configuration-tools, deepseq, either, enclosed-exceptions, lens
     , lifted-base, monad-control, mtl, optparse-applicative, stm
     , stm-chans, tagged, tasty, tasty-hunit, text, time, trace
     , transformers, transformers-base, void
     }:
     mkDerivation {
       pname = "yet-another-logger";
       version = "0.2.3.1";
       sha256 = "a0aa32135fa7e55f736a3dbca497edd035e284d6a6e9469a257937a827593ad5";
       revision = "1";
       editedCabalFile = "09206c65c7dfc32bff85a2f2f295561bfcb95067f74d460a0597ce448ed6fb27";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson ansi-terminal async base base-unicode-symbols bytestring
         case-insensitive clock configuration-tools deepseq either
         enclosed-exceptions lens lifted-base monad-control mtl
         optparse-applicative stm stm-chans text time trace transformers
         transformers-base void
       ];
       executableHaskellDepends = [ base Cabal ];
       testHaskellDepends = [
         async base base-unicode-symbols configuration-tools
         enclosed-exceptions lens lifted-base tagged tasty tasty-hunit text
         transformers transformers-base void
       ];
       homepage = "https://github.com/alephcloud/hs-yet-another-logger";
       description = "Yet Another Logger";
       license = stdenv.lib.licenses.asl20;
     }) {};

  "yhccore" = callPackage
    ({ mkDerivation, base, containers, mtl, pretty, uniplate }:
     mkDerivation {
       pname = "yhccore";
       version = "0.9.1";
       sha256 = "23715d06a973b5967ac9681d0d2f8e65d0bbda0ff8c9e587381702db2ffdf2a1";
       libraryHaskellDepends = [ base containers mtl pretty uniplate ];
       homepage = "http://www.haskell.org/haskellwiki/Yhc";
       description = "Yhc's Internal Core language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yi" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, Cabal, containers
     , data-default, directory, dlist, dynamic-state, dyre, exceptions
     , filepath, glib, gtk, hashable, hint, HUnit, lens, mtl, old-locale
     , oo-prototypes, pango, parsec, pointedlist, process, QuickCheck
     , random, safe, semigroups, split, stm, tasty, tasty-hunit
     , tasty-quickcheck, template-haskell, text, text-icu, time
     , transformers-base, unix, unix-compat, unordered-containers, vty
     , word-trie, xdg-basedir, yi-language, yi-rope
     }:
     mkDerivation {
       pname = "yi";
       version = "0.12.3";
       sha256 = "2ce8a6cd30f67839eba0581f8643fd80ff9138059d9b66d3b689cc867b9562b6";
       configureFlags = [ "-fpango" "-fvty" ];
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring Cabal containers data-default
         directory dlist dynamic-state dyre exceptions filepath glib gtk
         hashable hint lens mtl old-locale oo-prototypes pango parsec
         pointedlist process QuickCheck random safe semigroups split stm
         template-haskell text text-icu time transformers-base unix
         unix-compat unordered-containers vty word-trie xdg-basedir
         yi-language yi-rope
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         base directory filepath HUnit lens QuickCheck semigroups tasty
         tasty-hunit tasty-quickcheck text yi-language yi-rope
       ];
       homepage = "https://yi-editor.github.io";
       description = "The Haskell-Scriptable Editor";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "yi-contrib" = callPackage
    ({ mkDerivation, base, containers, directory, filepath, lens, mtl
     , old-locale, oo-prototypes, split, text, time, transformers-base
     , yi, yi-language, yi-rope
     }:
     mkDerivation {
       pname = "yi-contrib";
       version = "0.10.1";
       sha256 = "33241e693d944410061d244a8c5b48a77414e42b4912389cade2f13ea1d27014";
       libraryHaskellDepends = [
         base containers directory filepath lens mtl old-locale
         oo-prototypes split text time transformers-base yi yi-language
         yi-rope
       ];
       jailbreak = true;
       homepage = "http://haskell.org/haskellwiki/Yi";
       description = "Add-ons to Yi, the Haskell-Scriptable Editor";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yi-emacs-colours" = callPackage
    ({ mkDerivation, base, containers, split, yi-language }:
     mkDerivation {
       pname = "yi-emacs-colours";
       version = "0.1.0.1";
       sha256 = "1ba373a9bf2311b35f9664df6b6e6bd6c545352a0c4cf9e26eeb980c74d26dcd";
       libraryHaskellDepends = [ base containers split yi-language ];
       homepage = "https://github.com/Fuuzetsu/yi-emacs-colours";
       description = "Simple mapping from colour names used in emacs to Color";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "yi-fuzzy-open" = callPackage
    ({ mkDerivation, base, binary, containers, data-default, directory
     , filepath, mtl, text, transformers-base, vector, yi, yi-language
     , yi-rope
     }:
     mkDerivation {
       pname = "yi-fuzzy-open";
       version = "0.1.0.1";
       sha256 = "92eda3ac60f57509716f8473c840d6a46b1be52f3713b27c1a5d0aa70978b02a";
       libraryHaskellDepends = [
         base binary containers data-default directory filepath mtl text
         transformers-base vector yi yi-language yi-rope
       ];
       homepage = "https://github.com/yi-editor/yi-fuzzy-open";
       description = "Fuzzy open plugin for Yi";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "yi-gtk" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "yi-gtk";
       version = "0.3";
       sha256 = "df9a6f64b41999e8f46f6e096b67d3d3eb88d2b2b379548ce744bc817bfeedd1";
       doHaddock = false;
       homepage = "http://haskell.org/haskellwiki/Yi";
       description = "The Haskell-Scriptable Editor, helper package";
       license = "GPL";
     }) {};

  "yi-language" = callPackage
    ({ mkDerivation, alex, array, base, binary, containers
     , data-default, filepath, hashable, hspec, lens, oo-prototypes
     , pointedlist, QuickCheck, regex-base, regex-tdfa, template-haskell
     , transformers-base, unordered-containers
     }:
     mkDerivation {
       pname = "yi-language";
       version = "0.2.0";
       sha256 = "70efb97b787367600871fa68ad794b1af9868ca8e21d0e32960997615bdb14a8";
       libraryHaskellDepends = [
         array base binary containers data-default hashable lens
         oo-prototypes pointedlist regex-base regex-tdfa template-haskell
         transformers-base unordered-containers
       ];
       libraryToolDepends = [ alex ];
       testHaskellDepends = [
         array base binary containers data-default filepath hashable hspec
         lens pointedlist QuickCheck regex-base regex-tdfa template-haskell
         transformers-base unordered-containers
       ];
       homepage = "https://github.com/yi-editor/yi-language";
       description = "Collection of language-related Yi libraries";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "yi-monokai" = callPackage
    ({ mkDerivation, base, yi }:
     mkDerivation {
       pname = "yi-monokai";
       version = "0.1.1.2";
       sha256 = "1498c5e391b1a12989f8e68531abf4dd58e41b130cf0650909bf49e4a377f0d9";
       libraryHaskellDepends = [ base yi ];
       homepage = "https://github.com/Fuuzetsu/yi-monokai";
       description = "Monokai colour theme for the Yi text editor";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yi-rope" = callPackage
    ({ mkDerivation, base, binary, bytestring, charsetdetect-ae
     , data-default, deepseq, fingertree, hspec, QuickCheck
     , quickcheck-instances, text, text-icu
     }:
     mkDerivation {
       pname = "yi-rope";
       version = "0.7.0.1";
       sha256 = "e0d56d061a7b5e44d0b82290e7c03ef0c5cf278071c8264a23feb7bd725919a4";
       libraryHaskellDepends = [
         base binary bytestring charsetdetect-ae data-default deepseq
         fingertree text text-icu
       ];
       testHaskellDepends = [
         base hspec QuickCheck quickcheck-instances text
       ];
       description = "A rope data structure used by Yi";
       license = stdenv.lib.licenses.gpl2;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {};

  "yi-snippet" = callPackage
    ({ mkDerivation, base, containers, yi, yi-rope }:
     mkDerivation {
       pname = "yi-snippet";
       version = "0.1.0.0";
       sha256 = "2d8d646ed19ab1f911d15a0095942abefce3fd6f743fdc9e8169ed454f2f7661";
       libraryHaskellDepends = [ base containers yi yi-rope ];
       homepage = "https://github.com/yi-editor/yi-snippet";
       description = "Snippet support for Yi";
       license = stdenv.lib.licenses.gpl2;
     }) {};

  "yi-solarized" = callPackage
    ({ mkDerivation, base, yi }:
     mkDerivation {
       pname = "yi-solarized";
       version = "0.1.1";
       sha256 = "cca668fc697f2fa70b4ece2d234c78d621f0a34ef2174a17001be6b753952e9e";
       libraryHaskellDepends = [ base yi ];
       homepage = "https://github.com/NorfairKing/yi-solarized";
       description = "Solarized colour theme for the Yi text editor";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yi-spolsky" = callPackage
    ({ mkDerivation, base, yi }:
     mkDerivation {
       pname = "yi-spolsky";
       version = "0.1";
       sha256 = "d8ecaf71704c295944ae6648685a6b00d3787911b1763b0213629840bad05e94";
       libraryHaskellDepends = [ base yi ];
       jailbreak = true;
       homepage = "https://github.com/melrief/yi-spolsky";
       description = "Spolsky colour theme for the Yi text editor";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yi-vty" = callPackage
    ({ mkDerivation }:
     mkDerivation {
       pname = "yi-vty";
       version = "0.3";
       sha256 = "89a59deaa080460e6103d48393a3dc1a1155f2b63b7a729dd14125dc59475706";
       doHaddock = false;
       homepage = "http://haskell.org/haskellwiki/Yi";
       description = "The Haskell-Scriptable Editor, helper package";
       license = "GPL";
     }) {};

  "yices" = callPackage
    ({ mkDerivation, base, parsec, process }:
     mkDerivation {
       pname = "yices";
       version = "0.0.0.12";
       sha256 = "3fa62e7d44fe212070874aaacdc677cb660440265c9c1ec260605ed5123a78cc";
       libraryHaskellDepends = [ base parsec process ];
       description = "Haskell programming interface to Yices SMT solver";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yices-easy" = callPackage
    ({ mkDerivation, base, bindings-yices, containers, transformers }:
     mkDerivation {
       pname = "yices-easy";
       version = "0.1";
       sha256 = "e0ec40beff46076b71a89914a3c69816f8f3463887d5a3f4abf85ae4741cd48e";
       libraryHaskellDepends = [
         base bindings-yices containers transformers
       ];
       homepage = "http://www.ugcs.caltech.edu/~keegan/haskell/yices-easy/";
       description = "Simple interface to the Yices SMT (SAT modulo theories) solver";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yices-painless" = callPackage
    ({ mkDerivation, base, containers, gmp, pretty, strict-concurrency
     , vector, yices
     }:
     mkDerivation {
       pname = "yices-painless";
       version = "0.1.2";
       sha256 = "705c91fc3c814680109a923adf1be50c436b8085465fefc0c2e0a606f7ef10e0";
       libraryHaskellDepends = [
         base containers pretty strict-concurrency vector
       ];
       librarySystemDepends = [ gmp yices ];
       homepage = "http://code.haskell.org/~dons/code/yices-painless";
       description = "An embedded language for programming the Yices SMT solver";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) gmp; inherit (pkgs) yices;};

  "yjftp" = callPackage
    ({ mkDerivation, base, directory, ftphs, haskeline, hsConfigure
     , mtl, process, unix
     }:
     mkDerivation {
       pname = "yjftp";
       version = "0.3.6.5";
       sha256 = "d548eb7232947803143ff06800a412e2808716de3f51d24614c78d9eebf93c86";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base directory ftphs haskeline mtl process unix
       ];
       executableHaskellDepends = [ hsConfigure ];
       jailbreak = true;
       homepage = "http://homepage3.nifty.com/salamander/second/projects/yjftp/index.xhtml";
       description = "CUI FTP client like 'ftp', 'ncftp'";
       license = "GPL";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yjftp-libs" = callPackage
    ({ mkDerivation, base, directory, ftphs, mtl, process, unix }:
     mkDerivation {
       pname = "yjftp-libs";
       version = "0.0.2";
       sha256 = "44c0e175e422b616287f851c76d5cabeb069a0ecd301c3de79940ca0424c9ce6";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base directory ftphs mtl process unix ];
       jailbreak = true;
       homepage = "http://homepage3.nifty.com/salamander/second/projects/yjftp/index.xhtml";
       description = "CUI FTP client like 'ftp', 'ncftp'";
       license = "GPL";
     }) {};

  "yjsvg" = callPackage
    ({ mkDerivation, base, HaXml }:
     mkDerivation {
       pname = "yjsvg";
       version = "0.2.0.0";
       sha256 = "4841c8f1120ba253c616ff48cffd63d2ca7ba87127bc428b5fa5fc7d6dbe6f17";
       libraryHaskellDepends = [ base HaXml ];
       jailbreak = true;
       description = "make SVG string from Haskell data";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yjtools" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "yjtools";
       version = "0.9.18";
       sha256 = "9b121c6fcece8241d87aec737458d49c0b76313e9e5e1e70f72b5f71cfc0eb8f";
       libraryHaskellDepends = [ base ];
       homepage = "http://homepage3.nifty.com/salamander/second/projects/yjtools/index.xhtml";
       description = "some tools for Monad, List, Tuple and so on";
       license = "LGPL";
     }) {};

  "yocto" = callPackage
    ({ mkDerivation, base, containers, parsec, QuickCheck
     , quickcheck-instances
     }:
     mkDerivation {
       pname = "yocto";
       version = "1.0.1";
       sha256 = "2ae1b12de08bab5911f69220a3e34dfe49c65fdda5f221f8c4c642ae54f62245";
       libraryHaskellDepends = [ base containers parsec ];
       testHaskellDepends = [
         base containers parsec QuickCheck quickcheck-instances
       ];
       homepage = "https://github.com/ajg/yocto";
       description = "A Minimal JSON Parser & Printer for Haskell";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yoctoparsec" = callPackage
    ({ mkDerivation, base, free, mtl }:
     mkDerivation {
       pname = "yoctoparsec";
       version = "0.1.0.0";
       sha256 = "d70739d3429dede8800290939dbd08d0e23cacb5717402ba93f931fa80e1335d";
       libraryHaskellDepends = [ base free mtl ];
       homepage = "https://github.com/mniip/yoctoparsec";
       description = "A truly tiny monadic parsing library";
       license = stdenv.lib.licenses.mit;
     }) {};

  "yoko" = callPackage
    ({ mkDerivation, base, bifunctors, containers, invariant, kinds
     , mtl, records, semigroups, template-haskell, th-sccs, type-cereal
     , type-digits, type-equality, type-functions, type-ord
     , type-ord-spine-cereal, type-spine
     }:
     mkDerivation {
       pname = "yoko";
       version = "2.0";
       sha256 = "e69b423a169d66af78eebd35c929bdc71f324309d78d028ef457d6d54d673b1e";
       libraryHaskellDepends = [
         base bifunctors containers invariant kinds mtl records semigroups
         template-haskell th-sccs type-cereal type-digits type-equality
         type-functions type-ord type-ord-spine-cereal type-spine
       ];
       description = "Generic Programming with Disbanded Data Types";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "york-lava" = callPackage
    ({ mkDerivation, base, containers, haskell98 }:
     mkDerivation {
       pname = "york-lava";
       version = "0.2";
       sha256 = "0b1fe9f05c493bdba3319745abb9496d6af6e9bdabcc584ca29fa0b91dedf3e6";
       libraryHaskellDepends = [ base containers haskell98 ];
       homepage = "http://www.cs.york.ac.uk/fp/reduceron/";
       description = "A library for digital circuit description";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "youtube" = callPackage
    ({ mkDerivation, base, bytestring, process, utility-ht }:
     mkDerivation {
       pname = "youtube";
       version = "0.2.0.1";
       sha256 = "a40a7a4d25e701c805262f9b0c9e6fdfd78d5b57185cc366fb8d51a7d0396358";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base bytestring process utility-ht ];
       description = "Upload video to YouTube via YouTube API";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "yql" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , containers, cryptohash, data-default, ecma262, exceptions
     , hslogger, http-conduit, http-types, hxt, lens, opendatatable
     , parsec, SHA, text, transformers, unordered-containers
     , uri-template, utf8-string, uuid, vector, zlib
     }:
     mkDerivation {
       pname = "yql";
       version = "0.0.0";
       sha256 = "e65d91f868a2abe3f903a6c69625e91c159683c474761b11a96236db143a93e3";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring containers cryptohash
         data-default ecma262 exceptions hslogger http-conduit http-types
         lens opendatatable parsec SHA text transformers
         unordered-containers uri-template utf8-string uuid vector zlib
       ];
       executableHaskellDepends = [
         base containers ecma262 exceptions hxt opendatatable
       ];
       jailbreak = true;
       homepage = "https://github.com/fabianbergmark/YQL";
       description = "A YQL engine to execute Open Data Tables";
       license = stdenv.lib.licenses.bsd2;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yst" = callPackage
    ({ mkDerivation, aeson, base, containers, csv, directory, filepath
     , HDBC, HDBC-sqlite3, HStringTemplate, lucid, old-locale, old-time
     , pandoc, parsec, scientific, split, text, time
     , unordered-containers, yaml
     }:
     mkDerivation {
       pname = "yst";
       version = "0.5.1";
       sha256 = "603afd33877c086221b0914463bb92943df49aecc9e4a7fb58f4f35386199f71";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         aeson base containers csv directory filepath HDBC HDBC-sqlite3
         HStringTemplate lucid old-locale old-time pandoc parsec scientific
         split text time unordered-containers yaml
       ];
       homepage = "http://github.com/jgm/yst";
       description = "Builds a static website from templates and data in YAML or CSV files";
       license = "GPL";
     }) {};

  "yuiGrid" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "yuiGrid";
       version = "0.1";
       sha256 = "f873ff02496984d5a6bdcc028b78261240c2b93d05e766c00988029a7206b400";
       libraryHaskellDepends = [ base ];
       description = "Grids defined by layout hints and implemented on top of Yahoo grids";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yuuko" = callPackage
    ({ mkDerivation, base, bytestring, containers, curl, deepseq
     , directory, filepath, haskell98, mtl, network, parsec
     }:
     mkDerivation {
       pname = "yuuko";
       version = "2010.11.28";
       sha256 = "e48caecf03ad2afec5d95e7a50e2aed0ef40241edfd5c0b226a33e6a5e05ee06";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring containers curl deepseq directory filepath
         haskell98 mtl network parsec
       ];
       executableHaskellDepends = [
         base bytestring containers curl deepseq directory filepath
         haskell98 mtl network parsec
       ];
       homepage = "http://github.com/nfjinjing/yuuko";
       description = "A transcendental HTML parser gently wrapping the HXT library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "yxdb-utils" = callPackage
    ({ mkDerivation, array, attoparsec, base, bimap, binary
     , binary-conduit, bytestring, Codec-Compression-LZF, conduit
     , conduit-combinators, conduit-extra, containers, csv-conduit
     , Decimal, directory, exceptions, ghc-prim, HUnit, lens
     , monad-loops, mtl, newtype, old-locale, parsec, primitive
     , QuickCheck, quickcheck-instances, reinterpret-cast, resourcet
     , test-framework, test-framework-hunit, test-framework-quickcheck2
     , text, text-binary, time, transformers, vector, xml-conduit
     }:
     mkDerivation {
       pname = "yxdb-utils";
       version = "0.1.0.1";
       sha256 = "e8a9963ac48c55a4ed28e4f4bd2884eef340c67b84677fb2d2a7e3db1c514b15";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array attoparsec base bimap binary binary-conduit bytestring
         Codec-Compression-LZF conduit conduit-combinators conduit-extra
         containers csv-conduit Decimal directory exceptions ghc-prim lens
         monad-loops mtl newtype old-locale parsec primitive
         reinterpret-cast resourcet text text-binary time transformers
         vector xml-conduit
       ];
       executableHaskellDepends = [ base ];
       testHaskellDepends = [
         array attoparsec base bimap binary binary-conduit bytestring
         Codec-Compression-LZF conduit conduit-combinators conduit-extra
         containers csv-conduit Decimal directory exceptions ghc-prim HUnit
         lens monad-loops mtl newtype old-locale parsec primitive QuickCheck
         quickcheck-instances reinterpret-cast resourcet test-framework
         test-framework-hunit test-framework-quickcheck2 text text-binary
         time transformers vector xml-conduit
       ];
       description = "Utilities for reading and writing Alteryx .yxdb files";
       license = stdenv.lib.licenses.gpl3;
       hydraPlatforms = [ "x86_64-darwin" "x86_64-linux" ];
     }) {};

  "z3" = callPackage
    ({ mkDerivation, base, containers, gomp, hspec, mtl, QuickCheck, z3
     }:
     mkDerivation {
       pname = "z3";
       version = "4.1.0";
       sha256 = "096f9f4b92f5c9591d3098022b0b4047d1d6c4b970dc7d3ead6129d67fe4f5ee";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base containers mtl ];
       librarySystemDepends = [ gomp z3 ];
       testHaskellDepends = [ base hspec QuickCheck ];
       homepage = "http://bitbucket.org/iago/z3-haskell";
       description = "Bindings for the Z3 Theorem Prover";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = [ "i686-linux" "x86_64-linux" ];
     }) {gomp = null; inherit (pkgs) z3;};

  "zalgo" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "zalgo";
       version = "0.2.0.0";
       sha256 = "5f63a88038ee13dd594907b3591ea2747a563f2a591294b7285a9db83539bf5b";
       libraryHaskellDepends = [ base ];
       homepage = "http://github.com/mniip/zalgo";
       description = "Z-algorithm implemented on haskell's built-in cons-cell-based lists";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "zampolit" = callPackage
    ({ mkDerivation, base, cmdargs, containers, directory, filepath
     , HSH, MissingH, old-locale, parsec, time
     }:
     mkDerivation {
       pname = "zampolit";
       version = "0.3";
       sha256 = "c3b7da5e2ca328c89cebafe0179550db4e471659ac774468eb980662174a17ae";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base cmdargs containers directory filepath HSH MissingH old-locale
         parsec time
       ];
       homepage = "https://github.com/briansniffen/zampolit";
       description = "A tool for checking how much work is done on group projects";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zasni-gerna" = callPackage
    ({ mkDerivation, base, papillon }:
     mkDerivation {
       pname = "zasni-gerna";
       version = "0.0.7";
       sha256 = "5c4f6baddaa6d0c8274e633202301360ddba3bef7bcb6b680f0264081a9b82fe";
       libraryHaskellDepends = [ base papillon ];
       homepage = "https://skami.iocikun.jp/haskell/packages/zasni-gerna";
       description = "lojban parser (zasni gerna)";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zcache" = callPackage
    ({ mkDerivation, array, base, containers, mersenne-random-pure64 }:
     mkDerivation {
       pname = "zcache";
       version = "0.0.0";
       sha256 = "6bab54d3a935c6623433f34bfb5490291abf50fea7dce30891e045541c774082";
       libraryHaskellDepends = [
         array base containers mersenne-random-pure64
       ];
       homepage = "https://patch-tag.com/r/salazar/zcache/";
       description = "Zobrist keys for game state tracking";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "zenc" = callPackage
    ({ mkDerivation, base }:
     mkDerivation {
       pname = "zenc";
       version = "0.1.1";
       sha256 = "62d14fd204a292a780ff0b3ca9f73e6686188c6269cd6bf5433b4d12fe3e105c";
       libraryHaskellDepends = [ base ];
       description = "GHC style name Z-encoding and Z-decoding";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "zendesk-api" = callPackage
    ({ mkDerivation, aeson, base, bytestring, case-insensitive, conduit
     , connection, data-default, failure, http-client, http-client-tls
     , http-conduit, http-types, monad-logger, mtl, pem
     , template-haskell, text, time, tls, transformers
     , unordered-containers, x509, x509-store, x509-validation
     }:
     mkDerivation {
       pname = "zendesk-api";
       version = "0.1.0.0";
       sha256 = "acd6761b86a1ff71e17afee47358e21c2335eb2220c2d89c05caf05c6200c8f4";
       libraryHaskellDepends = [
         aeson base bytestring case-insensitive conduit connection
         data-default failure http-client http-client-tls http-conduit
         http-types monad-logger mtl pem template-haskell text time tls
         transformers unordered-containers x509 x509-store x509-validation
       ];
       jailbreak = true;
       homepage = "https://github.com/VictorDenisov/zendesk-api";
       description = "Zendesk API for Haskell programming language";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zeno" = callPackage
    ({ mkDerivation, array, base, containers, directory, ghc, ghc-paths
     , mtl, parallel, process, random, text, transformers
     }:
     mkDerivation {
       pname = "zeno";
       version = "0.2.0.1";
       sha256 = "dba8a5cc985efd9c54151345a9a1d5532fafb76f935b64ef3f3b269be2835c0e";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers directory ghc ghc-paths mtl parallel process
         random text transformers
       ];
       description = "An automated proof system for Haskell programs";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zero_0_1_2" = callPackage
    ({ mkDerivation, base, semigroups }:
     mkDerivation {
       pname = "zero";
       version = "0.1.2";
       sha256 = "37f9b003e202bf88fe8dcf5e7e4fd8eae1e373d8ad4135a4244b909744d40e06";
       libraryHaskellDepends = [ base semigroups ];
       jailbreak = true;
       homepage = "https://github.com/phaazon/zero";
       description = "Semigroups with absorption";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zero_0_1_3" = callPackage
    ({ mkDerivation, base, semigroups }:
     mkDerivation {
       pname = "zero";
       version = "0.1.3";
       sha256 = "bc57b63f12a935ee20558fea1930ebcf3c4f0ddffa5e1e9be05af6222466fbfe";
       libraryHaskellDepends = [ base semigroups ];
       jailbreak = true;
       homepage = "https://github.com/phaazon/zero";
       description = "Semigroups with absorption";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zero" = callPackage
    ({ mkDerivation, base, semigroups }:
     mkDerivation {
       pname = "zero";
       version = "0.1.3.1";
       sha256 = "ff37a60d48c7c6fa648699c7f0d2a6b923b6565d6843e2f90e50218e098bb85b";
       libraryHaskellDepends = [ base semigroups ];
       homepage = "https://github.com/phaazon/zero";
       description = "Semigroups with absorption";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "zerobin" = callPackage
    ({ mkDerivation, aeson, base, base64-bytestring, bytestring
     , cryptonite, docopt, http-conduit, memory, raw-strings-qq
     }:
     mkDerivation {
       pname = "zerobin";
       version = "1.5.0";
       sha256 = "f2ad48725b473c417f1b4c607b5e1f46e3d6fdfa50aaf15a576e86c8a020f318";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         aeson base base64-bytestring bytestring cryptonite http-conduit
         memory
       ];
       executableHaskellDepends = [
         base bytestring docopt raw-strings-qq
       ];
       jailbreak = true;
       description = "Post to 0bin services";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zeromq-haskell" = callPackage
    ({ mkDerivation, base, bytestring, containers, QuickCheck
     , test-framework, test-framework-quickcheck2, zeromq
     }:
     mkDerivation {
       pname = "zeromq-haskell";
       version = "0.8.4";
       sha256 = "63dff94c8b132c220bc1d03e91f16bcce4488f1f250c0059a9bc6404e2d77253";
       libraryHaskellDepends = [ base bytestring containers ];
       librarySystemDepends = [ zeromq ];
       testHaskellDepends = [
         base bytestring containers QuickCheck test-framework
         test-framework-quickcheck2
       ];
       homepage = "http://github.com/twittner/zeromq-haskell/";
       description = "Bindings to ZeroMQ 2.1.x";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) zeromq;};

  "zeromq3-conduit" = callPackage
    ({ mkDerivation, base, bytestring, conduit, lifted-base
     , monad-control, mtl, resourcet, transformers, zeromq3-haskell
     }:
     mkDerivation {
       pname = "zeromq3-conduit";
       version = "0.1.0.0";
       sha256 = "e7381f7c3a2f447f16f934f2ff96cc1781a715cb3eeb4a561574cdf663a1ddd8";
       libraryHaskellDepends = [
         base bytestring conduit lifted-base monad-control mtl resourcet
         transformers zeromq3-haskell
       ];
       homepage = "https://github.com/NicolasT/zeromq3-conduit";
       description = "Conduit bindings for zeromq3-haskell";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zeromq3-haskell" = callPackage
    ({ mkDerivation, ansi-terminal, async, base, bytestring, checkers
     , containers, MonadCatchIO-transformers, QuickCheck, semigroups
     , transformers, zeromq
     }:
     mkDerivation {
       pname = "zeromq3-haskell";
       version = "0.5.2";
       sha256 = "23889f12625079658c29055be1730aef4ce87d621548b56dd7f888e93916c9cf";
       libraryHaskellDepends = [
         async base bytestring containers MonadCatchIO-transformers
         semigroups transformers
       ];
       libraryPkgconfigDepends = [ zeromq ];
       testHaskellDepends = [
         ansi-terminal async base bytestring checkers containers
         MonadCatchIO-transformers QuickCheck transformers
       ];
       homepage = "http://github.com/twittner/zeromq-haskell/";
       description = "Bindings to ZeroMQ 3.x";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) zeromq;};

  "zeromq4-haskell_0_6_2" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, exceptions
     , QuickCheck, semigroups, tasty, tasty-hunit, tasty-quickcheck
     , transformers, zeromq
     }:
     mkDerivation {
       pname = "zeromq4-haskell";
       version = "0.6.2";
       sha256 = "cba96be736bf3c58189f6c74fd13c47a84a6a4e7640ff374c21812f6afd2ab1d";
       libraryHaskellDepends = [
         async base bytestring containers exceptions semigroups transformers
       ];
       libraryPkgconfigDepends = [ zeromq ];
       testHaskellDepends = [
         async base bytestring QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "http://github.com/twittner/zeromq-haskell/";
       description = "Bindings to ZeroMQ 4.x";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) zeromq;};

  "zeromq4-haskell_0_6_3" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, exceptions
     , QuickCheck, semigroups, tasty, tasty-hunit, tasty-quickcheck
     , transformers, zeromq
     }:
     mkDerivation {
       pname = "zeromq4-haskell";
       version = "0.6.3";
       sha256 = "c7dc92a02b893f5b7cf6d0e07bc40d6d96b2232c7ea914cd99c922206ac73c7b";
       libraryHaskellDepends = [
         async base bytestring containers exceptions semigroups transformers
       ];
       libraryPkgconfigDepends = [ zeromq ];
       testHaskellDepends = [
         async base bytestring QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       jailbreak = true;
       homepage = "http://github.com/twittner/zeromq-haskell/";
       description = "Bindings to ZeroMQ 4.x";
       license = stdenv.lib.licenses.mit;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) zeromq;};

  "zeromq4-haskell" = callPackage
    ({ mkDerivation, async, base, bytestring, containers, exceptions
     , QuickCheck, semigroups, tasty, tasty-hunit, tasty-quickcheck
     , transformers, zeromq
     }:
     mkDerivation {
       pname = "zeromq4-haskell";
       version = "0.6.4";
       sha256 = "b4ea358c669ccbacf6654ff5437623db3c9ee3161630bc83737a47f430e7746e";
       libraryHaskellDepends = [
         async base bytestring containers exceptions semigroups transformers
       ];
       libraryPkgconfigDepends = [ zeromq ];
       testHaskellDepends = [
         async base bytestring QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       homepage = "http://github.com/twittner/zeromq-haskell/";
       description = "Bindings to ZeroMQ 4.x";
       license = stdenv.lib.licenses.mit;
     }) {inherit (pkgs) zeromq;};

  "zeroth" = callPackage
    ({ mkDerivation, base, Cabal, derive, directory, filepath
     , haskell-src-exts, hskeleton, monoid-record, process, syb
     , template-haskell
     }:
     mkDerivation {
       pname = "zeroth";
       version = "2009.6.23.3";
       sha256 = "80112fe3f96fdfef075042552ca67fd1682bd9f4d450393e6187120569d73482";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base Cabal derive directory filepath haskell-src-exts hskeleton
         monoid-record process syb template-haskell
       ];
       executableHaskellDepends = [
         base Cabal derive directory filepath haskell-src-exts hskeleton
         monoid-record process syb template-haskell
       ];
       jailbreak = true;
       description = "ZeroTH - remove unnecessary TH dependencies";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zigbee-znet25" = callPackage
    ({ mkDerivation, base, bytestring, cereal, MissingH, mtl
     , QuickCheck, random, transformers
     }:
     mkDerivation {
       pname = "zigbee-znet25";
       version = "0.1.1.0";
       sha256 = "c5e17c0386f6afd6eb278e2084ea383ac6aeb34ce835a108e9a23df88f13654f";
       libraryHaskellDepends = [
         base bytestring cereal MissingH mtl transformers
       ];
       testHaskellDepends = [ base bytestring mtl QuickCheck random ];
       homepage = "https://github.com/djoyner/zigbee-znet25";
       description = "XBee ZNet 2.5 (ZigBee) wireless modem communications";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "zim-parser" = callPackage
    ({ mkDerivation, array, base, binary, binary-conduit, bytestring
     , conduit, conduit-extra, hspec, lzma-conduit, resourcet
     }:
     mkDerivation {
       pname = "zim-parser";
       version = "0.1.0.0";
       sha256 = "2d0d49978feb7eb2ed52715ff22ad5687e2d0a6aefc55690793c2bd6c58a344f";
       libraryHaskellDepends = [
         array base binary binary-conduit bytestring conduit conduit-extra
         lzma-conduit resourcet
       ];
       testHaskellDepends = [
         array base binary binary-conduit bytestring conduit conduit-extra
         hspec lzma-conduit resourcet
       ];
       homepage = "https://github.com/robbinch/zim-parser#readme";
       description = "Read and parse ZIM files";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "zip-archive_0_2_3_5" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , digest, directory, filepath, HUnit, mtl, old-time, pretty
     , process, text, time, unix, zlib
     }:
     mkDerivation {
       pname = "zip-archive";
       version = "0.2.3.5";
       sha256 = "286896bb3dff58534fa5d78bf40cc516fa59db9ad9247d3826707620d5c64361";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers digest directory filepath
         mtl old-time pretty text time unix zlib
       ];
       executableHaskellDepends = [ base bytestring directory ];
       testHaskellDepends = [
         base bytestring directory HUnit old-time process time
       ];
       homepage = "http://github.com/jgm/zip-archive";
       description = "Library for creating and modifying zip archives";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zip-archive" = callPackage
    ({ mkDerivation, array, base, binary, bytestring, containers
     , digest, directory, filepath, HUnit, mtl, old-time, pretty
     , process, text, time, unix, zip, zlib
     }:
     mkDerivation {
       pname = "zip-archive";
       version = "0.2.3.7";
       sha256 = "41623b3831795e785329b017f42af3116f6332a690361f7eac7ed15f729f3699";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         array base binary bytestring containers digest directory filepath
         mtl old-time pretty text time unix zlib
       ];
       executableHaskellDepends = [ base bytestring directory ];
       testHaskellDepends = [
         base bytestring directory HUnit old-time process time
       ];
       testToolDepends = [ zip ];
       homepage = "http://github.com/jgm/zip-archive";
       description = "Library for creating and modifying zip archives";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) zip;};

  "zip-conduit" = callPackage
    ({ mkDerivation, base, bytestring, cereal, conduit, conduit-extra
     , digest, directory, filepath, hpc, HUnit, mtl, old-time, resourcet
     , temporary, test-framework, test-framework-hunit, time
     , transformers, utf8-string
     }:
     mkDerivation {
       pname = "zip-conduit";
       version = "0.2.2.2";
       sha256 = "1b1c83eeae0755fa03744d0ef0c1643259caa0d125862172fe1c335ec332eb6a";
       libraryHaskellDepends = [
         base bytestring cereal conduit conduit-extra digest directory
         filepath mtl old-time resourcet time transformers utf8-string
       ];
       testHaskellDepends = [
         base bytestring conduit directory filepath hpc HUnit mtl resourcet
         temporary test-framework test-framework-hunit time
       ];
       jailbreak = true;
       homepage = "https://github.com/tymmym/zip-conduit";
       description = "Working with zip archives via conduits";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "zipedit" = callPackage
    ({ mkDerivation, base, directory, mtl, process }:
     mkDerivation {
       pname = "zipedit";
       version = "0.2.3";
       sha256 = "998db1dd9fe403b7b6d5b1dc35094810c12e722ca097ef978aba52cfdf80ba9e";
       libraryHaskellDepends = [ base directory mtl process ];
       homepage = "http://code.haskell.org/~byorgey/code/zipedit";
       description = "Create simple list editor interfaces";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zipkin" = callPackage
    ({ mkDerivation, base, bytestring, mersenne-random-pure64, mtl
     , safe
     }:
     mkDerivation {
       pname = "zipkin";
       version = "0.1.0.0";
       sha256 = "16c92701223c1df16f23638ea51e35ddb5720e715bf4a43ac835884b723f1be6";
       libraryHaskellDepends = [
         base bytestring mersenne-random-pure64 mtl safe
       ];
       homepage = "https://github.com/srijs/haskell-zipkin";
       description = "Zipkin-style request tracing monad";
       license = stdenv.lib.licenses.mit;
     }) {};

  "zipper" = callPackage
    ({ mkDerivation, base, multirec }:
     mkDerivation {
       pname = "zipper";
       version = "0.4.2";
       sha256 = "84780973df7730a21c67bf5dc566b5fda0ce4f0e94f9af0b7d89175c954800e5";
       libraryHaskellDepends = [ base multirec ];
       homepage = "http://www.cs.uu.nl/wiki/GenericProgramming/Multirec";
       description = "Generic zipper for families of recursive datatypes";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "zippers" = callPackage
    ({ mkDerivation, base, directory, doctest, filepath, lens
     , profunctors, semigroupoids
     }:
     mkDerivation {
       pname = "zippers";
       version = "0.2";
       sha256 = "9a864aa9acb62f018caea6f92520d9e9f9f09b8efada84ba4e9e35c35a008ee6";
       revision = "1";
       editedCabalFile = "3e27022f7ed27e35e73ed36f3aa6b396c7e7b52e864965b8d3cd4dab8394e960";
       libraryHaskellDepends = [ base lens profunctors semigroupoids ];
       testHaskellDepends = [ base directory doctest filepath ];
       homepage = "http://github.com/ekmett/zippers/";
       description = "Traversal based zippers";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "zippo" = callPackage
    ({ mkDerivation, base, mtl, yall }:
     mkDerivation {
       pname = "zippo";
       version = "0.3";
       sha256 = "a273353e1511fe5f80a170dc295fad4cf68524649caf14a758ce675f5a8e0dc6";
       libraryHaskellDepends = [ base mtl yall ];
       homepage = "http://brandon.si/code/zippo/";
       description = "A simple lens-based, generic, heterogenous, type-checked zipper library";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "zlib_0_5_4_2" = callPackage
    ({ mkDerivation, base, bytestring, zlib }:
     mkDerivation {
       pname = "zlib";
       version = "0.5.4.2";
       sha256 = "75d617d8a77d85ba5a0d69e42c2cd5371b56140b5fb028be3e75bff1cfd41096";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ zlib ];
       description = "Compression and decompression in the gzip and zlib formats";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {inherit (pkgs) zlib;};

  "zlib" = callPackage
    ({ mkDerivation, base, bytestring, HUnit, QuickCheck, tasty
     , tasty-hunit, tasty-quickcheck, zlib
     }:
     mkDerivation {
       pname = "zlib";
       version = "0.6.1.1";
       sha256 = "c5f5b4285473657a7997d74f7642f3e7bda40f92c3c5d49471a899e27a4ba735";
       revision = "3";
       editedCabalFile = "b5fff98d06289c9c16ab78d994f88f18345ccf7d0ef3e5334bb417d763b07046";
       libraryHaskellDepends = [ base bytestring ];
       librarySystemDepends = [ zlib ];
       testHaskellDepends = [
         base bytestring HUnit QuickCheck tasty tasty-hunit tasty-quickcheck
       ];
       jailbreak = true;
       doCheck = false;
       description = "Compression and decompression in the gzip and zlib formats";
       license = stdenv.lib.licenses.bsd3;
     }) {inherit (pkgs) zlib;};

  "zlib-bindings" = callPackage
    ({ mkDerivation, base, bytestring, hspec, QuickCheck, zlib }:
     mkDerivation {
       pname = "zlib-bindings";
       version = "0.1.1.5";
       sha256 = "c83bb438f9b6c5fe860982731eb8ac7eff993e8b56cbc15ef5b471f229f79109";
       revision = "2";
       editedCabalFile = "0c6f9f81832af2473281fd58631aff8c6bbad24191e00d2a5a6ae2479249043b";
       libraryHaskellDepends = [ base bytestring zlib ];
       testHaskellDepends = [ base bytestring hspec QuickCheck zlib ];
       homepage = "http://github.com/snapframework/zlib-bindings";
       description = "Low-level bindings to the zlib package";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "zlib-conduit" = callPackage
    ({ mkDerivation, base, conduit }:
     mkDerivation {
       pname = "zlib-conduit";
       version = "1.1.0";
       sha256 = "6aa47ff9c2bdf5b34e3fc21bb1026fe2fdc9cad21878040972e7ad8514ab42ac";
       libraryHaskellDepends = [ base conduit ];
       doHaddock = false;
       homepage = "http://github.com/snoyberg/conduit";
       description = "Streaming compression/decompression via conduits. (deprecated)";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "zlib-enum" = callPackage
    ({ mkDerivation, base, bytestring, enumerator, transformers
     , zlib-bindings
     }:
     mkDerivation {
       pname = "zlib-enum";
       version = "0.2.3.1";
       sha256 = "e43dc9ea85ceea02c4f4204c95e8d8540205839c58079f9399dfa96e63fdccd9";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base bytestring enumerator transformers zlib-bindings
       ];
       homepage = "http://github.com/maltem/zlib-enum";
       description = "Enumerator interface for zlib compression";
       license = stdenv.lib.licenses.mit;
     }) {};

  "zlib-lens_0_1" = callPackage
    ({ mkDerivation, base, bytestring, lens, zlib }:
     mkDerivation {
       pname = "zlib-lens";
       version = "0.1";
       sha256 = "fdbb05a65439a83fbebb9ea9aea0a34fa7809382ad935dfb3db1c629b86bbbe9";
       libraryHaskellDepends = [ base bytestring lens zlib ];
       jailbreak = true;
       homepage = "lens.github.io";
       description = "Lenses for zlib";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zlib-lens_0_1_1_1" = callPackage
    ({ mkDerivation, base, bytestring, profunctors, zlib }:
     mkDerivation {
       pname = "zlib-lens";
       version = "0.1.1.1";
       sha256 = "3fb8a31d5ff081fa22d3fd628b49e61eb5be8a0bc43d52b5e73c60b2098b67c8";
       revision = "1";
       editedCabalFile = "fe783bc66f56cb660f1b06012c28f12ae025c97e24f0254ed938eb5e132f9cc2";
       libraryHaskellDepends = [ base bytestring profunctors zlib ];
       jailbreak = true;
       homepage = "http://lens.github.io/";
       description = "Lenses for zlib";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zlib-lens_0_1_1_2" = callPackage
    ({ mkDerivation, base, bytestring, profunctors, zlib }:
     mkDerivation {
       pname = "zlib-lens";
       version = "0.1.1.2";
       sha256 = "c1e47feb44ca0aa70b152db60db7bc29b2b1820ba0d015bbb301a1340c80ee8f";
       revision = "1";
       editedCabalFile = "2cd596d95a3665d374fb519a9698017abd1c2c0bc0b27669708500af24c7b7ed";
       libraryHaskellDepends = [ base bytestring profunctors zlib ];
       jailbreak = true;
       homepage = "http://lens.github.io/";
       description = "Lenses for zlib";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zlib-lens_0_1_2" = callPackage
    ({ mkDerivation, base, bytestring, profunctors, zlib }:
     mkDerivation {
       pname = "zlib-lens";
       version = "0.1.2";
       sha256 = "1649c2d05f8a720804b0d380f51b854fdeea4ce9bcfe682d2e335e9faa16a1ee";
       revision = "2";
       editedCabalFile = "167ebeb448d8097a8a7d1375006d1f791139b71ac6ec5f4b66d80d5b2c7eec42";
       libraryHaskellDepends = [ base bytestring profunctors zlib ];
       homepage = "http://lens.github.io/";
       description = "Lenses for zlib";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zlib-lens" = callPackage
    ({ mkDerivation, base, bytestring, profunctors, zlib }:
     mkDerivation {
       pname = "zlib-lens";
       version = "0.1.2.1";
       sha256 = "e5a563453899e0896cfa3aed22a2fbfc67012990ace6d14631f31b704ff766eb";
       libraryHaskellDepends = [ base bytestring profunctors zlib ];
       homepage = "http://lens.github.io/";
       description = "Lenses for zlib";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "zmcat" = callPackage
    ({ mkDerivation, base, bytestring, zeromq3-haskell }:
     mkDerivation {
       pname = "zmcat";
       version = "0.3";
       sha256 = "37b2584351d92b5db563915b19824bff8bd55704e6c027eea2ab489e9075e551";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base bytestring zeromq3-haskell ];
       executableHaskellDepends = [ base bytestring ];
       homepage = "https://github.com/lucasdicioccio/zmcat";
       description = "Command-line tool for ZeroMQ";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zmidi-core" = callPackage
    ({ mkDerivation, base, binary, bytestring, containers }:
     mkDerivation {
       pname = "zmidi-core";
       version = "0.8.1";
       sha256 = "5bfb08b41d20ea1d0520dac48fefe07fc4f174bcfa9de6d7eb613234e962cbd8";
       libraryHaskellDepends = [ base binary bytestring containers ];
       homepage = "https://github.com/stephentetley/zmidi-core";
       description = "Read and write MIDI files";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "zmidi-score" = callPackage
    ({ mkDerivation, aeson, base, binary, containers, data-ordlist
     , deepseq, deepseq-generics, directory, filepath, mtl, parallel-io
     , text, zmidi-core
     }:
     mkDerivation {
       pname = "zmidi-score";
       version = "0.3.0.0";
       sha256 = "3baeb121c81cdceea4ff7244ea3d62afa0d16c1572b72e954ee6d975db32107e";
       libraryHaskellDepends = [
         aeson base binary containers data-ordlist deepseq deepseq-generics
         directory filepath mtl parallel-io text zmidi-core
       ];
       jailbreak = true;
       homepage = "https://bitbucket.org/bash/zmidi-score";
       description = "Representing MIDI a simple score";
       license = stdenv.lib.licenses.gpl3;
     }) {};

  "zmqat" = callPackage
    ({ mkDerivation, base, classy-prelude, optparse-applicative
     , semigroups, zeromq4-haskell
     }:
     mkDerivation {
       pname = "zmqat";
       version = "0.2.0.0";
       sha256 = "3b6faab9d0b07085b0f9597d8cfea8a6df69d1826bd02d453a7847eda8e320cc";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base classy-prelude optparse-applicative semigroups zeromq4-haskell
       ];
       description = "A socat-like tool for zeromq library";
       license = "unknown";
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zoneinfo" = callPackage
    ({ mkDerivation, base, time }:
     mkDerivation {
       pname = "zoneinfo";
       version = "0.5";
       sha256 = "1e693e02e977fbc727b0485bfadd3751982f6730b79d79ac8c41a5a3189247d8";
       libraryHaskellDepends = [ base time ];
       jailbreak = true;
       description = "ZoneInfo library";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zoom" = callPackage
    ({ mkDerivation, base, directory, filepath, ghc, hamlet, hint, mtl
     , template-haskell, text
     }:
     mkDerivation {
       pname = "zoom";
       version = "0.1.0.1";
       sha256 = "d4ee9458e5d90723e512129af31778a47eedac1652d1c159a14135c3c81c597f";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [ base ghc hamlet template-haskell text ];
       executableHaskellDepends = [
         base directory filepath ghc hint mtl
       ];
       jailbreak = true;
       homepage = "http://github.com/iand675/Zoom";
       description = "A rake/thor-like task runner written in Haskell";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zoom-cache" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers
     , data-default, iteratee, iteratee-compress, ListLike
     , MonadCatchIO-transformers, mtl, old-locale, QuickCheck, random
     , test-framework, test-framework-quickcheck2, time, transformers
     , type-level, ui-command, unix, zlib
     }:
     mkDerivation {
       pname = "zoom-cache";
       version = "1.2.1.6";
       sha256 = "aecc91f3c9eef63b454f8009fafcd42d11fd453f5d11924d4e60d45addedc11c";
       isLibrary = true;
       isExecutable = true;
       libraryHaskellDepends = [
         base blaze-builder bytestring containers data-default iteratee
         iteratee-compress ListLike MonadCatchIO-transformers mtl old-locale
         QuickCheck time transformers type-level unix zlib
       ];
       executableHaskellDepends = [
         base blaze-builder bytestring containers data-default iteratee
         iteratee-compress ListLike MonadCatchIO-transformers mtl old-locale
         QuickCheck time transformers type-level ui-command unix zlib
       ];
       testHaskellDepends = [
         base blaze-builder iteratee QuickCheck random test-framework
         test-framework-quickcheck2 transformers type-level unix
       ];
       jailbreak = true;
       description = "A streamable, seekable, zoomable cache file format";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zoom-cache-pcm" = callPackage
    ({ mkDerivation, base, blaze-builder, bytestring, containers
     , iteratee, ListLike, mtl, type-level, zoom-cache
     }:
     mkDerivation {
       pname = "zoom-cache-pcm";
       version = "0.3.0.1";
       sha256 = "d8ef64a3828ab0bd2e63a23b561f70eddd41781105e248878d951f4c1637c764";
       libraryHaskellDepends = [
         base blaze-builder bytestring containers iteratee ListLike mtl
         type-level zoom-cache
       ];
       jailbreak = true;
       description = "Library for zoom-cache PCM audio codecs";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zoom-cache-sndfile" = callPackage
    ({ mkDerivation, base, bytestring, containers, data-default
     , hsndfile, hsndfile-vector, mtl, ui-command, vector, zoom-cache
     , zoom-cache-pcm
     }:
     mkDerivation {
       pname = "zoom-cache-sndfile";
       version = "1.1.0.1";
       sha256 = "1f72a67a5b7a6f57b0c7b9db08b312d9aac7b421e9ea61a57aa42f9c8de7421c";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         base bytestring containers data-default hsndfile hsndfile-vector
         mtl ui-command vector zoom-cache zoom-cache-pcm
       ];
       jailbreak = true;
       description = "Tools for generating zoom-cache-pcm files";
       license = stdenv.lib.licenses.lgpl21;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zoom-refs" = callPackage
    ({ mkDerivation, base, lens, stm }:
     mkDerivation {
       pname = "zoom-refs";
       version = "0.0.0.0";
       sha256 = "3780dd561d0902772ff3ddca00fc5431c14e469c568381f5ab2f13eaf4e3765d";
       libraryHaskellDepends = [ base lens stm ];
       description = "Zoom (~ Functor) and pairing (~ Applicative) for mutable references";
       license = stdenv.lib.licenses.bsd3;
     }) {};

  "zot" = callPackage
    ({ mkDerivation, base, monads-tf }:
     mkDerivation {
       pname = "zot";
       version = "0.0.2";
       sha256 = "03b7086b3a1d4ab4bed9a1781ee7bb59796448f75c3e3b8d7fc02fb8699e8f8b";
       revision = "1";
       editedCabalFile = "325ccedb3426935b4a56f838f3d05fc914b72729a2b80d6c804bec5657593a40";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base monads-tf ];
       description = "Zot language";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "zsh-battery" = callPackage
    ({ mkDerivation, base, directory, filepath, mtl }:
     mkDerivation {
       pname = "zsh-battery";
       version = "0.2";
       sha256 = "b9abcac09fdddea5e7b2508a49ca14d9a667722908130cbc7872cdcd9a08a811";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [ base directory filepath mtl ];
       homepage = "https://github.com/MasseR/zsh-battery";
       description = "Ascii bars representing battery status";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

  "ztail" = callPackage
    ({ mkDerivation, array, base, containers, filepath, hinotify
     , old-locale, process, regex-compat, time, unix
     }:
     mkDerivation {
       pname = "ztail";
       version = "1.1";
       sha256 = "d81e30a9b2039c9b008482542719eaf1db28c2049335b88a6aaf3de739e4a687";
       isLibrary = false;
       isExecutable = true;
       executableHaskellDepends = [
         array base containers filepath hinotify old-locale process
         regex-compat time unix
       ];
       description = "Multi-file, colored, filtered log tailer";
       license = stdenv.lib.licenses.bsd3;
       hydraPlatforms = stdenv.lib.platforms.none;
     }) {};

}